fec-dev-designer 1.0.0

package/es/node_modules/element-plus/es/components/tree/src/model/util.js

@@ -0,0 +1,19 @@
+const t = "$treeNodeId", c = function(n, e) {
+  !e || e[t] || Object.defineProperty(e, t, {
+    value: n.id,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  });
+}, l = (n, e) => e == null ? void 0 : e[n || t], a = (n, e, o) => {
+  const u = n.value.currentNode;
+  o();
+  const r = n.value.currentNode;
+  u !== r && e("current-change", r ? r.data : null, r);
+};
+export {
+  t as NODE_KEY,
+  l as getNodeKey,
+  a as handleCurrentChange,
+  c as markNodeData
+};

package/es/node_modules/element-plus/es/components/tree/src/tokens.js

@@ -0,0 +1,6 @@
+const E = "RootTree", N = "NodeInstance", _ = "TreeNodeMap";
+export {
+  N as NODE_INSTANCE_INJECTION_KEY,
+  E as ROOT_TREE_INJECTION_KEY,
+  _ as TREE_NODE_MAP_INJECTION_KEY
+};

package/es/node_modules/element-plus/es/components/tree/src/tree-node-content.js

@@ -0,0 +1,34 @@
+import { defineComponent as m, inject as o, h as r, renderSlot as l } from "vue";
+import { ElText as u } from "../../text/index.js";
+import { NODE_INSTANCE_INJECTION_KEY as p, ROOT_TREE_INJECTION_KEY as _ } from "./tokens.js";
+import f from "../../../_virtual/plugin-vue_export-helper.js";
+import { useNamespace as i } from "../../../hooks/use-namespace/index.js";
+const E = m({
+  name: "ElTreeNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    renderContent: Function
+  },
+  setup(t) {
+    const s = i("tree"), c = o(
+      p
+    ), a = o(_);
+    return () => {
+      const e = t.node, { data: n, store: d } = e;
+      return t.renderContent ? t.renderContent(r, { _self: c, node: e, data: n, store: d }) : l(a.ctx.slots, "default", { node: e, data: n }, () => [
+        r(
+          u,
+          { tag: "span", truncated: !0, class: s.be("node", "label") },
+          () => [e.label]
+        )
+      ]);
+    };
+  }
+});
+var b = /* @__PURE__ */ f(E, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree-node-content.vue"]]);
+export {
+  b as default
+};

package/es/node_modules/element-plus/es/components/tree/src/tree-node.js

@@ -0,0 +1,269 @@
+import { defineComponent as V, inject as R, ref as C, getCurrentInstance as j, provide as z, watch as k, nextTick as $, resolveComponent as u, withDirectives as B, openBlock as i, createElementBlock as D, normalizeClass as N, withModifiers as s, createElementVNode as H, normalizeStyle as J, createBlock as v, withCtx as K, resolveDynamicComponent as Y, createCommentVNode as E, createVNode as O, Fragment as W, renderList as q, vShow as A } from "vue";
+import { ElCollapseTransition as G } from "../../collapse-transition/index.js";
+import { ElCheckbox as Q } from "../../checkbox/index.js";
+import { ElIcon as U } from "../../icon/index.js";
+import { Loading as X, CaretRight as Z } from "../../../../../@element-plus/icons-vue/dist/index.js";
+import x from "./tree-node-content.js";
+import { getNodeKey as _, handleCurrentChange as ee } from "./model/util.js";
+import { useNodeExpandEventBroadcast as ne } from "./model/useNodeExpandEventBroadcast.js";
+import { dragEventsKey as oe } from "./model/useDragNode.js";
+import de from "./model/node.js";
+import { ROOT_TREE_INJECTION_KEY as ae, NODE_INSTANCE_INJECTION_KEY as te } from "./tokens.js";
+import re from "../../../_virtual/plugin-vue_export-helper.js";
+import { useNamespace as le } from "../../../hooks/use-namespace/index.js";
+import { debugWarn as ie } from "../../../utils/error.js";
+import { isFunction as se, isString as ce } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+const he = V({
+  name: "ElTreeNode",
+  components: {
+    ElCollapseTransition: G,
+    ElCheckbox: Q,
+    NodeContent: x,
+    ElIcon: U,
+    Loading: X
+  },
+  props: {
+    node: {
+      type: de,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: Boolean
+  },
+  emits: ["node-expand"],
+  setup(e, a) {
+    const w = le("tree"), { broadcastExpanded: S } = ne(e), o = R(ae), f = C(!1), h = C(!1), p = C(), m = C(), b = C(), g = R(oe), c = j();
+    z(te, c), o || ie("Tree", "Can not find node's tree."), e.node.expanded && (f.value = !0, h.value = !0);
+    const t = o.props.props.children || "children";
+    k(
+      () => {
+        var n;
+        const d = (n = e.node.data) == null ? void 0 : n[t];
+        return d && [...d];
+      },
+      () => {
+        e.node.updateChildren();
+      }
+    ), k(
+      () => e.node.indeterminate,
+      (n) => {
+        y(e.node.checked, n);
+      }
+    ), k(
+      () => e.node.checked,
+      (n) => {
+        y(n, e.node.indeterminate);
+      }
+    ), k(
+      () => e.node.childNodes.length,
+      () => e.node.reInitChecked()
+    ), k(
+      () => e.node.expanded,
+      (n) => {
+        $(() => f.value = n), n && (h.value = !0);
+      }
+    );
+    const I = (n) => _(o.props.nodeKey, n.data), F = (n) => {
+      const d = e.props.class;
+      if (!d)
+        return {};
+      let r;
+      if (se(d)) {
+        const { data: l } = n;
+        r = d(l, n);
+      } else
+        r = d;
+      return ce(r) ? { [r]: !0 } : r;
+    }, y = (n, d) => {
+      (p.value !== n || m.value !== d) && o.ctx.emit("check-change", e.node.data, n, d), p.value = n, m.value = d;
+    }, M = (n) => {
+      ee(o.store, o.ctx.emit, () => {
+        var d;
+        if ((d = o == null ? void 0 : o.props) == null ? void 0 : d.nodeKey) {
+          const l = I(e.node);
+          o.store.value.setCurrentNodeKey(l);
+        } else
+          o.store.value.setCurrentNode(e.node);
+      }), o.currentNode.value = e.node, o.props.expandOnClickNode && T(), (o.props.checkOnClickNode || e.node.isLeaf && o.props.checkOnClickLeaf && e.showCheckbox) && !e.node.disabled && L(!e.node.checked), o.ctx.emit("node-click", e.node.data, e.node, c, n);
+    }, P = (n) => {
+      var d;
+      (d = o.instance.vnode.props) != null && d.onNodeContextmenu && (n.stopPropagation(), n.preventDefault()), o.ctx.emit(
+        "node-contextmenu",
+        n,
+        e.node.data,
+        e.node,
+        c
+      );
+    }, T = () => {
+      e.node.isLeaf || (f.value ? (o.ctx.emit("node-collapse", e.node.data, e.node, c), e.node.collapse()) : e.node.expand(() => {
+        a.emit("node-expand", e.node.data, e.node, c);
+      }));
+    }, L = (n) => {
+      const d = o == null ? void 0 : o.props.checkStrictly, r = e.node.childNodes;
+      !d && r.length && (n = r.some((l) => !l.isEffectivelyChecked)), e.node.setChecked(n, !d), $(() => {
+        const l = o.store.value;
+        o.ctx.emit("check", e.node.data, {
+          checkedNodes: l.getCheckedNodes(),
+          checkedKeys: l.getCheckedKeys(),
+          halfCheckedNodes: l.getHalfCheckedNodes(),
+          halfCheckedKeys: l.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: w,
+      node$: b,
+      tree: o,
+      expanded: f,
+      childNodeRendered: h,
+      oldChecked: p,
+      oldIndeterminate: m,
+      getNodeKey: I,
+      getNodeClass: F,
+      handleSelectChange: y,
+      handleClick: M,
+      handleContextMenu: P,
+      handleExpandIconClick: T,
+      handleCheckChange: L,
+      handleChildNodeExpand: (n, d, r) => {
+        S(d), o.ctx.emit("node-expand", n, d, r);
+      },
+      handleDragStart: (n) => {
+        o.props.draggable && g.treeNodeDragStart({ event: n, treeNode: e });
+      },
+      handleDragOver: (n) => {
+        n.preventDefault(), o.props.draggable && g.treeNodeDragOver({
+          event: n,
+          treeNode: { $el: b.value, node: e.node }
+        });
+      },
+      handleDrop: (n) => {
+        n.preventDefault();
+      },
+      handleDragEnd: (n) => {
+        o.props.draggable && g.treeNodeDragEnd(n);
+      },
+      CaretRight: Z
+    };
+  }
+}), ue = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"], fe = ["aria-expanded"];
+function pe(e, a, w, S, o, f) {
+  const h = u("el-icon"), p = u("el-checkbox"), m = u("loading"), b = u("node-content"), g = u("el-tree-node"), c = u("el-collapse-transition");
+  return B((i(), D("div", {
+    ref: "node$",
+    class: N([
+      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: a[2] || (a[2] = s((...t) => e.handleClick && e.handleClick(...t), ["stop"])),
+    onContextmenu: a[3] || (a[3] = (...t) => e.handleContextMenu && e.handleContextMenu(...t)),
+    onDragstart: a[4] || (a[4] = s((...t) => e.handleDragStart && e.handleDragStart(...t), ["stop"])),
+    onDragover: a[5] || (a[5] = s((...t) => e.handleDragOver && e.handleDragOver(...t), ["stop"])),
+    onDragend: a[6] || (a[6] = s((...t) => e.handleDragEnd && e.handleDragEnd(...t), ["stop"])),
+    onDrop: a[7] || (a[7] = s((...t) => e.handleDrop && e.handleDrop(...t), ["stop"]))
+  }, [
+    H(
+      "div",
+      {
+        class: N(e.ns.be("node", "content")),
+        style: J({ paddingLeft: (e.node.level - 1) * e.tree.props.indent + "px" })
+      },
+      [
+        e.tree.props.icon || e.CaretRight ? (i(), v(h, {
+          key: 0,
+          class: N([
+            e.ns.be("node", "expand-icon"),
+            e.ns.is("leaf", e.node.isLeaf),
+            {
+              expanded: !e.node.isLeaf && e.expanded
+            }
+          ]),
+          onClick: s(e.handleExpandIconClick, ["stop"])
+        }, {
+          default: K(() => [
+            (i(), v(Y(e.tree.props.icon || e.CaretRight)))
+          ]),
+          _: 1
+        }, 8, ["class", "onClick"])) : E("v-if", !0),
+        e.showCheckbox ? (i(), v(p, {
+          key: 1,
+          "model-value": e.node.checked,
+          indeterminate: e.node.indeterminate,
+          disabled: !!e.node.disabled,
+          onClick: a[0] || (a[0] = s(() => {
+          }, ["stop"])),
+          onChange: e.handleCheckChange
+        }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : E("v-if", !0),
+        e.node.loading ? (i(), v(h, {
+          key: 2,
+          class: N([e.ns.be("node", "loading-icon"), e.ns.is("loading")])
+        }, {
+          default: K(() => [
+            O(m)
+          ]),
+          _: 1
+        }, 8, ["class"])) : E("v-if", !0),
+        O(b, {
+          node: e.node,
+          "render-content": e.renderContent
+        }, null, 8, ["node", "render-content"])
+      ],
+      6
+    ),
+    O(c, null, {
+      default: K(() => [
+        !e.renderAfterExpand || e.childNodeRendered ? B((i(), D("div", {
+          key: 0,
+          class: N(e.ns.be("node", "children")),
+          role: "group",
+          "aria-expanded": e.expanded,
+          onClick: a[1] || (a[1] = s(() => {
+          }, ["stop"]))
+        }, [
+          (i(!0), D(
+            W,
+            null,
+            q(e.node.childNodes, (t) => (i(), v(g, {
+              key: e.getNodeKey(t),
+              "render-content": e.renderContent,
+              "render-after-expand": e.renderAfterExpand,
+              "show-checkbox": e.showCheckbox,
+              node: t,
+              accordion: e.accordion,
+              props: e.props,
+              onNodeExpand: e.handleChildNodeExpand
+            }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]))),
+            128
+          ))
+        ], 10, fe)), [
+          [A, e.expanded]
+        ]) : E("v-if", !0)
+      ]),
+      _: 1
+    })
+  ], 42, ue)), [
+    [A, e.node.visible]
+  ]);
+}
+var Ae = /* @__PURE__ */ re(he, [["render", pe], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree-node.vue"]]);
+export {
+  Ae as default
+};

package/es/node_modules/element-plus/es/components/tree/src/tree.js

@@ -0,0 +1,95 @@
+import { buildProps as r, definePropType as a } from "../../../utils/vue/props/runtime.js";
+import { iconPropType as l } from "../../../utils/vue/icon.js";
+import { isBoolean as d } from "../../../utils/types.js";
+const y = r({
+  data: {
+    type: a(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: a(Function)
+  },
+  showCheckbox: Boolean,
+  draggable: Boolean,
+  allowDrag: {
+    type: a(Function)
+  },
+  allowDrop: {
+    type: a(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: l
+  }
+}), u = {
+  "check-change": (e, n, o) => e && d(n) && d(o),
+  "current-change": (e, n) => !0,
+  "node-click": (e, n, o, t) => e && n && t instanceof Event,
+  "node-contextmenu": (e, n, o, t) => e instanceof Event && n && o,
+  "node-collapse": (e, n, o) => e && n,
+  "node-expand": (e, n, o) => e && n,
+  check: (e, n) => e && n,
+  "node-drag-start": (e, n) => e && n,
+  "node-drag-end": (e, n, o, t) => e && t,
+  "node-drop": (e, n, o, t) => e && n && t,
+  "node-drag-leave": (e, n, o) => e && n && o,
+  "node-drag-enter": (e, n, o) => e && n && o,
+  "node-drag-over": (e, n, o) => e && n && o
+};
+export {
+  u as treeEmits,
+  y as treeProps
+};

package/es/node_modules/element-plus/es/components/tree/src/tree2.js

@@ -0,0 +1,250 @@
+import { defineComponent as X, ref as c, getCurrentInstance as Z, computed as k, watch as i, provide as E, resolveComponent as x, openBlock as m, createElementBlock as N, normalizeClass as f, Fragment as V, renderList as _, createBlock as ee, renderSlot as te, createElementVNode as w, toDisplayString as re, createCommentVNode as ne, withDirectives as oe, vShow as de } from "vue";
+import ae from "./model/tree-store.js";
+import { getNodeKey as le, handleCurrentChange as S } from "./model/util.js";
+import se from "./tree-node.js";
+import { useNodeExpandEventBroadcast as ue } from "./model/useNodeExpandEventBroadcast.js";
+import { useDragNodeHandler as ce } from "./model/useDragNode.js";
+import { useKeydown as ie } from "./model/useKeydown.js";
+import { ROOT_TREE_INJECTION_KEY as he } from "./tokens.js";
+import { treeProps as me, treeEmits as fe } from "./tree.js";
+import ye from "../../../_virtual/plugin-vue_export-helper.js";
+import { useLocale as pe } from "../../../hooks/use-locale/index.js";
+import { useNamespace as Ne } from "../../../hooks/use-namespace/index.js";
+import { formItemContextKey as ve } from "../../form/src/constants.js";
+import Ce from "../../../../../lodash-es/isEqual.js";
+const ge = X({
+  name: "ElTree",
+  components: { ElTreeNode: se },
+  props: me,
+  emits: fe,
+  setup(t, a) {
+    const { t: v } = pe(), C = Ne("tree"), r = c(
+      new ae({
+        key: t.nodeKey,
+        data: t.data,
+        lazy: t.lazy,
+        props: t.props,
+        load: t.load,
+        currentNodeKey: t.currentNodeKey,
+        checkStrictly: t.checkStrictly,
+        checkDescendants: t.checkDescendants,
+        defaultCheckedKeys: t.defaultCheckedKeys,
+        defaultExpandedKeys: t.defaultExpandedKeys,
+        autoExpandParent: t.autoExpandParent,
+        defaultExpandAll: t.defaultExpandAll,
+        filterNodeMethod: t.filterNodeMethod
+      })
+    );
+    r.value.initialize();
+    const s = c(r.value.root), h = c(null), o = c(null), g = c(null), { broadcastExpanded: y } = ue(t), { dragState: T } = ce({
+      props: t,
+      ctx: a,
+      el$: o,
+      dropIndicator$: g,
+      store: r
+    });
+    ie({ el$: o }, r);
+    const p = Z(), $ = k(() => {
+      let e = p == null ? void 0 : p.parent;
+      for (; e; ) {
+        if (e.type.name === "ElTreeSelect")
+          return !0;
+        e = e.parent;
+      }
+      return !1;
+    }), D = k(() => {
+      const { childNodes: e } = s.value;
+      return (!e || e.length === 0 || e.every(({ visible: n }) => !n)) && !$.value;
+    });
+    i(
+      () => t.currentNodeKey,
+      (e) => {
+        r.value.setCurrentNodeKey(e ?? null);
+      }
+    ), i(
+      () => t.defaultCheckedKeys,
+      (e, n) => {
+        Ce(e, n) || r.value.setDefaultCheckedKey(e ?? []);
+      }
+    ), i(
+      () => t.defaultExpandedKeys,
+      (e) => {
+        r.value.setDefaultExpandedKeys(e ?? []);
+      }
+    ), i(
+      () => t.data,
+      (e) => {
+        r.value.setData(e);
+      },
+      { deep: !0 }
+    ), i(
+      () => t.checkStrictly,
+      (e) => {
+        r.value.checkStrictly = e;
+      }
+    );
+    const I = (e) => {
+      if (!t.filterNodeMethod)
+        throw new Error("[Tree] filterNodeMethod is required when filter");
+      r.value.filter(e);
+    }, b = (e) => le(t.nodeKey, e.data), d = (e) => {
+      if (!t.nodeKey)
+        throw new Error(`[Tree] nodeKey is required in ${e}`);
+    }, B = (e) => {
+      d("getNodePath");
+      const n = r.value.getNode(e);
+      if (!n)
+        return [];
+      const l = [n.data];
+      let u = n.parent;
+      for (; u && u !== s.value; )
+        l.push(u.data), u = u.parent;
+      return l.reverse();
+    }, A = (e, n) => r.value.getCheckedNodes(e, n), H = (e) => r.value.getCheckedKeys(e), K = () => {
+      const e = r.value.getCurrentNode();
+      return e ? e.data : null;
+    }, P = () => {
+      d("getCurrentKey");
+      const e = K();
+      return e ? e[t.nodeKey] : null;
+    }, q = (e, n) => {
+      d("setCheckedNodes"), r.value.setCheckedNodes(e, n);
+    }, z = (e, n) => {
+      d("setCheckedKeys"), r.value.setCheckedKeys(e, n);
+    }, M = (e, n, l) => {
+      r.value.setChecked(e, n, l);
+    }, O = () => r.value.getHalfCheckedNodes(), L = () => r.value.getHalfCheckedKeys(), R = (e, n = !0) => {
+      d("setCurrentNode"), S(r, a.emit, () => {
+        y(e), r.value.setUserCurrentNode(e, n);
+      });
+    }, F = (e = null, n = !0) => {
+      d("setCurrentKey"), S(r, a.emit, () => {
+        y(), r.value.setCurrentNodeKey(e, n);
+      });
+    }, J = (e) => r.value.getNode(e), U = (e) => {
+      r.value.remove(e);
+    }, Y = (e, n) => {
+      r.value.append(e, n);
+    }, j = (e, n) => {
+      r.value.insertBefore(e, n);
+    }, G = (e, n) => {
+      r.value.insertAfter(e, n);
+    }, Q = (e, n, l) => {
+      y(n), a.emit("node-expand", e, n, l);
+    }, W = (e, n) => {
+      d("updateKeyChild"), r.value.updateChildren(e, n);
+    };
+    return E(he, {
+      ctx: a,
+      props: t,
+      store: r,
+      root: s,
+      currentNode: h,
+      instance: p
+    }), E(ve, void 0), {
+      ns: C,
+      store: r,
+      root: s,
+      currentNode: h,
+      dragState: T,
+      el$: o,
+      dropIndicator$: g,
+      isEmpty: D,
+      filter: I,
+      getNodeKey: b,
+      getNodePath: B,
+      getCheckedNodes: A,
+      getCheckedKeys: H,
+      getCurrentNode: K,
+      getCurrentKey: P,
+      setCheckedNodes: q,
+      setCheckedKeys: z,
+      setChecked: M,
+      getHalfCheckedNodes: O,
+      getHalfCheckedKeys: L,
+      setCurrentNode: R,
+      setCurrentKey: F,
+      t: v,
+      getNode: J,
+      remove: U,
+      append: Y,
+      insertBefore: j,
+      insertAfter: G,
+      handleNodeExpand: Q,
+      updateKeyChildren: W
+    };
+  }
+});
+function Ke(t, a, v, C, r, s) {
+  const h = x("el-tree-node");
+  return m(), N(
+    "div",
+    {
+      ref: "el$",
+      class: f([
+        t.ns.b(),
+        t.ns.is("dragging", !!t.dragState.draggingNode),
+        t.ns.is("drop-not-allow", !t.dragState.allowDrop),
+        t.ns.is("drop-inner", t.dragState.dropType === "inner"),
+        { [t.ns.m("highlight-current")]: t.highlightCurrent }
+      ]),
+      role: "tree"
+    },
+    [
+      (m(!0), N(
+        V,
+        null,
+        _(t.root.childNodes, (o) => (m(), ee(h, {
+          key: t.getNodeKey(o),
+          node: o,
+          props: t.props,
+          accordion: t.accordion,
+          "render-after-expand": t.renderAfterExpand,
+          "show-checkbox": t.showCheckbox,
+          "render-content": t.renderContent,
+          onNodeExpand: t.handleNodeExpand
+        }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]))),
+        128
+      )),
+      t.isEmpty ? (m(), N(
+        "div",
+        {
+          key: 0,
+          class: f(t.ns.e("empty-block"))
+        },
+        [
+          te(t.$slots, "empty", {}, () => {
+            var o;
+            return [
+              w(
+                "span",
+                {
+                  class: f(t.ns.e("empty-text"))
+                },
+                re((o = t.emptyText) != null ? o : t.t("el.tree.emptyText")),
+                3
+              )
+            ];
+          })
+        ],
+        2
+      )) : ne("v-if", !0),
+      oe(w(
+        "div",
+        {
+          ref: "dropIndicator$",
+          class: f(t.ns.e("drop-indicator"))
+        },
+        null,
+        2
+      ), [
+        [de, t.dragState.showDropIndicator]
+      ])
+    ],
+    2
+  );
+}
+var ze = /* @__PURE__ */ ye(ge, [["render", Ke], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree.vue"]]);
+export {
+  ze as default
+};

package/es/node_modules/element-plus/es/components/virtual-list/src/defaults.js

@@ -0,0 +1,4 @@
+const o = "horizontal";
+export {
+  o as HORIZONTAL
+};