bp-aicc-editor 1.2.521 → 1.2.522

package/lib/index-DDHxrdAo.js

@@ -0,0 +1,1773 @@
+import { e as He, Z as ot, g as ye, at as dt, h as ne, aU as W, w as Re, bi as Ne, ak as Ce, R as ue, aA as be, az as ve, V as Ve, aB as st, j as at, aV as Le, aH as ke, aJ as lt, aS as it, E as qe, a5 as rt, bj as ct, B as ut, M as ht, N as G, Y as ft, f as he, t as pt, $ as vt, bk as yt, _ as Se, a as Ge, bd as gt, bb as V, u as mt, d as kt } from "./index-B8QqTLfg.js";
+import { E as Nt, a as Ct } from "./el-form-item-BbaNohQv.js";
+/* empty css                    */
+/* empty css                   */
+import { defineComponent as oe, ref as $, computed as J, onMounted as Ye, onUpdated as We, createBlock as M, openBlock as k, resolveDynamicComponent as Je, normalizeStyle as ee, normalizeClass as F, withCtx as I, renderSlot as Ie, useAttrs as bt, reactive as Et, nextTick as Ee, inject as le, h as Ae, onBeforeUnmount as xt, provide as ie, resolveComponent as Y, withDirectives as re, createElementBlock as L, withModifiers as z, createElementVNode as A, createVNode as S, createCommentVNode as H, Fragment as ae, renderList as Xe, vShow as xe, getCurrentInstance as Ze, watch as U, toDisplayString as De, resolveDirective as Dt, unref as q, withKeys as Be, vModelText as Oe, createTextVNode as fe } from "vue";
+import { u as wt } from "./toolbar-Dhf_BVAU.js";
+import { u as Qe } from "./index-CPa_MnOD.js";
+import { I as Kt } from "./delete-COj0ilHh.js";
+import { I as St, b as Me, a as Pe } from "./unlock-B2FVPQlm.js";
+import { a as ze, I as Fe } from "./show-BCwE3hGY.js";
+import { E as It } from "./index-DVyjilLy.js";
+import { E as $t } from "./index-C35Yp3i8.js";
+import { E as Tt } from "./index-C_WopEui.js";
+import { E as Lt } from "./index-CJjljoJG.js";
+import { E as At } from "./index-bOWjoplU.js";
+const Bt = He({
+  type: {
+    type: String,
+    values: ["primary", "success", "info", "warning", "danger", ""],
+    default: ""
+  },
+  size: {
+    type: String,
+    values: ot,
+    default: ""
+  },
+  truncated: Boolean,
+  lineClamp: {
+    type: [String, Number]
+  },
+  tag: {
+    type: String,
+    default: "span"
+  }
+}), Ot = oe({
+  name: "ElText",
+  __name: "text",
+  props: Bt,
+  setup(e) {
+    const t = e, n = $(), d = dt(), o = ne("text"), s = J(() => [
+      o.b(),
+      o.m(t.type),
+      o.m(d.value),
+      o.is("truncated", t.truncated),
+      o.is("line-clamp", !W(t.lineClamp))
+    ]), a = () => {
+      var i, f, h, r, c, u, v;
+      if (bt().title)
+        return;
+      let N = !1;
+      const C = ((i = n.value) == null ? void 0 : i.textContent) || "";
+      if (t.truncated) {
+        const K = (f = n.value) == null ? void 0 : f.offsetWidth, w = (h = n.value) == null ? void 0 : h.scrollWidth;
+        K && w && w > K && (N = !0);
+      } else if (!W(t.lineClamp)) {
+        const K = (r = n.value) == null ? void 0 : r.offsetHeight, w = (c = n.value) == null ? void 0 : c.scrollHeight;
+        K && w && w > K && (N = !0);
+      }
+      N ? (u = n.value) == null || u.setAttribute("title", C) : (v = n.value) == null || v.removeAttribute("title");
+    };
+    return Ye(a), We(a), (i, f) => (k(), M(Je(i.tag), {
+      ref_key: "textRef",
+      ref: n,
+      class: F(s.value),
+      style: ee({ "-webkit-line-clamp": i.lineClamp })
+    }, {
+      default: I(() => [
+        Ie(i.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["class", "style"]));
+  }
+});
+var Mt = /* @__PURE__ */ ye(Ot, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/text/src/text.vue"]]);
+const Pt = Re(Mt), te = "$treeNodeId", je = function(e, t) {
+  !t || t[te] || Object.defineProperty(t, te, {
+    value: e.id,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  });
+}, $e = (e, t) => t?.[e || te], we = (e, t, n) => {
+  const d = e.value.currentNode;
+  n();
+  const o = e.value.currentNode;
+  d !== o && t("current-change", o ? o.data : null, o);
+}, _e = (e) => {
+  let t = !0, n = !0, d = !0, o = !0;
+  for (let s = 0, a = e.length; s < a; s++) {
+    const i = e[s];
+    (i.checked !== !0 || i.indeterminate) && (t = !1, i.disabled || (d = !1)), (i.checked !== !1 || i.indeterminate) && (n = !1), i.isEffectivelyChecked || (o = !1);
+  }
+  return {
+    all: t,
+    none: n,
+    allWithoutDisable: d,
+    half: !t && !n,
+    isEffectivelyChecked: o
+  };
+}, se = function(e) {
+  if (e.childNodes.length === 0 || e.loading) {
+    e.isEffectivelyChecked = e.disabled || e.checked;
+    return;
+  }
+  const { all: t, none: n, half: d, isEffectivelyChecked: o } = _e(
+    e.childNodes
+  );
+  e.isEffectivelyChecked = o, t ? (e.checked = !0, e.indeterminate = !1) : d ? (e.checked = !1, e.indeterminate = !0) : n && (e.checked = !1, e.indeterminate = !1);
+  const s = e.parent;
+  !s || s.level === 0 || e.store.checkStrictly || se(s);
+}, pe = function(e, t) {
+  const n = e.store.props, d = e.data || {}, o = n[t];
+  if (ve(o))
+    return o(d, e);
+  if (Ve(o))
+    return d[o];
+  if (W(o)) {
+    const s = d[t];
+    return W(s) ? "" : s;
+  }
+}, Ke = function(e, t) {
+  e.forEach((n) => {
+    n.canFocus = t, Ke(n.childNodes, t);
+  });
+};
+let zt = 0;
+class X {
+  constructor(t) {
+    this.isLeafByUser = void 0, this.isLeaf = void 0, this.isEffectivelyChecked = !1, this.id = zt++, this.text = null, this.checked = !1, this.indeterminate = !1, this.data = null, this.expanded = !1, this.parent = null, this.visible = !0, this.isCurrent = !1, this.canFocus = !1;
+    for (const n in t)
+      Ne(t, n) && (this[n] = t[n]);
+    this.level = 0, this.loaded = !1, this.childNodes = [], this.loading = !1, this.parent && (this.level = this.parent.level + 1);
+  }
+  initialize() {
+    var t;
+    const n = this.store;
+    if (!n)
+      throw new Error("[Node]store is required!");
+    n.registerNode(this);
+    const d = n.props;
+    if (d && typeof d.isLeaf < "u") {
+      const a = pe(this, "isLeaf");
+      Ce(a) && (this.isLeafByUser = a);
+    }
+    if (n.lazy !== !0 && this.data ? (this.setData(this.data), n.defaultExpandAll && (this.expanded = !0, this.canFocus = !0)) : this.level > 0 && n.lazy && n.defaultExpandAll && !this.isLeafByUser && this.expand(), ue(this.data) || je(this, this.data), !this.data)
+      return;
+    const o = n.defaultExpandedKeys, s = n.key;
+    s && !be(this.key) && o && o.includes(this.key) && this.expand(null, n.autoExpandParent), s && n.currentNodeKey !== void 0 && this.key === n.currentNodeKey && (n.currentNode && (n.currentNode.isCurrent = !1), n.currentNode = this, n.currentNode.isCurrent = !0), n.lazy && n._initDefaultCheckedNode(this), this.updateLeafState(), (this.level === 1 || ((t = this.parent) == null ? void 0 : t.expanded) === !0) && (this.canFocus = !0);
+  }
+  setData(t) {
+    ue(t) || je(this, t), this.data = t, this.childNodes = [];
+    let n;
+    this.level === 0 && ue(this.data) ? n = this.data : n = pe(this, "children") || [];
+    for (let d = 0, o = n.length; d < o; d++)
+      this.insertChild({ data: n[d] });
+  }
+  get label() {
+    return pe(this, "label");
+  }
+  get key() {
+    const t = this.store.key;
+    return this.data ? this.data[t] : null;
+  }
+  get disabled() {
+    return pe(this, "disabled");
+  }
+  get nextSibling() {
+    const t = this.parent;
+    if (t) {
+      const n = t.childNodes.indexOf(this);
+      if (n > -1)
+        return t.childNodes[n + 1];
+    }
+    return null;
+  }
+  get previousSibling() {
+    const t = this.parent;
+    if (t) {
+      const n = t.childNodes.indexOf(this);
+      if (n > -1)
+        return n > 0 ? t.childNodes[n - 1] : null;
+    }
+    return null;
+  }
+  contains(t, n = !0) {
+    return (this.childNodes || []).some(
+      (d) => d === t || n && d.contains(t)
+    );
+  }
+  remove() {
+    const t = this.parent;
+    t && t.removeChild(this);
+  }
+  insertChild(t, n, d) {
+    if (!t)
+      throw new Error("InsertChild error: child is required.");
+    if (!(t instanceof X)) {
+      if (!d) {
+        const o = this.getChildren(!0);
+        o?.includes(t.data) || (W(n) || n < 0 ? o?.push(t.data) : o?.splice(n, 0, t.data));
+      }
+      Object.assign(t, {
+        parent: this,
+        store: this.store
+      }), t = Et(new X(t)), t instanceof X && t.initialize();
+    }
+    t.level = this.level + 1, W(n) || n < 0 ? this.childNodes.push(t) : this.childNodes.splice(n, 0, t), this.updateLeafState();
+  }
+  insertBefore(t, n) {
+    let d;
+    n && (d = this.childNodes.indexOf(n)), this.insertChild(t, d);
+  }
+  insertAfter(t, n) {
+    let d;
+    n && (d = this.childNodes.indexOf(n), d !== -1 && (d += 1)), this.insertChild(t, d);
+  }
+  removeChild(t) {
+    const n = this.getChildren() || [], d = n.indexOf(t.data);
+    d > -1 && n.splice(d, 1);
+    const o = this.childNodes.indexOf(t);
+    o > -1 && (this.store && this.store.deregisterNode(t), t.parent = null, this.childNodes.splice(o, 1)), this.updateLeafState();
+  }
+  removeChildByData(t) {
+    const n = this.childNodes.find((d) => d.data === t);
+    n && this.removeChild(n);
+  }
+  expand(t, n) {
+    const d = () => {
+      if (n) {
+        let o = this.parent;
+        for (; o && o.level > 0; )
+          o.expanded = !0, o = o.parent;
+      }
+      this.expanded = !0, t && t(), Ke(this.childNodes, !0);
+    };
+    this.shouldLoadData() ? this.loadData((o) => {
+      ue(o) && (this.checked ? this.setChecked(!0, !0) : this.store.checkStrictly || se(this), d());
+    }) : d();
+  }
+  doCreateChildren(t, n = {}) {
+    t.forEach((d) => {
+      this.insertChild(
+        Object.assign({ data: d }, n),
+        void 0,
+        !0
+      );
+    });
+  }
+  collapse() {
+    this.expanded = !1, Ke(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, n, d, o) {
+    if (this.indeterminate = t === "half", this.checked = t === !0, this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked), this.store.checkStrictly)
+      return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      const a = () => {
+        if (n) {
+          const i = this.childNodes;
+          for (let c = 0, u = i.length; c < u; c++) {
+            const v = i[c];
+            o = o || t !== !1;
+            const g = v.disabled && v.isLeaf ? v.checked : o;
+            v.setChecked(g, n, !0, o);
+          }
+          const { half: f, all: h, isEffectivelyChecked: r } = _e(i);
+          h || (this.checked = h, this.indeterminate = f), this.isEffectivelyChecked = this.childNodes.length ? r : this.disabled || this.checked;
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(
+          () => {
+            a(), se(this);
+          },
+          {
+            checked: t !== !1
+          }
+        );
+        return;
+      } else
+        a();
+    }
+    const s = this.parent;
+    !s || s.level === 0 || d || se(s);
+  }
+  getChildren(t = !1) {
+    if (this.level === 0)
+      return this.data;
+    const n = this.data;
+    if (!n)
+      return null;
+    const d = this.store.props;
+    let o = "children";
+    return d && (o = d.children || "children"), W(n[o]) && (n[o] = null), t && !n[o] && (n[o] = []), n[o];
+  }
+  updateChildren() {
+    const t = this.getChildren() || [], n = this.childNodes.map((s) => s.data), d = {}, o = [];
+    t.forEach((s, a) => {
+      const i = s[te];
+      !!i && n.some((h) => h?.[te] === i) ? d[i] = { index: a, data: s } : o.push({ index: a, data: s });
+    }), this.store.lazy || n.forEach((s) => {
+      d[s?.[te]] || this.removeChildByData(s);
+    }), o.forEach(({ index: s, data: a }) => {
+      this.insertChild({ data: a }, s);
+    }), this.updateLeafState();
+  }
+  loadData(t, n = {}) {
+    if (this.store.lazy === !0 && this.store.load && !this.loaded && (!this.loading || Object.keys(n).length)) {
+      this.loading = !0;
+      const d = (s) => {
+        this.childNodes = [], this.doCreateChildren(s, n), this.loaded = !0, this.loading = !1, this.updateLeafState(), t && t.call(this, s);
+      }, o = () => {
+        this.loading = !1;
+      };
+      this.store.load(this, d, o);
+    } else
+      t && t.call(this);
+  }
+  eachNode(t) {
+    const n = [this];
+    for (; n.length; ) {
+      const d = n.shift();
+      n.unshift(...d.childNodes), t(d);
+    }
+  }
+  reInitChecked() {
+    this.store.checkStrictly || se(this);
+  }
+}
+class Ft {
+  constructor(t) {
+    this.lazy = !1, this.checkStrictly = !1, this.autoExpandParent = !1, this.defaultExpandAll = !1, this.checkDescendants = !1, this.currentNode = null, this.currentNodeKey = null;
+    for (const n in t)
+      Ne(t, n) && (this[n] = t[n]);
+    this.nodesMap = {};
+  }
+  initialize() {
+    if (this.root = new X({
+      data: this.data,
+      store: this
+    }), this.root.initialize(), this.lazy && this.load) {
+      const t = this.load;
+      t(
+        this.root,
+        (n) => {
+          this.root.doCreateChildren(n), this._initDefaultCheckedNodes();
+        },
+        st
+      );
+    } else
+      this._initDefaultCheckedNodes();
+  }
+  filter(t) {
+    const n = this.filterNodeMethod, d = this.lazy, o = async function(s) {
+      const a = s.root ? s.root.childNodes : s.childNodes;
+      for (const [i, f] of a.entries())
+        f.visible = !!n?.call(
+          f,
+          t,
+          f.data,
+          f
+        ), i % 80 === 0 && i > 0 && await Ee(), await o(f);
+      if (!s.visible && a.length) {
+        let i = !0;
+        i = !a.some((f) => f.visible), s.root ? s.root.visible = i === !1 : s.visible = i === !1;
+      }
+      t && s.visible && !s.isLeaf && (!d || s.loaded) && s.expand();
+    };
+    o(this);
+  }
+  setData(t) {
+    t !== this.root.data ? (this.nodesMap = {}, this.root.setData(t), this._initDefaultCheckedNodes(), this.setCurrentNodeKey(this.currentNodeKey)) : this.root.updateChildren();
+  }
+  getNode(t) {
+    if (t instanceof X)
+      return t;
+    const n = at(t) ? $e(this.key, t) : t;
+    return this.nodesMap[n] || null;
+  }
+  insertBefore(t, n) {
+    var d;
+    const o = this.getNode(n);
+    (d = o.parent) == null || d.insertBefore({ data: t }, o);
+  }
+  insertAfter(t, n) {
+    var d;
+    const o = this.getNode(n);
+    (d = o.parent) == null || d.insertAfter({ data: t }, o);
+  }
+  remove(t) {
+    const n = this.getNode(t);
+    n && n.parent && (n === this.currentNode && (this.currentNode = null), n.parent.removeChild(n));
+  }
+  append(t, n) {
+    const d = Le(n) ? this.root : this.getNode(n);
+    d && d.insertChild({ data: t });
+  }
+  _initDefaultCheckedNodes() {
+    const t = this.defaultCheckedKeys || [], n = this.nodesMap;
+    t.forEach((d) => {
+      const o = n[d];
+      o && o.setChecked(!0, !this.checkStrictly);
+    });
+  }
+  _initDefaultCheckedNode(t) {
+    const n = this.defaultCheckedKeys || [];
+    !be(t.key) && n.includes(t.key) && t.setChecked(!0, !this.checkStrictly);
+  }
+  setDefaultCheckedKey(t) {
+    t !== this.defaultCheckedKeys && (this.defaultCheckedKeys = t, this._initDefaultCheckedNodes());
+  }
+  registerNode(t) {
+    const n = this.key;
+    if (!(!t || !t.data))
+      if (!n)
+        this.nodesMap[t.id] = t;
+      else {
+        const d = t.key;
+        be(d) || (this.nodesMap[d] = t);
+      }
+  }
+  deregisterNode(t) {
+    !this.key || !t || !t.data || (t.childNodes.forEach((d) => {
+      this.deregisterNode(d);
+    }), delete this.nodesMap[t.key]);
+  }
+  getCheckedNodes(t = !1, n = !1) {
+    const d = [], o = function(s) {
+      (s.root ? s.root.childNodes : s.childNodes).forEach((i) => {
+        (i.checked || n && i.indeterminate) && (!t || t && i.isLeaf) && d.push(i.data), o(i);
+      });
+    };
+    return o(this), d;
+  }
+  getCheckedKeys(t = !1) {
+    return this.getCheckedNodes(t).map((n) => (n || {})[this.key]);
+  }
+  getHalfCheckedNodes() {
+    const t = [], n = function(d) {
+      (d.root ? d.root.childNodes : d.childNodes).forEach((s) => {
+        s.indeterminate && t.push(s.data), n(s);
+      });
+    };
+    return n(this), t;
+  }
+  getHalfCheckedKeys() {
+    return this.getHalfCheckedNodes().map((t) => (t || {})[this.key]);
+  }
+  _getAllNodes() {
+    const t = [], n = this.nodesMap;
+    for (const d in n)
+      Ne(n, d) && t.push(n[d]);
+    return t;
+  }
+  updateChildren(t, n) {
+    const d = this.nodesMap[t];
+    if (!d)
+      return;
+    const o = d.childNodes;
+    for (let s = o.length - 1; s >= 0; s--) {
+      const a = o[s];
+      this.remove(a.data);
+    }
+    for (let s = 0, a = n.length; s < a; s++) {
+      const i = n[s];
+      this.append(i, d.data);
+    }
+  }
+  _setCheckedKeys(t, n = !1, d) {
+    const o = this._getAllNodes().sort((f, h) => f.level - h.level), s = /* @__PURE__ */ Object.create(null), a = Object.keys(d);
+    o.forEach((f) => f.setChecked(!1, !1));
+    const i = (f) => {
+      f.childNodes.forEach((h) => {
+        var r;
+        s[h.data[t]] = !0, (r = h.childNodes) != null && r.length && i(h);
+      });
+    };
+    for (let f = 0, h = o.length; f < h; f++) {
+      const r = o[f], c = r.data[t].toString();
+      if (!a.includes(c)) {
+        r.checked && !s[c] && r.setChecked(!1, !1);
+        continue;
+      }
+      if (r.childNodes.length && i(r), r.isLeaf || this.checkStrictly) {
+        r.setChecked(!0, !1);
+        continue;
+      }
+      if (r.setChecked(!0, !0), n) {
+        r.setChecked(!1, !1);
+        const v = function(g) {
+          g.childNodes.forEach((C) => {
+            C.isLeaf || C.setChecked(!1, !1), v(C);
+          });
+        };
+        v(r);
+      }
+    }
+  }
+  setCheckedNodes(t, n = !1) {
+    const d = this.key, o = {};
+    t.forEach((s) => {
+      o[(s || {})[d]] = !0;
+    }), this._setCheckedKeys(d, n, o);
+  }
+  setCheckedKeys(t, n = !1) {
+    this.defaultCheckedKeys = t;
+    const d = this.key, o = {};
+    t.forEach((s) => {
+      o[s] = !0;
+    }), this._setCheckedKeys(d, n, o);
+  }
+  setDefaultExpandedKeys(t) {
+    t = t || [], this.defaultExpandedKeys = t, t.forEach((n) => {
+      const d = this.getNode(n);
+      d && d.expand(null, this.autoExpandParent);
+    });
+  }
+  setChecked(t, n, d) {
+    const o = this.getNode(t);
+    o && o.setChecked(!!n, d);
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+  setCurrentNode(t) {
+    const n = this.currentNode;
+    n && (n.isCurrent = !1), this.currentNode = t, this.currentNode.isCurrent = !0;
+  }
+  setUserCurrentNode(t, n = !0) {
+    var d;
+    const o = t[this.key], s = this.nodesMap[o];
+    this.setCurrentNode(s), n && this.currentNode && this.currentNode.level > 1 && ((d = this.currentNode.parent) == null || d.expand(null, !0));
+  }
+  setCurrentNodeKey(t, n = !0) {
+    var d;
+    if (this.currentNodeKey = t, Le(t)) {
+      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+      return;
+    }
+    const o = this.getNode(t);
+    o && (this.setCurrentNode(o), n && this.currentNode && this.currentNode.level > 1 && ((d = this.currentNode.parent) == null || d.expand(null, !0)));
+  }
+}
+const Te = "RootTree", et = "NodeInstance", Ue = "TreeNodeMap", jt = oe({
+  name: "ElTreeNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    renderContent: Function
+  },
+  setup(e) {
+    const t = ne("tree"), n = le(
+      et
+    ), d = le(Te);
+    return () => {
+      const o = e.node, { data: s, store: a } = o;
+      return e.renderContent ? e.renderContent(Ae, { _self: n, node: o, data: s, store: a }) : Ie(d.ctx.slots, "default", { node: o, data: s }, () => [
+        Ae(
+          Pt,
+          { tag: "span", truncated: !0, class: t.be("node", "label") },
+          () => [o.label]
+        )
+      ]);
+    };
+  }
+});
+var Ut = /* @__PURE__ */ ye(jt, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree-node-content.vue"]]);
+function tt(e) {
+  const t = le(
+    Ue,
+    null
+  );
+  let n = {
+    treeNodeExpand: (d) => {
+      var o;
+      e.node !== d && ((o = e.node) == null || o.collapse());
+    },
+    children: /* @__PURE__ */ new Set()
+  };
+  return t && t.children.add(n), xt(() => {
+    t && t.children.delete(n), n = null;
+  }), ie(Ue, n), {
+    broadcastExpanded: (d) => {
+      if (e.accordion)
+        for (const o of n.children)
+          o.treeNodeExpand(d);
+    }
+  };
+}
+const nt = Symbol("dragEvents");
+function Ht({
+  props: e,
+  ctx: t,
+  el$: n,
+  dropIndicator$: d,
+  store: o
+}) {
+  const s = ne("tree"), a = $({
+    showDropIndicator: !1,
+    draggingNode: null,
+    dropNode: null,
+    allowDrop: !0,
+    dropType: null
+  });
+  return ie(nt, {
+    treeNodeDragStart: ({ event: r, treeNode: c }) => {
+      if (r.dataTransfer) {
+        if (ve(e.allowDrag) && !e.allowDrag(c.node))
+          return r.preventDefault(), !1;
+        r.dataTransfer.effectAllowed = "move";
+        try {
+          r.dataTransfer.setData("text/plain", "");
+        } catch {
+        }
+        a.value.draggingNode = c, t.emit("node-drag-start", c.node, r);
+      }
+    },
+    treeNodeDragOver: ({ event: r, treeNode: c }) => {
+      if (!r.dataTransfer)
+        return;
+      const u = c, v = a.value.dropNode;
+      v && v.node.id !== u.node.id && ke(v.$el, s.is("drop-inner"));
+      const g = a.value.draggingNode;
+      if (!g || !u)
+        return;
+      let N = !0, C = !0, K = !0, w = !0;
+      ve(e.allowDrop) && (N = e.allowDrop(g.node, u.node, "prev"), w = C = e.allowDrop(
+        g.node,
+        u.node,
+        "inner"
+      ), K = e.allowDrop(g.node, u.node, "next")), r.dataTransfer.dropEffect = C || N || K ? "move" : "none", (N || C || K) && v?.node.id !== u.node.id && (v && t.emit("node-drag-leave", g.node, v.node, r), t.emit("node-drag-enter", g.node, u.node, r)), N || C || K ? a.value.dropNode = u : a.value.dropNode = null, u.node.nextSibling === g.node && (K = !1), u.node.previousSibling === g.node && (N = !1), u.node.contains(g.node, !1) && (C = !1), (g.node === u.node || g.node.contains(u.node)) && (N = !1, C = !1, K = !1);
+      const y = u.$el, O = y.querySelector(`.${s.be("node", "content")}`).getBoundingClientRect(), j = n.value.getBoundingClientRect(), P = n.value.scrollTop;
+      let b;
+      const R = N ? C ? 0.25 : K ? 0.45 : 1 : Number.NEGATIVE_INFINITY, p = K ? C ? 0.75 : N ? 0.55 : 0 : Number.POSITIVE_INFINITY;
+      let x = -9999;
+      const T = r.clientY - O.top;
+      T < O.height * R ? b = "before" : T > O.height * p ? b = "after" : C ? b = "inner" : b = "none";
+      const B = y.querySelector(`.${s.be("node", "expand-icon")}`).getBoundingClientRect(), E = d.value;
+      b === "before" ? x = B.top - j.top + P : b === "after" && (x = B.bottom - j.top + P), E.style.top = `${x}px`, E.style.left = `${B.right - j.left}px`, b === "inner" ? lt(y, s.is("drop-inner")) : ke(y, s.is("drop-inner")), a.value.showDropIndicator = b === "before" || b === "after", a.value.allowDrop = a.value.showDropIndicator || w, a.value.dropType = b, t.emit("node-drag-over", g.node, u.node, r);
+    },
+    treeNodeDragEnd: (r) => {
+      var c, u;
+      const { draggingNode: v, dropType: g, dropNode: N } = a.value;
+      if (r.preventDefault(), r.dataTransfer && (r.dataTransfer.dropEffect = "move"), v?.node.data && N) {
+        const C = { data: v.node.data };
+        g !== "none" && v.node.remove(), g === "before" ? (c = N.node.parent) == null || c.insertBefore(C, N.node) : g === "after" ? (u = N.node.parent) == null || u.insertAfter(C, N.node) : g === "inner" && N.node.insertChild(C), g !== "none" && (o.value.registerNode(C), o.value.key && v.node.eachNode((K) => {
+          var w;
+          (w = o.value.nodesMap[K.data[o.value.key]]) == null || w.setChecked(
+            K.checked,
+            !o.value.checkStrictly
+          );
+        })), ke(N.$el, s.is("drop-inner")), t.emit(
+          "node-drag-end",
+          v.node,
+          N.node,
+          g,
+          r
+        ), g !== "none" && t.emit(
+          "node-drop",
+          v.node,
+          N.node,
+          g,
+          r
+        );
+      }
+      v && !N && t.emit("node-drag-end", v.node, null, g, r), a.value.showDropIndicator = !1, a.value.draggingNode = null, a.value.dropNode = null, a.value.allowDrop = !0;
+    }
+  }), {
+    dragState: a
+  };
+}
+const Rt = oe({
+  name: "ElTreeNode",
+  components: {
+    ElCollapseTransition: It,
+    ElCheckbox: $t,
+    NodeContent: Ut,
+    ElIcon: qe,
+    Loading: it
+  },
+  props: {
+    node: {
+      type: X,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: Boolean
+  },
+  emits: ["node-expand"],
+  setup(e, t) {
+    const n = ne("tree"), { broadcastExpanded: d } = tt(e), o = le(Te), s = $(!1), a = $(!1), i = $(), f = $(), h = $(), r = le(nt), c = Ze();
+    ie(et, c), o || rt("Tree", "Can not find node's tree."), e.node.expanded && (s.value = !0, a.value = !0);
+    const u = o.props.props.children || "children";
+    U(
+      () => {
+        var p;
+        const x = (p = e.node.data) == null ? void 0 : p[u];
+        return x && [...x];
+      },
+      () => {
+        e.node.updateChildren();
+      }
+    ), U(
+      () => e.node.indeterminate,
+      (p) => {
+        N(e.node.checked, p);
+      }
+    ), U(
+      () => e.node.checked,
+      (p) => {
+        N(p, e.node.indeterminate);
+      }
+    ), U(
+      () => e.node.childNodes.length,
+      () => e.node.reInitChecked()
+    ), U(
+      () => e.node.expanded,
+      (p) => {
+        Ee(() => s.value = p), p && (a.value = !0);
+      }
+    );
+    const v = (p) => $e(o.props.nodeKey, p.data), g = (p) => {
+      const x = e.props.class;
+      if (!x)
+        return {};
+      let T;
+      if (ve(x)) {
+        const { data: B } = p;
+        T = x(B, p);
+      } else
+        T = x;
+      return Ve(T) ? { [T]: !0 } : T;
+    }, N = (p, x) => {
+      (i.value !== p || f.value !== x) && o.ctx.emit("check-change", e.node.data, p, x), i.value = p, f.value = x;
+    }, C = (p) => {
+      we(o.store, o.ctx.emit, () => {
+        var x;
+        if ((x = o?.props) == null ? void 0 : x.nodeKey) {
+          const B = v(e.node);
+          o.store.value.setCurrentNodeKey(B);
+        } else
+          o.store.value.setCurrentNode(e.node);
+      }), o.currentNode.value = e.node, o.props.expandOnClickNode && w(), (o.props.checkOnClickNode || e.node.isLeaf && o.props.checkOnClickLeaf && e.showCheckbox) && !e.node.disabled && y(!e.node.checked), o.ctx.emit("node-click", e.node.data, e.node, c, p);
+    }, K = (p) => {
+      var x;
+      (x = o.instance.vnode.props) != null && x.onNodeContextmenu && (p.stopPropagation(), p.preventDefault()), o.ctx.emit(
+        "node-contextmenu",
+        p,
+        e.node.data,
+        e.node,
+        c
+      );
+    }, w = () => {
+      e.node.isLeaf || (s.value ? (o.ctx.emit("node-collapse", e.node.data, e.node, c), e.node.collapse()) : e.node.expand(() => {
+        t.emit("node-expand", e.node.data, e.node, c);
+      }));
+    }, y = (p) => {
+      const x = o?.props.checkStrictly, T = e.node.childNodes;
+      !x && T.length && (p = T.some((B) => !B.isEffectivelyChecked)), e.node.setChecked(p, !x), Ee(() => {
+        const B = o.store.value;
+        o.ctx.emit("check", e.node.data, {
+          checkedNodes: B.getCheckedNodes(),
+          checkedKeys: B.getCheckedKeys(),
+          halfCheckedNodes: B.getHalfCheckedNodes(),
+          halfCheckedKeys: B.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: n,
+      node$: h,
+      tree: o,
+      expanded: s,
+      childNodeRendered: a,
+      oldChecked: i,
+      oldIndeterminate: f,
+      getNodeKey: v,
+      getNodeClass: g,
+      handleSelectChange: N,
+      handleClick: C,
+      handleContextMenu: K,
+      handleExpandIconClick: w,
+      handleCheckChange: y,
+      handleChildNodeExpand: (p, x, T) => {
+        d(x), o.ctx.emit("node-expand", p, x, T);
+      },
+      handleDragStart: (p) => {
+        o.props.draggable && r.treeNodeDragStart({ event: p, treeNode: e });
+      },
+      handleDragOver: (p) => {
+        p.preventDefault(), o.props.draggable && r.treeNodeDragOver({
+          event: p,
+          treeNode: { $el: h.value, node: e.node }
+        });
+      },
+      handleDrop: (p) => {
+        p.preventDefault();
+      },
+      handleDragEnd: (p) => {
+        o.props.draggable && r.treeNodeDragEnd(p);
+      },
+      CaretRight: ct
+    };
+  }
+}), Vt = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"], qt = ["aria-expanded"];
+function Gt(e, t, n, d, o, s) {
+  const a = Y("el-icon"), i = Y("el-checkbox"), f = Y("loading"), h = Y("node-content"), r = Y("el-tree-node"), c = Y("el-collapse-transition");
+  return re((k(), L("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] = z((...u) => e.handleClick && e.handleClick(...u), ["stop"])),
+    onContextmenu: t[3] || (t[3] = (...u) => e.handleContextMenu && e.handleContextMenu(...u)),
+    onDragstart: t[4] || (t[4] = z((...u) => e.handleDragStart && e.handleDragStart(...u), ["stop"])),
+    onDragover: t[5] || (t[5] = z((...u) => e.handleDragOver && e.handleDragOver(...u), ["stop"])),
+    onDragend: t[6] || (t[6] = z((...u) => e.handleDragEnd && e.handleDragEnd(...u), ["stop"])),
+    onDrop: t[7] || (t[7] = z((...u) => e.handleDrop && e.handleDrop(...u), ["stop"]))
+  }, [
+    A(
+      "div",
+      {
+        class: F(e.ns.be("node", "content")),
+        style: ee({ paddingLeft: (e.node.level - 1) * e.tree.props.indent + "px" })
+      },
+      [
+        e.tree.props.icon || e.CaretRight ? (k(), M(a, {
+          key: 0,
+          class: F([
+            e.ns.be("node", "expand-icon"),
+            e.ns.is("leaf", e.node.isLeaf),
+            {
+              expanded: !e.node.isLeaf && e.expanded
+            }
+          ]),
+          onClick: z(e.handleExpandIconClick, ["stop"])
+        }, {
+          default: I(() => [
+            (k(), M(Je(e.tree.props.icon || e.CaretRight)))
+          ]),
+          _: 1
+        }, 8, ["class", "onClick"])) : H("v-if", !0),
+        e.showCheckbox ? (k(), M(i, {
+          key: 1,
+          "model-value": e.node.checked,
+          indeterminate: e.node.indeterminate,
+          disabled: !!e.node.disabled,
+          onClick: t[0] || (t[0] = z(() => {
+          }, ["stop"])),
+          onChange: e.handleCheckChange
+        }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : H("v-if", !0),
+        e.node.loading ? (k(), M(a, {
+          key: 2,
+          class: F([e.ns.be("node", "loading-icon"), e.ns.is("loading")])
+        }, {
+          default: I(() => [
+            S(f)
+          ]),
+          _: 1
+        }, 8, ["class"])) : H("v-if", !0),
+        S(h, {
+          node: e.node,
+          "render-content": e.renderContent
+        }, null, 8, ["node", "render-content"])
+      ],
+      6
+    ),
+    S(c, null, {
+      default: I(() => [
+        !e.renderAfterExpand || e.childNodeRendered ? re((k(), L("div", {
+          key: 0,
+          class: F(e.ns.be("node", "children")),
+          role: "group",
+          "aria-expanded": e.expanded,
+          onClick: t[1] || (t[1] = z(() => {
+          }, ["stop"]))
+        }, [
+          (k(!0), L(
+            ae,
+            null,
+            Xe(e.node.childNodes, (u) => (k(), M(r, {
+              key: e.getNodeKey(u),
+              "render-content": e.renderContent,
+              "render-after-expand": e.renderAfterExpand,
+              "show-checkbox": e.showCheckbox,
+              node: u,
+              accordion: e.accordion,
+              props: e.props,
+              onNodeExpand: e.handleChildNodeExpand
+            }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]))),
+            128
+          ))
+        ], 10, qt)), [
+          [xe, e.expanded]
+        ]) : H("v-if", !0)
+      ]),
+      _: 1
+    })
+  ], 42, Vt)), [
+    [xe, e.node.visible]
+  ]);
+}
+var Yt = /* @__PURE__ */ ye(Rt, [["render", Gt], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree-node.vue"]]);
+function Wt({ el$: e }, t) {
+  const n = ne("tree");
+  Ye(() => {
+    s();
+  }), We(() => {
+    var a;
+    (a = e.value) == null || a.querySelectorAll("input[type=checkbox]").forEach((i) => {
+      i.setAttribute("tabindex", "-1");
+    });
+  });
+  function d(a, i) {
+    var f, h;
+    const r = t.value.getNode(a[i].dataset.key);
+    return r.canFocus && r.visible && (((f = r.parent) == null ? void 0 : f.expanded) || ((h = r.parent) == null ? void 0 : h.level) === 0);
+  }
+  ut(e, "keydown", (a) => {
+    const i = a.target;
+    if (!i.className.includes(n.b("node")))
+      return;
+    const f = ht(a), h = Array.from(
+      e.value.querySelectorAll(`.${n.is("focusable")}[role=treeitem]`)
+    ), r = h.indexOf(i);
+    let c;
+    if ([G.up, G.down].includes(f)) {
+      if (a.preventDefault(), f === G.up) {
+        c = r === -1 ? 0 : r !== 0 ? r - 1 : h.length - 1;
+        const v = c;
+        for (; !d(h, c); ) {
+          if (c--, c === v) {
+            c = -1;
+            break;
+          }
+          c < 0 && (c = h.length - 1);
+        }
+      } else {
+        c = r === -1 ? 0 : r < h.length - 1 ? r + 1 : 0;
+        const v = c;
+        for (; !d(h, c); ) {
+          if (c++, c === v) {
+            c = -1;
+            break;
+          }
+          c >= h.length && (c = 0);
+        }
+      }
+      c !== -1 && h[c].focus();
+    }
+    [G.left, G.right].includes(f) && (a.preventDefault(), i.click());
+    const u = i.querySelector(
+      '[type="checkbox"]'
+    );
+    [G.enter, G.numpadEnter, G.space].includes(
+      f
+    ) && u && (a.preventDefault(), u.click());
+  });
+  const s = () => {
+    var a;
+    if (!e.value)
+      return;
+    const i = Array.from(
+      e.value.querySelectorAll(`.${n.is("focusable")}[role=treeitem]`)
+    );
+    Array.from(
+      e.value.querySelectorAll("input[type=checkbox]")
+    ).forEach((r) => {
+      r.setAttribute("tabindex", "-1");
+    });
+    const h = e.value.querySelectorAll(
+      `.${n.is("checked")}[role=treeitem]`
+    );
+    if (h.length) {
+      h[0].setAttribute("tabindex", "0");
+      return;
+    }
+    (a = i[0]) == null || a.setAttribute("tabindex", "0");
+  };
+}
+const Jt = He({
+  data: {
+    type: he(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: he(Function)
+  },
+  showCheckbox: Boolean,
+  draggable: Boolean,
+  allowDrag: {
+    type: he(Function)
+  },
+  allowDrop: {
+    type: he(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: ft
+  }
+}), Xt = {
+  "check-change": (e, t, n) => e && Ce(t) && Ce(n),
+  "current-change": (e, t) => !0,
+  "node-click": (e, t, n, d) => e && t && d instanceof Event,
+  "node-contextmenu": (e, t, n, d) => e instanceof Event && t && n,
+  "node-collapse": (e, t, n) => e && t,
+  "node-expand": (e, t, n) => e && t,
+  check: (e, t) => e && t,
+  "node-drag-start": (e, t) => e && t,
+  "node-drag-end": (e, t, n, d) => e && d,
+  "node-drop": (e, t, n, d) => e && t && d,
+  "node-drag-leave": (e, t, n) => e && t && n,
+  "node-drag-enter": (e, t, n) => e && t && n,
+  "node-drag-over": (e, t, n) => e && t && n
+}, Zt = oe({
+  name: "ElTree",
+  components: { ElTreeNode: Yt },
+  props: Jt,
+  emits: Xt,
+  setup(e, t) {
+    const { t: n } = pt(), d = ne("tree"), o = $(
+      new Ft({
+        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
+      })
+    );
+    o.value.initialize();
+    const s = $(o.value.root), a = $(null), i = $(null), f = $(null), { broadcastExpanded: h } = tt(e), { dragState: r } = Ht({
+      props: e,
+      ctx: t,
+      el$: i,
+      dropIndicator$: f,
+      store: o
+    });
+    Wt({ el$: i }, o);
+    const c = Ze(), u = J(() => {
+      let l = c?.parent;
+      for (; l; ) {
+        if (l.type.name === "ElTreeSelect")
+          return !0;
+        l = l.parent;
+      }
+      return !1;
+    }), v = J(() => {
+      const { childNodes: l } = s.value;
+      return (!l || l.length === 0 || l.every(({ visible: D }) => !D)) && !u.value;
+    });
+    U(
+      () => e.currentNodeKey,
+      (l) => {
+        o.value.setCurrentNodeKey(l ?? null);
+      }
+    ), U(
+      () => e.defaultCheckedKeys,
+      (l, D) => {
+        vt(l, D) || o.value.setDefaultCheckedKey(l ?? []);
+      }
+    ), U(
+      () => e.defaultExpandedKeys,
+      (l) => {
+        o.value.setDefaultExpandedKeys(l ?? []);
+      }
+    ), U(
+      () => e.data,
+      (l) => {
+        o.value.setData(l);
+      },
+      { deep: !0 }
+    ), U(
+      () => e.checkStrictly,
+      (l) => {
+        o.value.checkStrictly = l;
+      }
+    );
+    const g = (l) => {
+      if (!e.filterNodeMethod)
+        throw new Error("[Tree] filterNodeMethod is required when filter");
+      o.value.filter(l);
+    }, N = (l) => $e(e.nodeKey, l.data), C = (l) => {
+      if (!e.nodeKey)
+        throw new Error(`[Tree] nodeKey is required in ${l}`);
+    }, K = (l) => {
+      C("getNodePath");
+      const D = o.value.getNode(l);
+      if (!D)
+        return [];
+      const _ = [D.data];
+      let de = D.parent;
+      for (; de && de !== s.value; )
+        _.push(de.data), de = de.parent;
+      return _.reverse();
+    }, w = (l, D) => o.value.getCheckedNodes(l, D), y = (l) => o.value.getCheckedKeys(l), O = () => {
+      const l = o.value.getCurrentNode();
+      return l ? l.data : null;
+    }, j = () => {
+      C("getCurrentKey");
+      const l = O();
+      return l ? l[e.nodeKey] : null;
+    }, P = (l, D) => {
+      C("setCheckedNodes"), o.value.setCheckedNodes(l, D);
+    }, b = (l, D) => {
+      C("setCheckedKeys"), o.value.setCheckedKeys(l, D);
+    }, R = (l, D, _) => {
+      o.value.setChecked(l, D, _);
+    }, p = () => o.value.getHalfCheckedNodes(), x = () => o.value.getHalfCheckedKeys(), T = (l, D = !0) => {
+      C("setCurrentNode"), we(o, t.emit, () => {
+        h(l), o.value.setUserCurrentNode(l, D);
+      });
+    }, B = (l = null, D = !0) => {
+      C("setCurrentKey"), we(o, t.emit, () => {
+        h(), o.value.setCurrentNodeKey(l, D);
+      });
+    }, E = (l) => o.value.getNode(l), m = (l) => {
+      o.value.remove(l);
+    }, Z = (l, D) => {
+      o.value.append(l, D);
+    }, Q = (l, D) => {
+      o.value.insertBefore(l, D);
+    }, ce = (l, D) => {
+      o.value.insertAfter(l, D);
+    }, ge = (l, D, _) => {
+      h(D), t.emit("node-expand", l, D, _);
+    }, me = (l, D) => {
+      C("updateKeyChild"), o.value.updateChildren(l, D);
+    };
+    return ie(Te, {
+      ctx: t,
+      props: e,
+      store: o,
+      root: s,
+      currentNode: a,
+      instance: c
+    }), ie(yt, void 0), {
+      ns: d,
+      store: o,
+      root: s,
+      currentNode: a,
+      dragState: r,
+      el$: i,
+      dropIndicator$: f,
+      isEmpty: v,
+      filter: g,
+      getNodeKey: N,
+      getNodePath: K,
+      getCheckedNodes: w,
+      getCheckedKeys: y,
+      getCurrentNode: O,
+      getCurrentKey: j,
+      setCheckedNodes: P,
+      setCheckedKeys: b,
+      setChecked: R,
+      getHalfCheckedNodes: p,
+      getHalfCheckedKeys: x,
+      setCurrentNode: T,
+      setCurrentKey: B,
+      t: n,
+      getNode: E,
+      remove: m,
+      append: Z,
+      insertBefore: Q,
+      insertAfter: ce,
+      handleNodeExpand: ge,
+      updateKeyChildren: me
+    };
+  }
+});
+function Qt(e, t, n, d, o, s) {
+  const a = Y("el-tree-node");
+  return k(), L(
+    "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"
+    },
+    [
+      (k(!0), L(
+        ae,
+        null,
+        Xe(e.root.childNodes, (i) => (k(), M(a, {
+          key: e.getNodeKey(i),
+          node: i,
+          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 ? (k(), L(
+        "div",
+        {
+          key: 0,
+          class: F(e.ns.e("empty-block"))
+        },
+        [
+          Ie(e.$slots, "empty", {}, () => {
+            var i;
+            return [
+              A(
+                "span",
+                {
+                  class: F(e.ns.e("empty-text"))
+                },
+                De((i = e.emptyText) != null ? i : e.t("el.tree.emptyText")),
+                3
+              )
+            ];
+          })
+        ],
+        2
+      )) : H("v-if", !0),
+      re(A(
+        "div",
+        {
+          ref: "dropIndicator$",
+          class: F(e.ns.e("drop-indicator"))
+        },
+        null,
+        2
+      ), [
+        [xe, e.dragState.showDropIndicator]
+      ])
+    ],
+    2
+  );
+}
+var _t = /* @__PURE__ */ ye(Zt, [["render", Qt], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree.vue"]]);
+const en = Re(_t), tn = {}, nn = {
+  t: "1639132000791",
+  class: "icon",
+  viewBox: "0 0 1024 1024",
+  version: "1.1",
+  xmlns: "http://www.w3.org/2000/svg",
+  "p-id": "5015",
+  width: "64",
+  height: "64"
+};
+function on(e, t) {
+  return k(), L("svg", nn, [...t[0] || (t[0] = [
+    A("path", {
+      d: "M309.952512 148.95240533a50.331648 50.331648 0 0 1 61.16693332 4.390912L701.94517333 448.49561599a84.91281067 84.91281067 0 0 1 0 126.98692268L371.14129067 870.67852801a50.331648 50.331648 0 0 1-62.76164267 3.27679999c-16.318464-12.058624-19.68264533-34.95253333-7.51479467-51.11808l204.95291734-272.52053333a63.635456 63.635456 0 0 0 0-76.58973867l-204.95291734-272.52053333-1.13595733-1.572864a36.32878933 36.32878933 0 0 1 10.223616-50.659328z",
+      "p-id": "5016"
+    }, null, -1)
+  ])]);
+}
+const dn = /* @__PURE__ */ Se(tn, [["render", on]]), sn = ["title"], an = {
+  key: 2,
+  class: "layer-item-span"
+}, ln = { class: "layer-item-actions" }, rn = { class: "layer-manager-thumbail" }, cn = { class: "layer-item-actions" }, un = /* @__PURE__ */ oe({
+  __name: "layer-manager-item",
+  props: {
+    com: {},
+    level: {},
+    showText: { type: Boolean }
+  },
+  emits: ["dragGroup"],
+  setup(e, { emit: t }) {
+    const n = e, d = t, { showMenu: o } = Qe(), s = Ge(), a = $(!1), i = window.ikBasicsUrl, f = J(() => gt(n.com));
+    function h(w) {
+      n.com.renameing = w === 1;
+    }
+    function r(w) {
+      n.com.hovered = n.com.selected ? !1 : w === 1;
+    }
+    function c(w) {
+      n.com.hided = w === 1;
+    }
+    function u(w) {
+      n.com.locked = w === 1;
+    }
+    function v() {
+      s.delete(n.com);
+    }
+    function g() {
+      n.com.fold = !n.com.fold;
+    }
+    function N() {
+      n.com.type === V.layer && (a.value = !0, d("dragGroup", { key: "enter" }));
+    }
+    function C() {
+      n.com.type === V.layer && (a.value = !1, d("dragGroup", { key: "leave" }));
+    }
+    function K() {
+      n.com.type === V.layer && (a.value = !1, d("dragGroup", {
+        key: "drop",
+        level: n.level + 1,
+        com: n.com.children?.[0]
+      }));
+    }
+    return (w, y) => {
+      const O = qe, j = Y("g-com-icon"), P = Dt("focus");
+      return k(), L("div", {
+        title: e.com.alias,
+        class: F(["layer-manager-item", {
+          "layer-manager-com": e.com.type === q(V).com,
+          "layer-manager-group": e.com.type === q(V).layer,
+          "layer-manager-thumbail-wrap": !e.showText,
+          "--child-hovered": f.value.hovered || a.value,
+          "--child-selected": f.value.selected,
+          hided: e.com.hided,
+          locked: e.com.locked,
+          hovered: e.com.hovered
+        }]),
+        style: ee({
+          paddingLeft: `${6 + e.level * 10}px`
+        }),
+        draggable: "true",
+        onMouseenter: y[12] || (y[12] = (b) => r(1)),
+        onMouseleave: y[13] || (y[13] = (b) => r(0)),
+        onContextmenu: y[14] || (y[14] = (b) => q(o)(b, e.com))
+      }, [
+        e.com.type === q(V).layer ? (k(), L(ae, { key: 0 }, [
+          S(O, {
+            class: F(["fold-toggle-btn", { "icon-fold": e.com.fold }])
+          }, {
+            default: I(() => [
+              S(dn)
+            ]),
+            _: 1
+          }, 8, ["class"]),
+          S(O, { class: "layer-item-icon" }, {
+            default: I(() => [
+              S(St)
+            ]),
+            _: 1
+          })
+        ], 64)) : H("", !0),
+        e.showText ? (k(), L(ae, { key: 1 }, [
+          e.com.type === q(V).com ? (k(), M(j, {
+            key: 0,
+            icon: e.com.icon
+          }, null, 8, ["icon"])) : H("", !0),
+          e.com.renameing ? re((k(), L("input", {
+            key: 1,
+            "onUpdate:modelValue": y[0] || (y[0] = (b) => e.com.alias = b),
+            class: "layer-item-input",
+            onBlur: y[1] || (y[1] = (b) => h(0)),
+            onKeydown: y[2] || (y[2] = Be((b) => h(0), ["enter"]))
+          }, null, 544)), [
+            [
+              Oe,
+              e.com.alias,
+              void 0,
+              { trim: !0 }
+            ],
+            [P]
+          ]) : (k(), L("span", an, [
+            A("span", {
+              class: "layer-item-text",
+              onDblclick: y[3] || (y[3] = (b) => h(1))
+            }, De(e.com.alias), 33)
+          ])),
+          A("div", ln, [
+            S(O, {
+              class: "action-icon",
+              onClick: y[4] || (y[4] = z((b) => c(e.com.hided ? 0 : 1), ["stop"]))
+            }, {
+              default: I(() => [
+                e.com.hided ? (k(), M(ze, { key: 0 })) : (k(), M(Fe, { key: 1 }))
+              ]),
+              _: 1
+            }),
+            S(O, {
+              class: "action-icon",
+              onClick: y[5] || (y[5] = z((b) => u(e.com.locked ? 0 : 1), ["stop"]))
+            }, {
+              default: I(() => [
+                e.com.locked ? (k(), M(Me, { key: 0 })) : (k(), M(Pe, { key: 1 }))
+              ]),
+              _: 1
+            }),
+            S(O, {
+              class: "action-icon delete-icon",
+              onClick: z(v, ["stop"])
+            }, {
+              default: I(() => [
+                S(Kt)
+              ]),
+              _: 1
+            })
+          ])
+        ], 64)) : (k(), L(ae, { key: 2 }, [
+          e.com.type === q(V).com ? (k(), L("div", {
+            key: 0,
+            class: "layer-item-thumbail",
+            style: ee(`background-image: url(${q(i)}${e.com.img})`)
+          }, null, 4)) : H("", !0),
+          A("div", rn, [
+            e.com.renameing ? re((k(), L("input", {
+              key: 0,
+              "onUpdate:modelValue": y[6] || (y[6] = (b) => e.com.alias = b),
+              class: "layer-item-input",
+              onBlur: y[7] || (y[7] = (b) => h(0)),
+              onKeydown: y[8] || (y[8] = Be((b) => h(0), ["enter"]))
+            }, null, 544)), [
+              [
+                Oe,
+                e.com.alias,
+                void 0,
+                { trim: !0 }
+              ],
+              [P]
+            ]) : (k(), L("span", {
+              key: 1,
+              class: "layer-item-span",
+              onDragenter: N,
+              onDragleave: C,
+              onDrop: K
+            }, [
+              A("span", {
+                class: "layer-item-text",
+                onDblclick: y[9] || (y[9] = (b) => h(1))
+              }, De(e.com.alias), 33)
+            ], 32))
+          ]),
+          A("div", cn, [
+            S(O, {
+              class: "action-icon",
+              onClick: y[10] || (y[10] = z((b) => c(e.com.hided ? 0 : 1), ["stop"]))
+            }, {
+              default: I(() => [
+                e.com.hided ? (k(), M(ze, { key: 0 })) : (k(), M(Fe, { key: 1 }))
+              ]),
+              _: 1
+            }),
+            S(O, {
+              class: "action-icon",
+              onClick: y[11] || (y[11] = z((b) => u(e.com.locked ? 0 : 1), ["stop"]))
+            }, {
+              default: I(() => [
+                e.com.locked ? (k(), M(Me, { key: 0 })) : (k(), M(Pe, { key: 1 }))
+              ]),
+              _: 1
+            })
+          ])
+        ], 64)),
+        e.com.type === q(V).layer ? (k(), L("div", {
+          key: 3,
+          class: "group-fold-controller",
+          style: ee({
+            width: `${e.level > 0 ? 50 : 40}px`,
+            transform: `translateX(-${6 + e.level * 10}px)`
+          }),
+          onMouseup: z(g, ["stop"])
+        }, null, 36)) : H("", !0)
+      ], 46, sn);
+    };
+  }
+}), hn = /* @__PURE__ */ Se(un, [["__scopeId", "data-v-3e4dd165"]]), fn = { class: "layer-manager" }, pn = { class: "layer-manager-wrap" }, vn = { style: { display: "flex", "align-items": "center" } }, yn = { class: "dialog-footer" }, gn = { class: "dialog-footer" }, mn = /* @__PURE__ */ oe({
+  __name: "index",
+  setup(e) {
+    const t = wt(), n = mt(), d = Ge(), { showMenu: o } = Qe(), s = J(() => t.layer.show), a = $({
+      visible: !1,
+      x: 0,
+      y: 0,
+      toLevel: 0,
+      toIndex: 0,
+      toCom: null,
+      drop: !1
+    }), i = J(() => d.coms);
+    function f() {
+      d.select("");
+    }
+    function h(E, m, Z) {
+    }
+    function r(E, m, Z) {
+    }
+    function c(E) {
+      a.value.drop = E.key === "drop", E.key === "enter" && (a.value.visible = !0, a.value.y = E.y, a.value.x = E.level * 10, a.value.toLevel = E.level, a.value.toIndex = E.idx, a.value.toCom = E.com);
+    }
+    function u(E, m) {
+      d.select(m.id), o(E, m);
+    }
+    const v = $(/* @__PURE__ */ new Set()), g = J(() => Array.from(v.value));
+    function N(E) {
+      d.select(E.id);
+    }
+    function C(E) {
+      N(E);
+    }
+    function K(E) {
+      v.value.delete(E.id);
+    }
+    function w(E) {
+      v.value.add(E.id);
+    }
+    const y = $(""), O = $("");
+    U(
+      () => n.allPages[0]?.id,
+      (E) => {
+        y.value = E ?? "", O.value = E ?? "";
+      },
+      { immediate: !0 }
+    );
+    const j = $(!1), P = $("");
+    function b(E) {
+      if (E === 2) {
+        if (!P.value)
+          return At({
+            message: "新页面名称不能为空",
+            type: "warning"
+          });
+        n.addPages(P.value);
+      }
+      P.value = "", j.value = !1;
+    }
+    const R = $(!1), p = $({}), x = {
+      name: [{ required: !0, message: "请输入名称", trigger: "blur" }]
+    }, T = $();
+    function B() {
+      T.value?.validate((E) => {
+        E && (n.editNamePage(p.value), R.value = !1);
+      });
+    }
+    return (E, m) => {
+      const Z = kt, Q = Lt, ce = Tt, ge = Ct, me = Nt;
+      return k(), L("div", {
+        class: F(["g-aside layer-panel-wp", [{ "--hide": !s.value }]])
+      }, [
+        A("div", fn, [
+          m[8] || (m[8] = A("div", { class: "layer-manager-top" }, [
+            A("div", { class: "layer-num" }, " 图层 ")
+          ], -1)),
+          A("div", pn, [
+            S(q(en), {
+              "node-key": "id",
+              data: i.value,
+              "expand-on-click-node": !1,
+              "default-expanded-keys": g.value,
+              "empty-text": "暂无图层",
+              onNodeClick: C,
+              onNodeContextmenu: u,
+              onNodeDragOver: r,
+              onNodeDragEnter: h,
+              onNodeCollapse: K,
+              onNodeExpand: w
+            }, {
+              default: I(({ data: l }) => [
+                S(hn, {
+                  com: l,
+                  level: 1,
+                  "show-text": !0,
+                  onDragGroup: c
+                }, null, 8, ["com"])
+              ]),
+              _: 1
+            }, 8, ["data", "default-expanded-keys"]),
+            A("div", {
+              class: "last-flex-item",
+              onClick: f
+            }),
+            a.value.visible ? (k(), L("div", {
+              key: 0,
+              class: "layer-move-to-line",
+              style: ee({
+                width: `calc(100% - ${a.value.x}px)`,
+                transform: `translate(${a.value.x}px, ${a.value.y}px)`
+              })
+            }, null, 4)) : H("", !0),
+            m[7] || (m[7] = A("div", { class: "draging-wrap" }, null, -1))
+          ])
+        ]),
+        S(ce, {
+          modelValue: j.value,
+          "onUpdate:modelValue": m[3] || (m[3] = (l) => j.value = l),
+          title: "添加新页面",
+          width: "500",
+          "append-to": ".screen-editor-root"
+        }, {
+          footer: I(() => [
+            A("div", yn, [
+              S(Q, {
+                onClick: m[1] || (m[1] = (l) => b(1))
+              }, {
+                default: I(() => [...m[10] || (m[10] = [
+                  fe(" 取消 ", -1)
+                ])]),
+                _: 1
+              }),
+              S(Q, {
+                type: "primary",
+                onClick: m[2] || (m[2] = (l) => b(2))
+              }, {
+                default: I(() => [...m[11] || (m[11] = [
+                  fe(" 确定 ", -1)
+                ])]),
+                _: 1
+              })
+            ])
+          ]),
+          default: I(() => [
+            A("div", vn, [
+              m[9] || (m[9] = A("p", { style: { width: "58px" } }, " 名称 ", -1)),
+              S(Z, {
+                modelValue: P.value,
+                "onUpdate:modelValue": m[0] || (m[0] = (l) => P.value = l)
+              }, null, 8, ["modelValue"])
+            ])
+          ]),
+          _: 1
+        }, 8, ["modelValue"]),
+        S(ce, {
+          modelValue: R.value,
+          "onUpdate:modelValue": m[6] || (m[6] = (l) => R.value = l),
+          title: "修改页面名称",
+          width: "500px",
+          "append-to": ".screen-editor-root"
+        }, {
+          footer: I(() => [
+            A("div", gn, [
+              S(Q, {
+                onClick: m[5] || (m[5] = (l) => R.value = !1)
+              }, {
+                default: I(() => [...m[12] || (m[12] = [
+                  fe(" 取消 ", -1)
+                ])]),
+                _: 1
+              }),
+              S(Q, {
+                type: "primary",
+                onClick: B
+              }, {
+                default: I(() => [...m[13] || (m[13] = [
+                  fe(" 确定 ", -1)
+                ])]),
+                _: 1
+              })
+            ])
+          ]),
+          default: I(() => [
+            S(me, {
+              ref_key: "ruleFormRef",
+              ref: T,
+              model: p.value,
+              rules: x,
+              "label-width": "auto",
+              class: "demo-ruleForm",
+              "status-icon": ""
+            }, {
+              default: I(() => [
+                S(ge, {
+                  label: "名称",
+                  prop: "name"
+                }, {
+                  default: I(() => [
+                    S(Z, {
+                      modelValue: p.value.name,
+                      "onUpdate:modelValue": m[4] || (m[4] = (l) => p.value.name = l)
+                    }, null, 8, ["modelValue"])
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            }, 8, ["model"])
+          ]),
+          _: 1
+        }, 8, ["modelValue"])
+      ], 2);
+    };
+  }
+}), Bn = /* @__PURE__ */ Se(mn, [["__scopeId", "data-v-1a745476"]]);
+export {
+  Bn as default
+};