@dazhicheng/ui 1.4.14 → 1.4.15

package/dist/index-DEFw7uAt.js

@@ -0,0 +1,3559 @@
+import { isVNode as st, inject as ce, computed as w, getCurrentInstance as we, toRaw as ll, watch as P, defineComponent as oe, unref as at, toRefs as Ye, reactive as he, onBeforeUnmount as Dt, nextTick as q, withDirectives as Ee, createElementBlock as M, openBlock as D, withModifiers as ne, normalizeClass as K, renderSlot as j, createElementVNode as F, toDisplayString as ie, vShow as Me, ref as V, onMounted as Oe, normalizeStyle as Ve, createCommentVNode as z, useSlots as ol, watchEffect as sl, provide as Se, resolveComponent as X, resolveDirective as al, mergeProps as it, toHandlerKey as il, createVNode as re, withCtx as H, createBlock as W, Fragment as Ne, renderList as Ie, createTextVNode as Xt, resolveDynamicComponent as je, Transition as rl, toHandlers as dl, onUpdated as an, useAttrs as ul, h as qe } from "vue";
+import { castArray as pe, get as $e, isEqual as ve, isNil as Ue, findLastIndex as cl, clamp as fl, pick as ut } from "lodash-es";
+import { _ as Be, b as hl, u as pl, a as xt, E as vl, c as gl } from "./util-Boou02y4.js";
+import { s as yl, E as ml } from "./index-YgAUM4hl.js";
+import { B as bl, M as Cl, d as Nl, t as _t, E as kl, a as El, u as Sl } from "./useProps-B1w2fNNy.js";
+import { E as rn, r as mt, b as wl } from "./index-BKQp009w.js";
+import { b as ft, t as Ol, j as Dl, d as bt, h as dn, p as un, g as ae, e as Kl, a as _, u as Tl, w as Qe, o as cn, l as Ct, n as en, k as Il, c as $l } from "./use-form-common-props-QWQdZzPI.js";
+import { a as Q, o as de, G as fn, d as le, i as ue, F as Vl, U as se, C as hn, g as Kt, e as Ll, c as Ml, r as Nt, N as Bl, l as Pl, H as Al } from "./index-WNukMwgV.js";
+import { b as pn, u as Rl, a as Hl } from "./use-form-item-aIqGB1on.js";
+import { isClient as Tt, useResizeObserver as Te, isIOS as tn, useDebounceFn as Fl, useMutationObserver as zl, useEventListener as vn } from "@vueuse/core";
+import { u as gn } from "./index-BQfVaV7A.js";
+import { b as Wl, u as jl } from "./index-jX-ESk9T.js";
+import { V as ql, i as kt } from "./icon-D7yoP9ir.js";
+import { g as ct, E as A } from "./event-DFRZD7LK.js";
+import { u as Ul } from "./index-D3Ax_E0B.js";
+import { C as Gl } from "./index-D9W_gSi5.js";
+import { ElCheckbox as Yl } from "./index-CrIIQxqW.js";
+function Ql(e, t) {
+  if (!Tt) return;
+  if (!t) {
+    e.scrollTop = 0;
+    return;
+  }
+  const l = [];
+  let o = t.offsetParent;
+  for (; o !== null && e !== o && e.contains(o); )
+    l.push(o), o = o.offsetParent;
+  const n = t.offsetTop + l.reduce((f, h) => f + h.offsetTop, 0), i = n + t.offsetHeight, r = e.scrollTop, s = r + e.clientHeight;
+  n < r ? e.scrollTop = n : i > s && (e.scrollTop = i - e.clientHeight);
+}
+const ze = (e) => {
+  const t = Q(e) ? e : [e], l = [];
+  return t.forEach((o) => {
+    var n;
+    Q(o) ? l.push(...ze(o)) : st(o) && ((n = o.component) != null && n.subTree) ? l.push(o, ...ze(o.component.subTree)) : st(o) && Q(o.children) ? l.push(...ze(o.children)) : st(o) && o.shapeFlag === 2 ? l.push(...ze(o.type())) : l.push(o);
+  }), l;
+}, yn = /* @__PURE__ */ Symbol("ElSelectGroup"), Je = /* @__PURE__ */ Symbol("ElSelect"), Et = "ElOption", Jl = ft({
+  /**
+   * @description value of option
+   */
+  value: {
+    type: [String, Number, Boolean, Object],
+    required: !0
+  },
+  /**
+   * @description label of option, same as `value` if omitted
+   */
+  label: {
+    type: [String, Number]
+  },
+  created: Boolean,
+  /**
+   * @description whether option is disabled
+   */
+  disabled: Boolean
+});
+function Zl(e, t) {
+  const l = ce(Je);
+  l || Ol(Et, "usage: <el-select><el-option /></el-select/>");
+  const o = ce(yn, { disabled: !1 }), n = w(() => c(pe(l.props.modelValue), e.value)), i = w(() => {
+    var u;
+    if (l.props.multiple) {
+      const g = pe((u = l.props.modelValue) != null ? u : []);
+      return !n.value && g.length >= l.props.multipleLimit && l.props.multipleLimit > 0;
+    } else
+      return !1;
+  }), r = w(() => {
+    var u;
+    return (u = e.label) != null ? u : de(e.value) ? "" : e.value;
+  }), s = w(() => e.value || e.label || ""), f = w(() => e.disabled || t.groupDisabled || i.value), h = we(), c = (u = [], g) => {
+    if (de(e.value)) {
+      const y = l.props.valueKey;
+      return u && u.some((p) => ll($e(p, y)) === $e(g, y));
+    } else
+      return u && u.includes(g);
+  }, m = () => {
+    f.value || (l.states.hoveringIndex = l.optionsArray.indexOf(h.proxy));
+  }, d = (u) => {
+    const g = new RegExp(fn(u), "i");
+    t.visible = g.test(String(r.value)) || e.created;
+  };
+  return P(
+    () => r.value,
+    () => {
+      !e.created && !l.props.remote && l.setSelected();
+    }
+  ), P(
+    () => e.value,
+    (u, g) => {
+      const { remote: y, valueKey: p } = l.props;
+      if ((y ? u !== g : !ve(u, g)) && (l.onOptionDestroy(g, h.proxy), l.onOptionCreate(h.proxy)), !e.created && !y) {
+        if (p && de(u) && de(g) && u[p] === g[p])
+          return;
+        l.setSelected();
+      }
+    }
+  ), P(
+    () => o.disabled,
+    () => {
+      t.groupDisabled = o.disabled;
+    },
+    { immediate: !0 }
+  ), {
+    select: l,
+    currentLabel: r,
+    currentValue: s,
+    itemSelected: n,
+    isDisabled: f,
+    hoverItem: m,
+    updateOption: d
+  };
+}
+var Xl = oe({
+  name: Et,
+  componentName: Et,
+  props: Jl,
+  setup(e) {
+    const t = le("select"), l = pn(), o = w(() => [
+      t.be("dropdown", "item"),
+      t.is("disabled", at(s)),
+      t.is("selected", at(r)),
+      t.is("hovering", at(d))
+    ]), n = he({
+      index: -1,
+      groupDisabled: !1,
+      visible: !0,
+      hover: !1
+    }), {
+      currentLabel: i,
+      itemSelected: r,
+      isDisabled: s,
+      select: f,
+      hoverItem: h,
+      updateOption: c
+    } = Zl(e, n), { visible: m, hover: d } = Ye(n), u = we().proxy;
+    f.onOptionCreate(u), Dt(() => {
+      const y = u.value;
+      q(() => {
+        const { selected: p } = f.states, O = p.some((C) => C.value === u.value);
+        f.states.cachedOptions.get(y) === u && !O && f.states.cachedOptions.delete(y);
+      }), f.onOptionDestroy(y, u);
+    });
+    function g() {
+      s.value || f.handleOptionSelect(u);
+    }
+    return {
+      ns: t,
+      id: l,
+      containerKls: o,
+      currentLabel: i,
+      itemSelected: r,
+      isDisabled: s,
+      select: f,
+      visible: m,
+      hover: d,
+      states: n,
+      hoverItem: h,
+      updateOption: c,
+      selectOptionClick: g
+    };
+  }
+});
+const xl = ["id", "aria-disabled", "aria-selected"];
+function _l(e, t, l, o, n, i) {
+  return Ee((D(), M("li", {
+    id: e.id,
+    class: K(e.containerKls),
+    role: "option",
+    "aria-disabled": e.isDisabled || void 0,
+    "aria-selected": e.itemSelected,
+    onMousemove: t[0] || (t[0] = (...r) => e.hoverItem && e.hoverItem(...r)),
+    onClick: t[1] || (t[1] = ne((...r) => e.selectOptionClick && e.selectOptionClick(...r), ["stop"]))
+  }, [
+    j(e.$slots, "default", {}, () => [
+      F(
+        "span",
+        null,
+        ie(e.currentLabel),
+        1
+        /* TEXT */
+      )
+    ])
+  ], 42, xl)), [
+    [Me, e.visible]
+  ]);
+}
+var It = /* @__PURE__ */ Be(Xl, [["render", _l]]), eo = oe({
+  name: "ElSelectDropdown",
+  componentName: "ElSelectDropdown",
+  setup() {
+    const e = ce(Je), t = le("select"), l = w(() => e.props.popperClass), o = w(() => e.props.multiple), n = w(() => e.props.fitInputWidth), i = V("");
+    function r() {
+      var s;
+      const f = (s = e.selectRef) == null ? void 0 : s.offsetWidth;
+      f ? i.value = `${f - bl}px` : i.value = "";
+    }
+    return Oe(() => {
+      r(), Te(e.selectRef, r);
+    }), {
+      ns: t,
+      minWidth: i,
+      popperClass: l,
+      isMultiple: o,
+      isFitInputWidth: n
+    };
+  }
+});
+function to(e, t, l, o, n, i) {
+  return D(), M(
+    "div",
+    {
+      class: K([e.ns.b("dropdown"), e.ns.is("multiple", e.isMultiple), e.popperClass]),
+      style: Ve({ [e.isFitInputWidth ? "width" : "minWidth"]: e.minWidth })
+    },
+    [
+      e.$slots.header ? (D(), M(
+        "div",
+        {
+          key: 0,
+          class: K(e.ns.be("dropdown", "header"))
+        },
+        [
+          j(e.$slots, "header")
+        ],
+        2
+        /* CLASS */
+      )) : z("v-if", !0),
+      j(e.$slots, "default"),
+      e.$slots.footer ? (D(), M(
+        "div",
+        {
+          key: 1,
+          class: K(e.ns.be("dropdown", "footer"))
+        },
+        [
+          j(e.$slots, "footer")
+        ],
+        2
+        /* CLASS */
+      )) : z("v-if", !0)
+    ],
+    6
+    /* CLASS, STYLE */
+  );
+}
+var no = /* @__PURE__ */ Be(eo, [["render", to]]);
+const lo = (e, t) => {
+  const { t: l } = gn(), o = ol(), n = pn(), i = le("select"), r = le("input"), s = he({
+    inputValue: "",
+    options: /* @__PURE__ */ new Map(),
+    cachedOptions: /* @__PURE__ */ new Map(),
+    optionValues: [],
+    // sorted value of options
+    selected: [],
+    selectionWidth: 0,
+    collapseItemWidth: 0,
+    selectedLabel: "",
+    hoveringIndex: -1,
+    previousQuery: null,
+    inputHovering: !1,
+    menuVisibleOnFocus: !1,
+    isBeforeHide: !1
+  }), f = V(), h = V(), c = V(), m = V(), d = V(), u = V(), g = V(), y = V(), p = V(), O = V(), C = V(), E = V(!1), k = V(), U = V(!1), { form: ee, formItem: T } = Rl(), { inputId: ge } = Hl(e, {
+    formItemContext: T
+  }), { valueOnClear: S, isEmptyValue: $ } = hl(e), {
+    isComposing: R,
+    handleCompositionStart: G,
+    handleCompositionUpdate: De,
+    handleCompositionEnd: ht
+  } = Wl({
+    afterComposition: (a) => zt(a)
+  }), ye = Dl(), { wrapperRef: Ze, isFocused: Pe, handleBlur: pt } = jl(d, {
+    disabled: ye,
+    afterFocus() {
+      e.automaticDropdown && !E.value && (E.value = !0, s.menuVisibleOnFocus = !0);
+    },
+    beforeBlur(a) {
+      var v, N;
+      return ((v = c.value) == null ? void 0 : v.isFocusInsideContent(a)) || ((N = m.value) == null ? void 0 : N.isFocusInsideContent(a));
+    },
+    afterBlur() {
+      var a;
+      E.value = !1, s.menuVisibleOnFocus = !1, e.validateEvent && ((a = T == null ? void 0 : T.validate) == null || a.call(T, "blur").catch((v) => bt(v)));
+    }
+  }), Ae = w(() => Q(e.modelValue) ? e.modelValue.length > 0 : !$(e.modelValue)), b = w(() => {
+    var a;
+    return (a = ee == null ? void 0 : ee.statusIcon) != null ? a : !1;
+  }), I = w(() => e.clearable && !ye.value && Ae.value && (Pe.value || s.inputHovering)), fe = w(
+    () => e.remote && e.filterable && !e.remoteShowSuffix ? "" : e.suffixIcon
+  ), me = w(
+    () => i.is("reverse", !!(fe.value && E.value))
+  ), vt = w(() => (T == null ? void 0 : T.validateState) || ""), On = w(
+    () => vt.value && ql[vt.value]
+  ), Dn = w(() => e.remote ? e.debounce : 0), Kn = w(
+    () => e.remote && !s.inputValue && s.options.size === 0
+  ), Tn = w(() => e.loading ? e.loadingText || l("el.select.loading") : e.filterable && s.inputValue && s.options.size > 0 && Re.value === 0 ? e.noMatchText || l("el.select.noMatch") : s.options.size === 0 ? e.noDataText || l("el.select.noData") : null), Re = w(
+    () => J.value.filter((a) => a.visible).length
+  ), J = w(() => {
+    const a = Array.from(s.options.values()), v = [];
+    return s.optionValues.forEach((N) => {
+      const L = a.findIndex((B) => B.value === N);
+      L > -1 && v.push(a[L]);
+    }), v.length >= a.length ? v : a;
+  }), In = w(
+    () => Array.from(s.cachedOptions.values())
+  ), $n = w(() => {
+    const a = J.value.filter((v) => !v.created).some((v) => v.currentLabel === s.inputValue);
+    return e.filterable && e.allowCreate && s.inputValue !== "" && !a;
+  }), Bt = () => {
+    e.filterable && ue(e.filterMethod) || e.filterable && e.remote && ue(e.remoteMethod) || J.value.forEach((a) => {
+      var v;
+      (v = a.updateOption) == null || v.call(a, s.inputValue);
+    });
+  }, Pt = dn(), Vn = w(
+    () => ["small"].includes(Pt.value) ? "small" : "default"
+  ), At = w({
+    get() {
+      return E.value && (e.loading || !Kn.value || e.remote && !!o.empty) && (!U.value || !un(s.previousQuery));
+    },
+    set(a) {
+      E.value = a;
+    }
+  }), Ln = w(() => {
+    if (e.multiple && !ae(e.modelValue))
+      return pe(e.modelValue).length === 0 && !s.inputValue;
+    const a = Q(e.modelValue) ? e.modelValue[0] : e.modelValue;
+    return e.filterable || ae(a) ? !s.inputValue : !0;
+  }), Mn = w(() => {
+    var a;
+    const v = (a = e.placeholder) != null ? a : l("el.select.placeholder");
+    return e.multiple || !Ae.value ? v : s.selectedLabel;
+  }), Bn = w(() => tn ? null : "mouseenter");
+  P(
+    () => e.modelValue,
+    (a, v) => {
+      e.multiple && e.filterable && !e.reserveKeyword && (s.inputValue = "", Xe("")), xe(), !ve(a, v) && e.validateEvent && (T == null || T.validate("change").catch((N) => bt(N)));
+    },
+    {
+      flush: "post",
+      deep: !0
+    }
+  ), P(
+    () => E.value,
+    (a) => {
+      a ? Xe(s.inputValue) : (s.inputValue = "", s.previousQuery = null, s.isBeforeHide = !0, s.menuVisibleOnFocus = !1);
+    }
+  ), P(
+    // fix `Array.prototype.push/splice/..` cannot trigger non-deep watcher
+    // https://github.com/vuejs/vue-next/issues/2116
+    () => s.options.entries(),
+    () => {
+      Tt && (xe(), e.defaultFirstOption && (e.filterable || e.remote) && Re.value && Rt());
+    },
+    {
+      flush: "post"
+    }
+  ), P([() => s.hoveringIndex, J], ([a]) => {
+    Kl(a) && a > -1 ? k.value = J.value[a] || {} : k.value = {}, J.value.forEach((v) => {
+      v.hover = k.value === v;
+    });
+  }), sl(() => {
+    s.isBeforeHide || Bt();
+  });
+  const Xe = (a) => {
+    s.previousQuery === a || R.value || (s.previousQuery = a, e.filterable && ue(e.filterMethod) ? e.filterMethod(a) : e.filterable && e.remote && ue(e.remoteMethod) && e.remoteMethod(a), e.defaultFirstOption && (e.filterable || e.remote) && Re.value ? q(Rt) : q(Pn));
+  }, Rt = () => {
+    const a = J.value.filter(
+      (B) => B.visible && !B.disabled && !B.states.groupDisabled
+    ), v = a.find((B) => B.created), N = a[0], L = J.value.map((B) => B.value);
+    s.hoveringIndex = Gt(
+      L,
+      v || N
+    );
+  }, xe = () => {
+    if (e.multiple)
+      s.selectedLabel = "";
+    else {
+      const v = Q(e.modelValue) ? e.modelValue[0] : e.modelValue, N = gt(v);
+      s.selectedLabel = N.currentLabel, s.selected = [N];
+      return;
+    }
+    const a = [];
+    ae(e.modelValue) || pe(e.modelValue).forEach((v) => {
+      a.push(gt(v));
+    }), s.selected = a;
+  }, gt = (a) => {
+    let v;
+    const N = Vl(a);
+    for (let x = s.cachedOptions.size - 1; x >= 0; x--) {
+      const te = In.value[x];
+      if (N ? $e(te.value, e.valueKey) === $e(a, e.valueKey) : te.value === a) {
+        v = {
+          index: J.value.filter((Ce) => !Ce.created).indexOf(te),
+          value: a,
+          currentLabel: te.currentLabel,
+          get isDisabled() {
+            return te.isDisabled;
+          }
+        };
+        break;
+      }
+    }
+    if (v) return v;
+    const L = N ? a.label : a ?? "";
+    return {
+      index: -1,
+      value: a,
+      currentLabel: L
+    };
+  }, Pn = () => {
+    const a = s.selected.length;
+    if (a > 0) {
+      const v = s.selected[a - 1];
+      s.hoveringIndex = J.value.findIndex(
+        (N) => et(v) === et(N)
+      );
+    } else
+      s.hoveringIndex = -1;
+  }, An = () => {
+    s.selectionWidth = Number.parseFloat(
+      window.getComputedStyle(h.value).width
+    );
+  }, Rn = () => {
+    s.collapseItemWidth = O.value.getBoundingClientRect().width;
+  }, yt = () => {
+    var a, v;
+    (v = (a = c.value) == null ? void 0 : a.updatePopper) == null || v.call(a);
+  }, Ht = () => {
+    var a, v;
+    (v = (a = m.value) == null ? void 0 : a.updatePopper) == null || v.call(a);
+  }, Ft = () => {
+    s.inputValue.length > 0 && !E.value && (E.value = !0), Xe(s.inputValue);
+  }, zt = (a) => {
+    if (s.inputValue = a.target.value, e.remote)
+      U.value = !0, Wt();
+    else
+      return Ft();
+  }, Wt = Fl(() => {
+    Ft(), U.value = !1;
+  }, Dn), He = (a) => {
+    ve(e.modelValue, a) || t(hn, a);
+  }, Hn = (a) => cl(a, (v) => {
+    const N = s.cachedOptions.get(v);
+    return !(N != null && N.disabled) && !(N != null && N.states.groupDisabled);
+  }), jt = (a) => {
+    const v = ct(a);
+    if (e.multiple && v !== A.delete && a.target.value.length <= 0) {
+      const N = pe(e.modelValue).slice(), L = Hn(N);
+      if (L < 0) return;
+      const B = N[L];
+      N.splice(L, 1), t(se, N), He(N), t("remove-tag", B);
+    }
+  }, Fn = (a, v) => {
+    const N = s.selected.indexOf(v);
+    if (N > -1 && !ye.value) {
+      const L = pe(e.modelValue).slice();
+      L.splice(N, 1), t(se, L), He(L), t("remove-tag", v.value);
+    }
+    a.stopPropagation(), _e();
+  }, qt = (a) => {
+    a.stopPropagation();
+    const v = e.multiple ? [] : S.value;
+    if (e.multiple)
+      for (const N of s.selected)
+        N.isDisabled && v.push(N.value);
+    t(se, v), He(v), s.hoveringIndex = -1, E.value = !1, t("clear"), _e();
+  }, Ut = (a) => {
+    var v;
+    if (e.multiple) {
+      const N = pe((v = e.modelValue) != null ? v : []).slice(), L = Gt(N, a);
+      L > -1 ? N.splice(L, 1) : (e.multipleLimit <= 0 || N.length < e.multipleLimit) && N.push(a.value), t(se, N), He(N), a.created && Xe(""), e.filterable && !e.reserveKeyword && (s.inputValue = "");
+    } else
+      !ve(e.modelValue, a.value) && t(se, a.value), He(a.value), E.value = !1;
+    _e(), !E.value && q(() => {
+      Fe(a);
+    });
+  }, Gt = (a, v) => ae(v) ? -1 : de(v.value) ? a.findIndex((N) => ve($e(N, e.valueKey), et(v))) : a.indexOf(v.value), Fe = (a) => {
+    var v, N, L, B, x;
+    const te = Q(a) ? a[a.length - 1] : a;
+    let be = null;
+    if (!Ue(te == null ? void 0 : te.value)) {
+      const Ce = J.value.filter(
+        (nl) => nl.value === te.value
+      );
+      Ce.length > 0 && (be = Ce[0].$el);
+    }
+    if (c.value && be) {
+      const Ce = (B = (L = (N = (v = c.value) == null ? void 0 : v.popperRef) == null ? void 0 : N.contentRef) == null ? void 0 : L.querySelector) == null ? void 0 : B.call(
+        L,
+        `.${i.be("dropdown", "wrap")}`
+      );
+      Ce && Ql(Ce, be);
+    }
+    (x = C.value) == null || x.handleScroll();
+  }, zn = (a) => {
+    s.options.set(a.value, a), s.cachedOptions.set(a.value, a);
+  }, Wn = (a, v) => {
+    s.options.get(a) === v && s.options.delete(a);
+  }, jn = w(() => {
+    var a, v;
+    return (v = (a = c.value) == null ? void 0 : a.popperRef) == null ? void 0 : v.contentRef;
+  }), qn = () => {
+    s.isBeforeHide = !1, q(() => {
+      var a;
+      (a = C.value) == null || a.update(), Fe(s.selected);
+    });
+  }, _e = () => {
+    var a;
+    (a = d.value) == null || a.focus();
+  }, Un = () => {
+    var a;
+    if (E.value) {
+      E.value = !1, q(() => {
+        var v;
+        return (v = d.value) == null ? void 0 : v.blur();
+      });
+      return;
+    }
+    (a = d.value) == null || a.blur();
+  }, Gn = (a) => {
+    qt(a);
+  }, Yn = (a) => {
+    if (E.value = !1, Pe.value) {
+      const v = new FocusEvent("blur", a);
+      q(() => pt(v));
+    }
+  }, Yt = () => {
+    s.inputValue.length > 0 ? s.inputValue = "" : E.value = !1;
+  }, Qt = (a) => {
+    var v;
+    ye.value || e.filterable && E.value && a && !((v = g.value) != null && v.contains(a.target)) || (tn && (s.inputHovering = !0), s.menuVisibleOnFocus ? s.menuVisibleOnFocus = !1 : E.value = !E.value);
+  }, Jt = () => {
+    if (!E.value)
+      Qt();
+    else {
+      const a = J.value[s.hoveringIndex];
+      a && !a.isDisabled && Ut(a);
+    }
+  }, et = (a) => de(a.value) ? $e(a.value, e.valueKey) : a.value, Qn = w(
+    () => J.value.filter((a) => a.visible).every((a) => a.isDisabled)
+  ), Jn = w(() => e.multiple ? e.collapseTags ? s.selected.slice(0, e.maxCollapseTags) : s.selected : []), Zn = w(() => e.multiple ? e.collapseTags ? s.selected.slice(e.maxCollapseTags) : [] : []), tt = (a) => {
+    if (!E.value) {
+      E.value = !0;
+      return;
+    }
+    if (!(s.options.size === 0 || Re.value === 0 || R.value) && !Qn.value) {
+      a === "next" ? (s.hoveringIndex++, s.hoveringIndex === s.options.size && (s.hoveringIndex = 0)) : a === "prev" && (s.hoveringIndex--, s.hoveringIndex < 0 && (s.hoveringIndex = s.options.size - 1));
+      const v = J.value[s.hoveringIndex];
+      (v.isDisabled || !v.visible) && tt(a), q(() => Fe(k.value));
+    }
+  }, Zt = (a, v, N, L) => {
+    for (let B = v; B >= 0 && B < L; B += N) {
+      const x = a[B];
+      if (!(x != null && x.isDisabled) && (x != null && x.visible))
+        return B;
+    }
+    return null;
+  }, nt = (a, v) => {
+    var N;
+    const L = s.options.size;
+    if (L === 0) return;
+    const B = fl(a, 0, L - 1), x = J.value, te = v === "up" ? -1 : 1, be = (N = Zt(x, B, te, L)) != null ? N : Zt(x, B - te, -te, L);
+    be != null && (s.hoveringIndex = be, q(() => Fe(k.value)));
+  }, Xn = (a) => {
+    const v = ct(a);
+    let N = !0;
+    switch (v) {
+      case A.up:
+        tt("prev");
+        break;
+      case A.down:
+        tt("next");
+        break;
+      case A.enter:
+      case A.numpadEnter:
+        R.value || Jt();
+        break;
+      case A.esc:
+        Yt();
+        break;
+      case A.backspace:
+        N = !1, jt(a);
+        return;
+      case A.home:
+        if (!E.value) return;
+        nt(0, "down");
+        break;
+      case A.end:
+        if (!E.value) return;
+        nt(s.options.size - 1, "up");
+        break;
+      case A.pageUp:
+        if (!E.value) return;
+        nt(s.hoveringIndex - 10, "up");
+        break;
+      case A.pageDown:
+        if (!E.value) return;
+        nt(s.hoveringIndex + 10, "down");
+        break;
+      default:
+        N = !1;
+        break;
+    }
+    N && (a.preventDefault(), a.stopPropagation());
+  }, xn = () => {
+    if (!h.value) return 0;
+    const a = window.getComputedStyle(h.value);
+    return Number.parseFloat(a.gap || "6px");
+  }, _n = w(() => {
+    const a = xn(), v = e.filterable ? a + Cl : 0;
+    return { maxWidth: `${O.value && e.maxCollapseTags === 1 ? s.selectionWidth - s.collapseItemWidth - a - v : s.selectionWidth - v}px` };
+  }), el = w(() => ({ maxWidth: `${s.selectionWidth}px` })), tl = (a) => {
+    t("popup-scroll", a);
+  };
+  Te(h, An), Te(Ze, yt), Te(p, Ht), Te(O, Rn);
+  let lt;
+  return P(
+    () => At.value,
+    (a) => {
+      a ? lt = Te(y, yt).stop : (lt == null || lt(), lt = void 0), t("visible-change", a);
+    }
+  ), Oe(() => {
+    xe();
+  }), {
+    inputId: ge,
+    contentId: n,
+    nsSelect: i,
+    nsInput: r,
+    states: s,
+    isFocused: Pe,
+    expanded: E,
+    optionsArray: J,
+    hoverOption: k,
+    selectSize: Pt,
+    filteredOptionsCount: Re,
+    updateTooltip: yt,
+    updateTagTooltip: Ht,
+    debouncedOnInputChange: Wt,
+    onInput: zt,
+    deletePrevTag: jt,
+    deleteTag: Fn,
+    deleteSelected: qt,
+    handleOptionSelect: Ut,
+    scrollToOption: Fe,
+    hasModelValue: Ae,
+    shouldShowPlaceholder: Ln,
+    currentPlaceholder: Mn,
+    mouseEnterEventName: Bn,
+    needStatusIcon: b,
+    showClearBtn: I,
+    iconComponent: fe,
+    iconReverse: me,
+    validateState: vt,
+    validateIcon: On,
+    showNewOption: $n,
+    updateOptions: Bt,
+    collapseTagSize: Vn,
+    setSelected: xe,
+    selectDisabled: ye,
+    emptyText: Tn,
+    handleCompositionStart: G,
+    handleCompositionUpdate: De,
+    handleCompositionEnd: ht,
+    handleKeydown: Xn,
+    onOptionCreate: zn,
+    onOptionDestroy: Wn,
+    handleMenuEnter: qn,
+    focus: _e,
+    blur: Un,
+    handleClearClick: Gn,
+    handleClickOutside: Yn,
+    handleEsc: Yt,
+    toggleMenu: Qt,
+    selectOption: Jt,
+    getValueKey: et,
+    navigateOptions: tt,
+    dropdownMenuVisible: At,
+    showTagList: Jn,
+    collapseTagList: Zn,
+    popupScroll: tl,
+    getOption: gt,
+    // computed style
+    tagStyle: _n,
+    collapseTagStyle: el,
+    // DOM ref
+    popperRef: jn,
+    inputRef: d,
+    tooltipRef: c,
+    tagTooltipRef: m,
+    prefixRef: u,
+    suffixRef: g,
+    selectRef: f,
+    wrapperRef: Ze,
+    selectionRef: h,
+    scrollbarRef: C,
+    menuRef: y,
+    tagMenuRef: p,
+    collapseItemRef: O
+  };
+};
+var oo = oe({
+  name: "ElOptions",
+  setup(e, { slots: t }) {
+    const l = ce(Je);
+    let o = [];
+    return () => {
+      var n, i;
+      const r = (n = t.default) == null ? void 0 : n.call(t), s = [];
+      function f(h) {
+        Q(h) && h.forEach((c) => {
+          var m, d, u, g;
+          const y = (m = (c == null ? void 0 : c.type) || {}) == null ? void 0 : m.name;
+          y === "ElOptionGroup" ? f(
+            !Kt(c.children) && !Q(c.children) && ue((d = c.children) == null ? void 0 : d.default) ? (u = c.children) == null ? void 0 : u.default() : c.children
+          ) : y === "ElOption" ? s.push((g = c.props) == null ? void 0 : g.value) : Q(c.children) && f(c.children);
+        });
+      }
+      return r.length && f((i = r[0]) == null ? void 0 : i.children), ve(s, o) || (o = s, l && (l.states.optionValues = s)), r;
+    };
+  }
+});
+const mn = ft({
+  /**
+   * @description the name attribute of select input
+   */
+  name: String,
+  /**
+   * @description native input id
+   */
+  id: String,
+  /**
+   * @description binding value
+   */
+  modelValue: {
+    type: _([
+      Array,
+      String,
+      Number,
+      Boolean,
+      Object
+    ]),
+    default: void 0
+  },
+  /**
+   * @description the autocomplete attribute of select input
+   */
+  autocomplete: {
+    type: String,
+    default: "off"
+  },
+  /**
+   * @description for non-filterable Select, this prop decides if the option menu pops up when the input is focused
+   */
+  automaticDropdown: Boolean,
+  /**
+   * @description size of Input
+   */
+  size: Tl,
+  /**
+   * @description tooltip theme, built-in theme: `dark` / `light`
+   */
+  effect: {
+    type: _(String),
+    default: "light"
+  },
+  /**
+   * @description whether Select is disabled
+   */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+   * @description whether select can be cleared
+   */
+  clearable: Boolean,
+  /**
+   * @description whether Select is filterable
+   */
+  filterable: Boolean,
+  /**
+   * @description whether creating new items is allowed. To use this, `filterable` must be true
+   */
+  allowCreate: Boolean,
+  /**
+   * @description whether Select is loading data from server
+   */
+  loading: Boolean,
+  /**
+   * @description custom class name for Select's dropdown
+   */
+  popperClass: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description custom style for Select's dropdown
+   */
+  popperStyle: {
+    type: _([String, Object])
+  },
+  /**
+   * @description [popper.js](https://popper.js.org/docs/v2/) parameters
+   */
+  popperOptions: {
+    type: _(Object),
+    default: () => ({})
+  },
+  /**
+   * @description whether options are loaded from server
+   */
+  remote: Boolean,
+  /**
+   * @description debounce delay during remote search, in milliseconds
+   */
+  debounce: {
+    type: Number,
+    default: 300
+  },
+  /**
+   * @description displayed text while loading data from server, default is 'Loading'
+   */
+  loadingText: String,
+  /**
+   * @description displayed text when no data matches the filtering query, you can also use slot `empty`, default is 'No matching data'
+   */
+  noMatchText: String,
+  /**
+   * @description displayed text when there is no options, you can also use slot `empty`, default is 'No data'
+   */
+  noDataText: String,
+  /**
+   * @description function that gets called when the input value changes. Its parameter is the current input value. To use this, `filterable` must be true
+   */
+  remoteMethod: {
+    type: _(Function)
+  },
+  /**
+   * @description custom filter method, the first parameter is the current input value. To use this, `filterable` must be true
+   */
+  filterMethod: {
+    type: _(Function)
+  },
+  /**
+   * @description whether multiple-select is activated
+   */
+  multiple: Boolean,
+  /**
+   * @description maximum number of options user can select when `multiple` is `true`. No limit when set to 0
+   */
+  multipleLimit: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description placeholder, default is 'Select'
+   */
+  placeholder: {
+    type: String
+  },
+  /**
+   * @description select first matching option on enter key. Use with `filterable` or `remote`
+   */
+  defaultFirstOption: Boolean,
+  /**
+   * @description when `multiple` and `filter` is true, whether to reserve current keyword after selecting an option
+   */
+  reserveKeyword: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description unique identity key name for value, required when value is an object
+   */
+  valueKey: {
+    type: String,
+    default: "value"
+  },
+  /**
+   * @description whether to collapse tags to a text when multiple selecting
+   */
+  collapseTags: Boolean,
+  /**
+   * @description whether show all selected tags when mouse hover text of collapse-tags. To use this, `collapse-tags` must be true
+   */
+  collapseTagsTooltip: Boolean,
+  /**
+   * @description the max tags number to be shown. To use this, `collapse-tags` must be true
+   */
+  maxCollapseTags: {
+    type: Number,
+    default: 1
+  },
+  /**
+   * @description whether select dropdown is teleported, if `true` it will be teleported to where `append-to` sets
+   */
+  teleported: xt.teleported,
+  /**
+   * @description when select dropdown is inactive and `persistent` is `false`, select dropdown will be destroyed
+   */
+  persistent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description custom clear icon component
+   */
+  clearIcon: {
+    type: kt,
+    default: Ml
+  },
+  /**
+   * @description whether the width of the dropdown is the same as the input
+   */
+  fitInputWidth: Boolean,
+  /**
+   * @description custom suffix icon component
+   */
+  suffixIcon: {
+    type: kt,
+    default: Ll
+  },
+  /**
+   * @description tag type
+   */
+  tagType: { ..._t.type, default: "info" },
+  /**
+   * @description tag effect
+   */
+  tagEffect: { ..._t.effect, default: "light" },
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description in remote search method show suffix icon
+   */
+  remoteShowSuffix: Boolean,
+  /**
+   * @description determines whether the arrow is displayed
+   */
+  showArrow: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description offset of the dropdown
+   */
+  offset: {
+    type: Number,
+    default: 12
+  },
+  /**
+   * @description position of dropdown
+   */
+  placement: {
+    type: _(String),
+    values: vl,
+    default: "bottom-start"
+  },
+  /**
+   * @description list of possible positions for dropdown
+   */
+  fallbackPlacements: {
+    type: _(Array),
+    default: ["bottom-start", "top-start", "right", "left"]
+  },
+  /**
+   * @description tabindex for input
+   */
+  tabindex: {
+    type: [String, Number],
+    default: 0
+  },
+  /**
+   * @description which element the selection dropdown appends to
+   */
+  appendTo: xt.appendTo,
+  options: {
+    type: _(Array)
+  },
+  props: {
+    type: _(Object),
+    default: () => Nl
+  },
+  ...pl,
+  ...Ul(["ariaLabel"])
+});
+yl.scroll;
+var so = oe({
+  name: "ElOptionGroup",
+  componentName: "ElOptionGroup",
+  props: {
+    /**
+     * @description name of the group
+     */
+    label: String,
+    /**
+     * @description whether to disable all options in this group
+     */
+    disabled: Boolean
+  },
+  setup(e) {
+    const t = le("select"), l = V(), o = we(), n = V([]);
+    Se(
+      yn,
+      he({
+        ...Ye(e)
+      })
+    );
+    const i = w(
+      () => n.value.some((h) => h.visible === !0)
+    ), r = (h) => {
+      var c;
+      return h.type.name === "ElOption" && !!((c = h.component) != null && c.proxy);
+    }, s = (h) => {
+      const c = pe(h), m = [];
+      return c.forEach((d) => {
+        var u;
+        st(d) && (r(d) ? m.push(d.component.proxy) : Q(d.children) && d.children.length ? m.push(...s(d.children)) : (u = d.component) != null && u.subTree && m.push(...s(d.component.subTree)));
+      }), m;
+    }, f = () => {
+      n.value = s(o.subTree);
+    };
+    return Oe(() => {
+      f();
+    }), zl(l, f, {
+      attributes: !0,
+      subtree: !0,
+      childList: !0
+    }), {
+      groupRef: l,
+      visible: i,
+      ns: t
+    };
+  }
+});
+function ao(e, t, l, o, n, i) {
+  return Ee((D(), M(
+    "ul",
+    {
+      ref: "groupRef",
+      class: K(e.ns.be("group", "wrap"))
+    },
+    [
+      F(
+        "li",
+        {
+          class: K(e.ns.be("group", "title"))
+        },
+        ie(e.label),
+        3
+        /* TEXT, CLASS */
+      ),
+      F("li", null, [
+        F(
+          "ul",
+          {
+            class: K(e.ns.b("group"))
+          },
+          [
+            j(e.$slots, "default")
+          ],
+          2
+          /* CLASS */
+        )
+      ])
+    ],
+    2
+    /* CLASS */
+  )), [
+    [Me, e.visible]
+  ]);
+}
+var $t = /* @__PURE__ */ Be(so, [["render", ao]]);
+const nn = "ElSelect", Ge = /* @__PURE__ */ new WeakMap(), io = (e) => (...t) => {
+  var l, o;
+  const n = t[0];
+  if (!n || n.includes(
+    'Slot "default" invoked outside of the render function'
+  ) && ((l = t[2]) != null && l.includes("ElTreeSelect")))
+    return;
+  const i = (o = Ge.get(e)) == null ? void 0 : o.originalWarnHandler;
+  if (i) {
+    i(...t);
+    return;
+  }
+  console.warn(...t);
+}, ro = (e) => {
+  let t = Ge.get(e);
+  return t || (t = {
+    originalWarnHandler: e.config.warnHandler,
+    handler: io(e),
+    count: 0
+  }, Ge.set(e, t)), t;
+};
+var uo = oe({
+  name: nn,
+  componentName: nn,
+  components: {
+    ElSelectMenu: no,
+    ElOption: It,
+    ElOptions: oo,
+    ElOptionGroup: $t,
+    ElTag: kl,
+    ElScrollbar: ml,
+    ElTooltip: gl,
+    ElIcon: rn
+  },
+  directives: { ClickOutside: Gl },
+  props: mn,
+  emits: [
+    se,
+    hn,
+    "remove-tag",
+    "clear",
+    "visible-change",
+    "focus",
+    "blur",
+    "popup-scroll"
+  ],
+  setup(e, { emit: t, slots: l }) {
+    const o = we(), n = ro(o.appContext);
+    n.count += 1, o.appContext.config.warnHandler = n.handler;
+    const i = w(() => {
+      const { modelValue: C, multiple: E } = e, k = E ? [] : void 0;
+      return Q(C) ? E ? C : k : E ? k : C;
+    }), r = he({
+      ...Ye(e),
+      modelValue: i
+    }), s = lo(r, t), { calculatorRef: f, inputStyle: h } = El(), { getLabel: c, getValue: m, getOptions: d, getDisabled: u } = Sl(e), g = (C) => ({
+      label: c(C),
+      value: m(C),
+      disabled: u(C)
+    }), y = (C) => C.reduce((E, k) => (E.push(k), k.children && k.children.length > 0 && E.push(...y(k.children)), E), []), p = (C) => {
+      ze(C || []).forEach((k) => {
+        var U;
+        if (de(k) && // @ts-expect-error
+        (k.type.name === "ElOption" || k.type.name === "ElTree")) {
+          const ee = k.type.name;
+          if (ee === "ElTree") {
+            const T = ((U = k.props) == null ? void 0 : U.data) || [];
+            y(T).forEach((S) => {
+              S.currentLabel = S.label || (de(S.value) ? "" : S.value), s.onOptionCreate(S);
+            });
+          } else if (ee === "ElOption") {
+            const T = { ...k.props };
+            T.currentLabel = T.label || (de(T.value) ? "" : T.value), s.onOptionCreate(T);
+          }
+        }
+      });
+    };
+    P(
+      () => {
+        var C;
+        return [(C = l.default) == null ? void 0 : C.call(l), i.value];
+      },
+      () => {
+        var C;
+        e.persistent || s.expanded.value || (s.states.options.clear(), p((C = l.default) == null ? void 0 : C.call(l)));
+      },
+      {
+        immediate: !0
+      }
+    ), Se(
+      Je,
+      he({
+        props: r,
+        states: s.states,
+        selectRef: s.selectRef,
+        optionsArray: s.optionsArray,
+        setSelected: s.setSelected,
+        handleOptionSelect: s.handleOptionSelect,
+        onOptionCreate: s.onOptionCreate,
+        onOptionDestroy: s.onOptionDestroy
+      })
+    );
+    const O = w(() => e.multiple ? s.states.selected.map((C) => C.currentLabel) : s.states.selectedLabel);
+    return Dt(() => {
+      const C = Ge.get(o.appContext);
+      C && (C.count -= 1, C.count <= 0 && (o.appContext.config.warnHandler = C.originalWarnHandler, Ge.delete(o.appContext)));
+    }), {
+      ...s,
+      modelValue: i,
+      selectedLabel: O,
+      calculatorRef: f,
+      inputStyle: h,
+      getLabel: c,
+      getValue: m,
+      getOptions: d,
+      getDisabled: u,
+      getOptionProps: g
+    };
+  }
+});
+const co = ["id", "value", "name", "disabled", "autocomplete", "tabindex", "readonly", "aria-activedescendant", "aria-controls", "aria-expanded", "aria-label"], fo = ["textContent"], ho = { key: 1 };
+function po(e, t, l, o, n, i) {
+  const r = X("el-tag"), s = X("el-tooltip"), f = X("el-icon"), h = X("el-option"), c = X("el-option-group"), m = X("el-options"), d = X("el-scrollbar"), u = X("el-select-menu"), g = al("click-outside");
+  return Ee((D(), M(
+    "div",
+    it({
+      ref: "selectRef",
+      class: [e.nsSelect.b(), e.nsSelect.m(e.selectSize)]
+    }, {
+      [il(e.mouseEnterEventName)]: t[10] || (t[10] = (y) => e.states.inputHovering = !0)
+    }, {
+      onMouseleave: t[11] || (t[11] = (y) => e.states.inputHovering = !1)
+    }),
+    [
+      re(s, {
+        ref: "tooltipRef",
+        visible: e.dropdownMenuVisible,
+        placement: e.placement,
+        teleported: e.teleported,
+        "popper-class": [e.nsSelect.e("popper"), e.popperClass],
+        "popper-style": e.popperStyle,
+        "popper-options": e.popperOptions,
+        "fallback-placements": e.fallbackPlacements,
+        effect: e.effect,
+        pure: "",
+        trigger: "click",
+        transition: `${e.nsSelect.namespace.value}-zoom-in-top`,
+        "stop-popper-mouse-event": !1,
+        "gpu-acceleration": !1,
+        persistent: e.persistent,
+        "append-to": e.appendTo,
+        "show-arrow": e.showArrow,
+        offset: e.offset,
+        onBeforeShow: e.handleMenuEnter,
+        onHide: t[9] || (t[9] = (y) => e.states.isBeforeHide = !1)
+      }, {
+        default: H(() => {
+          var y;
+          return [
+            F(
+              "div",
+              {
+                ref: "wrapperRef",
+                class: K([
+                  e.nsSelect.e("wrapper"),
+                  e.nsSelect.is("focused", e.isFocused),
+                  e.nsSelect.is("hovering", e.states.inputHovering),
+                  e.nsSelect.is("filterable", e.filterable),
+                  e.nsSelect.is("disabled", e.selectDisabled)
+                ]),
+                onClick: t[6] || (t[6] = ne((...p) => e.toggleMenu && e.toggleMenu(...p), ["prevent"]))
+              },
+              [
+                e.$slots.prefix ? (D(), M(
+                  "div",
+                  {
+                    key: 0,
+                    ref: "prefixRef",
+                    class: K(e.nsSelect.e("prefix"))
+                  },
+                  [
+                    j(e.$slots, "prefix")
+                  ],
+                  2
+                  /* CLASS */
+                )) : z("v-if", !0),
+                F(
+                  "div",
+                  {
+                    ref: "selectionRef",
+                    class: K([
+                      e.nsSelect.e("selection"),
+                      e.nsSelect.is(
+                        "near",
+                        e.multiple && !e.$slots.prefix && !!e.states.selected.length
+                      )
+                    ])
+                  },
+                  [
+                    e.multiple ? j(e.$slots, "tag", {
+                      key: 0,
+                      data: e.states.selected,
+                      deleteTag: e.deleteTag,
+                      selectDisabled: e.selectDisabled
+                    }, () => [
+                      (D(!0), M(
+                        Ne,
+                        null,
+                        Ie(e.showTagList, (p) => (D(), M(
+                          "div",
+                          {
+                            key: e.getValueKey(p),
+                            class: K(e.nsSelect.e("selected-item"))
+                          },
+                          [
+                            re(r, {
+                              closable: !e.selectDisabled && !p.isDisabled,
+                              size: e.collapseTagSize,
+                              type: e.tagType,
+                              effect: e.tagEffect,
+                              "disable-transitions": "",
+                              style: Ve(e.tagStyle),
+                              onClose: (O) => e.deleteTag(O, p)
+                            }, {
+                              default: H(() => [
+                                F(
+                                  "span",
+                                  {
+                                    class: K(e.nsSelect.e("tags-text"))
+                                  },
+                                  [
+                                    j(e.$slots, "label", {
+                                      index: p.index,
+                                      label: p.currentLabel,
+                                      value: p.value
+                                    }, () => [
+                                      Xt(
+                                        ie(p.currentLabel),
+                                        1
+                                        /* TEXT */
+                                      )
+                                    ])
+                                  ],
+                                  2
+                                  /* CLASS */
+                                )
+                              ]),
+                              _: 2
+                              /* DYNAMIC */
+                            }, 1032, ["closable", "size", "type", "effect", "style", "onClose"])
+                          ],
+                          2
+                          /* CLASS */
+                        ))),
+                        128
+                        /* KEYED_FRAGMENT */
+                      )),
+                      e.collapseTags && e.states.selected.length > e.maxCollapseTags ? (D(), W(s, {
+                        key: 0,
+                        ref: "tagTooltipRef",
+                        disabled: e.dropdownMenuVisible || !e.collapseTagsTooltip,
+                        "fallback-placements": ["bottom", "top", "right", "left"],
+                        effect: e.effect,
+                        placement: "bottom",
+                        "popper-class": e.popperClass,
+                        "popper-style": e.popperStyle,
+                        teleported: e.teleported,
+                        "popper-options": e.popperOptions
+                      }, {
+                        default: H(() => [
+                          F(
+                            "div",
+                            {
+                              ref: "collapseItemRef",
+                              class: K(e.nsSelect.e("selected-item"))
+                            },
+                            [
+                              re(r, {
+                                closable: !1,
+                                size: e.collapseTagSize,
+                                type: e.tagType,
+                                effect: e.tagEffect,
+                                "disable-transitions": "",
+                                style: Ve(e.collapseTagStyle)
+                              }, {
+                                default: H(() => [
+                                  F(
+                                    "span",
+                                    {
+                                      class: K(e.nsSelect.e("tags-text"))
+                                    },
+                                    " + " + ie(e.states.selected.length - e.maxCollapseTags),
+                                    3
+                                    /* TEXT, CLASS */
+                                  )
+                                ]),
+                                _: 1
+                                /* STABLE */
+                              }, 8, ["size", "type", "effect", "style"])
+                            ],
+                            2
+                            /* CLASS */
+                          )
+                        ]),
+                        content: H(() => [
+                          F(
+                            "div",
+                            {
+                              ref: "tagMenuRef",
+                              class: K(e.nsSelect.e("selection"))
+                            },
+                            [
+                              (D(!0), M(
+                                Ne,
+                                null,
+                                Ie(e.collapseTagList, (p) => (D(), M(
+                                  "div",
+                                  {
+                                    key: e.getValueKey(p),
+                                    class: K(e.nsSelect.e("selected-item"))
+                                  },
+                                  [
+                                    re(r, {
+                                      class: "in-tooltip",
+                                      closable: !e.selectDisabled && !p.isDisabled,
+                                      size: e.collapseTagSize,
+                                      type: e.tagType,
+                                      effect: e.tagEffect,
+                                      "disable-transitions": "",
+                                      onClose: (O) => e.deleteTag(O, p)
+                                    }, {
+                                      default: H(() => [
+                                        F(
+                                          "span",
+                                          {
+                                            class: K(e.nsSelect.e("tags-text"))
+                                          },
+                                          [
+                                            j(e.$slots, "label", {
+                                              index: p.index,
+                                              label: p.currentLabel,
+                                              value: p.value
+                                            }, () => [
+                                              Xt(
+                                                ie(p.currentLabel),
+                                                1
+                                                /* TEXT */
+                                              )
+                                            ])
+                                          ],
+                                          2
+                                          /* CLASS */
+                                        )
+                                      ]),
+                                      _: 2
+                                      /* DYNAMIC */
+                                    }, 1032, ["closable", "size", "type", "effect", "onClose"])
+                                  ],
+                                  2
+                                  /* CLASS */
+                                ))),
+                                128
+                                /* KEYED_FRAGMENT */
+                              ))
+                            ],
+                            2
+                            /* CLASS */
+                          )
+                        ]),
+                        _: 3
+                        /* FORWARDED */
+                      }, 8, ["disabled", "effect", "popper-class", "popper-style", "teleported", "popper-options"])) : z("v-if", !0)
+                    ]) : z("v-if", !0),
+                    F(
+                      "div",
+                      {
+                        class: K([
+                          e.nsSelect.e("selected-item"),
+                          e.nsSelect.e("input-wrapper"),
+                          e.nsSelect.is("hidden", !e.filterable || e.selectDisabled)
+                        ])
+                      },
+                      [
+                        F("input", {
+                          id: e.inputId,
+                          ref: "inputRef",
+                          value: e.states.inputValue,
+                          type: "text",
+                          name: e.name,
+                          class: K([e.nsSelect.e("input"), e.nsSelect.is(e.selectSize)]),
+                          disabled: e.selectDisabled,
+                          autocomplete: e.autocomplete,
+                          style: Ve(e.inputStyle),
+                          tabindex: e.tabindex,
+                          role: "combobox",
+                          readonly: !e.filterable,
+                          spellcheck: "false",
+                          "aria-activedescendant": ((y = e.hoverOption) == null ? void 0 : y.id) || "",
+                          "aria-controls": e.contentId,
+                          "aria-expanded": e.dropdownMenuVisible,
+                          "aria-label": e.ariaLabel,
+                          "aria-autocomplete": "none",
+                          "aria-haspopup": "listbox",
+                          onKeydown: t[0] || (t[0] = (...p) => e.handleKeydown && e.handleKeydown(...p)),
+                          onCompositionstart: t[1] || (t[1] = (...p) => e.handleCompositionStart && e.handleCompositionStart(...p)),
+                          onCompositionupdate: t[2] || (t[2] = (...p) => e.handleCompositionUpdate && e.handleCompositionUpdate(...p)),
+                          onCompositionend: t[3] || (t[3] = (...p) => e.handleCompositionEnd && e.handleCompositionEnd(...p)),
+                          onInput: t[4] || (t[4] = (...p) => e.onInput && e.onInput(...p)),
+                          onClick: t[5] || (t[5] = ne((...p) => e.toggleMenu && e.toggleMenu(...p), ["stop"]))
+                        }, null, 46, co),
+                        e.filterable ? (D(), M("span", {
+                          key: 0,
+                          ref: "calculatorRef",
+                          "aria-hidden": "true",
+                          class: K(e.nsSelect.e("input-calculator")),
+                          textContent: ie(e.states.inputValue)
+                        }, null, 10, fo)) : z("v-if", !0)
+                      ],
+                      2
+                      /* CLASS */
+                    ),
+                    e.shouldShowPlaceholder ? (D(), M(
+                      "div",
+                      {
+                        key: 1,
+                        class: K([
+                          e.nsSelect.e("selected-item"),
+                          e.nsSelect.e("placeholder"),
+                          e.nsSelect.is(
+                            "transparent",
+                            !e.hasModelValue || e.expanded && !e.states.inputValue
+                          )
+                        ])
+                      },
+                      [
+                        e.hasModelValue ? j(e.$slots, "label", {
+                          key: 0,
+                          index: e.getOption(e.modelValue).index,
+                          label: e.currentPlaceholder,
+                          value: e.modelValue
+                        }, () => [
+                          F(
+                            "span",
+                            null,
+                            ie(e.currentPlaceholder),
+                            1
+                            /* TEXT */
+                          )
+                        ]) : (D(), M(
+                          "span",
+                          ho,
+                          ie(e.currentPlaceholder),
+                          1
+                          /* TEXT */
+                        ))
+                      ],
+                      2
+                      /* CLASS */
+                    )) : z("v-if", !0)
+                  ],
+                  2
+                  /* CLASS */
+                ),
+                F(
+                  "div",
+                  {
+                    ref: "suffixRef",
+                    class: K(e.nsSelect.e("suffix"))
+                  },
+                  [
+                    e.iconComponent && !e.showClearBtn ? (D(), W(f, {
+                      key: 0,
+                      class: K([e.nsSelect.e("caret"), e.nsSelect.e("icon"), e.iconReverse])
+                    }, {
+                      default: H(() => [
+                        (D(), W(je(e.iconComponent)))
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    }, 8, ["class"])) : z("v-if", !0),
+                    e.showClearBtn && e.clearIcon ? (D(), W(f, {
+                      key: 1,
+                      class: K([
+                        e.nsSelect.e("caret"),
+                        e.nsSelect.e("icon"),
+                        e.nsSelect.e("clear")
+                      ]),
+                      onClick: e.handleClearClick
+                    }, {
+                      default: H(() => [
+                        (D(), W(je(e.clearIcon)))
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    }, 8, ["class", "onClick"])) : z("v-if", !0),
+                    e.validateState && e.validateIcon && e.needStatusIcon ? (D(), W(f, {
+                      key: 2,
+                      class: K([
+                        e.nsInput.e("icon"),
+                        e.nsInput.e("validateIcon"),
+                        e.nsInput.is("loading", e.validateState === "validating")
+                      ])
+                    }, {
+                      default: H(() => [
+                        (D(), W(je(e.validateIcon)))
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    }, 8, ["class"])) : z("v-if", !0)
+                  ],
+                  2
+                  /* CLASS */
+                )
+              ],
+              2
+              /* CLASS */
+            )
+          ];
+        }),
+        content: H(() => [
+          re(
+            u,
+            { ref: "menuRef" },
+            {
+              default: H(() => [
+                e.$slots.header ? (D(), M(
+                  "div",
+                  {
+                    key: 0,
+                    class: K(e.nsSelect.be("dropdown", "header")),
+                    onClick: t[7] || (t[7] = ne(() => {
+                    }, ["stop"]))
+                  },
+                  [
+                    j(e.$slots, "header")
+                  ],
+                  2
+                  /* CLASS */
+                )) : z("v-if", !0),
+                Ee(re(d, {
+                  id: e.contentId,
+                  ref: "scrollbarRef",
+                  tag: "ul",
+                  "wrap-class": e.nsSelect.be("dropdown", "wrap"),
+                  "view-class": e.nsSelect.be("dropdown", "list"),
+                  class: K([e.nsSelect.is("empty", e.filteredOptionsCount === 0)]),
+                  role: "listbox",
+                  "aria-label": e.ariaLabel,
+                  "aria-orientation": "vertical",
+                  onScroll: e.popupScroll
+                }, {
+                  default: H(() => [
+                    e.showNewOption ? (D(), W(h, {
+                      key: 0,
+                      value: e.states.inputValue,
+                      created: !0
+                    }, null, 8, ["value"])) : z("v-if", !0),
+                    re(m, null, {
+                      default: H(() => [
+                        j(e.$slots, "default", {}, () => [
+                          (D(!0), M(
+                            Ne,
+                            null,
+                            Ie(e.options, (y, p) => {
+                              var O;
+                              return D(), M(
+                                Ne,
+                                { key: p },
+                                [
+                                  (O = e.getOptions(y)) != null && O.length ? (D(), W(c, {
+                                    key: 0,
+                                    label: e.getLabel(y),
+                                    disabled: e.getDisabled(y)
+                                  }, {
+                                    default: H(() => [
+                                      (D(!0), M(
+                                        Ne,
+                                        null,
+                                        Ie(e.getOptions(y), (C) => (D(), W(
+                                          h,
+                                          it({
+                                            key: e.getValue(C)
+                                          }, { ref_for: !0 }, e.getOptionProps(C)),
+                                          null,
+                                          16
+                                          /* FULL_PROPS */
+                                        ))),
+                                        128
+                                        /* KEYED_FRAGMENT */
+                                      ))
+                                    ]),
+                                    _: 2
+                                    /* DYNAMIC */
+                                  }, 1032, ["label", "disabled"])) : (D(), W(
+                                    h,
+                                    it({
+                                      key: 1,
+                                      ref_for: !0
+                                    }, e.getOptionProps(y)),
+                                    null,
+                                    16
+                                    /* FULL_PROPS */
+                                  ))
+                                ],
+                                64
+                                /* STABLE_FRAGMENT */
+                              );
+                            }),
+                            128
+                            /* KEYED_FRAGMENT */
+                          ))
+                        ])
+                      ]),
+                      _: 3
+                      /* FORWARDED */
+                    })
+                  ]),
+                  _: 3
+                  /* FORWARDED */
+                }, 8, ["id", "wrap-class", "view-class", "class", "aria-label", "onScroll"]), [
+                  [Me, e.states.options.size > 0 && !e.loading]
+                ]),
+                e.$slots.loading && e.loading ? (D(), M(
+                  "div",
+                  {
+                    key: 1,
+                    class: K(e.nsSelect.be("dropdown", "loading"))
+                  },
+                  [
+                    j(e.$slots, "loading")
+                  ],
+                  2
+                  /* CLASS */
+                )) : e.loading || e.filteredOptionsCount === 0 ? (D(), M(
+                  "div",
+                  {
+                    key: 2,
+                    class: K(e.nsSelect.be("dropdown", "empty"))
+                  },
+                  [
+                    j(e.$slots, "empty", {}, () => [
+                      F(
+                        "span",
+                        null,
+                        ie(e.emptyText),
+                        1
+                        /* TEXT */
+                      )
+                    ])
+                  ],
+                  2
+                  /* CLASS */
+                )) : z("v-if", !0),
+                e.$slots.footer ? (D(), M(
+                  "div",
+                  {
+                    key: 3,
+                    class: K(e.nsSelect.be("dropdown", "footer")),
+                    onClick: t[8] || (t[8] = ne(() => {
+                    }, ["stop"]))
+                  },
+                  [
+                    j(e.$slots, "footer")
+                  ],
+                  2
+                  /* CLASS */
+                )) : z("v-if", !0)
+              ]),
+              _: 3
+              /* FORWARDED */
+            },
+            512
+            /* NEED_PATCH */
+          )
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["visible", "placement", "teleported", "popper-class", "popper-style", "popper-options", "fallback-placements", "effect", "transition", "persistent", "append-to", "show-arrow", "offset", "onBeforeShow"])
+    ],
+    16
+    /* FULL_PROPS */
+  )), [
+    [g, e.handleClickOutside, e.popperRef]
+  ]);
+}
+var vo = /* @__PURE__ */ Be(uo, [["render", po]]);
+const bn = Qe(vo, {
+  Option: It,
+  OptionGroup: $t
+}), ln = cn(It);
+cn($t);
+const Le = "$treeNodeId", on = function(e, t) {
+  !t || t[Le] || Object.defineProperty(t, Le, {
+    value: e.id,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  });
+}, Vt = (e, t) => t == null ? void 0 : t[e || Le], St = (e, t, l) => {
+  const o = e.value.currentNode;
+  l();
+  const n = e.value.currentNode;
+  o !== n && t("current-change", n ? n.data : null, n);
+};
+var go = Object.defineProperty, yo = (e, t, l) => t in e ? go(e, t, { enumerable: !0, configurable: !0, writable: !0, value: l }) : e[t] = l, Y = (e, t, l) => yo(e, typeof t != "symbol" ? t + "" : t, l);
+const Cn = (e) => {
+  let t = !0, l = !0, o = !0, n = !0;
+  for (let i = 0, r = e.length; i < r; i++) {
+    const s = e[i];
+    (s.checked !== !0 || s.indeterminate) && (t = !1, s.disabled || (o = !1)), (s.checked !== !1 || s.indeterminate) && (l = !1), s.isEffectivelyChecked || (n = !1);
+  }
+  return {
+    all: t,
+    none: l,
+    allWithoutDisable: o,
+    half: !t && !l,
+    isEffectivelyChecked: n
+  };
+}, We = function(e) {
+  if (e.childNodes.length === 0 || e.loading) {
+    e.isEffectivelyChecked = e.disabled || e.checked;
+    return;
+  }
+  const { all: t, none: l, half: o, isEffectivelyChecked: n } = Cn(
+    e.childNodes
+  );
+  e.isEffectivelyChecked = n, t ? (e.checked = !0, e.indeterminate = !1) : o ? (e.checked = !1, e.indeterminate = !0) : l && (e.checked = !1, e.indeterminate = !1);
+  const i = e.parent;
+  !i || i.level === 0 || e.store.checkStrictly || We(i);
+}, ot = function(e, t) {
+  const l = e.store.props, o = e.data || {}, n = l[t];
+  if (ue(n))
+    return n(o, e);
+  if (Kt(n))
+    return o[n];
+  if (ae(n)) {
+    const i = o[t];
+    return ae(i) ? "" : i;
+  }
+}, wt = function(e, t) {
+  e.forEach((l) => {
+    l.canFocus = t, wt(l.childNodes, t);
+  });
+};
+let mo = 0;
+class ke {
+  constructor(t) {
+    Y(this, "id"), Y(this, "text"), Y(this, "checked"), Y(this, "indeterminate"), Y(this, "data"), Y(this, "expanded"), Y(this, "parent"), Y(this, "visible"), Y(this, "isCurrent"), Y(this, "store"), Y(this, "isLeafByUser"), Y(this, "isLeaf"), Y(this, "canFocus"), Y(this, "level"), Y(this, "loaded"), Y(this, "childNodes"), Y(this, "loading"), Y(this, "isEffectivelyChecked", !1), this.id = mo++, 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 l in t)
+      Nt(t, l) && (this[l] = t[l]);
+    this.level = 0, this.loaded = !1, this.childNodes = [], this.loading = !1, this.parent && (this.level = this.parent.level + 1);
+  }
+  initialize() {
+    var t;
+    const l = this.store;
+    if (!l)
+      throw new Error("[Node]store is required!");
+    l.registerNode(this);
+    const o = l.props;
+    if (o && typeof o.isLeaf < "u") {
+      const r = ot(this, "isLeaf");
+      Ct(r) && (this.isLeafByUser = r);
+    }
+    if (l.lazy !== !0 && this.data ? (this.setData(this.data), l.defaultExpandAll && (this.expanded = !0, this.canFocus = !0)) : this.level > 0 && l.lazy && l.defaultExpandAll && !this.isLeafByUser && this.expand(), Q(this.data) || on(this, this.data), !this.data) return;
+    const n = l.defaultExpandedKeys, i = l.key;
+    i && !Ue(this.key) && n && n.includes(this.key) && this.expand(null, l.autoExpandParent), i && l.currentNodeKey !== void 0 && this.key === l.currentNodeKey && (l.currentNode && (l.currentNode.isCurrent = !1), l.currentNode = this, l.currentNode.isCurrent = !0), l.lazy && l._initDefaultCheckedNode(this), this.updateLeafState(), (this.level === 1 || ((t = this.parent) == null ? void 0 : t.expanded) === !0) && (this.canFocus = !0);
+  }
+  setData(t) {
+    Q(t) || on(this, t), this.data = t, this.childNodes = [];
+    let l;
+    this.level === 0 && Q(this.data) ? l = this.data : l = ot(this, "children") || [];
+    for (let o = 0, n = l.length; o < n; o++)
+      this.insertChild({ data: l[o] });
+  }
+  get label() {
+    return ot(this, "label");
+  }
+  get key() {
+    const t = this.store.key;
+    return this.data ? this.data[t] : null;
+  }
+  get disabled() {
+    return ot(this, "disabled");
+  }
+  get nextSibling() {
+    const t = this.parent;
+    if (t) {
+      const l = t.childNodes.indexOf(this);
+      if (l > -1)
+        return t.childNodes[l + 1];
+    }
+    return null;
+  }
+  get previousSibling() {
+    const t = this.parent;
+    if (t) {
+      const l = t.childNodes.indexOf(this);
+      if (l > -1)
+        return l > 0 ? t.childNodes[l - 1] : null;
+    }
+    return null;
+  }
+  contains(t, l = !0) {
+    return (this.childNodes || []).some(
+      (o) => o === t || l && o.contains(t)
+    );
+  }
+  remove() {
+    const t = this.parent;
+    t && t.removeChild(this);
+  }
+  insertChild(t, l, o) {
+    if (!t) throw new Error("InsertChild error: child is required.");
+    if (!(t instanceof ke)) {
+      if (!o) {
+        const n = this.getChildren(!0);
+        n != null && n.includes(t.data) || (ae(l) || l < 0 ? n == null || n.push(t.data) : n == null || n.splice(l, 0, t.data));
+      }
+      Object.assign(t, {
+        parent: this,
+        store: this.store
+      }), t = he(new ke(t)), t instanceof ke && t.initialize();
+    }
+    t.level = this.level + 1, ae(l) || l < 0 ? this.childNodes.push(t) : this.childNodes.splice(l, 0, t), this.updateLeafState();
+  }
+  insertBefore(t, l) {
+    let o;
+    l && (o = this.childNodes.indexOf(l)), this.insertChild(t, o);
+  }
+  insertAfter(t, l) {
+    let o;
+    l && (o = this.childNodes.indexOf(l), o !== -1 && (o += 1)), this.insertChild(t, o);
+  }
+  removeChild(t) {
+    const l = this.getChildren() || [], o = l.indexOf(t.data);
+    o > -1 && l.splice(o, 1);
+    const n = this.childNodes.indexOf(t);
+    n > -1 && (this.store && this.store.deregisterNode(t), t.parent = null, this.childNodes.splice(n, 1)), this.updateLeafState();
+  }
+  removeChildByData(t) {
+    const l = this.childNodes.find((o) => o.data === t);
+    l && this.removeChild(l);
+  }
+  expand(t, l) {
+    const o = () => {
+      if (l) {
+        let n = this.parent;
+        for (; n && n.level > 0; )
+          n.expanded = !0, n = n.parent;
+      }
+      this.expanded = !0, t && t(), wt(this.childNodes, !0);
+    };
+    this.shouldLoadData() ? this.loadData((n) => {
+      Q(n) && (this.checked ? this.setChecked(!0, !0) : this.store.checkStrictly || We(this), o());
+    }) : o();
+  }
+  doCreateChildren(t, l = {}) {
+    t.forEach((o) => {
+      this.insertChild(
+        Object.assign({ data: o }, l),
+        void 0,
+        !0
+      );
+    });
+  }
+  collapse() {
+    this.expanded = !1, wt(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, l, o, n) {
+    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 r = () => {
+        if (l) {
+          const s = this.childNodes;
+          for (let m = 0, d = s.length; m < d; m++) {
+            const u = s[m];
+            n = n || t !== !1;
+            const g = u.disabled && u.isLeaf ? u.checked : n;
+            u.setChecked(g, l, !0, n);
+          }
+          const { half: f, all: h, isEffectivelyChecked: c } = Cn(s);
+          h || (this.checked = h, this.indeterminate = f), this.isEffectivelyChecked = this.childNodes.length ? c : this.disabled || this.checked;
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(
+          () => {
+            r(), We(this);
+          },
+          {
+            checked: t !== !1
+          }
+        );
+        return;
+      } else
+        r();
+    }
+    const i = this.parent;
+    !i || i.level === 0 || o || We(i);
+  }
+  getChildren(t = !1) {
+    if (this.level === 0) return this.data;
+    const l = this.data;
+    if (!l) return null;
+    const o = this.store.props;
+    let n = "children";
+    return o && (n = o.children || "children"), ae(l[n]) && (l[n] = null), t && !l[n] && (l[n] = []), l[n];
+  }
+  updateChildren() {
+    const t = this.getChildren() || [], l = this.childNodes.map((i) => i.data), o = {}, n = [];
+    t.forEach((i, r) => {
+      const s = i[Le];
+      !!s && l.some((h) => (h == null ? void 0 : h[Le]) === s) ? o[s] = { index: r, data: i } : n.push({ index: r, data: i });
+    }), this.store.lazy || l.forEach((i) => {
+      o[i == null ? void 0 : i[Le]] || this.removeChildByData(i);
+    }), n.forEach(({ index: i, data: r }) => {
+      this.insertChild({ data: r }, i);
+    }), this.updateLeafState();
+  }
+  loadData(t, l = {}) {
+    if (this.store.lazy === !0 && this.store.load && !this.loaded && (!this.loading || Object.keys(l).length)) {
+      this.loading = !0;
+      const o = (i) => {
+        this.childNodes = [], this.doCreateChildren(i, l), this.loaded = !0, this.loading = !1, this.updateLeafState(), t && t.call(this, i);
+      }, n = () => {
+        this.loading = !1;
+      };
+      this.store.load(this, o, n);
+    } else
+      t && t.call(this);
+  }
+  eachNode(t) {
+    const l = [this];
+    for (; l.length; ) {
+      const o = l.shift();
+      l.unshift(...o.childNodes), t(o);
+    }
+  }
+  reInitChecked() {
+    this.store.checkStrictly || We(this);
+  }
+}
+var bo = Object.defineProperty, Co = (e, t, l) => t in e ? bo(e, t, { enumerable: !0, configurable: !0, writable: !0, value: l }) : e[t] = l, Z = (e, t, l) => Co(e, typeof t != "symbol" ? t + "" : t, l);
+class No {
+  constructor(t) {
+    Z(this, "currentNode"), Z(this, "currentNodeKey"), Z(this, "nodesMap"), Z(this, "root"), Z(this, "data"), Z(this, "lazy", !1), Z(this, "load"), Z(this, "filterNodeMethod"), Z(this, "key"), Z(this, "defaultCheckedKeys"), Z(this, "checkStrictly", !1), Z(this, "defaultExpandedKeys"), Z(this, "autoExpandParent", !1), Z(this, "defaultExpandAll", !1), Z(this, "checkDescendants", !1), Z(this, "props"), this.currentNode = null, this.currentNodeKey = null;
+    for (const l in t)
+      Nt(t, l) && (this[l] = t[l]);
+    this.nodesMap = {};
+  }
+  initialize() {
+    if (this.root = new ke({
+      data: this.data,
+      store: this
+    }), this.root.initialize(), this.lazy && this.load) {
+      const t = this.load;
+      t(
+        this.root,
+        (l) => {
+          this.root.doCreateChildren(l), this._initDefaultCheckedNodes();
+        },
+        Bl
+      );
+    } else
+      this._initDefaultCheckedNodes();
+  }
+  filter(t) {
+    const l = this.filterNodeMethod, o = this.lazy, n = async function(i) {
+      const r = i.root ? i.root.childNodes : i.childNodes;
+      for (const [s, f] of r.entries())
+        f.visible = !!(l != null && l.call(
+          f,
+          t,
+          f.data,
+          f
+        )), s % 80 === 0 && s > 0 && await q(), await n(f);
+      if (!i.visible && r.length) {
+        let s = !0;
+        s = !r.some((f) => f.visible), i.root ? i.root.visible = s === !1 : i.visible = s === !1;
+      }
+      t && i.visible && !i.isLeaf && (!o || i.loaded) && i.expand();
+    };
+    n(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 ke) return t;
+    const l = de(t) ? Vt(this.key, t) : t;
+    return this.nodesMap[l] || null;
+  }
+  insertBefore(t, l) {
+    var o;
+    const n = this.getNode(l);
+    (o = n.parent) == null || o.insertBefore({ data: t }, n);
+  }
+  insertAfter(t, l) {
+    var o;
+    const n = this.getNode(l);
+    (o = n.parent) == null || o.insertAfter({ data: t }, n);
+  }
+  remove(t) {
+    const l = this.getNode(t);
+    l && l.parent && (l === this.currentNode && (this.currentNode = null), l.parent.removeChild(l));
+  }
+  append(t, l) {
+    const o = en(l) ? this.root : this.getNode(l);
+    o && o.insertChild({ data: t });
+  }
+  _initDefaultCheckedNodes() {
+    const t = this.defaultCheckedKeys || [], l = this.nodesMap;
+    t.forEach((o) => {
+      const n = l[o];
+      n && n.setChecked(!0, !this.checkStrictly);
+    });
+  }
+  _initDefaultCheckedNode(t) {
+    const l = this.defaultCheckedKeys || [];
+    !Ue(t.key) && l.includes(t.key) && t.setChecked(!0, !this.checkStrictly);
+  }
+  setDefaultCheckedKey(t) {
+    t !== this.defaultCheckedKeys && (this.defaultCheckedKeys = t, this._initDefaultCheckedNodes());
+  }
+  registerNode(t) {
+    const l = this.key;
+    if (!(!t || !t.data))
+      if (!l)
+        this.nodesMap[t.id] = t;
+      else {
+        const o = t.key;
+        Ue(o) || (this.nodesMap[o] = t);
+      }
+  }
+  deregisterNode(t) {
+    !this.key || !t || !t.data || (t.childNodes.forEach((o) => {
+      this.deregisterNode(o);
+    }), delete this.nodesMap[t.key]);
+  }
+  getCheckedNodes(t = !1, l = !1) {
+    const o = [], n = function(i) {
+      (i.root ? i.root.childNodes : i.childNodes).forEach((s) => {
+        (s.checked || l && s.indeterminate) && (!t || t && s.isLeaf) && o.push(s.data), n(s);
+      });
+    };
+    return n(this), o;
+  }
+  getCheckedKeys(t = !1) {
+    return this.getCheckedNodes(t).map((l) => (l || {})[this.key]);
+  }
+  getHalfCheckedNodes() {
+    const t = [], l = function(o) {
+      (o.root ? o.root.childNodes : o.childNodes).forEach((i) => {
+        i.indeterminate && t.push(i.data), l(i);
+      });
+    };
+    return l(this), t;
+  }
+  getHalfCheckedKeys() {
+    return this.getHalfCheckedNodes().map((t) => (t || {})[this.key]);
+  }
+  _getAllNodes() {
+    const t = [], l = this.nodesMap;
+    for (const o in l)
+      Nt(l, o) && t.push(l[o]);
+    return t;
+  }
+  updateChildren(t, l) {
+    const o = this.nodesMap[t];
+    if (!o) return;
+    const n = o.childNodes;
+    for (let i = n.length - 1; i >= 0; i--) {
+      const r = n[i];
+      this.remove(r.data);
+    }
+    for (let i = 0, r = l.length; i < r; i++) {
+      const s = l[i];
+      this.append(s, o.data);
+    }
+  }
+  _setCheckedKeys(t, l = !1, o) {
+    const n = this._getAllNodes().sort((f, h) => f.level - h.level), i = /* @__PURE__ */ Object.create(null), r = Object.keys(o);
+    n.forEach((f) => f.setChecked(!1, !1));
+    const s = (f) => {
+      f.childNodes.forEach((h) => {
+        var c;
+        i[h.data[t]] = !0, (c = h.childNodes) != null && c.length && s(h);
+      });
+    };
+    for (let f = 0, h = n.length; f < h; f++) {
+      const c = n[f], m = c.data[t].toString();
+      if (!r.includes(m)) {
+        c.checked && !i[m] && c.setChecked(!1, !1);
+        continue;
+      }
+      if (c.childNodes.length && s(c), c.isLeaf || this.checkStrictly) {
+        c.setChecked(!0, !1);
+        continue;
+      }
+      if (c.setChecked(!0, !0), l) {
+        c.setChecked(!1, !1);
+        const u = function(g) {
+          g.childNodes.forEach((p) => {
+            p.isLeaf || p.setChecked(!1, !1), u(p);
+          });
+        };
+        u(c);
+      }
+    }
+  }
+  setCheckedNodes(t, l = !1) {
+    const o = this.key, n = {};
+    t.forEach((i) => {
+      n[(i || {})[o]] = !0;
+    }), this._setCheckedKeys(o, l, n);
+  }
+  setCheckedKeys(t, l = !1) {
+    this.defaultCheckedKeys = t;
+    const o = this.key, n = {};
+    t.forEach((i) => {
+      n[i] = !0;
+    }), this._setCheckedKeys(o, l, n);
+  }
+  setDefaultExpandedKeys(t) {
+    t = t || [], this.defaultExpandedKeys = t, t.forEach((l) => {
+      const o = this.getNode(l);
+      o && o.expand(null, this.autoExpandParent);
+    });
+  }
+  setChecked(t, l, o) {
+    const n = this.getNode(t);
+    n && n.setChecked(!!l, o);
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+  setCurrentNode(t) {
+    const l = this.currentNode;
+    l && (l.isCurrent = !1), this.currentNode = t, this.currentNode.isCurrent = !0;
+  }
+  setUserCurrentNode(t, l = !0) {
+    var o;
+    const n = t[this.key], i = this.nodesMap[n];
+    this.setCurrentNode(i), l && this.currentNode && this.currentNode.level > 1 && ((o = this.currentNode.parent) == null || o.expand(null, !0));
+  }
+  setCurrentNodeKey(t, l = !0) {
+    var o;
+    if (this.currentNodeKey = t, en(t)) {
+      this.currentNode && (this.currentNode.isCurrent = !1), this.currentNode = null;
+      return;
+    }
+    const n = this.getNode(t);
+    n && (this.setCurrentNode(n), l && this.currentNode && this.currentNode.level > 1 && ((o = this.currentNode.parent) == null || o.expand(null, !0)));
+  }
+}
+var ko = /* @__PURE__ */ oe({
+  name: "ElCollapseTransition",
+  __name: "collapse-transition",
+  setup(e) {
+    const t = le("collapse-transition"), l = (n) => {
+      n.style.maxHeight = "", n.style.overflow = n.dataset.oldOverflow, n.style.paddingTop = n.dataset.oldPaddingTop, n.style.paddingBottom = n.dataset.oldPaddingBottom;
+    }, o = {
+      beforeEnter(n) {
+        n.dataset || (n.dataset = {}), n.dataset.oldPaddingTop = n.style.paddingTop, n.dataset.oldPaddingBottom = n.style.paddingBottom, n.style.height && (n.dataset.elExistsHeight = n.style.height), n.style.maxHeight = 0, n.style.paddingTop = 0, n.style.paddingBottom = 0;
+      },
+      enter(n) {
+        requestAnimationFrame(() => {
+          n.dataset.oldOverflow = n.style.overflow, n.dataset.elExistsHeight ? n.style.maxHeight = n.dataset.elExistsHeight : n.scrollHeight !== 0 ? n.style.maxHeight = `${n.scrollHeight}px` : n.style.maxHeight = 0, n.style.paddingTop = n.dataset.oldPaddingTop, n.style.paddingBottom = n.dataset.oldPaddingBottom, n.style.overflow = "hidden";
+        });
+      },
+      afterEnter(n) {
+        n.style.maxHeight = "", n.style.overflow = n.dataset.oldOverflow;
+      },
+      enterCancelled(n) {
+        l(n);
+      },
+      beforeLeave(n) {
+        n.dataset || (n.dataset = {}), n.dataset.oldPaddingTop = n.style.paddingTop, n.dataset.oldPaddingBottom = n.style.paddingBottom, n.dataset.oldOverflow = n.style.overflow, n.style.maxHeight = `${n.scrollHeight}px`, n.style.overflow = "hidden";
+      },
+      leave(n) {
+        n.scrollHeight !== 0 && (n.style.maxHeight = 0, n.style.paddingTop = 0, n.style.paddingBottom = 0);
+      },
+      afterLeave(n) {
+        l(n);
+      },
+      leaveCancelled(n) {
+        l(n);
+      }
+    };
+    return (n, i) => (D(), W(rl, it({
+      name: at(t).b()
+    }, dl(o)), {
+      default: H(() => [
+        j(n.$slots, "default")
+      ]),
+      _: 3
+      /* FORWARDED */
+    }, 16, ["name"]));
+  }
+});
+const Eo = Qe(ko), So = ft({
+  /**
+   * @description text type
+   */
+  type: {
+    type: String,
+    values: ["primary", "success", "info", "warning", "danger", ""],
+    default: ""
+  },
+  /**
+   * @description text size
+   */
+  size: {
+    type: String,
+    values: Il,
+    default: ""
+  },
+  /**
+   * @description render ellipsis
+   */
+  truncated: Boolean,
+  /**
+   * @description maximum lines
+   */
+  lineClamp: {
+    type: [String, Number]
+  },
+  /**
+   * @description custom element tag
+   */
+  tag: {
+    type: String,
+    default: "span"
+  }
+});
+var wo = /* @__PURE__ */ oe({
+  name: "ElText",
+  __name: "text",
+  props: So,
+  setup(e) {
+    const t = e, l = V(), o = dn(), n = le("text"), i = w(() => [
+      n.b(),
+      n.m(t.type),
+      n.m(o.value),
+      n.is("truncated", t.truncated),
+      n.is("line-clamp", !ae(t.lineClamp))
+    ]), r = () => {
+      var s, f, h, c, m, d, u;
+      if (ul().title) return;
+      let y = !1;
+      const p = ((s = l.value) == null ? void 0 : s.textContent) || "";
+      if (t.truncated) {
+        const O = (f = l.value) == null ? void 0 : f.offsetWidth, C = (h = l.value) == null ? void 0 : h.scrollWidth;
+        O && C && C > O && (y = !0);
+      } else if (!ae(t.lineClamp)) {
+        const O = (c = l.value) == null ? void 0 : c.offsetHeight, C = (m = l.value) == null ? void 0 : m.scrollHeight;
+        O && C && C > O && (y = !0);
+      }
+      y ? (d = l.value) == null || d.setAttribute("title", p) : (u = l.value) == null || u.removeAttribute("title");
+    };
+    return Oe(r), an(r), (s, f) => (D(), W(je(e.tag), {
+      ref_key: "textRef",
+      ref: l,
+      class: K(i.value),
+      style: Ve({ "-webkit-line-clamp": e.lineClamp })
+    }, {
+      default: H(() => [
+        j(s.$slots, "default")
+      ]),
+      _: 3
+      /* FORWARDED */
+    }, 8, ["class", "style"]));
+  }
+});
+const Oo = Qe(wo), Lt = "RootTree", Nn = "NodeInstance", sn = "TreeNodeMap";
+var Do = oe({
+  name: "ElTreeNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    renderContent: Function
+  },
+  setup(e) {
+    const t = le("tree"), l = ce(
+      Nn
+    ), o = ce(Lt);
+    return () => {
+      const n = e.node, { data: i, store: r } = n;
+      return e.renderContent ? e.renderContent(qe, { _self: l, node: n, data: i, store: r }) : j(o.ctx.slots, "default", { node: n, data: i }, () => [
+        qe(
+          Oo,
+          { tag: "span", truncated: !0, class: t.be("node", "label") },
+          () => [n.label]
+        )
+      ]);
+    };
+  }
+});
+function kn(e) {
+  const t = ce(
+    sn,
+    null
+  );
+  let l = {
+    treeNodeExpand: (o) => {
+      var n;
+      e.node !== o && ((n = e.node) == null || n.collapse());
+    },
+    children: /* @__PURE__ */ new Set()
+  };
+  return t && t.children.add(l), Dt(() => {
+    t && t.children.delete(l), l = null;
+  }), Se(sn, l), {
+    broadcastExpanded: (o) => {
+      if (e.accordion)
+        for (const n of l.children)
+          n.treeNodeExpand(o);
+    }
+  };
+}
+const En = /* @__PURE__ */ Symbol("dragEvents");
+function Ko({
+  props: e,
+  ctx: t,
+  el$: l,
+  dropIndicator$: o,
+  store: n
+}) {
+  const i = le("tree"), r = V({
+    showDropIndicator: !1,
+    draggingNode: null,
+    dropNode: null,
+    allowDrop: !0,
+    dropType: null
+  });
+  return Se(En, {
+    treeNodeDragStart: ({ event: c, treeNode: m }) => {
+      if (c.dataTransfer) {
+        if (ue(e.allowDrag) && !e.allowDrag(m.node))
+          return c.preventDefault(), !1;
+        c.dataTransfer.effectAllowed = "move";
+        try {
+          c.dataTransfer.setData("text/plain", "");
+        } catch {
+        }
+        r.value.draggingNode = m, t.emit("node-drag-start", m.node, c);
+      }
+    },
+    treeNodeDragOver: ({ event: c, treeNode: m }) => {
+      if (!c.dataTransfer) return;
+      const d = m, u = r.value.dropNode;
+      u && u.node.id !== d.node.id && mt(u.$el, i.is("drop-inner"));
+      const g = r.value.draggingNode;
+      if (!g || !d) return;
+      let y = !0, p = !0, O = !0, C = !0;
+      ue(e.allowDrop) && (y = e.allowDrop(g.node, d.node, "prev"), C = p = e.allowDrop(
+        g.node,
+        d.node,
+        "inner"
+      ), O = e.allowDrop(g.node, d.node, "next")), c.dataTransfer.dropEffect = p || y || O ? "move" : "none", (y || p || O) && (u == null ? void 0 : u.node.id) !== d.node.id && (u && t.emit("node-drag-leave", g.node, u.node, c), t.emit("node-drag-enter", g.node, d.node, c)), y || p || O ? r.value.dropNode = d : r.value.dropNode = null, d.node.nextSibling === g.node && (O = !1), d.node.previousSibling === g.node && (y = !1), d.node.contains(g.node, !1) && (p = !1), (g.node === d.node || g.node.contains(d.node)) && (y = !1, p = !1, O = !1);
+      const E = d.$el, k = E.querySelector(`.${i.be("node", "content")}`).getBoundingClientRect(), U = l.value.getBoundingClientRect(), ee = l.value.scrollTop;
+      let T;
+      const ge = y ? p ? 0.25 : O ? 0.45 : 1 : Number.NEGATIVE_INFINITY, S = O ? p ? 0.75 : y ? 0.55 : 0 : Number.POSITIVE_INFINITY;
+      let $ = -9999;
+      const R = c.clientY - k.top;
+      R < k.height * ge ? T = "before" : R > k.height * S ? T = "after" : p ? T = "inner" : T = "none";
+      const G = E.querySelector(`.${i.be("node", "expand-icon")}`).getBoundingClientRect(), De = o.value;
+      T === "before" ? $ = G.top - U.top + ee : T === "after" && ($ = G.bottom - U.top + ee), De.style.top = `${$}px`, De.style.left = `${G.right - U.left}px`, T === "inner" ? wl(E, i.is("drop-inner")) : mt(E, i.is("drop-inner")), r.value.showDropIndicator = T === "before" || T === "after", r.value.allowDrop = r.value.showDropIndicator || C, r.value.dropType = T, t.emit("node-drag-over", g.node, d.node, c);
+    },
+    treeNodeDragEnd: (c) => {
+      var m, d;
+      const { draggingNode: u, dropType: g, dropNode: y } = r.value;
+      if (c.preventDefault(), c.dataTransfer && (c.dataTransfer.dropEffect = "move"), u != null && u.node.data && y) {
+        const p = { data: u.node.data };
+        g !== "none" && u.node.remove(), g === "before" ? (m = y.node.parent) == null || m.insertBefore(p, y.node) : g === "after" ? (d = y.node.parent) == null || d.insertAfter(p, y.node) : g === "inner" && y.node.insertChild(p), g !== "none" && (n.value.registerNode(p), n.value.key && u.node.eachNode((O) => {
+          var C;
+          (C = n.value.nodesMap[O.data[n.value.key]]) == null || C.setChecked(
+            O.checked,
+            !n.value.checkStrictly
+          );
+        })), mt(y.$el, i.is("drop-inner")), t.emit(
+          "node-drag-end",
+          u.node,
+          y.node,
+          g,
+          c
+        ), g !== "none" && t.emit(
+          "node-drop",
+          u.node,
+          y.node,
+          g,
+          c
+        );
+      }
+      u && !y && t.emit("node-drag-end", u.node, null, g, c), r.value.showDropIndicator = !1, r.value.draggingNode = null, r.value.dropNode = null, r.value.allowDrop = !0;
+    }
+  }), {
+    dragState: r
+  };
+}
+var To = oe({
+  name: "ElTreeNode",
+  components: {
+    ElCollapseTransition: Eo,
+    ElCheckbox: Yl,
+    NodeContent: Do,
+    ElIcon: rn,
+    Loading: Pl
+  },
+  props: {
+    node: {
+      type: ke,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: Boolean
+  },
+  emits: ["node-expand"],
+  setup(e, t) {
+    const l = le("tree"), { broadcastExpanded: o } = kn(e), n = ce(Lt), i = V(!1), r = V(!1), s = V(), f = V(), h = V(), c = ce(En), m = we();
+    Se(Nn, m), n || bt("Tree", "Can not find node's tree."), e.node.expanded && (i.value = !0, r.value = !0);
+    const d = n.props.props.children || "children";
+    P(
+      () => {
+        var S;
+        const $ = (S = e.node.data) == null ? void 0 : S[d];
+        return $ && [...$];
+      },
+      () => {
+        e.node.updateChildren();
+      }
+    ), P(
+      () => e.node.indeterminate,
+      (S) => {
+        y(e.node.checked, S);
+      }
+    ), P(
+      () => e.node.checked,
+      (S) => {
+        y(S, e.node.indeterminate);
+      }
+    ), P(
+      () => e.node.childNodes.length,
+      () => e.node.reInitChecked()
+    ), P(
+      () => e.node.expanded,
+      (S) => {
+        q(() => i.value = S), S && (r.value = !0);
+      }
+    );
+    const u = (S) => Vt(n.props.nodeKey, S.data), g = (S) => {
+      const $ = e.props.class;
+      if (!$)
+        return {};
+      let R;
+      if (ue($)) {
+        const { data: G } = S;
+        R = $(G, S);
+      } else
+        R = $;
+      return Kt(R) ? { [R]: !0 } : R;
+    }, y = (S, $) => {
+      (s.value !== S || f.value !== $) && n.ctx.emit("check-change", e.node.data, S, $), s.value = S, f.value = $;
+    }, p = (S) => {
+      St(n.store, n.ctx.emit, () => {
+        var $;
+        if (($ = n == null ? void 0 : n.props) == null ? void 0 : $.nodeKey) {
+          const G = u(e.node);
+          n.store.value.setCurrentNodeKey(G);
+        } else
+          n.store.value.setCurrentNode(e.node);
+      }), n.currentNode.value = e.node, n.props.expandOnClickNode && C(), (n.props.checkOnClickNode || e.node.isLeaf && n.props.checkOnClickLeaf && e.showCheckbox) && !e.node.disabled && E(!e.node.checked), n.ctx.emit("node-click", e.node.data, e.node, m, S);
+    }, O = (S) => {
+      var $;
+      ($ = n.instance.vnode.props) != null && $.onNodeContextmenu && (S.stopPropagation(), S.preventDefault()), n.ctx.emit(
+        "node-contextmenu",
+        S,
+        e.node.data,
+        e.node,
+        m
+      );
+    }, C = () => {
+      e.node.isLeaf || (i.value ? (n.ctx.emit("node-collapse", e.node.data, e.node, m), e.node.collapse()) : e.node.expand(() => {
+        t.emit("node-expand", e.node.data, e.node, m);
+      }));
+    }, E = (S) => {
+      const $ = n == null ? void 0 : n.props.checkStrictly, R = e.node.childNodes;
+      !$ && R.length && (S = R.some((G) => !G.isEffectivelyChecked)), e.node.setChecked(S, !$), q(() => {
+        const G = n.store.value;
+        n.ctx.emit("check", e.node.data, {
+          checkedNodes: G.getCheckedNodes(),
+          checkedKeys: G.getCheckedKeys(),
+          halfCheckedNodes: G.getHalfCheckedNodes(),
+          halfCheckedKeys: G.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: l,
+      node$: h,
+      tree: n,
+      expanded: i,
+      childNodeRendered: r,
+      oldChecked: s,
+      oldIndeterminate: f,
+      getNodeKey: u,
+      getNodeClass: g,
+      handleSelectChange: y,
+      handleClick: p,
+      handleContextMenu: O,
+      handleExpandIconClick: C,
+      handleCheckChange: E,
+      handleChildNodeExpand: (S, $, R) => {
+        o($), n.ctx.emit("node-expand", S, $, R);
+      },
+      handleDragStart: (S) => {
+        n.props.draggable && c.treeNodeDragStart({ event: S, treeNode: e });
+      },
+      handleDragOver: (S) => {
+        S.preventDefault(), n.props.draggable && c.treeNodeDragOver({
+          event: S,
+          treeNode: { $el: h.value, node: e.node }
+        });
+      },
+      handleDrop: (S) => {
+        S.preventDefault();
+      },
+      handleDragEnd: (S) => {
+        n.props.draggable && c.treeNodeDragEnd(S);
+      },
+      CaretRight: Al
+    };
+  }
+});
+const Io = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"], $o = ["aria-expanded"];
+function Vo(e, t, l, o, n, i) {
+  const r = X("el-icon"), s = X("el-checkbox"), f = X("loading"), h = X("node-content"), c = X("el-tree-node"), m = X("el-collapse-transition");
+  return Ee((D(), M("div", {
+    ref: "node$",
+    class: K([
+      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] = ne((...d) => e.handleClick && e.handleClick(...d), ["stop"])),
+    onContextmenu: t[3] || (t[3] = (...d) => e.handleContextMenu && e.handleContextMenu(...d)),
+    onDragstart: t[4] || (t[4] = ne((...d) => e.handleDragStart && e.handleDragStart(...d), ["stop"])),
+    onDragover: t[5] || (t[5] = ne((...d) => e.handleDragOver && e.handleDragOver(...d), ["stop"])),
+    onDragend: t[6] || (t[6] = ne((...d) => e.handleDragEnd && e.handleDragEnd(...d), ["stop"])),
+    onDrop: t[7] || (t[7] = ne((...d) => e.handleDrop && e.handleDrop(...d), ["stop"]))
+  }, [
+    F(
+      "div",
+      {
+        class: K(e.ns.be("node", "content")),
+        style: Ve({ paddingLeft: (e.node.level - 1) * e.tree.props.indent + "px" })
+      },
+      [
+        e.tree.props.icon || e.CaretRight ? (D(), W(r, {
+          key: 0,
+          class: K([
+            e.ns.be("node", "expand-icon"),
+            e.ns.is("leaf", e.node.isLeaf),
+            {
+              expanded: !e.node.isLeaf && e.expanded
+            }
+          ]),
+          onClick: ne(e.handleExpandIconClick, ["stop"])
+        }, {
+          default: H(() => [
+            (D(), W(je(e.tree.props.icon || e.CaretRight)))
+          ]),
+          _: 1
+          /* STABLE */
+        }, 8, ["class", "onClick"])) : z("v-if", !0),
+        e.showCheckbox ? (D(), W(s, {
+          key: 1,
+          "model-value": e.node.checked,
+          indeterminate: e.node.indeterminate,
+          disabled: !!e.node.disabled,
+          onClick: t[0] || (t[0] = ne(() => {
+          }, ["stop"])),
+          onChange: e.handleCheckChange
+        }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : z("v-if", !0),
+        e.node.loading ? (D(), W(r, {
+          key: 2,
+          class: K([e.ns.be("node", "loading-icon"), e.ns.is("loading")])
+        }, {
+          default: H(() => [
+            re(f)
+          ]),
+          _: 1
+          /* STABLE */
+        }, 8, ["class"])) : z("v-if", !0),
+        re(h, {
+          node: e.node,
+          "render-content": e.renderContent
+        }, null, 8, ["node", "render-content"])
+      ],
+      6
+      /* CLASS, STYLE */
+    ),
+    re(m, null, {
+      default: H(() => [
+        !e.renderAfterExpand || e.childNodeRendered ? Ee((D(), M("div", {
+          key: 0,
+          class: K(e.ns.be("node", "children")),
+          role: "group",
+          "aria-expanded": e.expanded,
+          onClick: t[1] || (t[1] = ne(() => {
+          }, ["stop"]))
+        }, [
+          (D(!0), M(
+            Ne,
+            null,
+            Ie(e.node.childNodes, (d) => (D(), W(c, {
+              key: e.getNodeKey(d),
+              "render-content": e.renderContent,
+              "render-after-expand": e.renderAfterExpand,
+              "show-checkbox": e.showCheckbox,
+              node: d,
+              accordion: e.accordion,
+              props: e.props,
+              onNodeExpand: e.handleChildNodeExpand
+            }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]))),
+            128
+            /* KEYED_FRAGMENT */
+          ))
+        ], 10, $o)), [
+          [Me, e.expanded]
+        ]) : z("v-if", !0)
+      ]),
+      _: 1
+      /* STABLE */
+    })
+  ], 42, Io)), [
+    [Me, e.node.visible]
+  ]);
+}
+var Lo = /* @__PURE__ */ Be(To, [["render", Vo]]);
+function Mo({ el$: e }, t) {
+  const l = le("tree");
+  Oe(() => {
+    i();
+  }), an(() => {
+    var r;
+    (r = e.value) == null || r.querySelectorAll("input[type=checkbox]").forEach((s) => {
+      s.setAttribute("tabindex", "-1");
+    });
+  });
+  function o(r, s) {
+    var f, h;
+    const c = t.value.getNode(r[s].dataset.key);
+    return c.canFocus && c.visible && (((f = c.parent) == null ? void 0 : f.expanded) || ((h = c.parent) == null ? void 0 : h.level) === 0);
+  }
+  vn(e, "keydown", (r) => {
+    const s = r.target;
+    if (!s.className.includes(l.b("node"))) return;
+    const f = ct(r), h = Array.from(
+      e.value.querySelectorAll(`.${l.is("focusable")}[role=treeitem]`)
+    ), c = h.indexOf(s);
+    let m;
+    if ([A.up, A.down].includes(f)) {
+      if (r.preventDefault(), f === A.up) {
+        m = c === -1 ? 0 : c !== 0 ? c - 1 : h.length - 1;
+        const u = m;
+        for (; !o(h, m); ) {
+          if (m--, m === u) {
+            m = -1;
+            break;
+          }
+          m < 0 && (m = h.length - 1);
+        }
+      } else {
+        m = c === -1 ? 0 : c < h.length - 1 ? c + 1 : 0;
+        const u = m;
+        for (; !o(h, m); ) {
+          if (m++, m === u) {
+            m = -1;
+            break;
+          }
+          m >= h.length && (m = 0);
+        }
+      }
+      m !== -1 && h[m].focus();
+    }
+    [A.left, A.right].includes(f) && (r.preventDefault(), s.click());
+    const d = s.querySelector(
+      '[type="checkbox"]'
+    );
+    [A.enter, A.numpadEnter, A.space].includes(
+      f
+    ) && d && (r.preventDefault(), d.click());
+  });
+  const i = () => {
+    var r;
+    if (!e.value) return;
+    const s = Array.from(
+      e.value.querySelectorAll(`.${l.is("focusable")}[role=treeitem]`)
+    );
+    Array.from(
+      e.value.querySelectorAll("input[type=checkbox]")
+    ).forEach((c) => {
+      c.setAttribute("tabindex", "-1");
+    });
+    const h = e.value.querySelectorAll(
+      `.${l.is("checked")}[role=treeitem]`
+    );
+    if (h.length) {
+      h[0].setAttribute("tabindex", "0");
+      return;
+    }
+    (r = s[0]) == null || r.setAttribute("tabindex", "0");
+  };
+}
+const Sn = ft({
+  data: {
+    type: _(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: _(Function)
+  },
+  showCheckbox: Boolean,
+  draggable: Boolean,
+  allowDrag: {
+    type: _(Function)
+  },
+  allowDrop: {
+    type: _(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: kt
+  }
+}), Bo = {
+  "check-change": (e, t, l) => e && Ct(t) && Ct(l),
+  "current-change": (e, t) => !0,
+  "node-click": (e, t, l, o) => e && t && o instanceof Event,
+  "node-contextmenu": (e, t, l, o) => e instanceof Event && t && l,
+  "node-collapse": (e, t, l) => e && t,
+  "node-expand": (e, t, l) => e && t,
+  check: (e, t) => e && t,
+  "node-drag-start": (e, t) => e && t,
+  "node-drag-end": (e, t, l, o) => e && o,
+  "node-drop": (e, t, l, o) => e && t && o,
+  "node-drag-leave": (e, t, l) => e && t && l,
+  "node-drag-enter": (e, t, l) => e && t && l,
+  "node-drag-over": (e, t, l) => e && t && l
+};
+var Po = oe({
+  name: "ElTree",
+  components: { ElTreeNode: Lo },
+  props: Sn,
+  emits: Bo,
+  setup(e, t) {
+    const { t: l } = gn(), o = le("tree"), n = V(
+      new No({
+        key: e.nodeKey,
+        data: e.data,
+        lazy: e.lazy,
+        props: e.props,
+        load: e.load,
+        currentNodeKey: e.currentNodeKey,
+        checkStrictly: e.checkStrictly,
+        checkDescendants: e.checkDescendants,
+        defaultCheckedKeys: e.defaultCheckedKeys,
+        defaultExpandedKeys: e.defaultExpandedKeys,
+        autoExpandParent: e.autoExpandParent,
+        defaultExpandAll: e.defaultExpandAll,
+        filterNodeMethod: e.filterNodeMethod
+      })
+    );
+    n.value.initialize();
+    const i = V(n.value.root), r = V(null), s = V(null), f = V(null), { broadcastExpanded: h } = kn(e), { dragState: c } = Ko({
+      props: e,
+      ctx: t,
+      el$: s,
+      dropIndicator$: f,
+      store: n
+    });
+    Mo({ el$: s }, n);
+    const m = we(), d = w(() => {
+      let b = m == null ? void 0 : m.parent;
+      for (; b; ) {
+        if (b.type.name === "ElTreeSelect")
+          return !0;
+        b = b.parent;
+      }
+      return !1;
+    }), u = w(() => {
+      const { childNodes: b } = i.value;
+      return (!b || b.length === 0 || b.every(({ visible: I }) => !I)) && !d.value;
+    });
+    P(
+      () => e.currentNodeKey,
+      (b) => {
+        n.value.setCurrentNodeKey(b ?? null);
+      }
+    ), P(
+      () => e.defaultCheckedKeys,
+      (b, I) => {
+        ve(b, I) || n.value.setDefaultCheckedKey(b ?? []);
+      }
+    ), P(
+      () => e.defaultExpandedKeys,
+      (b) => {
+        n.value.setDefaultExpandedKeys(b ?? []);
+      }
+    ), P(
+      () => e.data,
+      (b) => {
+        n.value.setData(b);
+      },
+      { deep: !0 }
+    ), P(
+      () => e.checkStrictly,
+      (b) => {
+        n.value.checkStrictly = b;
+      }
+    );
+    const g = (b) => {
+      if (!e.filterNodeMethod)
+        throw new Error("[Tree] filterNodeMethod is required when filter");
+      n.value.filter(b);
+    }, y = (b) => Vt(e.nodeKey, b.data), p = (b) => {
+      if (!e.nodeKey)
+        throw new Error(`[Tree] nodeKey is required in ${b}`);
+    }, O = (b) => {
+      p("getNodePath");
+      const I = n.value.getNode(b);
+      if (!I) return [];
+      const fe = [I.data];
+      let me = I.parent;
+      for (; me && me !== i.value; )
+        fe.push(me.data), me = me.parent;
+      return fe.reverse();
+    }, C = (b, I) => n.value.getCheckedNodes(b, I), E = (b) => n.value.getCheckedKeys(b), k = () => {
+      const b = n.value.getCurrentNode();
+      return b ? b.data : null;
+    }, U = () => {
+      p("getCurrentKey");
+      const b = k();
+      return b ? b[e.nodeKey] : null;
+    }, ee = (b, I) => {
+      p("setCheckedNodes"), n.value.setCheckedNodes(b, I);
+    }, T = (b, I) => {
+      p("setCheckedKeys"), n.value.setCheckedKeys(b, I);
+    }, ge = (b, I, fe) => {
+      n.value.setChecked(b, I, fe);
+    }, S = () => n.value.getHalfCheckedNodes(), $ = () => n.value.getHalfCheckedKeys(), R = (b, I = !0) => {
+      p("setCurrentNode"), St(n, t.emit, () => {
+        h(b), n.value.setUserCurrentNode(b, I);
+      });
+    }, G = (b = null, I = !0) => {
+      p("setCurrentKey"), St(n, t.emit, () => {
+        h(), n.value.setCurrentNodeKey(b, I);
+      });
+    }, De = (b) => n.value.getNode(b), ht = (b) => {
+      n.value.remove(b);
+    }, ye = (b, I) => {
+      n.value.append(b, I);
+    }, Ze = (b, I) => {
+      n.value.insertBefore(b, I);
+    }, Pe = (b, I) => {
+      n.value.insertAfter(b, I);
+    }, pt = (b, I, fe) => {
+      h(I), t.emit("node-expand", b, I, fe);
+    }, Ae = (b, I) => {
+      p("updateKeyChild"), n.value.updateChildren(b, I);
+    };
+    return Se(Lt, {
+      ctx: t,
+      props: e,
+      store: n,
+      root: i,
+      currentNode: r,
+      instance: m
+    }), Se($l, void 0), {
+      ns: o,
+      // ref
+      store: n,
+      root: i,
+      currentNode: r,
+      dragState: c,
+      el$: s,
+      dropIndicator$: f,
+      // computed
+      isEmpty: u,
+      // methods
+      filter: g,
+      getNodeKey: y,
+      getNodePath: O,
+      getCheckedNodes: C,
+      getCheckedKeys: E,
+      getCurrentNode: k,
+      getCurrentKey: U,
+      setCheckedNodes: ee,
+      setCheckedKeys: T,
+      setChecked: ge,
+      getHalfCheckedNodes: S,
+      getHalfCheckedKeys: $,
+      setCurrentNode: R,
+      setCurrentKey: G,
+      t: l,
+      getNode: De,
+      remove: ht,
+      append: ye,
+      insertBefore: Ze,
+      insertAfter: Pe,
+      handleNodeExpand: pt,
+      updateKeyChildren: Ae
+    };
+  }
+});
+function Ao(e, t, l, o, n, i) {
+  const r = X("el-tree-node");
+  return D(), M(
+    "div",
+    {
+      ref: "el$",
+      class: K([
+        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"
+    },
+    [
+      (D(!0), M(
+        Ne,
+        null,
+        Ie(e.root.childNodes, (s) => (D(), W(r, {
+          key: e.getNodeKey(s),
+          node: s,
+          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
+        /* KEYED_FRAGMENT */
+      )),
+      e.isEmpty ? (D(), M(
+        "div",
+        {
+          key: 0,
+          class: K(e.ns.e("empty-block"))
+        },
+        [
+          j(e.$slots, "empty", {}, () => {
+            var s;
+            return [
+              F(
+                "span",
+                {
+                  class: K(e.ns.e("empty-text"))
+                },
+                ie((s = e.emptyText) != null ? s : e.t("el.tree.emptyText")),
+                3
+                /* TEXT, CLASS */
+              )
+            ];
+          })
+        ],
+        2
+        /* CLASS */
+      )) : z("v-if", !0),
+      Ee(F(
+        "div",
+        {
+          ref: "dropIndicator$",
+          class: K(e.ns.e("drop-indicator"))
+        },
+        null,
+        2
+        /* CLASS */
+      ), [
+        [Me, e.dragState.showDropIndicator]
+      ])
+    ],
+    2
+    /* CLASS */
+  );
+}
+var Ro = /* @__PURE__ */ Be(Po, [["render", Ao]]);
+const wn = Qe(Ro), Ho = (e, { attrs: t, emit: l }, {
+  select: o,
+  tree: n,
+  key: i
+}) => {
+  const r = le("tree-select");
+  P(
+    () => e.data,
+    () => {
+      e.filterable && q(() => {
+        var h, c;
+        (c = n.value) == null || c.filter((h = o.value) == null ? void 0 : h.states.inputValue);
+      });
+    },
+    { flush: "post" }
+  );
+  const s = (h) => {
+    var c;
+    const m = h.at(-1);
+    if (m.expanded && m.childNodes.at(-1))
+      s([m.childNodes.at(-1)]);
+    else {
+      const d = (c = n.value.el$) == null ? void 0 : c.querySelector(
+        `[data-key="${h.at(-1).key}"]`
+      );
+      d == null || d.focus({ preventScroll: !0 });
+      return;
+    }
+  };
+  return Oe(() => {
+    vn(
+      () => {
+        var h;
+        return (h = o.value) == null ? void 0 : h.$el;
+      },
+      "keydown",
+      async (h) => {
+        const c = ct(h), { dropdownMenuVisible: m } = o.value;
+        [A.down, A.up].includes(c) && m && (await q(), setTimeout(() => {
+          var d, u, g;
+          if (A.up === c) {
+            const y = n.value.store.root.childNodes;
+            s(y);
+            return;
+          }
+          (g = (u = (d = o.value.optionsArray[o.value.states.hoveringIndex].$el) == null ? void 0 : d.parentNode) == null ? void 0 : u.parentNode) == null || g.focus({ preventScroll: !0 });
+        }));
+      },
+      {
+        capture: !0
+      }
+    );
+  }), {
+    ...ut(Ye(e), Object.keys(bn.props)),
+    ...t,
+    class: w(() => t.class),
+    style: w(() => t.style),
+    // attrs is not reactive, when v-model binding source changes,
+    // this listener is still old, see the bug(or test 'v-model source change'):
+    // https://github.com/element-plus/element-plus/issues/14204
+    "onUpdate:modelValue": (h) => l(se, h),
+    valueKey: i,
+    popperClass: w(() => {
+      const h = [r.e("popper")];
+      return e.popperClass && h.push(e.popperClass), h.join(" ");
+    }),
+    filterMethod: (h = "") => {
+      var c;
+      e.filterMethod ? e.filterMethod(h) : e.remoteMethod ? e.remoteMethod(h) : (c = n.value) == null || c.filter(h);
+    }
+  };
+}, Fo = oe({
+  extends: ln,
+  setup(e, t) {
+    const l = ln.setup(e, t);
+    delete l.selectOptionClick;
+    const o = we().proxy;
+    return q(() => {
+      l.select.states.cachedOptions.get(o.value) || l.select.onOptionCreate(o);
+    }), P(
+      () => t.attrs.visible,
+      (n) => {
+        q(() => {
+          l.states.visible = n;
+        });
+      },
+      {
+        immediate: !0
+      }
+    ), l;
+  },
+  methods: {
+    selectOptionClick() {
+      this.$el.parentElement.click();
+    }
+  }
+});
+function Ot(e) {
+  return e || e === 0;
+}
+function Mt(e) {
+  return Q(e) && e.length;
+}
+function Ke(e) {
+  return Q(e) ? e : Ot(e) ? [e] : [];
+}
+function rt(e, t, l, o, n) {
+  for (let i = 0; i < e.length; i++) {
+    const r = e[i];
+    if (t(r, i, e, n))
+      return o ? o(r, i, e, n) : r;
+    {
+      const s = l(r);
+      if (Mt(s)) {
+        const f = rt(
+          s,
+          t,
+          l,
+          o,
+          r
+        );
+        if (f) return f;
+      }
+    }
+  }
+}
+function dt(e, t, l, o) {
+  for (let n = 0; n < e.length; n++) {
+    const i = e[n];
+    t(i, n, e, o);
+    const r = l(i);
+    Mt(r) && dt(r, t, l, i);
+  }
+}
+const zo = (e, { attrs: t, slots: l, emit: o }, {
+  select: n,
+  tree: i,
+  key: r
+}) => {
+  P(
+    [() => e.modelValue, i],
+    () => {
+      e.showCheckbox && q(() => {
+        const d = i.value;
+        d && !ve(
+          d.getCheckedKeys(),
+          Ke(e.modelValue)
+        ) && d.setCheckedKeys(Ke(e.modelValue));
+      });
+    },
+    {
+      immediate: !0,
+      deep: !0
+    }
+  );
+  const s = w(() => ({
+    value: r.value,
+    label: "label",
+    children: "children",
+    disabled: "disabled",
+    isLeaf: "isLeaf",
+    ...e.props
+  })), f = (d, u) => {
+    var g;
+    const y = s.value[d];
+    return ue(y) ? y(
+      u,
+      (g = i.value) == null ? void 0 : g.getNode(f("value", u))
+    ) : u[y];
+  }, h = Ke(e.modelValue).map((d) => rt(
+    e.data || [],
+    (u) => f("value", u) === d,
+    (u) => f("children", u),
+    (u, g, y, p) => p && f("value", p)
+  )).filter((d) => Ot(d)), c = w(() => {
+    if (!e.renderAfterExpand && !e.lazy) return [];
+    const d = [];
+    return dt(
+      e.data.concat(e.cacheData),
+      (u) => {
+        const g = f("value", u);
+        d.push({
+          value: g,
+          currentLabel: f("label", u),
+          isDisabled: f("disabled", u)
+        });
+      },
+      (u) => f("children", u)
+    ), d;
+  }), m = () => {
+    var d;
+    return (d = i.value) == null ? void 0 : d.getCheckedKeys().filter((u) => {
+      var g;
+      const y = (g = i.value) == null ? void 0 : g.getNode(u);
+      return !Ue(y) && un(y.childNodes);
+    });
+  };
+  return {
+    ...ut(Ye(e), Object.keys(wn.props)),
+    ...t,
+    nodeKey: r,
+    // only expand on click node when the `check-strictly` is false
+    expandOnClickNode: w(() => !e.checkStrictly && e.expandOnClickNode),
+    // show current selected node only first time,
+    // fix the problem of expanding multiple nodes when checking multiple nodes
+    defaultExpandedKeys: w(() => e.defaultExpandedKeys ? e.defaultExpandedKeys.concat(h) : h),
+    renderContent: (d, { node: u, data: g, store: y }) => d(
+      Fo,
+      {
+        value: f("value", g),
+        label: f("label", g),
+        disabled: f("disabled", g),
+        visible: u.visible
+      },
+      e.renderContent ? () => e.renderContent(d, { node: u, data: g, store: y }) : l.default ? () => l.default({ node: u, data: g, store: y }) : void 0
+    ),
+    filterNodeMethod: (d, u, g) => e.filterNodeMethod ? e.filterNodeMethod(d, u, g) : d ? new RegExp(fn(d), "i").test(f("label", u) || "") : !0,
+    onNodeClick: (d, u, g) => {
+      var y, p, O;
+      if ((y = t.onNodeClick) == null || y.call(t, d, u, g), !(e.showCheckbox && e.checkOnClickNode))
+        if (!e.showCheckbox && (e.checkStrictly || u.isLeaf)) {
+          if (!f("disabled", d)) {
+            const C = (p = n.value) == null ? void 0 : p.states.options.get(
+              f("value", d)
+            );
+            (O = n.value) == null || O.handleOptionSelect(C);
+          }
+        } else e.expandOnClickNode && g.proxy.handleExpandIconClick();
+    },
+    onCheck: (d, u) => {
+      var g;
+      if (!e.showCheckbox) return;
+      const y = f("value", d), p = {};
+      dt(
+        [i.value.store.root],
+        (k) => p[k.key] = k,
+        (k) => k.childNodes
+      );
+      const O = u.checkedKeys, C = e.multiple ? Ke(e.modelValue).filter(
+        (k) => !(k in p) && !O.includes(k)
+      ) : [], E = C.concat(O);
+      if (e.checkStrictly)
+        o(
+          se,
+          // Checking for changes may come from `check-on-node-click`
+          e.multiple ? E : E.includes(y) ? y : void 0
+        );
+      else if (e.multiple) {
+        const k = m();
+        o(se, C.concat(k));
+      } else {
+        const k = rt(
+          [d],
+          (T) => !Mt(f("children", T)) && !f("disabled", T),
+          (T) => f("children", T)
+        ), U = k ? f("value", k) : void 0, ee = Ot(e.modelValue) && !!rt(
+          [d],
+          (T) => f("value", T) === e.modelValue,
+          (T) => f("children", T)
+        );
+        o(
+          se,
+          U === e.modelValue || ee ? void 0 : U
+        );
+      }
+      q(() => {
+        var k;
+        const U = Ke(e.modelValue);
+        i.value.setCheckedKeys(U), (k = t.onCheck) == null || k.call(t, d, {
+          checkedKeys: i.value.getCheckedKeys(),
+          checkedNodes: i.value.getCheckedNodes(),
+          halfCheckedKeys: i.value.getHalfCheckedKeys(),
+          halfCheckedNodes: i.value.getHalfCheckedNodes()
+        });
+      }), (g = n.value) == null || g.focus();
+    },
+    onNodeExpand: (d, u, g) => {
+      var y;
+      (y = t.onNodeExpand) == null || y.call(t, d, u, g), q(() => {
+        if (!e.checkStrictly && e.lazy && e.multiple && u.checked) {
+          const p = {}, O = i.value.getCheckedKeys();
+          dt(
+            [i.value.store.root],
+            (k) => p[k.key] = k,
+            (k) => k.childNodes
+          );
+          const C = Ke(e.modelValue).filter(
+            (k) => !(k in p) && !O.includes(k)
+          ), E = m();
+          o(se, C.concat(E));
+        }
+      });
+    },
+    // else
+    cacheOptions: c
+  };
+};
+var Wo = oe({
+  props: {
+    data: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(e) {
+    const t = ce(Je);
+    return P(
+      () => e.data,
+      () => {
+        var l;
+        e.data.forEach((n) => {
+          t.states.cachedOptions.has(n.value) || t.states.cachedOptions.set(n.value, n);
+        });
+        const o = ((l = t.selectRef) == null ? void 0 : l.querySelectorAll("input")) || [];
+        Tt && !Array.from(o).includes(
+          document.activeElement
+        ) && t.setSelected();
+      },
+      { flush: "post", immediate: !0 }
+    ), () => {
+    };
+  }
+}), jo = oe({
+  name: "ElTreeSelect",
+  // disable `ElSelect` inherit current attrs
+  inheritAttrs: !1,
+  props: {
+    ...mn,
+    ...Sn,
+    /**
+     * @description The cached data of the lazy node, the structure is the same as the data, used to get the label of the unloaded data
+     */
+    cacheData: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(e, t) {
+    const { slots: l, expose: o } = t, n = V(), i = V(), r = w(() => e.nodeKey || e.valueKey || "value"), s = Ho(e, t, { select: n, tree: i, key: r }), { cacheOptions: f, ...h } = zo(e, t, {
+      select: n,
+      tree: i,
+      key: r
+    }), c = he({});
+    return o(c), Oe(() => {
+      Object.assign(c, {
+        //TODO: let only tree and select in 3.0
+        ...ut(i.value, [
+          "filter",
+          "updateKeyChildren",
+          "getCheckedNodes",
+          "setCheckedNodes",
+          "getCheckedKeys",
+          "setCheckedKeys",
+          "setChecked",
+          "getHalfCheckedNodes",
+          "getHalfCheckedKeys",
+          "getCurrentKey",
+          "getCurrentNode",
+          "setCurrentKey",
+          "setCurrentNode",
+          "getNode",
+          "remove",
+          "append",
+          "insertBefore",
+          "insertAfter"
+        ]),
+        ...ut(n.value, ["focus", "blur", "selectedLabel"]),
+        treeRef: i.value,
+        selectRef: n.value
+      });
+    }), () => qe(
+      bn,
+      /**
+       * 1. The `props` is processed into `Refs`, but `v-bind` and
+       * render function props cannot read `Refs`, so use `reactive`
+       * unwrap the `Refs` and keep reactive.
+       * 2. The keyword `ref` requires `Ref`, but `reactive` broke it,
+       * so use function.
+       */
+      he({
+        ...s,
+        ref: (m) => n.value = m
+      }),
+      {
+        ...l,
+        default: () => [
+          qe(Wo, { data: f.value }),
+          qe(
+            wn,
+            he({
+              ...h,
+              ref: (m) => i.value = m
+            })
+          )
+        ]
+      }
+    );
+  }
+});
+const is = Qe(jo);
+export {
+  is as ElTreeSelect,
+  is as default
+};