ep-craft 0.1.8 → 0.1.9

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

@@ -0,0 +1,110 @@
+import D from "../../../_virtual/_plugin-vue_export-helper.js";
+import y from "./tree-node.vue_vue_type_script_lang.js";
+import { resolveComponent as a, withDirectives as h, openBlock as d, createElementBlock as p, withModifiers as r, normalizeClass as l, createElementVNode as N, normalizeStyle as E, createBlock as i, withCtx as t, resolveDynamicComponent as w, createCommentVNode as s, createVNode as u, Fragment as $, renderList as L, vShow as k } from "vue";
+const S = [
+  "aria-expanded",
+  "aria-disabled",
+  "aria-checked",
+  "draggable",
+  "data-key"
+], B = ["aria-expanded"];
+function M(e, n, R, V, z, A) {
+  const g = a("el-icon"), m = a("el-checkbox"), C = a("loading"), f = a("node-content"), b = a("el-tree-node"), v = a("el-collapse-transition");
+  return h((d(), p("div", {
+    ref: "node$",
+    class: l([
+      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: n[2] || (n[2] = r((...o) => e.handleClick && e.handleClick(...o), ["stop"])),
+    onContextmenu: n[3] || (n[3] = (...o) => e.handleContextMenu && e.handleContextMenu(...o)),
+    onDragstart: n[4] || (n[4] = r((...o) => e.handleDragStart && e.handleDragStart(...o), ["stop"])),
+    onDragover: n[5] || (n[5] = r((...o) => e.handleDragOver && e.handleDragOver(...o), ["stop"])),
+    onDragend: n[6] || (n[6] = r((...o) => e.handleDragEnd && e.handleDragEnd(...o), ["stop"])),
+    onDrop: n[7] || (n[7] = r((...o) => e.handleDrop && e.handleDrop(...o), ["stop"]))
+  }, [N("div", {
+    class: l(e.ns.be("node", "content")),
+    style: E({ paddingLeft: (e.node.level - 1) * e.tree.props.indent + "px" })
+  }, [
+    e.tree.props.icon || e.CaretRight ? (d(), i(g, {
+      key: 0,
+      class: l([
+        e.ns.be("node", "expand-icon"),
+        e.ns.is("leaf", e.node.isLeaf),
+        { expanded: !e.node.isLeaf && e.expanded }
+      ]),
+      onClick: r(e.handleExpandIconClick, ["stop"])
+    }, {
+      default: t(() => [(d(), i(w(e.tree.props.icon || e.CaretRight)))]),
+      _: 1
+    }, 8, ["class", "onClick"])) : s("v-if", !0),
+    e.showCheckbox ? (d(), i(m, {
+      key: 1,
+      "model-value": e.node.checked,
+      indeterminate: e.node.indeterminate,
+      disabled: !!e.node.disabled,
+      onClick: n[0] || (n[0] = r(() => {
+      }, ["stop"])),
+      onChange: e.handleCheckChange
+    }, null, 8, [
+      "model-value",
+      "indeterminate",
+      "disabled",
+      "onChange"
+    ])) : s("v-if", !0),
+    e.node.loading ? (d(), i(g, {
+      key: 2,
+      class: l([e.ns.be("node", "loading-icon"), e.ns.is("loading")])
+    }, {
+      default: t(() => [u(C)]),
+      _: 1
+    }, 8, ["class"])) : s("v-if", !0),
+    u(f, {
+      node: e.node,
+      "render-content": e.renderContent
+    }, null, 8, ["node", "render-content"])
+  ], 6), u(v, null, {
+    default: t(() => [!e.renderAfterExpand || e.childNodeRendered ? h((d(), p("div", {
+      key: 0,
+      class: l(e.ns.be("node", "children")),
+      role: "group",
+      "aria-expanded": e.expanded,
+      onClick: n[1] || (n[1] = r(() => {
+      }, ["stop"]))
+    }, [(d(!0), p($, null, L(e.node.childNodes, (o) => (d(), i(b, {
+      key: e.getNodeKey(o),
+      "render-content": e.renderContent,
+      "render-after-expand": e.renderAfterExpand,
+      "show-checkbox": e.showCheckbox,
+      node: o,
+      accordion: e.accordion,
+      props: e.props,
+      onNodeExpand: e.handleChildNodeExpand
+    }, null, 8, [
+      "render-content",
+      "render-after-expand",
+      "show-checkbox",
+      "node",
+      "accordion",
+      "props",
+      "onNodeExpand"
+    ]))), 128))], 10, B)), [[k, e.expanded]]) : s("v-if", !0)]),
+    _: 1
+  })], 42, S)), [[k, e.node.visible]]);
+}
+var I = /* @__PURE__ */ D(y, [["render", M]]);
+export {
+  I as default
+};

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

@@ -0,0 +1,139 @@
+import { isFunction as b, isString as I } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { debugWarn as T } from "../../../utils/error.js";
+import { useNamespace as S } from "../../../hooks/use-namespace/index.js";
+import { ElIcon as L } from "../../icon/index.js";
+import { ElCheckbox as R } from "../../checkbox/index.js";
+import { ElCollapseTransition as B } from "../../collapse-transition/index.js";
+import { handleCurrentChange as w, getNodeKey as F } from "./model/util.js";
+import $ from "./model/node.js";
+import { ROOT_TREE_INJECTION_KEY as j, NODE_INSTANCE_INJECTION_KEY as A } from "./tokens.js";
+import H from "./tree-node-content.js";
+import { useNodeExpandEventBroadcast as J } from "./model/useNodeExpandEventBroadcast.js";
+import { dragEventsKey as Y } from "./model/useDragNode.js";
+import { Loading as M, CaretRight as P } from "../../../../../@element-plus/icons-vue/dist/index.js";
+import { defineComponent as W, inject as x, ref as r, getCurrentInstance as q, provide as z, watch as l, nextTick as E } from "vue";
+var ue = W({
+  name: "ElTreeNode",
+  components: {
+    ElCollapseTransition: B,
+    ElCheckbox: R,
+    NodeContent: H,
+    ElIcon: L,
+    Loading: M
+  },
+  props: {
+    node: {
+      type: $,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: Boolean
+  },
+  emits: ["node-expand"],
+  setup(n, v) {
+    const y = S("tree"), { broadcastExpanded: _ } = J(n), t = x(j), i = r(!1), s = r(!1), h = r(), f = r(), C = r(), u = x(Y), c = q();
+    z(A, c), t || T("Tree", "Can not find node's tree."), n.node.expanded && (i.value = !0, s.value = !0);
+    const K = t.props.props.children || "children";
+    l(() => {
+      var d;
+      const e = (d = n.node.data) == null ? void 0 : d[K];
+      return e && [...e];
+    }, () => {
+      n.node.updateChildren();
+    }), l(() => n.node.indeterminate, (e) => {
+      m(n.node.checked, e);
+    }), l(() => n.node.checked, (e) => {
+      m(e, n.node.indeterminate);
+    }), l(() => n.node.childNodes.length, () => n.node.reInitChecked()), l(() => n.node.expanded, (e) => {
+      E(() => i.value = e), e && (s.value = !0);
+    });
+    const g = (e) => t.props.nodeKey ? F(t.props.nodeKey, e.data) : e.id, D = (e) => {
+      const d = n.props.class;
+      if (!d) return {};
+      let o;
+      if (b(d)) {
+        const { data: a } = e;
+        o = d(a, e);
+      } else o = d;
+      return I(o) ? { [o]: !0 } : o;
+    }, m = (e, d) => {
+      (h.value !== e || f.value !== d) && t.ctx.emit("check-change", n.node.data, e, d), h.value = e, f.value = d;
+    }, O = (e) => {
+      w(t.store, t.ctx.emit, () => {
+        var d;
+        if ((d = t == null ? void 0 : t.props) != null && d.nodeKey) {
+          const o = g(n.node);
+          t.store.value.setCurrentNodeKey(o);
+        } else t.store.value.setCurrentNode(n.node);
+      }), t.currentNode.value = n.node, t.props.expandOnClickNode && N(), (t.props.checkOnClickNode || n.node.isLeaf && t.props.checkOnClickLeaf && n.showCheckbox) && !n.node.disabled && k(!n.node.checked), t.ctx.emit("node-click", n.node.data, n.node, c, e);
+    }, p = (e) => {
+      var d;
+      (d = t.instance.vnode.props) != null && d.onNodeContextmenu && (e.stopPropagation(), e.preventDefault()), t.ctx.emit("node-contextmenu", e, n.node.data, n.node, c);
+    }, N = () => {
+      n.node.isLeaf || (i.value ? (t.ctx.emit("node-collapse", n.node.data, n.node, c), n.node.collapse()) : n.node.expand(() => {
+        v.emit("node-expand", n.node.data, n.node, c);
+      }));
+    }, k = (e) => {
+      const d = t == null ? void 0 : t.props.checkStrictly, o = n.node.childNodes;
+      !d && o.length && (e = o.some((a) => !a.isEffectivelyChecked)), n.node.setChecked(e, !d), E(() => {
+        const a = t.store.value;
+        t.ctx.emit("check", n.node.data, {
+          checkedNodes: a.getCheckedNodes(),
+          checkedKeys: a.getCheckedKeys(),
+          halfCheckedNodes: a.getHalfCheckedNodes(),
+          halfCheckedKeys: a.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: y,
+      node$: C,
+      tree: t,
+      expanded: i,
+      childNodeRendered: s,
+      oldChecked: h,
+      oldIndeterminate: f,
+      getNodeKey: g,
+      getNodeClass: D,
+      handleSelectChange: m,
+      handleClick: O,
+      handleContextMenu: p,
+      handleExpandIconClick: N,
+      handleCheckChange: k,
+      handleChildNodeExpand: (e, d, o) => {
+        _(d), t.ctx.emit("node-expand", e, d, o);
+      },
+      handleDragStart: (e) => {
+        t.props.draggable && u.treeNodeDragStart({
+          event: e,
+          treeNode: n
+        });
+      },
+      handleDragOver: (e) => {
+        e.preventDefault(), t.props.draggable && u.treeNodeDragOver({
+          event: e,
+          treeNode: {
+            $el: C.value,
+            node: n.node
+          }
+        });
+      },
+      handleDrop: (e) => {
+        e.preventDefault();
+      },
+      handleDragEnd: (e) => {
+        t.props.draggable && u.treeNodeDragEnd(e);
+      },
+      CaretRight: P
+    };
+  }
+});
+export {
+  ue as default
+};

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

@@ -0,0 +1,75 @@
+import { isBoolean as d } from "../../../utils/types.js";
+import { buildProps as r, definePropType as a } from "../../../utils/vue/props/runtime.js";
+import { iconPropType as l } from "../../../utils/vue/icon.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/dist/node_modules/element-plus/es/components/tree/src/tree.vue_vue_type_script_lang.js

@@ -0,0 +1,157 @@
+import { useLocale as Y } from "../../../hooks/use-locale/index.js";
+import { useNamespace as j } from "../../../hooks/use-namespace/index.js";
+import { formItemContextKey as F } from "../../form/src/constants.js";
+import { handleCurrentChange as C, getNodeKey as G } from "./model/util.js";
+import Q from "./model/tree-store.js";
+import { ROOT_TREE_INJECTION_KEY as W } from "./tokens.js";
+import { useNodeExpandEventBroadcast as X } from "./model/useNodeExpandEventBroadcast.js";
+import { useDragNodeHandler as Z } from "./model/useDragNode.js";
+import V from "./tree-node.js";
+import { useKeydown as ee } from "./model/useKeydown.js";
+import { treeEmits as te, treeProps as re } from "./tree.js";
+import { defineComponent as ne, ref as l, getCurrentInstance as de, computed as K, watch as s, provide as v } from "vue";
+import oe from "../../../../../lodash-es/isEqual.js";
+var ve = ne({
+  name: "ElTree",
+  components: { ElTreeNode: V },
+  props: re,
+  emits: te,
+  setup(n, a) {
+    const { t: k } = Y(), g = j("tree"), t = l(new Q({
+      key: n.nodeKey,
+      data: n.data,
+      lazy: n.lazy,
+      props: n.props,
+      load: n.load,
+      currentNodeKey: n.currentNodeKey,
+      checkStrictly: n.checkStrictly,
+      checkDescendants: n.checkDescendants,
+      defaultCheckedKeys: n.defaultCheckedKeys,
+      defaultExpandedKeys: n.defaultExpandedKeys,
+      autoExpandParent: n.autoExpandParent,
+      defaultExpandAll: n.defaultExpandAll,
+      filterNodeMethod: n.filterNodeMethod
+    }));
+    t.value.initialize();
+    const c = l(t.value.root), h = l(null), f = l(null), m = l(null), { broadcastExpanded: y } = X(n), { dragState: E } = Z({
+      props: n,
+      ctx: a,
+      el$: f,
+      dropIndicator$: m,
+      store: t
+    });
+    ee({ el$: f }, t);
+    const i = de(), _ = K(() => {
+      let e = i == null ? void 0 : i.parent;
+      for (; e; ) {
+        if (e.type.name === "ElTreeSelect") return !0;
+        e = e.parent;
+      }
+      return !1;
+    }), p = K(() => {
+      const { childNodes: e } = c.value;
+      return (!e || e.length === 0 || e.every(({ visible: r }) => !r)) && !_.value;
+    });
+    s(() => n.currentNodeKey, (e) => {
+      t.value.setCurrentNodeKey(e ?? null);
+    }), s(() => n.defaultCheckedKeys, (e, r) => {
+      oe(e, r) || t.value.setDefaultCheckedKey(e ?? []);
+    }), s(() => n.defaultExpandedKeys, (e) => {
+      t.value.setDefaultExpandedKeys(e ?? []);
+    }), s(() => n.data, (e) => {
+      t.value.setData(e);
+    }, { deep: !0 }), s(() => n.checkStrictly, (e) => {
+      t.value.checkStrictly = e;
+    });
+    const x = (e) => {
+      if (!n.filterNodeMethod) throw new Error("[Tree] filterNodeMethod is required when filter");
+      t.value.filter(e);
+    }, T = (e) => n.nodeKey ? G(n.nodeKey, e.data) : e.id, d = (e) => {
+      if (!n.nodeKey) throw new Error(`[Tree] nodeKey is required in ${e}`);
+    }, w = (e) => {
+      d("getNodePath");
+      const r = t.value.getNode(e);
+      if (!r) return [];
+      const o = [r.data];
+      let u = r.parent;
+      for (; u && u !== c.value; )
+        o.push(u.data), u = u.parent;
+      return o.reverse();
+    }, S = (e, r) => t.value.getCheckedNodes(e, r), D = (e) => t.value.getCheckedKeys(e), N = () => {
+      const e = t.value.getCurrentNode();
+      return e ? e.data : null;
+    }, H = () => {
+      d("getCurrentKey");
+      const e = N();
+      return e ? e[n.nodeKey] : null;
+    }, I = (e, r) => {
+      d("setCheckedNodes"), t.value.setCheckedNodes(e, r);
+    }, P = (e, r) => {
+      d("setCheckedKeys"), t.value.setCheckedKeys(e, r);
+    }, q = (e, r, o = !1) => {
+      t.value.setChecked(e, r, o);
+    }, A = () => t.value.getHalfCheckedNodes(), M = () => t.value.getHalfCheckedKeys(), $ = (e, r = !0) => {
+      d("setCurrentNode"), C(t, a.emit, () => {
+        y(e), t.value.setUserCurrentNode(e, r);
+      });
+    }, z = (e = null, r = !0) => {
+      d("setCurrentKey"), C(t, a.emit, () => {
+        y(), t.value.setCurrentNodeKey(e, r);
+      });
+    }, B = (e) => t.value.getNode(e), O = (e) => {
+      t.value.remove(e);
+    }, R = (e, r) => {
+      t.value.append(e, r);
+    }, b = (e, r) => {
+      t.value.insertBefore(e, r);
+    }, J = (e, r) => {
+      t.value.insertAfter(e, r);
+    }, L = (e, r, o) => {
+      y(r), a.emit("node-expand", e, r, o);
+    }, U = (e, r) => {
+      d("updateKeyChildren"), t.value.updateChildren(e, r);
+    };
+    return v(W, {
+      ctx: a,
+      props: n,
+      store: t,
+      root: c,
+      currentNode: h,
+      instance: i
+    }), v(F, void 0), {
+      ns: g,
+      store: t,
+      root: c,
+      currentNode: h,
+      dragState: E,
+      el$: f,
+      dropIndicator$: m,
+      isEmpty: p,
+      filter: x,
+      getNodeKey: T,
+      getNodePath: w,
+      getCheckedNodes: S,
+      getCheckedKeys: D,
+      getCurrentNode: N,
+      getCurrentKey: H,
+      setCheckedNodes: I,
+      setCheckedKeys: P,
+      setChecked: q,
+      getHalfCheckedNodes: A,
+      getHalfCheckedKeys: M,
+      setCurrentNode: $,
+      setCurrentKey: z,
+      t: k,
+      getNode: B,
+      remove: O,
+      append: R,
+      insertBefore: b,
+      insertAfter: J,
+      handleNodeExpand: L,
+      updateKeyChildren: U
+    };
+  }
+});
+export {
+  ve as default
+};

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

@@ -0,0 +1,48 @@
+import p from "../../../_virtual/_plugin-vue_export-helper.js";
+import s from "./tree.vue_vue_type_script_lang.js";
+import { resolveComponent as l, openBlock as r, createElementBlock as n, normalizeClass as o, Fragment as i, renderList as m, createBlock as g, renderSlot as u, createElementVNode as d, toDisplayString as h, createCommentVNode as f, withDirectives as c, vShow as y } from "vue";
+function v(e, k, w, N, E, S) {
+  const a = l("el-tree-node");
+  return r(), n("div", {
+    ref: "el$",
+    class: o([
+      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"
+  }, [
+    (r(!0), n(i, null, m(e.root.childNodes, (t) => (r(), g(a, {
+      key: e.getNodeKey(t),
+      node: t,
+      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 ? (r(), n("div", {
+      key: 0,
+      class: o(e.ns.e("empty-block"))
+    }, [u(e.$slots, "empty", {}, () => [d("span", { class: o(e.ns.e("empty-text")) }, h(e.emptyText ?? e.t("el.tree.emptyText")), 3)])], 2)) : f("v-if", !0),
+    c(d("div", {
+      ref: "dropIndicator$",
+      class: o(e.ns.e("drop-indicator"))
+    }, null, 2), [[y, e.dragState.showDropIndicator]])
+  ], 2);
+}
+var D = /* @__PURE__ */ p(s, [["render", v]]);
+export {
+  D as default
+};

package/dist/node_modules/element-plus/es/components/tree-select/index.js

@@ -0,0 +1,7 @@
+import { withInstall as e } from "../../utils/vue/install.js";
+import t from "./src/tree-select.js";
+const o = e(t);
+export {
+  o as ElTreeSelect,
+  o as default
+};

package/dist/node_modules/element-plus/es/components/tree-select/src/cache-options.js

@@ -0,0 +1,27 @@
+import { selectKey as c } from "../../select/src/token.js";
+import { defineComponent as r, inject as i, watch as l } from "vue";
+import { isClient as n } from "../../../../../@vueuse/shared/dist/index.js";
+var p = r({
+  props: { data: {
+    type: Array,
+    default: () => []
+  } },
+  setup(a) {
+    const e = i(c);
+    return l(() => a.data, () => {
+      var s;
+      a.data.forEach((t) => {
+        e.states.cachedOptions.has(t.value) || e.states.cachedOptions.set(t.value, t);
+      });
+      const o = ((s = e.selectRef) == null ? void 0 : s.querySelectorAll("input")) || [];
+      n && !Array.from(o).includes(document.activeElement) && e.setSelected();
+    }, {
+      flush: "post",
+      immediate: !0
+    }), () => {
+    };
+  }
+});
+export {
+  p as default
+};

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

@@ -0,0 +1,61 @@
+import { EVENT_CODE as i } from "../../../constants/aria.js";
+import { UPDATE_MODEL_EVENT as N } from "../../../constants/event.js";
+import { getEventCode as y } from "../../../utils/dom/event.js";
+import { useNamespace as M } from "../../../hooks/use-namespace/index.js";
+import { ElSelect as C } from "../../select/index.js";
+import { useEventListener as S } from "../../../../../@vueuse/core/dist/index.js";
+import { watch as T, nextTick as p, onMounted as V, computed as n, toRefs as k } from "vue";
+import x from "../../../../../lodash-es/pick.js";
+const j = (o, { attrs: u, emit: m }, { select: l, tree: s, key: v }) => {
+  const h = M("tree-select");
+  T(() => o.data, () => {
+    o.filterable && p(() => {
+      var e, t;
+      (t = s.value) == null || t.filter((e = l.value) == null ? void 0 : e.states.inputValue);
+    });
+  }, { flush: "post" });
+  const c = (e) => {
+    var a, r;
+    const t = e.at(-1);
+    if (t.expanded && t.childNodes.at(-1)) c([t.childNodes.at(-1)]);
+    else {
+      (r = (a = s.value.el$) == null ? void 0 : a.querySelector(`[data-key="${e.at(-1).key}"]`)) == null || r.focus({ preventScroll: !0 });
+      return;
+    }
+  };
+  return V(() => {
+    S(() => {
+      var e;
+      return (e = l.value) == null ? void 0 : e.$el;
+    }, "keydown", async (e) => {
+      const t = y(e), { dropdownMenuVisible: a } = l.value;
+      [i.down, i.up].includes(t) && a && (await p(), setTimeout(() => {
+        var r, d, f;
+        if (i.up === t) {
+          const E = s.value.store.root.childNodes;
+          c(E);
+          return;
+        }
+        (f = (d = (r = l.value.optionsArray[l.value.states.hoveringIndex].$el) == null ? void 0 : r.parentNode) == null ? void 0 : d.parentNode) == null || f.focus({ preventScroll: !0 });
+      }));
+    }, { capture: !0 });
+  }), {
+    ...x(k(o), Object.keys(C.props)),
+    ...u,
+    class: n(() => u.class),
+    style: n(() => u.style),
+    "onUpdate:modelValue": (e) => m(N, e),
+    valueKey: v,
+    popperClass: n(() => {
+      const e = [h.e("popper")];
+      return o.popperClass && e.push(o.popperClass), e.join(" ");
+    }),
+    filterMethod: (e = "") => {
+      var t;
+      o.filterMethod ? o.filterMethod(e) : o.remoteMethod ? o.remoteMethod(e) : (t = s.value) == null || t.filter(e);
+    }
+  };
+};
+export {
+  j as useSelect
+};

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

@@ -0,0 +1,23 @@
+import { ElOption as n } from "../../select/index.js";
+import { defineComponent as l, getCurrentInstance as r, nextTick as i, watch as p } from "vue";
+const u = l({
+  extends: n,
+  setup(o, t) {
+    const e = n.setup(o, t);
+    delete e.selectOptionClick;
+    const s = r().proxy;
+    return i(() => {
+      e.select.states.cachedOptions.get(s.value) || e.select.onOptionCreate(s);
+    }), p(() => t.attrs.visible, (c) => {
+      i(() => {
+        e.states.visible = c;
+      });
+    }, { immediate: !0 }), e;
+  },
+  methods: { selectOptionClick() {
+    this.$el.parentElement.click();
+  } }
+});
+export {
+  u as default
+};

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

@@ -0,0 +1,5 @@
+import e from "./tree-select.vue_vue_type_script_lang.js";
+var _ = e;
+export {
+  _ as default
+};