@voicenter-team/voicenter-ui-plus 1.1.21 → 2.0.2

package/library/VcTree.vue_vue_type_style_index_0_lang-DqIT64MT.mjs

@@ -1,2219 +0,0 @@
-import { defineComponent, createBlock, openBlock, Transition, mergeProps, unref, toHandlers, withCtx, renderSlot, ref, computed, onMounted, onUpdated, resolveDynamicComponent, normalizeStyle, normalizeClass, useAttrs, reactive, nextTick, inject, h, provide, resolveComponent, withDirectives, createElementBlock, withModifiers, createElementVNode, createVNode, createCommentVNode, Fragment, renderList, vShow, getCurrentInstance, watch, toDisplayString, onUnmounted } from "vue";
-import { aB as _export_sfc, aC as useNamespace, aD as withInstall, aE as buildProps, aF as componentSizes, aG as useFormSize, aH as isUndefined, aI as hasOwn, aJ as isBoolean, aK as isArray, aL as isNil, aM as isFunction, aN as isString, aO as NOOP, aP as isObject, aQ as isPropAbsent, aR as removeClass, aS as addClass, aT as loading_default, aU as ElIcon, aV as ElCheckbox, aW as caret_right_default, aX as useEventListener, aY as EVENT_CODE, aZ as iconPropType, a_ as definePropType, a$ as useLocale, b0 as selectKey, b1 as isEqual, b2 as formItemContextKey, b3 as useRTL, b4 as TEXT_COLORS, c as convertToUnit, b5 as VcLoading, b6 as resolveFieldData, b7 as set } from "./entry-EvdwF4XL.mjs";
-const __default__$1 = defineComponent({
-  name: "ElCollapseTransition"
-});
-const _sfc_main$5 = /* @__PURE__ */ defineComponent({
-  ...__default__$1,
-  setup(__props) {
-    const ns = useNamespace("collapse-transition");
-    const reset = (el) => {
-      el.style.maxHeight = "";
-      el.style.overflow = el.dataset.oldOverflow;
-      el.style.paddingTop = el.dataset.oldPaddingTop;
-      el.style.paddingBottom = el.dataset.oldPaddingBottom;
-    };
-    const on = {
-      beforeEnter(el) {
-        if (!el.dataset)
-          el.dataset = {};
-        el.dataset.oldPaddingTop = el.style.paddingTop;
-        el.dataset.oldPaddingBottom = el.style.paddingBottom;
-        if (el.style.height)
-          el.dataset.elExistsHeight = el.style.height;
-        el.style.maxHeight = 0;
-        el.style.paddingTop = 0;
-        el.style.paddingBottom = 0;
-      },
-      enter(el) {
-        requestAnimationFrame(() => {
-          el.dataset.oldOverflow = el.style.overflow;
-          if (el.dataset.elExistsHeight) {
-            el.style.maxHeight = el.dataset.elExistsHeight;
-          } else if (el.scrollHeight !== 0) {
-            el.style.maxHeight = `${el.scrollHeight}px`;
-          } else {
-            el.style.maxHeight = 0;
-          }
-          el.style.paddingTop = el.dataset.oldPaddingTop;
-          el.style.paddingBottom = el.dataset.oldPaddingBottom;
-          el.style.overflow = "hidden";
-        });
-      },
-      afterEnter(el) {
-        el.style.maxHeight = "";
-        el.style.overflow = el.dataset.oldOverflow;
-      },
-      enterCancelled(el) {
-        reset(el);
-      },
-      beforeLeave(el) {
-        if (!el.dataset)
-          el.dataset = {};
-        el.dataset.oldPaddingTop = el.style.paddingTop;
-        el.dataset.oldPaddingBottom = el.style.paddingBottom;
-        el.dataset.oldOverflow = el.style.overflow;
-        el.style.maxHeight = `${el.scrollHeight}px`;
-        el.style.overflow = "hidden";
-      },
-      leave(el) {
-        if (el.scrollHeight !== 0) {
-          el.style.maxHeight = 0;
-          el.style.paddingTop = 0;
-          el.style.paddingBottom = 0;
-        }
-      },
-      afterLeave(el) {
-        reset(el);
-      },
-      leaveCancelled(el) {
-        reset(el);
-      }
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(Transition, mergeProps({
-        name: unref(ns).b()
-      }, toHandlers(on)), {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 16, ["name"]);
-    };
-  }
-});
-var CollapseTransition = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__file", "collapse-transition.vue"]]);
-const ElCollapseTransition = withInstall(CollapseTransition);
-const textProps = buildProps({
-  type: {
-    type: String,
-    values: ["primary", "success", "info", "warning", "danger", ""],
-    default: ""
-  },
-  size: {
-    type: String,
-    values: componentSizes,
-    default: ""
-  },
-  truncated: Boolean,
-  lineClamp: {
-    type: [String, Number]
-  },
-  tag: {
-    type: String,
-    default: "span"
-  }
-});
-const __default__ = defineComponent({
-  name: "ElText"
-});
-const _sfc_main$4 = /* @__PURE__ */ defineComponent({
-  ...__default__,
-  props: textProps,
-  setup(__props) {
-    const props = __props;
-    const textRef = ref();
-    const textSize = useFormSize();
-    const ns = useNamespace("text");
-    const textKls = computed(() => [
-      ns.b(),
-      ns.m(props.type),
-      ns.m(textSize.value),
-      ns.is("truncated", props.truncated),
-      ns.is("line-clamp", !isUndefined(props.lineClamp))
-    ]);
-    const bindTitle = () => {
-      var _a, _b, _c, _d, _e, _f, _g;
-      const inheritTitle = useAttrs().title;
-      if (inheritTitle)
-        return;
-      let shouldAddTitle = false;
-      const text = ((_a = textRef.value) == null ? void 0 : _a.textContent) || "";
-      if (props.truncated) {
-        const width = (_b = textRef.value) == null ? void 0 : _b.offsetWidth;
-        const scrollWidth = (_c = textRef.value) == null ? void 0 : _c.scrollWidth;
-        if (width && scrollWidth && scrollWidth > width) {
-          shouldAddTitle = true;
-        }
-      } else if (!isUndefined(props.lineClamp)) {
-        const height = (_d = textRef.value) == null ? void 0 : _d.offsetHeight;
-        const scrollHeight = (_e = textRef.value) == null ? void 0 : _e.scrollHeight;
-        if (height && scrollHeight && scrollHeight > height) {
-          shouldAddTitle = true;
-        }
-      }
-      if (shouldAddTitle) {
-        (_f = textRef.value) == null ? void 0 : _f.setAttribute("title", text);
-      } else {
-        (_g = textRef.value) == null ? void 0 : _g.removeAttribute("title");
-      }
-    };
-    onMounted(bindTitle);
-    onUpdated(bindTitle);
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
-        ref_key: "textRef",
-        ref: textRef,
-        class: normalizeClass(unref(textKls)),
-        style: normalizeStyle({ "-webkit-line-clamp": _ctx.lineClamp })
-      }, {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 8, ["class", "style"]);
-    };
-  }
-});
-var Text = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__file", "text.vue"]]);
-const ElText = withInstall(Text);
-const NODE_KEY = "$treeNodeId";
-const markNodeData = function(node, data) {
-  if (!data || data[NODE_KEY])
-    return;
-  Object.defineProperty(data, NODE_KEY, {
-    value: node.id,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-};
-const getNodeKey = (key, data) => data == null ? void 0 : data[key || NODE_KEY];
-const handleCurrentChange = (store, emit, setCurrent) => {
-  const preCurrentNode = store.value.currentNode;
-  setCurrent();
-  const currentNode = store.value.currentNode;
-  if (preCurrentNode === currentNode)
-    return;
-  emit("current-change", currentNode ? currentNode.data : null, currentNode);
-};
-const getChildState = (node) => {
-  let all = true;
-  let none = true;
-  let allWithoutDisable = true;
-  for (let i = 0, j = node.length; i < j; i++) {
-    const n = node[i];
-    if (n.checked !== true || n.indeterminate) {
-      all = false;
-      if (!n.disabled) {
-        allWithoutDisable = false;
-      }
-    }
-    if (n.checked !== false || n.indeterminate) {
-      none = false;
-    }
-  }
-  return { all, none, allWithoutDisable, half: !all && !none };
-};
-const reInitChecked = function(node) {
-  if (node.childNodes.length === 0 || node.loading)
-    return;
-  const { all, none, half } = getChildState(node.childNodes);
-  if (all) {
-    node.checked = true;
-    node.indeterminate = false;
-  } else if (half) {
-    node.checked = false;
-    node.indeterminate = true;
-  } else if (none) {
-    node.checked = false;
-    node.indeterminate = false;
-  }
-  const parent = node.parent;
-  if (!parent || parent.level === 0)
-    return;
-  if (!node.store.checkStrictly) {
-    reInitChecked(parent);
-  }
-};
-const getPropertyFromData = function(node, prop) {
-  const props = node.store.props;
-  const data = node.data || {};
-  const config = props[prop];
-  if (isFunction(config)) {
-    return config(data, node);
-  } else if (isString(config)) {
-    return data[config];
-  } else if (isUndefined(config)) {
-    const dataProp = data[prop];
-    return isUndefined(dataProp) ? "" : dataProp;
-  }
-};
-const setCanFocus = function(childNodes, focus) {
-  childNodes.forEach((item) => {
-    item.canFocus = focus;
-    setCanFocus(item.childNodes, focus);
-  });
-};
-let nodeIdSeed = 0;
-class Node {
-  constructor(options) {
-    this.isLeafByUser = void 0;
-    this.isLeaf = void 0;
-    this.id = nodeIdSeed++;
-    this.text = null;
-    this.checked = false;
-    this.indeterminate = false;
-    this.data = null;
-    this.expanded = false;
-    this.parent = null;
-    this.visible = true;
-    this.isCurrent = false;
-    this.canFocus = false;
-    for (const name in options) {
-      if (hasOwn(options, name)) {
-        this[name] = options[name];
-      }
-    }
-    this.level = 0;
-    this.loaded = false;
-    this.childNodes = [];
-    this.loading = false;
-    if (this.parent) {
-      this.level = this.parent.level + 1;
-    }
-  }
-  initialize() {
-    var _a;
-    const store = this.store;
-    if (!store) {
-      throw new Error("[Node]store is required!");
-    }
-    store.registerNode(this);
-    const props = store.props;
-    if (props && typeof props.isLeaf !== "undefined") {
-      const isLeaf = getPropertyFromData(this, "isLeaf");
-      if (isBoolean(isLeaf)) {
-        this.isLeafByUser = isLeaf;
-      }
-    }
-    if (store.lazy !== true && this.data) {
-      this.setData(this.data);
-      if (store.defaultExpandAll) {
-        this.expanded = true;
-        this.canFocus = true;
-      }
-    } else if (this.level > 0 && store.lazy && store.defaultExpandAll && !this.isLeafByUser) {
-      this.expand();
-    }
-    if (!isArray(this.data)) {
-      markNodeData(this, this.data);
-    }
-    if (!this.data)
-      return;
-    const defaultExpandedKeys = store.defaultExpandedKeys;
-    const key = store.key;
-    if (key && !isNil(this.key) && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) {
-      this.expand(null, store.autoExpandParent);
-    }
-    if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
-      store.currentNode = this;
-      store.currentNode.isCurrent = true;
-    }
-    if (store.lazy) {
-      store._initDefaultCheckedNode(this);
-    }
-    this.updateLeafState();
-    if (this.level === 1 || ((_a = this.parent) == null ? void 0 : _a.expanded) === true)
-      this.canFocus = true;
-  }
-  setData(data) {
-    if (!isArray(data)) {
-      markNodeData(this, data);
-    }
-    this.data = data;
-    this.childNodes = [];
-    let children;
-    if (this.level === 0 && isArray(this.data)) {
-      children = this.data;
-    } else {
-      children = getPropertyFromData(this, "children") || [];
-    }
-    for (let i = 0, j = children.length; i < j; i++) {
-      this.insertChild({ data: children[i] });
-    }
-  }
-  get label() {
-    return getPropertyFromData(this, "label");
-  }
-  get key() {
-    const nodeKey = this.store.key;
-    if (this.data)
-      return this.data[nodeKey];
-    return null;
-  }
-  get disabled() {
-    return getPropertyFromData(this, "disabled");
-  }
-  get nextSibling() {
-    const parent = this.parent;
-    if (parent) {
-      const index = parent.childNodes.indexOf(this);
-      if (index > -1) {
-        return parent.childNodes[index + 1];
-      }
-    }
-    return null;
-  }
-  get previousSibling() {
-    const parent = this.parent;
-    if (parent) {
-      const index = parent.childNodes.indexOf(this);
-      if (index > -1) {
-        return index > 0 ? parent.childNodes[index - 1] : null;
-      }
-    }
-    return null;
-  }
-  contains(target, deep = true) {
-    return (this.childNodes || []).some((child) => child === target || deep && child.contains(target));
-  }
-  remove() {
-    const parent = this.parent;
-    if (parent) {
-      parent.removeChild(this);
-    }
-  }
-  insertChild(child, index, batch) {
-    if (!child)
-      throw new Error("InsertChild error: child is required.");
-    if (!(child instanceof Node)) {
-      if (!batch) {
-        const children = this.getChildren(true);
-        if (!(children == null ? void 0 : children.includes(child.data))) {
-          if (isUndefined(index) || index < 0) {
-            children == null ? void 0 : children.push(child.data);
-          } else {
-            children == null ? void 0 : children.splice(index, 0, child.data);
-          }
-        }
-      }
-      Object.assign(child, {
-        parent: this,
-        store: this.store
-      });
-      child = reactive(new Node(child));
-      if (child instanceof Node) {
-        child.initialize();
-      }
-    }
-    child.level = this.level + 1;
-    if (isUndefined(index) || index < 0) {
-      this.childNodes.push(child);
-    } else {
-      this.childNodes.splice(index, 0, child);
-    }
-    this.updateLeafState();
-  }
-  insertBefore(child, ref2) {
-    let index;
-    if (ref2) {
-      index = this.childNodes.indexOf(ref2);
-    }
-    this.insertChild(child, index);
-  }
-  insertAfter(child, ref2) {
-    let index;
-    if (ref2) {
-      index = this.childNodes.indexOf(ref2);
-      if (index !== -1)
-        index += 1;
-    }
-    this.insertChild(child, index);
-  }
-  removeChild(child) {
-    const children = this.getChildren() || [];
-    const dataIndex = children.indexOf(child.data);
-    if (dataIndex > -1) {
-      children.splice(dataIndex, 1);
-    }
-    const index = this.childNodes.indexOf(child);
-    if (index > -1) {
-      this.store && this.store.deregisterNode(child);
-      child.parent = null;
-      this.childNodes.splice(index, 1);
-    }
-    this.updateLeafState();
-  }
-  removeChildByData(data) {
-    let targetNode = null;
-    for (let i = 0; i < this.childNodes.length; i++) {
-      if (this.childNodes[i].data === data) {
-        targetNode = this.childNodes[i];
-        break;
-      }
-    }
-    if (targetNode) {
-      this.removeChild(targetNode);
-    }
-  }
-  expand(callback, expandParent) {
-    const done = () => {
-      if (expandParent) {
-        let parent = this.parent;
-        while (parent && parent.level > 0) {
-          parent.expanded = true;
-          parent = parent.parent;
-        }
-      }
-      this.expanded = true;
-      if (callback)
-        callback();
-      setCanFocus(this.childNodes, true);
-    };
-    if (this.shouldLoadData()) {
-      this.loadData((data) => {
-        if (isArray(data)) {
-          if (this.checked) {
-            this.setChecked(true, true);
-          } else if (!this.store.checkStrictly) {
-            reInitChecked(this);
-          }
-          done();
-        }
-      });
-    } else {
-      done();
-    }
-  }
-  doCreateChildren(array, defaultProps = {}) {
-    array.forEach((item) => {
-      this.insertChild(Object.assign({ data: item }, defaultProps), void 0, true);
-    });
-  }
-  collapse() {
-    this.expanded = false;
-    setCanFocus(this.childNodes, false);
-  }
-  shouldLoadData() {
-    return Boolean(this.store.lazy === true && this.store.load && !this.loaded);
-  }
-  updateLeafState() {
-    if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
-      this.isLeaf = this.isLeafByUser;
-      return;
-    }
-    const childNodes = this.childNodes;
-    if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
-      this.isLeaf = !childNodes || childNodes.length === 0;
-      return;
-    }
-    this.isLeaf = false;
-  }
-  setChecked(value, deep, recursion, passValue) {
-    this.indeterminate = value === "half";
-    this.checked = value === true;
-    if (this.store.checkStrictly)
-      return;
-    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
-      const { all, allWithoutDisable } = getChildState(this.childNodes);
-      if (!this.isLeaf && !all && allWithoutDisable) {
-        this.checked = false;
-        value = false;
-      }
-      const handleDescendants = () => {
-        if (deep) {
-          const childNodes = this.childNodes;
-          for (let i = 0, j = childNodes.length; i < j; i++) {
-            const child = childNodes[i];
-            passValue = passValue || value !== false;
-            const isCheck = child.disabled ? child.checked : passValue;
-            child.setChecked(isCheck, deep, true, passValue);
-          }
-          const { half, all: all2 } = getChildState(childNodes);
-          if (!all2) {
-            this.checked = all2;
-            this.indeterminate = half;
-          }
-        }
-      };
-      if (this.shouldLoadData()) {
-        this.loadData(() => {
-          handleDescendants();
-          reInitChecked(this);
-        }, {
-          checked: value !== false
-        });
-        return;
-      } else {
-        handleDescendants();
-      }
-    }
-    const parent = this.parent;
-    if (!parent || parent.level === 0)
-      return;
-    if (!recursion) {
-      reInitChecked(parent);
-    }
-  }
-  getChildren(forceInit = false) {
-    if (this.level === 0)
-      return this.data;
-    const data = this.data;
-    if (!data)
-      return null;
-    const props = this.store.props;
-    let children = "children";
-    if (props) {
-      children = props.children || "children";
-    }
-    if (isUndefined(data[children])) {
-      data[children] = null;
-    }
-    if (forceInit && !data[children]) {
-      data[children] = [];
-    }
-    return data[children];
-  }
-  updateChildren() {
-    const newData = this.getChildren() || [];
-    const oldData = this.childNodes.map((node) => node.data);
-    const newDataMap = {};
-    const newNodes = [];
-    newData.forEach((item, index) => {
-      const key = item[NODE_KEY];
-      const isNodeExists = !!key && oldData.findIndex((data) => (data == null ? void 0 : data[NODE_KEY]) === key) >= 0;
-      if (isNodeExists) {
-        newDataMap[key] = { index, data: item };
-      } else {
-        newNodes.push({ index, data: item });
-      }
-    });
-    if (!this.store.lazy) {
-      oldData.forEach((item) => {
-        if (!newDataMap[item == null ? void 0 : item[NODE_KEY]])
-          this.removeChildByData(item);
-      });
-    }
-    newNodes.forEach(({ index, data }) => {
-      this.insertChild({ data }, index);
-    });
-    this.updateLeafState();
-  }
-  loadData(callback, defaultProps = {}) {
-    if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
-      this.loading = true;
-      const resolve = (children) => {
-        this.childNodes = [];
-        this.doCreateChildren(children, defaultProps);
-        this.loaded = true;
-        this.loading = false;
-        this.updateLeafState();
-        if (callback) {
-          callback.call(this, children);
-        }
-      };
-      const reject = () => {
-        this.loading = false;
-      };
-      this.store.load(this, resolve, reject);
-    } else {
-      if (callback) {
-        callback.call(this);
-      }
-    }
-  }
-  eachNode(callback) {
-    const arr = [this];
-    while (arr.length) {
-      const node = arr.shift();
-      arr.unshift(...node.childNodes);
-      callback(node);
-    }
-  }
-  reInitChecked() {
-    if (this.store.checkStrictly)
-      return;
-    reInitChecked(this);
-  }
-}
-class TreeStore {
-  constructor(options) {
-    this.lazy = false;
-    this.checkStrictly = false;
-    this.autoExpandParent = false;
-    this.defaultExpandAll = false;
-    this.checkDescendants = false;
-    this.currentNode = null;
-    this.currentNodeKey = null;
-    for (const option in options) {
-      if (hasOwn(options, option)) {
-        this[option] = options[option];
-      }
-    }
-    this.nodesMap = {};
-  }
-  initialize() {
-    this.root = new Node({
-      data: this.data,
-      store: this
-    });
-    this.root.initialize();
-    if (this.lazy && this.load) {
-      const loadFn = this.load;
-      loadFn(this.root, (data) => {
-        this.root.doCreateChildren(data);
-        this._initDefaultCheckedNodes();
-      }, NOOP);
-    } else {
-      this._initDefaultCheckedNodes();
-    }
-  }
-  filter(value) {
-    const filterNodeMethod = this.filterNodeMethod;
-    const lazy = this.lazy;
-    const traverse = async function(node) {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-      for (const [index, child] of childNodes.entries()) {
-        child.visible = !!(filterNodeMethod == null ? void 0 : filterNodeMethod.call(child, value, child.data, child));
-        if (index % 80 === 0 && index > 0) {
-          await nextTick();
-        }
-        await traverse(child);
-      }
-      if (!node.visible && childNodes.length) {
-        let allHidden = true;
-        allHidden = !childNodes.some((child) => child.visible);
-        if (node.root) {
-          node.root.visible = allHidden === false;
-        } else {
-          node.visible = allHidden === false;
-        }
-      }
-      if (!value)
-        return;
-      if (node.visible && !node.isLeaf) {
-        if (!lazy || node.loaded) {
-          node.expand();
-        }
-      }
-    };
-    traverse(this);
-  }
-  setData(newVal) {
-    const instanceChanged = newVal !== this.root.data;
-    if (instanceChanged) {
-      this.nodesMap = {};
-      this.root.setData(newVal);
-      this._initDefaultCheckedNodes();
-      this.setCurrentNodeKey(this.currentNodeKey);
-    } else {
-      this.root.updateChildren();
-    }
-  }
-  getNode(data) {
-    if (data instanceof Node)
-      return data;
-    const key = isObject(data) ? getNodeKey(this.key, data) : data;
-    return this.nodesMap[key] || null;
-  }
-  insertBefore(data, refData) {
-    var _a;
-    const refNode = this.getNode(refData);
-    (_a = refNode.parent) == null ? void 0 : _a.insertBefore({ data }, refNode);
-  }
-  insertAfter(data, refData) {
-    var _a;
-    const refNode = this.getNode(refData);
-    (_a = refNode.parent) == null ? void 0 : _a.insertAfter({ data }, refNode);
-  }
-  remove(data) {
-    const node = this.getNode(data);
-    if (node && node.parent) {
-      if (node === this.currentNode) {
-        this.currentNode = null;
-      }
-      node.parent.removeChild(node);
-    }
-  }
-  append(data, parentData) {
-    const parentNode = !isPropAbsent(parentData) ? this.getNode(parentData) : this.root;
-    if (parentNode) {
-      parentNode.insertChild({ data });
-    }
-  }
-  _initDefaultCheckedNodes() {
-    const defaultCheckedKeys = this.defaultCheckedKeys || [];
-    const nodesMap = this.nodesMap;
-    defaultCheckedKeys.forEach((checkedKey) => {
-      const node = nodesMap[checkedKey];
-      if (node) {
-        node.setChecked(true, !this.checkStrictly);
-      }
-    });
-  }
-  _initDefaultCheckedNode(node) {
-    const defaultCheckedKeys = this.defaultCheckedKeys || [];
-    if (!isNil(node.key) && defaultCheckedKeys.includes(node.key)) {
-      node.setChecked(true, !this.checkStrictly);
-    }
-  }
-  setDefaultCheckedKey(newVal) {
-    if (newVal !== this.defaultCheckedKeys) {
-      this.defaultCheckedKeys = newVal;
-      this._initDefaultCheckedNodes();
-    }
-  }
-  registerNode(node) {
-    const key = this.key;
-    if (!node || !node.data)
-      return;
-    if (!key) {
-      this.nodesMap[node.id] = node;
-    } else {
-      const nodeKey = node.key;
-      if (!isNil(nodeKey))
-        this.nodesMap[nodeKey] = node;
-    }
-  }
-  deregisterNode(node) {
-    const key = this.key;
-    if (!key || !node || !node.data)
-      return;
-    node.childNodes.forEach((child) => {
-      this.deregisterNode(child);
-    });
-    delete this.nodesMap[node.key];
-  }
-  getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
-    const checkedNodes = [];
-    const traverse = function(node) {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-      childNodes.forEach((child) => {
-        if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) {
-          checkedNodes.push(child.data);
-        }
-        traverse(child);
-      });
-    };
-    traverse(this);
-    return checkedNodes;
-  }
-  getCheckedKeys(leafOnly = false) {
-    return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
-  }
-  getHalfCheckedNodes() {
-    const nodes = [];
-    const traverse = function(node) {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-      childNodes.forEach((child) => {
-        if (child.indeterminate) {
-          nodes.push(child.data);
-        }
-        traverse(child);
-      });
-    };
-    traverse(this);
-    return nodes;
-  }
-  getHalfCheckedKeys() {
-    return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
-  }
-  _getAllNodes() {
-    const allNodes = [];
-    const nodesMap = this.nodesMap;
-    for (const nodeKey in nodesMap) {
-      if (hasOwn(nodesMap, nodeKey)) {
-        allNodes.push(nodesMap[nodeKey]);
-      }
-    }
-    return allNodes;
-  }
-  updateChildren(key, data) {
-    const node = this.nodesMap[key];
-    if (!node)
-      return;
-    const childNodes = node.childNodes;
-    for (let i = childNodes.length - 1; i >= 0; i--) {
-      const child = childNodes[i];
-      this.remove(child.data);
-    }
-    for (let i = 0, j = data.length; i < j; i++) {
-      const child = data[i];
-      this.append(child, node.data);
-    }
-  }
-  _setCheckedKeys(key, leafOnly = false, checkedKeys) {
-    const allNodes = this._getAllNodes().sort((a, b) => a.level - b.level);
-    const cache = /* @__PURE__ */ Object.create(null);
-    const keys = Object.keys(checkedKeys);
-    allNodes.forEach((node) => node.setChecked(false, false));
-    const cacheCheckedChild = (node) => {
-      node.childNodes.forEach((child) => {
-        var _a;
-        cache[child.data[key]] = true;
-        if ((_a = child.childNodes) == null ? void 0 : _a.length) {
-          cacheCheckedChild(child);
-        }
-      });
-    };
-    for (let i = 0, j = allNodes.length; i < j; i++) {
-      const node = allNodes[i];
-      const nodeKey = node.data[key].toString();
-      const checked = keys.includes(nodeKey);
-      if (!checked) {
-        if (node.checked && !cache[nodeKey]) {
-          node.setChecked(false, false);
-        }
-        continue;
-      }
-      if (node.childNodes.length) {
-        cacheCheckedChild(node);
-      }
-      if (node.isLeaf || this.checkStrictly) {
-        node.setChecked(true, false);
-        continue;
-      }
-      node.setChecked(true, true);
-      if (leafOnly) {
-        node.setChecked(false, false);
-        const traverse = function(node2) {
-          const childNodes = node2.childNodes;
-          childNodes.forEach((child) => {
-            if (!child.isLeaf) {
-              child.setChecked(false, false);
-            }
-            traverse(child);
-          });
-        };
-        traverse(node);
-      }
-    }
-  }
-  setCheckedNodes(array, leafOnly = false) {
-    const key = this.key;
-    const checkedKeys = {};
-    array.forEach((item) => {
-      checkedKeys[(item || {})[key]] = true;
-    });
-    this._setCheckedKeys(key, leafOnly, checkedKeys);
-  }
-  setCheckedKeys(keys, leafOnly = false) {
-    this.defaultCheckedKeys = keys;
-    const key = this.key;
-    const checkedKeys = {};
-    keys.forEach((key2) => {
-      checkedKeys[key2] = true;
-    });
-    this._setCheckedKeys(key, leafOnly, checkedKeys);
-  }
-  setDefaultExpandedKeys(keys) {
-    keys = keys || [];
-    this.defaultExpandedKeys = keys;
-    keys.forEach((key) => {
-      const node = this.getNode(key);
-      if (node)
-        node.expand(null, this.autoExpandParent);
-    });
-  }
-  setChecked(data, checked, deep) {
-    const node = this.getNode(data);
-    if (node) {
-      node.setChecked(!!checked, deep);
-    }
-  }
-  getCurrentNode() {
-    return this.currentNode;
-  }
-  setCurrentNode(currentNode) {
-    const prevCurrentNode = this.currentNode;
-    if (prevCurrentNode) {
-      prevCurrentNode.isCurrent = false;
-    }
-    this.currentNode = currentNode;
-    this.currentNode.isCurrent = true;
-  }
-  setUserCurrentNode(node, shouldAutoExpandParent = true) {
-    var _a;
-    const key = node[this.key];
-    const currNode = this.nodesMap[key];
-    this.setCurrentNode(currNode);
-    if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) {
-      (_a = this.currentNode.parent) == null ? void 0 : _a.expand(null, true);
-    }
-  }
-  setCurrentNodeKey(key, shouldAutoExpandParent = true) {
-    var _a;
-    this.currentNodeKey = key;
-    if (isPropAbsent(key)) {
-      this.currentNode && (this.currentNode.isCurrent = false);
-      this.currentNode = null;
-      return;
-    }
-    const node = this.getNode(key);
-    if (node) {
-      this.setCurrentNode(node);
-      if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) {
-        (_a = this.currentNode.parent) == null ? void 0 : _a.expand(null, true);
-      }
-    }
-  }
-}
-const ROOT_TREE_INJECTION_KEY = "RootTree";
-const NODE_INSTANCE_INJECTION_KEY = "NodeInstance";
-const TREE_NODE_MAP_INJECTION_KEY = "TreeNodeMap";
-const _sfc_main$3 = defineComponent({
-  name: "ElTreeNodeContent",
-  props: {
-    node: {
-      type: Object,
-      required: true
-    },
-    renderContent: Function
-  },
-  setup(props) {
-    const ns = useNamespace("tree");
-    const nodeInstance = inject(NODE_INSTANCE_INJECTION_KEY);
-    const tree = inject(ROOT_TREE_INJECTION_KEY);
-    return () => {
-      const node = props.node;
-      const { data, store } = node;
-      return props.renderContent ? props.renderContent(h, { _self: nodeInstance, node, data, store }) : renderSlot(tree.ctx.slots, "default", { node, data }, () => [
-        h(ElText, { tag: "span", truncated: true, class: ns.be("node", "label") }, () => [node.label])
-      ]);
-    };
-  }
-});
-var NodeContent = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__file", "tree-node-content.vue"]]);
-function useNodeExpandEventBroadcast(props) {
-  const parentNodeMap = inject(TREE_NODE_MAP_INJECTION_KEY, null);
-  const currentNodeMap = {
-    treeNodeExpand: (node) => {
-      var _a;
-      if (props.node !== node) {
-        (_a = props.node) == null ? void 0 : _a.collapse();
-      }
-    },
-    children: []
-  };
-  if (parentNodeMap) {
-    parentNodeMap.children.push(currentNodeMap);
-  }
-  provide(TREE_NODE_MAP_INJECTION_KEY, currentNodeMap);
-  return {
-    broadcastExpanded: (node) => {
-      if (!props.accordion)
-        return;
-      for (const childNode of currentNodeMap.children) {
-        childNode.treeNodeExpand(node);
-      }
-    }
-  };
-}
-const dragEventsKey = Symbol("dragEvents");
-function useDragNodeHandler({
-  props,
-  ctx,
-  el$,
-  dropIndicator$,
-  store
-}) {
-  const ns = useNamespace("tree");
-  const dragState = ref({
-    showDropIndicator: false,
-    draggingNode: null,
-    dropNode: null,
-    allowDrop: true,
-    dropType: null
-  });
-  const treeNodeDragStart = ({ event, treeNode }) => {
-    if (!event.dataTransfer)
-      return;
-    if (isFunction(props.allowDrag) && !props.allowDrag(treeNode.node)) {
-      event.preventDefault();
-      return false;
-    }
-    event.dataTransfer.effectAllowed = "move";
-    try {
-      event.dataTransfer.setData("text/plain", "");
-    } catch (e) {
-    }
-    dragState.value.draggingNode = treeNode;
-    ctx.emit("node-drag-start", treeNode.node, event);
-  };
-  const treeNodeDragOver = ({ event, treeNode }) => {
-    if (!event.dataTransfer)
-      return;
-    const dropNode = treeNode;
-    const oldDropNode = dragState.value.dropNode;
-    if (oldDropNode && oldDropNode.node.id !== dropNode.node.id) {
-      removeClass(oldDropNode.$el, ns.is("drop-inner"));
-    }
-    const draggingNode = dragState.value.draggingNode;
-    if (!draggingNode || !dropNode)
-      return;
-    let dropPrev = true;
-    let dropInner = true;
-    let dropNext = true;
-    let userAllowDropInner = true;
-    if (isFunction(props.allowDrop)) {
-      dropPrev = props.allowDrop(draggingNode.node, dropNode.node, "prev");
-      userAllowDropInner = dropInner = props.allowDrop(draggingNode.node, dropNode.node, "inner");
-      dropNext = props.allowDrop(draggingNode.node, dropNode.node, "next");
-    }
-    event.dataTransfer.dropEffect = dropInner || dropPrev || dropNext ? "move" : "none";
-    if ((dropPrev || dropInner || dropNext) && (oldDropNode == null ? void 0 : oldDropNode.node.id) !== dropNode.node.id) {
-      if (oldDropNode) {
-        ctx.emit("node-drag-leave", draggingNode.node, oldDropNode.node, event);
-      }
-      ctx.emit("node-drag-enter", draggingNode.node, dropNode.node, event);
-    }
-    if (dropPrev || dropInner || dropNext) {
-      dragState.value.dropNode = dropNode;
-    } else {
-      dragState.value.dropNode = null;
-    }
-    if (dropNode.node.nextSibling === draggingNode.node) {
-      dropNext = false;
-    }
-    if (dropNode.node.previousSibling === draggingNode.node) {
-      dropPrev = false;
-    }
-    if (dropNode.node.contains(draggingNode.node, false)) {
-      dropInner = false;
-    }
-    if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
-      dropPrev = false;
-      dropInner = false;
-      dropNext = false;
-    }
-    const dropEl = dropNode.$el;
-    const targetPosition = dropEl.querySelector(`.${ns.be("node", "content")}`).getBoundingClientRect();
-    const treePosition = el$.value.getBoundingClientRect();
-    let dropType;
-    const prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : Number.NEGATIVE_INFINITY;
-    const nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : Number.POSITIVE_INFINITY;
-    let indicatorTop = -9999;
-    const distance = event.clientY - targetPosition.top;
-    if (distance < targetPosition.height * prevPercent) {
-      dropType = "before";
-    } else if (distance > targetPosition.height * nextPercent) {
-      dropType = "after";
-    } else if (dropInner) {
-      dropType = "inner";
-    } else {
-      dropType = "none";
-    }
-    const iconPosition = dropEl.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
-    const dropIndicator = dropIndicator$.value;
-    if (dropType === "before") {
-      indicatorTop = iconPosition.top - treePosition.top;
-    } else if (dropType === "after") {
-      indicatorTop = iconPosition.bottom - treePosition.top;
-    }
-    dropIndicator.style.top = `${indicatorTop}px`;
-    dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
-    if (dropType === "inner") {
-      addClass(dropEl, ns.is("drop-inner"));
-    } else {
-      removeClass(dropEl, ns.is("drop-inner"));
-    }
-    dragState.value.showDropIndicator = dropType === "before" || dropType === "after";
-    dragState.value.allowDrop = dragState.value.showDropIndicator || userAllowDropInner;
-    dragState.value.dropType = dropType;
-    ctx.emit("node-drag-over", draggingNode.node, dropNode.node, event);
-  };
-  const treeNodeDragEnd = (event) => {
-    var _a, _b;
-    const { draggingNode, dropType, dropNode } = dragState.value;
-    event.preventDefault();
-    if (event.dataTransfer) {
-      event.dataTransfer.dropEffect = "move";
-    }
-    if ((draggingNode == null ? void 0 : draggingNode.node.data) && dropNode) {
-      const draggingNodeCopy = { data: draggingNode.node.data };
-      if (dropType !== "none") {
-        draggingNode.node.remove();
-      }
-      if (dropType === "before") {
-        (_a = dropNode.node.parent) == null ? void 0 : _a.insertBefore(draggingNodeCopy, dropNode.node);
-      } else if (dropType === "after") {
-        (_b = dropNode.node.parent) == null ? void 0 : _b.insertAfter(draggingNodeCopy, dropNode.node);
-      } else if (dropType === "inner") {
-        dropNode.node.insertChild(draggingNodeCopy);
-      }
-      if (dropType !== "none") {
-        store.value.registerNode(draggingNodeCopy);
-        if (store.value.key) {
-          draggingNode.node.eachNode((node) => {
-            var _a2;
-            (_a2 = store.value.nodesMap[node.data[store.value.key]]) == null ? void 0 : _a2.setChecked(node.checked, !store.value.checkStrictly);
-          });
-        }
-      }
-      removeClass(dropNode.$el, ns.is("drop-inner"));
-      ctx.emit("node-drag-end", draggingNode.node, dropNode.node, dropType, event);
-      if (dropType !== "none") {
-        ctx.emit("node-drop", draggingNode.node, dropNode.node, dropType, event);
-      }
-    }
-    if (draggingNode && !dropNode) {
-      ctx.emit("node-drag-end", draggingNode.node, null, dropType, event);
-    }
-    dragState.value.showDropIndicator = false;
-    dragState.value.draggingNode = null;
-    dragState.value.dropNode = null;
-    dragState.value.allowDrop = true;
-  };
-  provide(dragEventsKey, {
-    treeNodeDragStart,
-    treeNodeDragOver,
-    treeNodeDragEnd
-  });
-  return {
-    dragState
-  };
-}
-const _sfc_main$2 = defineComponent({
-  name: "ElTreeNode",
-  components: {
-    ElCollapseTransition,
-    ElCheckbox,
-    NodeContent,
-    ElIcon,
-    Loading: loading_default
-  },
-  props: {
-    node: {
-      type: Node,
-      default: () => ({})
-    },
-    props: {
-      type: Object,
-      default: () => ({})
-    },
-    accordion: Boolean,
-    renderContent: Function,
-    renderAfterExpand: Boolean,
-    showCheckbox: Boolean
-  },
-  emits: ["node-expand"],
-  setup(props, ctx) {
-    const ns = useNamespace("tree");
-    const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
-    const tree = inject(ROOT_TREE_INJECTION_KEY);
-    const expanded = ref(false);
-    const childNodeRendered = ref(false);
-    const oldChecked = ref();
-    const oldIndeterminate = ref();
-    const node$ = ref();
-    const dragEvents = inject(dragEventsKey);
-    const instance = getCurrentInstance();
-    provide(NODE_INSTANCE_INJECTION_KEY, instance);
-    if (props.node.expanded) {
-      expanded.value = true;
-      childNodeRendered.value = true;
-    }
-    const childrenKey = tree.props.props["children"] || "children";
-    watch(() => {
-      var _a;
-      const children = (_a = props.node.data) == null ? void 0 : _a[childrenKey];
-      return children && [...children];
-    }, () => {
-      props.node.updateChildren();
-    });
-    watch(() => props.node.indeterminate, (val) => {
-      handleSelectChange(props.node.checked, val);
-    });
-    watch(() => props.node.checked, (val) => {
-      handleSelectChange(val, props.node.indeterminate);
-    });
-    watch(() => props.node.childNodes.length, () => props.node.reInitChecked());
-    watch(() => props.node.expanded, (val) => {
-      nextTick(() => expanded.value = val);
-      if (val) {
-        childNodeRendered.value = true;
-      }
-    });
-    const getNodeKey$1 = (node) => {
-      return getNodeKey(tree.props.nodeKey, node.data);
-    };
-    const getNodeClass = (node) => {
-      const nodeClassFunc = props.props.class;
-      if (!nodeClassFunc) {
-        return {};
-      }
-      let className;
-      if (isFunction(nodeClassFunc)) {
-        const { data } = node;
-        className = nodeClassFunc(data, node);
-      } else {
-        className = nodeClassFunc;
-      }
-      if (isString(className)) {
-        return { [className]: true };
-      } else {
-        return className;
-      }
-    };
-    const handleSelectChange = (checked, indeterminate) => {
-      if (oldChecked.value !== checked || oldIndeterminate.value !== indeterminate) {
-        tree.ctx.emit("check-change", props.node.data, checked, indeterminate);
-      }
-      oldChecked.value = checked;
-      oldIndeterminate.value = indeterminate;
-    };
-    const handleClick = (e) => {
-      handleCurrentChange(tree.store, tree.ctx.emit, () => {
-        var _a;
-        const nodeKeyProp = (_a = tree == null ? void 0 : tree.props) == null ? void 0 : _a.nodeKey;
-        if (nodeKeyProp) {
-          const curNodeKey = getNodeKey$1(props.node);
-          tree.store.value.setCurrentNodeKey(curNodeKey);
-        } else {
-          tree.store.value.setCurrentNode(props.node);
-        }
-      });
-      tree.currentNode.value = props.node;
-      if (tree.props.expandOnClickNode) {
-        handleExpandIconClick();
-      }
-      if ((tree.props.checkOnClickNode || props.node.isLeaf && tree.props.checkOnClickLeaf && props.showCheckbox) && !props.node.disabled) {
-        handleCheckChange(!props.node.checked);
-      }
-      tree.ctx.emit("node-click", props.node.data, props.node, instance, e);
-    };
-    const handleContextMenu = (event) => {
-      var _a;
-      if ((_a = tree.instance.vnode.props) == null ? void 0 : _a["onNodeContextmenu"]) {
-        event.stopPropagation();
-        event.preventDefault();
-      }
-      tree.ctx.emit("node-contextmenu", event, props.node.data, props.node, instance);
-    };
-    const handleExpandIconClick = () => {
-      if (props.node.isLeaf)
-        return;
-      if (expanded.value) {
-        tree.ctx.emit("node-collapse", props.node.data, props.node, instance);
-        props.node.collapse();
-      } else {
-        props.node.expand(() => {
-          ctx.emit("node-expand", props.node.data, props.node, instance);
-        });
-      }
-    };
-    const handleCheckChange = (value) => {
-      props.node.setChecked(value, !(tree == null ? void 0 : tree.props.checkStrictly));
-      nextTick(() => {
-        const store = tree.store.value;
-        tree.ctx.emit("check", props.node.data, {
-          checkedNodes: store.getCheckedNodes(),
-          checkedKeys: store.getCheckedKeys(),
-          halfCheckedNodes: store.getHalfCheckedNodes(),
-          halfCheckedKeys: store.getHalfCheckedKeys()
-        });
-      });
-    };
-    const handleChildNodeExpand = (nodeData, node, instance2) => {
-      broadcastExpanded(node);
-      tree.ctx.emit("node-expand", nodeData, node, instance2);
-    };
-    const handleDragStart = (event) => {
-      if (!tree.props.draggable)
-        return;
-      dragEvents.treeNodeDragStart({ event, treeNode: props });
-    };
-    const handleDragOver = (event) => {
-      event.preventDefault();
-      if (!tree.props.draggable)
-        return;
-      dragEvents.treeNodeDragOver({
-        event,
-        treeNode: { $el: node$.value, node: props.node }
-      });
-    };
-    const handleDrop = (event) => {
-      event.preventDefault();
-    };
-    const handleDragEnd = (event) => {
-      if (!tree.props.draggable)
-        return;
-      dragEvents.treeNodeDragEnd(event);
-    };
-    return {
-      ns,
-      node$,
-      tree,
-      expanded,
-      childNodeRendered,
-      oldChecked,
-      oldIndeterminate,
-      getNodeKey: getNodeKey$1,
-      getNodeClass,
-      handleSelectChange,
-      handleClick,
-      handleContextMenu,
-      handleExpandIconClick,
-      handleCheckChange,
-      handleChildNodeExpand,
-      handleDragStart,
-      handleDragOver,
-      handleDrop,
-      handleDragEnd,
-      CaretRight: caret_right_default
-    };
-  }
-});
-function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_el_icon = resolveComponent("el-icon");
-  const _component_el_checkbox = resolveComponent("el-checkbox");
-  const _component_loading = resolveComponent("loading");
-  const _component_node_content = resolveComponent("node-content");
-  const _component_el_tree_node = resolveComponent("el-tree-node");
-  const _component_el_collapse_transition = resolveComponent("el-collapse-transition");
-  return withDirectives((openBlock(), createElementBlock("div", {
-    ref: "node$",
-    class: normalizeClass([
-      _ctx.ns.b("node"),
-      _ctx.ns.is("expanded", _ctx.expanded),
-      _ctx.ns.is("current", _ctx.node.isCurrent),
-      _ctx.ns.is("hidden", !_ctx.node.visible),
-      _ctx.ns.is("focusable", !_ctx.node.disabled),
-      _ctx.ns.is("checked", !_ctx.node.disabled && _ctx.node.checked),
-      _ctx.getNodeClass(_ctx.node)
-    ]),
-    role: "treeitem",
-    tabindex: "-1",
-    "aria-expanded": _ctx.expanded,
-    "aria-disabled": _ctx.node.disabled,
-    "aria-checked": _ctx.node.checked,
-    draggable: _ctx.tree.props.draggable,
-    "data-key": _ctx.getNodeKey(_ctx.node),
-    onClick: withModifiers(_ctx.handleClick, ["stop"]),
-    onContextmenu: _ctx.handleContextMenu,
-    onDragstart: withModifiers(_ctx.handleDragStart, ["stop"]),
-    onDragover: withModifiers(_ctx.handleDragOver, ["stop"]),
-    onDragend: withModifiers(_ctx.handleDragEnd, ["stop"]),
-    onDrop: withModifiers(_ctx.handleDrop, ["stop"])
-  }, [
-    createElementVNode("div", {
-      class: normalizeClass(_ctx.ns.be("node", "content")),
-      style: normalizeStyle({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
-    }, [
-      _ctx.tree.props.icon || _ctx.CaretRight ? (openBlock(), createBlock(_component_el_icon, {
-        key: 0,
-        class: normalizeClass([
-          _ctx.ns.be("node", "expand-icon"),
-          _ctx.ns.is("leaf", _ctx.node.isLeaf),
-          {
-            expanded: !_ctx.node.isLeaf && _ctx.expanded
-          }
-        ]),
-        onClick: withModifiers(_ctx.handleExpandIconClick, ["stop"])
-      }, {
-        default: withCtx(() => [
-          (openBlock(), createBlock(resolveDynamicComponent(_ctx.tree.props.icon || _ctx.CaretRight)))
-        ]),
-        _: 1
-      }, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
-      _ctx.showCheckbox ? (openBlock(), createBlock(_component_el_checkbox, {
-        key: 1,
-        "model-value": _ctx.node.checked,
-        indeterminate: _ctx.node.indeterminate,
-        disabled: !!_ctx.node.disabled,
-        onClick: withModifiers(() => {
-        }, ["stop"]),
-        onChange: _ctx.handleCheckChange
-      }, null, 8, ["model-value", "indeterminate", "disabled", "onClick", "onChange"])) : createCommentVNode("v-if", true),
-      _ctx.node.loading ? (openBlock(), createBlock(_component_el_icon, {
-        key: 2,
-        class: normalizeClass([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
-      }, {
-        default: withCtx(() => [
-          createVNode(_component_loading)
-        ]),
-        _: 1
-      }, 8, ["class"])) : createCommentVNode("v-if", true),
-      createVNode(_component_node_content, {
-        node: _ctx.node,
-        "render-content": _ctx.renderContent
-      }, null, 8, ["node", "render-content"])
-    ], 6),
-    createVNode(_component_el_collapse_transition, null, {
-      default: withCtx(() => [
-        !_ctx.renderAfterExpand || _ctx.childNodeRendered ? withDirectives((openBlock(), createElementBlock("div", {
-          key: 0,
-          class: normalizeClass(_ctx.ns.be("node", "children")),
-          role: "group",
-          "aria-expanded": _ctx.expanded,
-          onClick: withModifiers(() => {
-          }, ["stop"])
-        }, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.node.childNodes, (child) => {
-            return openBlock(), createBlock(_component_el_tree_node, {
-              key: _ctx.getNodeKey(child),
-              "render-content": _ctx.renderContent,
-              "render-after-expand": _ctx.renderAfterExpand,
-              "show-checkbox": _ctx.showCheckbox,
-              node: child,
-              accordion: _ctx.accordion,
-              props: _ctx.props,
-              onNodeExpand: _ctx.handleChildNodeExpand
-            }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]);
-          }), 128))
-        ], 10, ["aria-expanded", "onClick"])), [
-          [vShow, _ctx.expanded]
-        ]) : createCommentVNode("v-if", true)
-      ]),
-      _: 1
-    })
-  ], 42, ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key", "onClick", "onContextmenu", "onDragstart", "onDragover", "onDragend", "onDrop"])), [
-    [vShow, _ctx.node.visible]
-  ]);
-}
-var ElTreeNode = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$1], ["__file", "tree-node.vue"]]);
-function useKeydown({ el$ }, store) {
-  const ns = useNamespace("tree");
-  onMounted(() => {
-    initTabIndex();
-  });
-  onUpdated(() => {
-    const checkboxItems = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
-    checkboxItems.forEach((checkbox) => {
-      checkbox.setAttribute("tabindex", "-1");
-    });
-  });
-  function canNodeFocus(treeItems, nextIndex) {
-    var _a, _b;
-    const currentNode = store.value.getNode(treeItems[nextIndex].dataset.key);
-    return currentNode.canFocus && currentNode.visible && (((_a = currentNode.parent) == null ? void 0 : _a.expanded) || ((_b = currentNode.parent) == null ? void 0 : _b.level) === 0);
-  }
-  const handleKeydown = (ev) => {
-    const currentItem = ev.target;
-    if (!currentItem.className.includes(ns.b("node")))
-      return;
-    const code = ev.code;
-    const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
-    const currentIndex = treeItems.indexOf(currentItem);
-    let nextIndex;
-    if ([EVENT_CODE.up, EVENT_CODE.down].includes(code)) {
-      ev.preventDefault();
-      if (code === EVENT_CODE.up) {
-        nextIndex = currentIndex === -1 ? 0 : currentIndex !== 0 ? currentIndex - 1 : treeItems.length - 1;
-        const startIndex = nextIndex;
-        while (true) {
-          if (canNodeFocus(treeItems, nextIndex)) {
-            break;
-          }
-          nextIndex--;
-          if (nextIndex === startIndex) {
-            nextIndex = -1;
-            break;
-          }
-          if (nextIndex < 0) {
-            nextIndex = treeItems.length - 1;
-          }
-        }
-      } else {
-        nextIndex = currentIndex === -1 ? 0 : currentIndex < treeItems.length - 1 ? currentIndex + 1 : 0;
-        const startIndex = nextIndex;
-        while (true) {
-          if (canNodeFocus(treeItems, nextIndex)) {
-            break;
-          }
-          nextIndex++;
-          if (nextIndex === startIndex) {
-            nextIndex = -1;
-            break;
-          }
-          if (nextIndex >= treeItems.length) {
-            nextIndex = 0;
-          }
-        }
-      }
-      nextIndex !== -1 && treeItems[nextIndex].focus();
-    }
-    if ([EVENT_CODE.left, EVENT_CODE.right].includes(code)) {
-      ev.preventDefault();
-      currentItem.click();
-    }
-    const hasInput = currentItem.querySelector('[type="checkbox"]');
-    if ([EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space].includes(code) && hasInput) {
-      ev.preventDefault();
-      hasInput.click();
-    }
-  };
-  useEventListener(el$, "keydown", handleKeydown);
-  const initTabIndex = () => {
-    var _a;
-    if (!el$.value)
-      return;
-    const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
-    const checkboxItems = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
-    checkboxItems.forEach((checkbox) => {
-      checkbox.setAttribute("tabindex", "-1");
-    });
-    const checkedItem = el$.value.querySelectorAll(`.${ns.is("checked")}[role=treeitem]`);
-    if (checkedItem.length) {
-      checkedItem[0].setAttribute("tabindex", "0");
-      return;
-    }
-    (_a = treeItems[0]) == null ? void 0 : _a.setAttribute("tabindex", "0");
-  };
-}
-const _sfc_main$1 = defineComponent({
-  name: "ElTree",
-  components: { ElTreeNode },
-  props: {
-    data: {
-      type: definePropType(Array),
-      default: () => []
-    },
-    emptyText: {
-      type: String
-    },
-    renderAfterExpand: {
-      type: Boolean,
-      default: true
-    },
-    nodeKey: String,
-    checkStrictly: Boolean,
-    defaultExpandAll: Boolean,
-    expandOnClickNode: {
-      type: Boolean,
-      default: true
-    },
-    checkOnClickNode: Boolean,
-    checkOnClickLeaf: {
-      type: Boolean,
-      default: true
-    },
-    checkDescendants: Boolean,
-    autoExpandParent: {
-      type: Boolean,
-      default: true
-    },
-    defaultCheckedKeys: Array,
-    defaultExpandedKeys: Array,
-    currentNodeKey: [String, Number],
-    renderContent: {
-      type: definePropType(Function)
-    },
-    showCheckbox: Boolean,
-    draggable: Boolean,
-    allowDrag: {
-      type: definePropType(Function)
-    },
-    allowDrop: {
-      type: definePropType(Function)
-    },
-    props: {
-      type: Object,
-      default: () => ({
-        children: "children",
-        label: "label",
-        disabled: "disabled"
-      })
-    },
-    lazy: Boolean,
-    highlightCurrent: Boolean,
-    load: Function,
-    filterNodeMethod: Function,
-    accordion: Boolean,
-    indent: {
-      type: Number,
-      default: 18
-    },
-    icon: {
-      type: iconPropType
-    }
-  },
-  emits: [
-    "check-change",
-    "current-change",
-    "node-click",
-    "node-contextmenu",
-    "node-collapse",
-    "node-expand",
-    "check",
-    "node-drag-start",
-    "node-drag-end",
-    "node-drop",
-    "node-drag-leave",
-    "node-drag-enter",
-    "node-drag-over"
-  ],
-  setup(props, ctx) {
-    const { t } = useLocale();
-    const ns = useNamespace("tree");
-    const selectInfo = inject(selectKey, null);
-    const store = ref(new TreeStore({
-      key: props.nodeKey,
-      data: props.data,
-      lazy: props.lazy,
-      props: props.props,
-      load: props.load,
-      currentNodeKey: props.currentNodeKey,
-      checkStrictly: props.checkStrictly,
-      checkDescendants: props.checkDescendants,
-      defaultCheckedKeys: props.defaultCheckedKeys,
-      defaultExpandedKeys: props.defaultExpandedKeys,
-      autoExpandParent: props.autoExpandParent,
-      defaultExpandAll: props.defaultExpandAll,
-      filterNodeMethod: props.filterNodeMethod
-    }));
-    store.value.initialize();
-    const root = ref(store.value.root);
-    const currentNode = ref(null);
-    const el$ = ref(null);
-    const dropIndicator$ = ref(null);
-    const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
-    const { dragState } = useDragNodeHandler({
-      props,
-      ctx,
-      el$,
-      dropIndicator$,
-      store
-    });
-    useKeydown({ el$ }, store);
-    const isEmpty = computed(() => {
-      const { childNodes } = root.value;
-      const hasFilteredOptions = selectInfo ? selectInfo.hasFilteredOptions !== 0 : false;
-      return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !hasFilteredOptions;
-    });
-    watch(() => props.currentNodeKey, (newVal) => {
-      store.value.setCurrentNodeKey(newVal != null ? newVal : null);
-    });
-    watch(() => props.defaultCheckedKeys, (newVal, oldVal) => {
-      if (isEqual(newVal, oldVal))
-        return;
-      store.value.setDefaultCheckedKey(newVal != null ? newVal : []);
-    });
-    watch(() => props.defaultExpandedKeys, (newVal) => {
-      store.value.setDefaultExpandedKeys(newVal != null ? newVal : []);
-    });
-    watch(() => props.data, (newVal) => {
-      store.value.setData(newVal);
-    }, { deep: true });
-    watch(() => props.checkStrictly, (newVal) => {
-      store.value.checkStrictly = newVal;
-    });
-    const filter = (value) => {
-      if (!props.filterNodeMethod)
-        throw new Error("[Tree] filterNodeMethod is required when filter");
-      store.value.filter(value);
-    };
-    const getNodeKey$1 = (node) => {
-      return getNodeKey(props.nodeKey, node.data);
-    };
-    const getNodePath = (data) => {
-      if (!props.nodeKey)
-        throw new Error("[Tree] nodeKey is required in getNodePath");
-      const node = store.value.getNode(data);
-      if (!node)
-        return [];
-      const path = [node.data];
-      let parent = node.parent;
-      while (parent && parent !== root.value) {
-        path.push(parent.data);
-        parent = parent.parent;
-      }
-      return path.reverse();
-    };
-    const getCheckedNodes = (leafOnly, includeHalfChecked) => {
-      return store.value.getCheckedNodes(leafOnly, includeHalfChecked);
-    };
-    const getCheckedKeys = (leafOnly) => {
-      return store.value.getCheckedKeys(leafOnly);
-    };
-    const getCurrentNode = () => {
-      const currentNode2 = store.value.getCurrentNode();
-      return currentNode2 ? currentNode2.data : null;
-    };
-    const getCurrentKey = () => {
-      if (!props.nodeKey)
-        throw new Error("[Tree] nodeKey is required in getCurrentKey");
-      const currentNode2 = getCurrentNode();
-      return currentNode2 ? currentNode2[props.nodeKey] : null;
-    };
-    const setCheckedNodes = (nodes, leafOnly) => {
-      if (!props.nodeKey)
-        throw new Error("[Tree] nodeKey is required in setCheckedNodes");
-      store.value.setCheckedNodes(nodes, leafOnly);
-    };
-    const setCheckedKeys = (keys, leafOnly) => {
-      if (!props.nodeKey)
-        throw new Error("[Tree] nodeKey is required in setCheckedKeys");
-      store.value.setCheckedKeys(keys, leafOnly);
-    };
-    const setChecked = (data, checked, deep) => {
-      store.value.setChecked(data, checked, deep);
-    };
-    const getHalfCheckedNodes = () => {
-      return store.value.getHalfCheckedNodes();
-    };
-    const getHalfCheckedKeys = () => {
-      return store.value.getHalfCheckedKeys();
-    };
-    const setCurrentNode = (node, shouldAutoExpandParent = true) => {
-      if (!props.nodeKey)
-        throw new Error("[Tree] nodeKey is required in setCurrentNode");
-      handleCurrentChange(store, ctx.emit, () => {
-        broadcastExpanded(node);
-        store.value.setUserCurrentNode(node, shouldAutoExpandParent);
-      });
-    };
-    const setCurrentKey = (key, shouldAutoExpandParent = true) => {
-      if (!props.nodeKey)
-        throw new Error("[Tree] nodeKey is required in setCurrentKey");
-      handleCurrentChange(store, ctx.emit, () => {
-        broadcastExpanded();
-        store.value.setCurrentNodeKey(key != null ? key : null, shouldAutoExpandParent);
-      });
-    };
-    const getNode = (data) => {
-      return store.value.getNode(data);
-    };
-    const remove = (data) => {
-      store.value.remove(data);
-    };
-    const append = (data, parentNode) => {
-      store.value.append(data, parentNode);
-    };
-    const insertBefore = (data, refNode) => {
-      store.value.insertBefore(data, refNode);
-    };
-    const insertAfter = (data, refNode) => {
-      store.value.insertAfter(data, refNode);
-    };
-    const handleNodeExpand = (nodeData, node, instance) => {
-      broadcastExpanded(node);
-      ctx.emit("node-expand", nodeData, node, instance);
-    };
-    const updateKeyChildren = (key, data) => {
-      if (!props.nodeKey)
-        throw new Error("[Tree] nodeKey is required in updateKeyChild");
-      store.value.updateChildren(key, data);
-    };
-    provide(ROOT_TREE_INJECTION_KEY, {
-      ctx,
-      props,
-      store,
-      root,
-      currentNode,
-      instance: getCurrentInstance()
-    });
-    provide(formItemContextKey, void 0);
-    return {
-      ns,
-      store,
-      root,
-      currentNode,
-      dragState,
-      el$,
-      dropIndicator$,
-      isEmpty,
-      filter,
-      getNodeKey: getNodeKey$1,
-      getNodePath,
-      getCheckedNodes,
-      getCheckedKeys,
-      getCurrentNode,
-      getCurrentKey,
-      setCheckedNodes,
-      setCheckedKeys,
-      setChecked,
-      getHalfCheckedNodes,
-      getHalfCheckedKeys,
-      setCurrentNode,
-      setCurrentKey,
-      t,
-      getNode,
-      remove,
-      append,
-      insertBefore,
-      insertAfter,
-      handleNodeExpand,
-      updateKeyChildren
-    };
-  }
-});
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_el_tree_node = resolveComponent("el-tree-node");
-  return openBlock(), createElementBlock("div", {
-    ref: "el$",
-    class: normalizeClass([
-      _ctx.ns.b(),
-      _ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
-      _ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
-      _ctx.ns.is("drop-inner", _ctx.dragState.dropType === "inner"),
-      { [_ctx.ns.m("highlight-current")]: _ctx.highlightCurrent }
-    ]),
-    role: "tree"
-  }, [
-    (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.root.childNodes, (child) => {
-      return openBlock(), createBlock(_component_el_tree_node, {
-        key: _ctx.getNodeKey(child),
-        node: child,
-        props: _ctx.props,
-        accordion: _ctx.accordion,
-        "render-after-expand": _ctx.renderAfterExpand,
-        "show-checkbox": _ctx.showCheckbox,
-        "render-content": _ctx.renderContent,
-        onNodeExpand: _ctx.handleNodeExpand
-      }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]);
-    }), 128)),
-    _ctx.isEmpty ? (openBlock(), createElementBlock("div", {
-      key: 0,
-      class: normalizeClass(_ctx.ns.e("empty-block"))
-    }, [
-      renderSlot(_ctx.$slots, "empty", {}, () => {
-        var _a;
-        return [
-          createElementVNode("span", {
-            class: normalizeClass(_ctx.ns.e("empty-text"))
-          }, toDisplayString((_a = _ctx.emptyText) != null ? _a : _ctx.t("el.tree.emptyText")), 3)
-        ];
-      })
-    ], 2)) : createCommentVNode("v-if", true),
-    withDirectives(createElementVNode("div", {
-      ref: "dropIndicator$",
-      class: normalizeClass(_ctx.ns.e("drop-indicator"))
-    }, null, 2), [
-      [vShow, _ctx.dragState.showDropIndicator]
-    ])
-  ], 2);
-}
-var Tree = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render], ["__file", "tree.vue"]]);
-const ElTree = withInstall(Tree);
-const _hoisted_1 = {
-  key: 0,
-  class: "vc-tree__filter-container"
-};
-const _hoisted_2 = {
-  key: 1,
-  class: "vc-tree__container-top"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "VcTree",
-  props: {
-    config: {},
-    nodeKey: { default: "key" },
-    color: { default: "primary" },
-    loading: { type: Boolean, default: false },
-    emptyText: { default: "" },
-    selectable: { type: Boolean, default: true },
-    defaultExpandAll: { type: Boolean, default: false },
-    expandedKeys: { default: () => [] },
-    defaultCheckedKeys: { default: () => [] },
-    filterPlaceholder: { default: "" },
-    lazy: { type: Boolean },
-    options: { default: () => [] },
-    filterPrefixIcon: { default: "" },
-    filterPrefixIconColor: { default: "" },
-    useTypes: { default: () => [] },
-    scrollHeight: { default: void 0 },
-    clearFilterOnOptionsChange: { type: Boolean, default: true }
-  },
-  emits: ["update:selectedKeys", "update:selectNode", "update:selectedNodes"],
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emit = __emit;
-    const filterValue = ref("");
-    const localOptions = ref([]);
-    const treeRef = ref();
-    const treeContainerRef = ref();
-    let mutationObserver = null;
-    const { isRTL } = useRTL();
-    const filterByKey = computed(() => props.config.filterBy);
-    const childrenKey = computed(() => props.config.childrenKey);
-    const colorClass = computed(() => {
-      return props.color ? TEXT_COLORS[props.color] || "" : "";
-    });
-    const filterable = computed(() => !!filterByKey.value);
-    const elTreeProps = computed(() => {
-      const _labelKey = props.config.labelKey || "label";
-      const _childKey = String(props.config.childrenKey || "children");
-      const _disabledKey = props.config.disabledKey || "disabled";
-      return {
-        label: _labelKey,
-        children: _childKey,
-        disabled: _disabledKey
-      };
-    });
-    const maxHeightWrapper = computed(() => {
-      if (!props.scrollHeight) {
-        return "";
-      }
-      return convertToUnit(props.scrollHeight);
-    });
-    function handleCheck(node, opt) {
-      emit("update:selectedKeys", opt.checkedKeys);
-      emit("update:selectedNodes", opt.checkedNodes);
-      emit("update:selectNode", node);
-    }
-    function filterNodeFn(value, data) {
-      const _filterByKey = filterByKey.value;
-      if (!value || !_filterByKey) return true;
-      const searchFields = _filterByKey.split(",");
-      const _searchVal = value.trim().toLocaleLowerCase(props.config.filterLocale);
-      return isFilterMatched(data, {
-        searchFields,
-        filterText: _searchVal
-      });
-    }
-    function isFilterMatched(node, params) {
-      var _a;
-      let matched = false;
-      for (const field of params.searchFields) {
-        const fieldValue = String(resolveFieldData(node, field.trim())).toLocaleLowerCase((_a = props == null ? void 0 : props.config) == null ? void 0 : _a.filterLocale);
-        if (fieldValue.indexOf(params.filterText) > -1) {
-          matched = true;
-        }
-      }
-      return matched;
-    }
-    function initOptions(options) {
-      if (props.clearFilterOnOptionsChange) {
-        filterValue.value = "";
-      }
-      if (props.useTypes.length) {
-        localOptions.value = [...filterOptionsByTypes(options)];
-      } else {
-        localOptions.value = [...options];
-      }
-    }
-    function filterOptionsByTypes(options) {
-      return [...options].reduce((acc, item) => {
-        var _a;
-        const _itemData = { ...item };
-        const nodeType = _itemData["type"];
-        const _isTypeValid = props.useTypes.includes(nodeType);
-        let _children = [];
-        if ((_a = _itemData[childrenKey.value]) == null ? void 0 : _a.length) {
-          _children = filterOptionsByTypes(_itemData[props.config.childrenKey]);
-        }
-        set(_itemData, childrenKey.value, _children);
-        if (_isTypeValid || _children.length) {
-          acc.push(_itemData);
-        }
-        return acc;
-      }, []);
-    }
-    function getCheckedNodesFn(leafOnly = false) {
-      return treeRef.value.getCheckedNodes(leafOnly, false);
-    }
-    function getCheckedKeysFn(leafOnly = false) {
-      return treeRef.value.getCheckedKeys(leafOnly);
-    }
-    function setCheckedNodesFn(nodes) {
-      treeRef.value.setCheckedNodes(nodes, false);
-    }
-    function setCheckedKeys(keys) {
-      treeRef.value.setCheckedKeys(keys, false);
-    }
-    function resetChecked() {
-      treeRef.value.setCheckedKeys([], false);
-    }
-    function getParentSelectedNodes(options = [], data = []) {
-      const _allChecked = getCheckedKeysFn();
-      return options.reduce((acc, item) => {
-        if (_allChecked.includes(item[props.nodeKey])) {
-          acc.push(item);
-        } else {
-          getParentSelectedNodes(item[props.config.childrenKey], acc);
-        }
-        return acc;
-      }, data);
-    }
-    function getAllNodeKeys(options) {
-      return options.reduce((acc, item) => {
-        var _a;
-        acc.push(item[props.nodeKey]);
-        if ((_a = item[childrenKey.value]) == null ? void 0 : _a.length) {
-          acc.push(...getAllNodeKeys(item[childrenKey.value]));
-        }
-        return acc;
-      }, []);
-    }
-    function fixRTLPadding() {
-      if (!treeContainerRef.value) return;
-      if (!isRTL.value) return;
-      const treeNodeContents = treeContainerRef.value.querySelectorAll(".el-tree-node__content");
-      treeNodeContents.forEach((element) => {
-        const computedStyle = window.getComputedStyle(element);
-        const paddingLeft = computedStyle.paddingLeft;
-        if (paddingLeft && paddingLeft !== "0px") {
-          element.style.paddingRight = paddingLeft;
-          element.style.paddingLeft = "0";
-        }
-      });
-    }
-    function setupRTLObserver() {
-      if (!treeContainerRef.value) return;
-      if (mutationObserver) {
-        mutationObserver.disconnect();
-      }
-      mutationObserver = new MutationObserver(() => {
-        setTimeout(() => {
-          fixRTLPadding();
-        }, 0);
-      });
-      mutationObserver.observe(treeContainerRef.value, {
-        childList: true,
-        subtree: true,
-        attributes: true,
-        attributeFilter: ["class", "style"]
-      });
-    }
-    watch(
-      filterValue,
-      (val) => {
-        treeRef.value.filter(val);
-      }
-    );
-    watch(
-      () => props.options,
-      (val) => {
-        var _a;
-        const currentCheckedKeys = ((_a = treeRef.value) == null ? void 0 : _a.getCheckedKeys(false)) || [];
-        initOptions(val);
-        if (!props.clearFilterOnOptionsChange && filterValue.value && treeRef.value) {
-          nextTick(() => {
-            var _a2;
-            (_a2 = treeRef.value) == null ? void 0 : _a2.filter(filterValue.value);
-          });
-        }
-        if (currentCheckedKeys.length > 0) {
-          const validKeys = getAllNodeKeys(localOptions.value);
-          const validCheckedKeys = currentCheckedKeys.filter((key) => validKeys.includes(key));
-          nextTick(() => {
-            if (treeRef.value) {
-              treeRef.value.setCheckedKeys(validCheckedKeys, false);
-              if (validCheckedKeys.length !== currentCheckedKeys.length) {
-                emit("update:selectedKeys", validCheckedKeys);
-                const checkedNodes = treeRef.value.getCheckedNodes(false, false) || [];
-                emit("update:selectedNodes", checkedNodes);
-              }
-            }
-          });
-        }
-        setTimeout(() => {
-          fixRTLPadding();
-        }, 0);
-      },
-      { immediate: true }
-    );
-    watch(
-      () => props.defaultCheckedKeys,
-      (newKeys) => {
-        if (treeRef.value) {
-          setTimeout(() => {
-            var _a;
-            (_a = treeRef.value) == null ? void 0 : _a.setCheckedKeys(newKeys, false);
-          }, 0);
-        }
-      }
-    );
-    watch(
-      () => props.expandedKeys,
-      () => {
-        setTimeout(() => {
-          fixRTLPadding();
-        }, 0);
-      }
-    );
-    onMounted(() => {
-      setTimeout(() => {
-        fixRTLPadding();
-        setupRTLObserver();
-      }, 0);
-    });
-    onUnmounted(() => {
-      if (mutationObserver) {
-        mutationObserver.disconnect();
-        mutationObserver = null;
-      }
-    });
-    __expose({
-      getCheckedNodes: getCheckedNodesFn,
-      getCheckedKeys: getCheckedKeysFn,
-      setCheckedNodes: setCheckedNodesFn,
-      setCheckedKeys,
-      resetChecked,
-      getParentSelectedNodes: () => {
-        return getParentSelectedNodes(localOptions.value);
-      }
-    });
-    return (_ctx, _cache) => {
-      const _component_VcInput = resolveComponent("VcInput");
-      return openBlock(), createElementBlock("div", {
-        ref_key: "treeContainerRef",
-        ref: treeContainerRef,
-        class: "vc-tree"
-      }, [
-        filterable.value ? (openBlock(), createElementBlock("div", _hoisted_1, [
-          createVNode(_component_VcInput, {
-            modelValue: filterValue.value,
-            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => filterValue.value = $event),
-            placeholder: _ctx.filterPlaceholder,
-            disabled: _ctx.loading || !_ctx.options.length,
-            color: _ctx.color,
-            "prefix-icon": _ctx.filterPrefixIcon,
-            "prefix-icon-color": _ctx.filterPrefixIconColor,
-            clearable: "",
-            class: "vc-tree__input",
-            "max-width": "100%"
-          }, null, 8, ["modelValue", "placeholder", "disabled", "color", "prefix-icon", "prefix-icon-color"])
-        ])) : createCommentVNode("", true),
-        _ctx.$slots["default"] ? (openBlock(), createElementBlock("div", _hoisted_2, [
-          renderSlot(_ctx.$slots, "default")
-        ])) : createCommentVNode("", true),
-        createElementVNode("div", {
-          style: normalizeStyle({ maxHeight: maxHeightWrapper.value }),
-          class: "vc-tree__container"
-        }, [
-          createVNode(unref(ElTree), {
-            ref_key: "treeRef",
-            ref: treeRef,
-            data: localOptions.value,
-            "empty-text": _ctx.emptyText,
-            "show-checkbox": _ctx.selectable,
-            "default-expand-all": _ctx.defaultExpandAll,
-            "default-expanded-keys": _ctx.expandedKeys,
-            "default-checked-keys": _ctx.defaultCheckedKeys,
-            "filter-node-method": filterNodeFn,
-            props: elTreeProps.value,
-            "node-key": String(props.nodeKey),
-            "auto-expand-parent": "",
-            onCheck: handleCheck
-          }, {
-            default: withCtx(({ node, data }) => [
-              _ctx.$slots["node-label"] ? renderSlot(_ctx.$slots, "node-label", {
-                key: 0,
-                node,
-                data
-              }) : (openBlock(), createElementBlock("div", {
-                key: 1,
-                class: normalizeClass([props.config.nodeClassName ? data[props.config.nodeClassName] : "", "vc-tree-node-item"])
-              }, [
-                data[props.config.iconKey] ? (openBlock(), createElementBlock("span", {
-                  key: 0,
-                  class: normalizeClass([[
-                    data[props.config.iconKey],
-                    colorClass.value
-                  ], "vc-tree-node-icon icon-lg"])
-                }, null, 2)) : createCommentVNode("", true),
-                createElementVNode("span", {
-                  class: normalizeClass([props.config.nodeLabelClassName ? data[props.config.nodeLabelClassName] : "", "vc-tree-node-label"])
-                }, toDisplayString(data[props.config.labelKey]), 3)
-              ], 2))
-            ]),
-            _: 3
-          }, 8, ["data", "empty-text", "show-checkbox", "default-expand-all", "default-expanded-keys", "default-checked-keys", "props", "node-key"])
-        ], 4),
-        createVNode(VcLoading, {
-          active: _ctx.loading,
-          loader: "lds-spinner",
-          color: "primary",
-          size: "30",
-          class: "z-1 rounded"
-        }, null, 8, ["active"])
-      ], 512);
-    };
-  }
-});
-export {
-  _sfc_main as _
-};