@wfrog/vc-ui 1.0.0

package/dist/es/chunk/BX-Ogf7p.mjs

@@ -0,0 +1,3743 @@
+import { defineComponent, inject, createVNode, Comment, computed, createElementBlock, openBlock, normalizeClass, unref, createCommentVNode, createBlock, withModifiers, withCtx, createElementVNode, Fragment, getCurrentInstance, ref, renderList, createTextVNode, toDisplayString, renderSlot, useSlots, provide, reactive, watch, onBeforeUpdate, onMounted, nextTick, useAttrs, withDirectives, isRef, vShow, normalizeStyle, createSlots, resolveDynamicComponent, withKeys, vModelText, Transition, mergeProps, toHandlers, onUpdated, h, resolveComponent, useTemplateRef, onBeforeUnmount } from 'vue';
+import { j as isLeaf, k as focusNode, l as getSibling, e as useResizeObserver, m as useCssVar, c as useEventListener } from './CEClY-_T.mjs';
+import { E as ElInput } from './Dvi7RsXg.mjs';
+import { g as unique, c as castArray, u as useTooltipContentProps, E as Ee, a as ElTooltip } from './DqUIKX7f.mjs';
+import { E as ElScrollbar } from './CaTfZePA.mjs';
+import { t as tagProps, E as ElTag } from './CZ4ggqDE.mjs';
+import { E as ElIcon } from './DMHNh_tw.mjs';
+import { Check, Loading, ArrowRight, CircleClose, ArrowDown, CaretRight } from '@element-plus/icons-vue';
+import { u as useNamespace, i as isArray, a as isEmpty, j as isFunction, g as isUndefined, C as isPropAbsent, c as buildProps, N as NOOP, d as definePropType, o as isClient, x as isBoolean, e as debugWarn, w as useDebounceFn, G as isPromise, H as hasOwn, k as isNil, h as isString, s as isObject } from './E_WRn0OP.mjs';
+import { u as useSizeProp, c as componentSizes } from './CS4VKsqy.mjs';
+import { i as iconPropType } from '../components/icon/icon2.mjs';
+import { u as useEmptyValuesProps, a as useEmptyValues } from './C5hWsUfD.mjs';
+import { C as CHANGE_EVENT, U as UPDATE_MODEL_EVENT } from './Ct6q2FXg.mjs';
+import { _ as _export_sfc, w as withInstall } from './D389hx_T.mjs';
+import { C as ClickOutside } from './HSv8BL8o.mjs';
+import { u as useLocale } from './aibQ9WSZ.mjs';
+import { u as useFormItem, b as useFormDisabled, c as useFormSize } from './DZACQ9LT.mjs';
+import { a as useComposition, u as useFocusController } from './JCIyOUEY.mjs';
+import { g as getEventCode, E as EVENT_CODE } from './BJS5Pdfp.mjs';
+import { c as cloneDeep } from './CyxEcbcy.mjs';
+import { b as ElCheckbox, c as ElRadio } from './D3DXeVfC.mjs';
+import { u as useVModel } from './CD98REcR.mjs';
+import { r as removeClass, b as addClass } from './D5259bwd.mjs';
+import { u as useId, f as formItemContextKey } from './8rLUmOVR.mjs';
+import { i as isEqual } from './-EkpfdcW.mjs';
+import { s as scrollIntoView } from './DyDMGLoF.mjs';
+import { b as baseFlatten } from './C2LgraHx.mjs';
+import { _ as _export_sfc$1 } from './pcqpp-6-.mjs';
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Recursively flattens `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flattenDeep([1, [2, [3, [4]], 5]]);
+ * // => [1, 2, 3, 4, 5]
+ */
+function flattenDeep(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? baseFlatten(array, INFINITY) : [];
+}
+
+const CASCADER_PANEL_INJECTION_KEY = Symbol();
+
+function isVNodeEmpty(vnodes) {
+  return !!(isArray(vnodes) ? vnodes.every(({
+    type
+  }) => type === Comment) : (vnodes == null ? void 0 : vnodes.type) === Comment);
+}
+var NodeContent$1 = defineComponent({
+  name: "NodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    const ns = useNamespace("cascader-node");
+    const {
+      renderLabelFn
+    } = inject(CASCADER_PANEL_INJECTION_KEY);
+    const {
+      node
+    } = props;
+    const {
+      data,
+      label: nodeLabel
+    } = node;
+    const label = () => {
+      const renderLabel = renderLabelFn == null ? void 0 : renderLabelFn({
+        node,
+        data
+      });
+      return isVNodeEmpty(renderLabel) ? nodeLabel : renderLabel != null ? renderLabel : nodeLabel;
+    };
+    return () => createVNode("span", {
+      "class": ns.e("label")
+    }, [label()]);
+  }
+});
+
+const __default__$5 = defineComponent({
+  name: "ElCascaderNode"
+});
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  ...__default__$5,
+  props: {
+    node: {
+      type: Object,
+      required: true
+    },
+    menuId: String
+  },
+  emits: ["expand"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const panel = inject(CASCADER_PANEL_INJECTION_KEY);
+    const ns = useNamespace("cascader-node");
+    const isHoverMenu = computed(() => panel.isHoverMenu);
+    const multiple = computed(() => panel.config.multiple);
+    const checkStrictly = computed(() => panel.config.checkStrictly);
+    const showPrefix = computed(() => panel.config.showPrefix);
+    const checkedNodeId = computed(() => {
+      var _a;
+      return (_a = panel.checkedNodes[0]) == null ? void 0 : _a.uid;
+    });
+    const isDisabled = computed(() => props.node.isDisabled);
+    const isLeaf = computed(() => props.node.isLeaf);
+    const expandable = computed(() => checkStrictly.value && !isLeaf.value || !isDisabled.value);
+    const inExpandingPath = computed(() => isInPath(panel.expandingNode));
+    const inCheckedPath = computed(() => checkStrictly.value && panel.checkedNodes.some(isInPath));
+    const isInPath = (node) => {
+      var _a;
+      const { level, uid } = props.node;
+      return ((_a = node == null ? void 0 : node.pathNodes[level - 1]) == null ? void 0 : _a.uid) === uid;
+    };
+    const doExpand = () => {
+      if (inExpandingPath.value)
+        return;
+      panel.expandNode(props.node);
+    };
+    const doCheck = (checked) => {
+      const { node } = props;
+      if (checked === node.checked)
+        return;
+      panel.handleCheckChange(node, checked);
+    };
+    const doLoad = () => {
+      panel.lazyLoad(props.node, () => {
+        if (!isLeaf.value)
+          doExpand();
+      });
+    };
+    const handleHoverExpand = (e) => {
+      if (!isHoverMenu.value)
+        return;
+      handleExpand();
+      !isLeaf.value && emit("expand", e);
+    };
+    const handleExpand = () => {
+      const { node } = props;
+      if (!expandable.value || node.loading)
+        return;
+      node.loaded ? doExpand() : doLoad();
+    };
+    const handleClick = () => {
+      if (isLeaf.value && !isDisabled.value && !checkStrictly.value && !multiple.value) {
+        handleCheck(true);
+      } else if ((panel.config.checkOnClickNode && (multiple.value || checkStrictly.value) || isLeaf.value && panel.config.checkOnClickLeaf) && !isDisabled.value) {
+        handleSelectCheck(!props.node.checked);
+      } else if (!isHoverMenu.value) {
+        handleExpand();
+      }
+    };
+    const handleSelectCheck = (checked) => {
+      if (checkStrictly.value) {
+        doCheck(checked);
+        if (props.node.loaded) {
+          doExpand();
+        }
+      } else {
+        handleCheck(checked);
+      }
+    };
+    const handleCheck = (checked) => {
+      if (!props.node.loaded) {
+        doLoad();
+      } else {
+        doCheck(checked);
+        !checkStrictly.value && doExpand();
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("li", {
+        id: `${__props.menuId}-${__props.node.uid}`,
+        role: "menuitem",
+        "aria-haspopup": !unref(isLeaf),
+        "aria-owns": unref(isLeaf) ? void 0 : __props.menuId,
+        "aria-expanded": unref(inExpandingPath),
+        tabindex: unref(expandable) ? -1 : void 0,
+        class: normalizeClass([
+          unref(ns).b(),
+          unref(ns).is("selectable", unref(checkStrictly)),
+          unref(ns).is("active", __props.node.checked),
+          unref(ns).is("disabled", !unref(expandable)),
+          unref(inExpandingPath) && "in-active-path",
+          unref(inCheckedPath) && "in-checked-path"
+        ]),
+        onMouseenter: handleHoverExpand,
+        onFocus: handleHoverExpand,
+        onClick: handleClick
+      }, [
+        createCommentVNode(" prefix "),
+        unref(multiple) && unref(showPrefix) ? (openBlock(), createBlock(unref(ElCheckbox), {
+          key: 0,
+          "model-value": __props.node.checked,
+          indeterminate: __props.node.indeterminate,
+          disabled: unref(isDisabled),
+          onClick: withModifiers(() => {
+          }, ["stop"]),
+          "onUpdate:modelValue": handleSelectCheck
+        }, null, 8, ["model-value", "indeterminate", "disabled", "onClick"])) : unref(checkStrictly) && unref(showPrefix) ? (openBlock(), createBlock(unref(ElRadio), {
+          key: 1,
+          "model-value": unref(checkedNodeId),
+          label: __props.node.uid,
+          disabled: unref(isDisabled),
+          "onUpdate:modelValue": handleSelectCheck,
+          onClick: withModifiers(() => {
+          }, ["stop"])
+        }, {
+          default: withCtx(() => [
+            createCommentVNode("\n        Add an empty element to avoid render label,\n        do not use empty fragment here for https://github.com/vuejs/vue-next/pull/2485\n      "),
+            createElementVNode("span")
+          ]),
+          _: 1
+        }, 8, ["model-value", "label", "disabled", "onClick"])) : unref(isLeaf) && __props.node.checked ? (openBlock(), createBlock(unref(ElIcon), {
+          key: 2,
+          class: normalizeClass(unref(ns).e("prefix"))
+        }, {
+          default: withCtx(() => [
+            createVNode(unref(Check))
+          ]),
+          _: 1
+        }, 8, ["class"])) : createCommentVNode("v-if", true),
+        createCommentVNode(" content "),
+        createVNode(unref(NodeContent$1), { node: __props.node }, null, 8, ["node"]),
+        createCommentVNode(" postfix "),
+        !unref(isLeaf) ? (openBlock(), createElementBlock(Fragment, { key: 3 }, [
+          __props.node.loading ? (openBlock(), createBlock(unref(ElIcon), {
+            key: 0,
+            class: normalizeClass([unref(ns).is("loading"), unref(ns).e("postfix")])
+          }, {
+            default: withCtx(() => [
+              createVNode(unref(Loading))
+            ]),
+            _: 1
+          }, 8, ["class"])) : (openBlock(), createBlock(unref(ElIcon), {
+            key: 1,
+            class: normalizeClass(["arrow-right", unref(ns).e("postfix")])
+          }, {
+            default: withCtx(() => [
+              createVNode(unref(ArrowRight))
+            ]),
+            _: 1
+          }, 8, ["class"]))
+        ], 64)) : createCommentVNode("v-if", true)
+      ], 42, ["id", "aria-haspopup", "aria-owns", "aria-expanded", "tabindex"]);
+    };
+  }
+});
+var ElCascaderNode = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["__file", "node.vue"]]);
+
+const __default__$4 = defineComponent({
+  name: "ElCascaderMenu"
+});
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  ...__default__$4,
+  props: {
+    nodes: {
+      type: Array,
+      required: true
+    },
+    index: {
+      type: Number,
+      required: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const instance = getCurrentInstance();
+    const ns = useNamespace("cascader-menu");
+    const { t } = useLocale();
+    const id = useId();
+    let activeNode;
+    let hoverTimer;
+    const panel = inject(CASCADER_PANEL_INJECTION_KEY);
+    const hoverZone = ref();
+    const isEmpty = computed(() => !props.nodes.length);
+    const isLoading = computed(() => !panel.initialLoaded);
+    const menuId = computed(() => `${id.value}-${props.index}`);
+    const handleExpand = (e) => {
+      activeNode = e.target;
+    };
+    const handleMouseMove = (e) => {
+      var _a;
+      if (!panel.isHoverMenu || !activeNode || !hoverZone.value)
+        return;
+      if (activeNode.contains(e.target)) {
+        clearHoverTimer();
+        const el = instance.vnode.el;
+        const { left } = el.getBoundingClientRect();
+        const { offsetWidth, offsetHeight } = el;
+        const startX = e.clientX - left;
+        const top = activeNode.offsetTop;
+        const bottom = top + activeNode.offsetHeight;
+        const scrollTop = ((_a = el.querySelector(`.${ns.e("wrap")}`)) == null ? void 0 : _a.scrollTop) || 0;
+        hoverZone.value.innerHTML = `
+          <path style="pointer-events: auto;" fill="transparent" d="M${startX} ${top} L${offsetWidth} ${scrollTop} V${top} Z" />
+          <path style="pointer-events: auto;" fill="transparent" d="M${startX} ${bottom} L${offsetWidth} ${offsetHeight + scrollTop} V${bottom} Z" />
+        `;
+      } else if (!hoverTimer) {
+        hoverTimer = window.setTimeout(clearHoverZone, panel.config.hoverThreshold);
+      }
+    };
+    const clearHoverTimer = () => {
+      if (!hoverTimer)
+        return;
+      clearTimeout(hoverTimer);
+      hoverTimer = void 0;
+    };
+    const clearHoverZone = () => {
+      if (!hoverZone.value)
+        return;
+      hoverZone.value.innerHTML = "";
+      clearHoverTimer();
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ElScrollbar), {
+        key: unref(menuId),
+        tag: "ul",
+        role: "menu",
+        class: normalizeClass(unref(ns).b()),
+        "wrap-class": unref(ns).e("wrap"),
+        "view-class": [unref(ns).e("list"), unref(ns).is("empty", unref(isEmpty))],
+        onMousemove: handleMouseMove,
+        onMouseleave: clearHoverZone
+      }, {
+        default: withCtx(() => {
+          var _a;
+          return [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.nodes, (node) => {
+              return openBlock(), createBlock(ElCascaderNode, {
+                key: node.uid,
+                node,
+                "menu-id": unref(menuId),
+                onExpand: handleExpand
+              }, null, 8, ["node", "menu-id"]);
+            }), 128)),
+            unref(isLoading) ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: normalizeClass(unref(ns).e("empty-text"))
+            }, [
+              createVNode(unref(ElIcon), {
+                size: "14",
+                class: normalizeClass(unref(ns).is("loading"))
+              }, {
+                default: withCtx(() => [
+                  createVNode(unref(Loading))
+                ]),
+                _: 1
+              }, 8, ["class"]),
+              createTextVNode(" " + toDisplayString(unref(t)("el.cascader.loading")), 1)
+            ], 2)) : unref(isEmpty) ? (openBlock(), createElementBlock("div", {
+              key: 1,
+              class: normalizeClass(unref(ns).e("empty-text"))
+            }, [
+              renderSlot(_ctx.$slots, "empty", {}, () => [
+                createTextVNode(toDisplayString(unref(t)("el.cascader.noData")), 1)
+              ])
+            ], 2)) : ((_a = unref(panel)) == null ? void 0 : _a.isHoverMenu) ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
+              createCommentVNode(" eslint-disable-next-line vue/html-self-closing "),
+              (openBlock(), createElementBlock("svg", {
+                ref_key: "hoverZone",
+                ref: hoverZone,
+                class: normalizeClass(unref(ns).e("hover-zone"))
+              }, null, 2))
+            ], 2112)) : createCommentVNode("v-if", true)
+          ];
+        }),
+        _: 3
+      }, 8, ["class", "wrap-class", "view-class"]);
+    };
+  }
+});
+var ElCascaderMenu = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__file", "menu.vue"]]);
+
+let uid = 0;
+const calculatePathNodes = (node) => {
+  const nodes = [node];
+  let { parent } = node;
+  while (parent) {
+    nodes.unshift(parent);
+    parent = parent.parent;
+  }
+  return nodes;
+};
+let Node$1 = class Node {
+  constructor(data, config, parent, root = false) {
+    this.data = data;
+    this.config = config;
+    this.parent = parent;
+    this.root = root;
+    this.uid = uid++;
+    this.checked = false;
+    this.indeterminate = false;
+    this.loading = false;
+    const { value: valueKey, label: labelKey, children: childrenKey } = config;
+    const childrenData = data[childrenKey];
+    const pathNodes = calculatePathNodes(this);
+    this.level = root ? 0 : parent ? parent.level + 1 : 1;
+    this.value = data[valueKey];
+    this.label = data[labelKey];
+    this.pathNodes = pathNodes;
+    this.pathValues = pathNodes.map((node) => node.value);
+    this.pathLabels = pathNodes.map((node) => node.label);
+    this.childrenData = childrenData;
+    this.children = (childrenData || []).map((child) => new Node(child, config, this));
+    this.loaded = !config.lazy || this.isLeaf || !isEmpty(childrenData);
+    this.text = "";
+  }
+  get isDisabled() {
+    const { data, parent, config } = this;
+    const { disabled, checkStrictly } = config;
+    const isDisabled = isFunction(disabled) ? disabled(data, this) : !!data[disabled];
+    return isDisabled || !checkStrictly && !!(parent == null ? void 0 : parent.isDisabled);
+  }
+  get isLeaf() {
+    const { data, config, childrenData, loaded } = this;
+    const { lazy, leaf } = config;
+    const isLeaf = isFunction(leaf) ? leaf(data, this) : data[leaf];
+    return isUndefined(isLeaf) ? lazy && !loaded ? false : !(isArray(childrenData) && childrenData.length) : !!isLeaf;
+  }
+  get valueByOption() {
+    return this.config.emitPath ? this.pathValues : this.value;
+  }
+  appendChild(childData) {
+    const { childrenData, children } = this;
+    const node = new Node(childData, this.config, this);
+    if (isArray(childrenData)) {
+      childrenData.push(childData);
+    } else {
+      this.childrenData = [childData];
+    }
+    children.push(node);
+    return node;
+  }
+  calcText(allLevels, separator) {
+    const text = allLevels ? this.pathLabels.join(separator) : this.label;
+    this.text = text;
+    return text;
+  }
+  broadcast(checked) {
+    this.children.forEach((child) => {
+      var _a;
+      if (child) {
+        child.broadcast(checked);
+        (_a = child.onParentCheck) == null ? void 0 : _a.call(child, checked);
+      }
+    });
+  }
+  emit() {
+    var _a;
+    const { parent } = this;
+    if (parent) {
+      (_a = parent.onChildCheck) == null ? void 0 : _a.call(parent);
+      parent.emit();
+    }
+  }
+  onParentCheck(checked) {
+    if (!this.isDisabled) {
+      this.setCheckState(checked);
+    }
+  }
+  onChildCheck() {
+    const { children } = this;
+    const validChildren = children.filter((child) => !child.isDisabled);
+    const checked = validChildren.length ? validChildren.every((child) => child.checked) : false;
+    this.setCheckState(checked);
+  }
+  setCheckState(checked) {
+    const totalNum = this.children.length;
+    const checkedNum = this.children.reduce((c, p) => {
+      const num = p.checked ? 1 : p.indeterminate ? 0.5 : 0;
+      return c + num;
+    }, 0);
+    this.checked = this.loaded && this.children.filter((child) => !child.isDisabled).every((child) => child.loaded && child.checked) && checked;
+    this.indeterminate = this.loaded && checkedNum !== totalNum && checkedNum > 0;
+  }
+  doCheck(checked) {
+    if (this.checked === checked)
+      return;
+    const { checkStrictly, multiple } = this.config;
+    if (checkStrictly || !multiple) {
+      this.checked = checked;
+    } else {
+      this.broadcast(checked);
+      this.setCheckState(checked);
+      this.emit();
+    }
+  }
+};
+
+const flatNodes = (nodes, leafOnly) => {
+  return nodes.reduce((res, node) => {
+    if (node.isLeaf) {
+      res.push(node);
+    } else {
+      !leafOnly && res.push(node);
+      res = res.concat(flatNodes(node.children, leafOnly));
+    }
+    return res;
+  }, []);
+};
+class Store {
+  constructor(data, config) {
+    this.config = config;
+    const nodes = (data || []).map((nodeData) => new Node$1(nodeData, this.config));
+    this.nodes = nodes;
+    this.allNodes = flatNodes(nodes, false);
+    this.leafNodes = flatNodes(nodes, true);
+  }
+  getNodes() {
+    return this.nodes;
+  }
+  getFlattedNodes(leafOnly) {
+    return leafOnly ? this.leafNodes : this.allNodes;
+  }
+  appendNode(nodeData, parentNode) {
+    const node = parentNode ? parentNode.appendChild(nodeData) : new Node$1(nodeData, this.config);
+    if (!parentNode)
+      this.nodes.push(node);
+    this.appendAllNodesAndLeafNodes(node);
+  }
+  appendNodes(nodeDataList, parentNode) {
+    if (nodeDataList.length > 0) {
+      nodeDataList.forEach((nodeData) => this.appendNode(nodeData, parentNode));
+    } else {
+      parentNode && parentNode.isLeaf && this.leafNodes.push(parentNode);
+    }
+  }
+  appendAllNodesAndLeafNodes(node) {
+    this.allNodes.push(node);
+    node.isLeaf && this.leafNodes.push(node);
+    if (node.children) {
+      node.children.forEach((subNode) => {
+        this.appendAllNodesAndLeafNodes(subNode);
+      });
+    }
+  }
+  getNodeByValue(value, leafOnly = false) {
+    if (isPropAbsent(value))
+      return null;
+    const node = this.getFlattedNodes(leafOnly).find((node2) => isEqual(node2.value, value) || isEqual(node2.pathValues, value));
+    return node || null;
+  }
+  getSameNode(node) {
+    if (!node)
+      return null;
+    const node_ = this.getFlattedNodes(false).find(({ value, level }) => isEqual(node.value, value) && node.level === level);
+    return node_ || null;
+  }
+}
+
+const CommonProps = buildProps({
+  modelValue: {
+    type: definePropType([Number, String, Array, Object])
+  },
+  options: {
+    type: definePropType(Array),
+    default: () => []
+  },
+  props: {
+    type: definePropType(Object),
+    default: () => ({})
+  }
+});
+const DefaultProps = {
+  expandTrigger: "click",
+  multiple: false,
+  checkStrictly: false,
+  emitPath: true,
+  lazy: false,
+  lazyLoad: NOOP,
+  value: "value",
+  label: "label",
+  children: "children",
+  leaf: "leaf",
+  disabled: "disabled",
+  hoverThreshold: 500,
+  checkOnClickNode: false,
+  checkOnClickLeaf: true,
+  showPrefix: true
+};
+const cascaderPanelProps = buildProps({
+  ...CommonProps,
+  border: {
+    type: Boolean,
+    default: true
+  },
+  renderLabel: {
+    type: Function
+  }
+});
+const emitChangeFn$1 = (value) => true;
+const cascaderPanelEmits = {
+  [UPDATE_MODEL_EVENT]: emitChangeFn$1,
+  [CHANGE_EVENT]: emitChangeFn$1,
+  close: () => true,
+  "expand-change": (value) => value
+};
+const useCascaderConfig = (props) => {
+  return computed(() => ({
+    ...DefaultProps,
+    ...props.props
+  }));
+};
+
+const getMenuIndex = (el) => {
+  if (!el)
+    return 0;
+  const pieces = el.id.split("-");
+  return Number(pieces[pieces.length - 2]);
+};
+const checkNode = (el) => {
+  if (!el)
+    return;
+  const input = el.querySelector("input");
+  if (input) {
+    input.click();
+  } else if (isLeaf(el)) {
+    el.click();
+  }
+};
+const sortByOriginalOrder = (oldNodes, newNodes) => {
+  const newNodesCopy = newNodes.slice(0);
+  const newIds = newNodesCopy.map((node) => node.uid);
+  const res = oldNodes.reduce((acc, item) => {
+    const index = newIds.indexOf(item.uid);
+    if (index > -1) {
+      acc.push(item);
+      newNodesCopy.splice(index, 1);
+      newIds.splice(index, 1);
+    }
+    return acc;
+  }, []);
+  res.push(...newNodesCopy);
+  return res;
+};
+
+const __default__$3 = defineComponent({
+  name: "ElCascaderPanel"
+});
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  ...__default__$3,
+  props: cascaderPanelProps,
+  emits: cascaderPanelEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    let manualChecked = false;
+    const ns = useNamespace("cascader");
+    const config = useCascaderConfig(props);
+    const slots = useSlots();
+    let store;
+    const initialLoaded = ref(true);
+    const initialLoadedOnce = ref(false);
+    const menuList = ref([]);
+    const checkedValue = ref();
+    const menus = ref([]);
+    const expandingNode = ref();
+    const checkedNodes = ref([]);
+    const isHoverMenu = computed(() => config.value.expandTrigger === "hover");
+    const renderLabelFn = computed(() => props.renderLabel || slots.default);
+    const initStore = () => {
+      const { options } = props;
+      const cfg = config.value;
+      manualChecked = false;
+      store = new Store(options, cfg);
+      menus.value = [store.getNodes()];
+      if (cfg.lazy && isEmpty(props.options)) {
+        initialLoaded.value = false;
+        lazyLoad(void 0, (list) => {
+          if (list) {
+            store = new Store(list, cfg);
+            menus.value = [store.getNodes()];
+          }
+          initialLoaded.value = true;
+          syncCheckedValue(false, true);
+        });
+      } else {
+        syncCheckedValue(false, true);
+      }
+    };
+    const lazyLoad = (node, cb) => {
+      const cfg = config.value;
+      node = node || new Node$1({}, cfg, void 0, true);
+      node.loading = true;
+      const resolve = (dataList) => {
+        const _node = node;
+        const parent = _node.root ? null : _node;
+        _node.loading = false;
+        _node.loaded = true;
+        _node.childrenData = _node.childrenData || [];
+        dataList && (store == null ? void 0 : store.appendNodes(dataList, parent));
+        dataList && (cb == null ? void 0 : cb(dataList));
+        if (node.level === 0) {
+          initialLoadedOnce.value = true;
+        }
+      };
+      const reject = () => {
+        node.loading = false;
+        node.loaded = false;
+        if (node.level === 0) {
+          initialLoaded.value = true;
+        }
+      };
+      cfg.lazyLoad(node, resolve, reject);
+    };
+    const expandNode = (node, silent) => {
+      var _a;
+      const { level } = node;
+      const newMenus = menus.value.slice(0, level);
+      let newExpandingNode;
+      if (node.isLeaf) {
+        newExpandingNode = node.pathNodes[level - 2];
+      } else {
+        newExpandingNode = node;
+        newMenus.push(node.children);
+      }
+      if (((_a = expandingNode.value) == null ? void 0 : _a.uid) !== (newExpandingNode == null ? void 0 : newExpandingNode.uid)) {
+        expandingNode.value = node;
+        menus.value = newMenus;
+        !silent && emit("expand-change", (node == null ? void 0 : node.pathValues) || []);
+      }
+    };
+    const handleCheckChange = (node, checked, emitClose = true) => {
+      const { checkStrictly, multiple } = config.value;
+      const oldNode = checkedNodes.value[0];
+      manualChecked = true;
+      !multiple && (oldNode == null ? void 0 : oldNode.doCheck(false));
+      node.doCheck(checked);
+      calculateCheckedValue();
+      emitClose && !multiple && !checkStrictly && emit("close");
+      !emitClose && !multiple && expandParentNode(node);
+    };
+    const expandParentNode = (node) => {
+      if (!node)
+        return;
+      node = node.parent;
+      expandParentNode(node);
+      node && expandNode(node);
+    };
+    const getFlattedNodes = (leafOnly) => store == null ? void 0 : store.getFlattedNodes(leafOnly);
+    const getCheckedNodes = (leafOnly) => {
+      var _a;
+      return (_a = getFlattedNodes(leafOnly)) == null ? void 0 : _a.filter(({ checked }) => checked !== false);
+    };
+    const clearCheckedNodes = () => {
+      checkedNodes.value.forEach((node) => node.doCheck(false));
+      calculateCheckedValue();
+      menus.value = menus.value.slice(0, 1);
+      expandingNode.value = void 0;
+      emit("expand-change", []);
+    };
+    const calculateCheckedValue = () => {
+      var _a;
+      const { checkStrictly, multiple } = config.value;
+      const oldNodes = checkedNodes.value;
+      const newNodes = getCheckedNodes(!checkStrictly);
+      const nodes = sortByOriginalOrder(oldNodes, newNodes);
+      const values = nodes.map((node) => node.valueByOption);
+      checkedNodes.value = nodes;
+      checkedValue.value = multiple ? values : (_a = values[0]) != null ? _a : null;
+    };
+    const syncCheckedValue = (loaded = false, forced = false) => {
+      const { modelValue } = props;
+      const { lazy, multiple, checkStrictly } = config.value;
+      const leafOnly = !checkStrictly;
+      if (!initialLoaded.value || manualChecked || !forced && isEqual(modelValue, checkedValue.value))
+        return;
+      if (lazy && !loaded) {
+        const values = unique(flattenDeep(castArray(modelValue)));
+        const nodes = values.map((val) => store == null ? void 0 : store.getNodeByValue(val)).filter((node) => !!node && !node.loaded && !node.loading);
+        if (nodes.length) {
+          nodes.forEach((node) => {
+            lazyLoad(node, () => syncCheckedValue(false, forced));
+          });
+        } else {
+          syncCheckedValue(true, forced);
+        }
+      } else {
+        const values = multiple ? castArray(modelValue) : [modelValue];
+        const nodes = unique(values.map((val) => store == null ? void 0 : store.getNodeByValue(val, leafOnly)));
+        syncMenuState(nodes, forced);
+        checkedValue.value = cloneDeep(modelValue != null ? modelValue : void 0);
+      }
+    };
+    const syncMenuState = (newCheckedNodes, reserveExpandingState = true) => {
+      const { checkStrictly } = config.value;
+      const oldNodes = checkedNodes.value;
+      const newNodes = newCheckedNodes.filter((node) => !!node && (checkStrictly || node.isLeaf));
+      const oldExpandingNode = store == null ? void 0 : store.getSameNode(expandingNode.value);
+      const newExpandingNode = reserveExpandingState && oldExpandingNode || newNodes[0];
+      if (newExpandingNode) {
+        newExpandingNode.pathNodes.forEach((node) => expandNode(node, true));
+      } else {
+        expandingNode.value = void 0;
+      }
+      oldNodes.forEach((node) => node.doCheck(false));
+      reactive(newNodes).forEach((node) => node.doCheck(true));
+      checkedNodes.value = newNodes;
+      nextTick(scrollToExpandingNode);
+    };
+    const scrollToExpandingNode = () => {
+      if (!isClient)
+        return;
+      menuList.value.forEach((menu) => {
+        const menuElement = menu == null ? void 0 : menu.$el;
+        if (menuElement) {
+          const container = menuElement.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
+          const activeNode = menuElement.querySelector(`.${ns.b("node")}.${ns.is("active")}:last-child`) || menuElement.querySelector(`.${ns.b("node")}.in-active-path`);
+          scrollIntoView(container, activeNode);
+        }
+      });
+    };
+    const handleKeyDown = (e) => {
+      const target = e.target;
+      const code = getEventCode(e);
+      switch (code) {
+        case EVENT_CODE.up:
+        case EVENT_CODE.down: {
+          e.preventDefault();
+          const distance = code === EVENT_CODE.up ? -1 : 1;
+          focusNode(getSibling(target, distance, `.${ns.b("node")}[tabindex="-1"]`));
+          break;
+        }
+        case EVENT_CODE.left: {
+          e.preventDefault();
+          const preMenu = menuList.value[getMenuIndex(target) - 1];
+          const expandedNode = preMenu == null ? void 0 : preMenu.$el.querySelector(`.${ns.b("node")}[aria-expanded="true"]`);
+          focusNode(expandedNode);
+          break;
+        }
+        case EVENT_CODE.right: {
+          e.preventDefault();
+          const nextMenu = menuList.value[getMenuIndex(target) + 1];
+          const firstNode = nextMenu == null ? void 0 : nextMenu.$el.querySelector(`.${ns.b("node")}[tabindex="-1"]`);
+          focusNode(firstNode);
+          break;
+        }
+        case EVENT_CODE.enter:
+        case EVENT_CODE.numpadEnter:
+          checkNode(target);
+          break;
+      }
+    };
+    provide(CASCADER_PANEL_INJECTION_KEY, reactive({
+      config,
+      expandingNode,
+      checkedNodes,
+      isHoverMenu,
+      initialLoaded,
+      renderLabelFn,
+      lazyLoad,
+      expandNode,
+      handleCheckChange
+    }));
+    watch(config, (newVal, oldVal) => {
+      if (isEqual(newVal, oldVal))
+        return;
+      initStore();
+    }, {
+      immediate: true
+    });
+    watch(() => props.options, initStore, {
+      deep: true
+    });
+    watch(() => props.modelValue, () => {
+      manualChecked = false;
+      syncCheckedValue();
+    }, {
+      deep: true
+    });
+    watch(() => checkedValue.value, (val) => {
+      if (!isEqual(val, props.modelValue)) {
+        emit(UPDATE_MODEL_EVENT, val);
+        emit(CHANGE_EVENT, val);
+      }
+    });
+    const loadLazyRootNodes = () => {
+      if (initialLoadedOnce.value)
+        return;
+      initStore();
+    };
+    onBeforeUpdate(() => menuList.value = []);
+    onMounted(() => !isEmpty(props.modelValue) && syncCheckedValue());
+    expose({
+      menuList,
+      menus,
+      checkedNodes,
+      handleKeyDown,
+      handleCheckChange,
+      getFlattedNodes,
+      getCheckedNodes,
+      clearCheckedNodes,
+      calculateCheckedValue,
+      scrollToExpandingNode,
+      loadLazyRootNodes
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([unref(ns).b("panel"), unref(ns).is("bordered", _ctx.border)]),
+        onKeydown: handleKeyDown
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(menus.value, (menu, index) => {
+          return openBlock(), createBlock(ElCascaderMenu, {
+            key: index,
+            ref_for: true,
+            ref: (item) => menuList.value[index] = item,
+            index,
+            nodes: [...menu]
+          }, {
+            empty: withCtx(() => [
+              renderSlot(_ctx.$slots, "empty")
+            ]),
+            _: 2
+          }, 1032, ["index", "nodes"]);
+        }), 128))
+      ], 34);
+    };
+  }
+});
+var CascaderPanel = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__file", "index.vue"]]);
+
+const ElCascaderPanel = withInstall(CascaderPanel);
+
+const cascaderProps = buildProps({
+  ...CommonProps,
+  size: useSizeProp,
+  placeholder: String,
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  clearable: Boolean,
+  clearIcon: {
+    type: iconPropType,
+    default: CircleClose
+  },
+  filterable: Boolean,
+  filterMethod: {
+    type: definePropType(Function),
+    default: (node, keyword) => node.text.includes(keyword)
+  },
+  separator: {
+    type: String,
+    default: " / "
+  },
+  showAllLevels: {
+    type: Boolean,
+    default: true
+  },
+  collapseTags: Boolean,
+  maxCollapseTags: {
+    type: Number,
+    default: 1
+  },
+  collapseTagsTooltip: Boolean,
+  maxCollapseTagsTooltipHeight: {
+    type: [String, Number]
+  },
+  debounce: {
+    type: Number,
+    default: 300
+  },
+  beforeFilter: {
+    type: definePropType(Function),
+    default: () => true
+  },
+  placement: {
+    type: definePropType(String),
+    values: Ee,
+    default: "bottom-start"
+  },
+  fallbackPlacements: {
+    type: definePropType(Array),
+    default: ["bottom-start", "bottom", "top-start", "top", "right", "left"]
+  },
+  popperClass: useTooltipContentProps.popperClass,
+  popperStyle: useTooltipContentProps.popperStyle,
+  teleported: useTooltipContentProps.teleported,
+  effect: {
+    type: definePropType(String),
+    default: "light"
+  },
+  tagType: { ...tagProps.type, default: "info" },
+  tagEffect: { ...tagProps.effect, default: "light" },
+  validateEvent: {
+    type: Boolean,
+    default: true
+  },
+  persistent: {
+    type: Boolean,
+    default: true
+  },
+  showCheckedStrategy: {
+    type: String,
+    values: ["parent", "child"],
+    default: "child"
+  },
+  checkOnClickNode: Boolean,
+  showPrefix: {
+    type: Boolean,
+    default: true
+  },
+  ...useEmptyValuesProps
+});
+const emitChangeFn = (value) => true;
+const cascaderEmits = {
+  [UPDATE_MODEL_EVENT]: emitChangeFn,
+  [CHANGE_EVENT]: emitChangeFn,
+  focus: (evt) => evt instanceof FocusEvent,
+  blur: (evt) => evt instanceof FocusEvent,
+  clear: () => true,
+  visibleChange: (val) => isBoolean(val),
+  expandChange: (val) => !!val,
+  removeTag: (val) => !!val
+};
+
+const __default__$2 = defineComponent({
+  name: "ElCascader"
+});
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  ...__default__$2,
+  props: cascaderProps,
+  emits: cascaderEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const popperOptions = {
+      modifiers: [
+        {
+          name: "arrowPosition",
+          enabled: true,
+          phase: "main",
+          fn: ({ state }) => {
+            const { modifiersData, placement } = state;
+            if (["right", "left", "bottom", "top"].includes(placement))
+              return;
+            if (modifiersData.arrow) {
+              modifiersData.arrow.x = 35;
+            }
+          },
+          requires: ["arrow"]
+        }
+      ]
+    };
+    const attrs = useAttrs();
+    let inputInitialHeight = 0;
+    let pressDeleteCount = 0;
+    const nsCascader = useNamespace("cascader");
+    const nsInput = useNamespace("input");
+    const { t } = useLocale();
+    const { formItem } = useFormItem();
+    const isDisabled = useFormDisabled();
+    const { valueOnClear } = useEmptyValues(props);
+    const { isComposing, handleComposition } = useComposition({
+      afterComposition(event) {
+        var _a;
+        const text = (_a = event.target) == null ? void 0 : _a.value;
+        handleInput(text);
+      }
+    });
+    const tooltipRef = ref();
+    const tagTooltipRef = ref();
+    const inputRef = ref();
+    const tagWrapper = ref();
+    const cascaderPanelRef = ref();
+    const suggestionPanel = ref();
+    const popperVisible = ref(false);
+    const inputHover = ref(false);
+    const filtering = ref(false);
+    const inputValue = ref("");
+    const searchInputValue = ref("");
+    const tags = ref([]);
+    const suggestions = ref([]);
+    const showTagList = computed(() => {
+      if (!props.props.multiple) {
+        return [];
+      }
+      return props.collapseTags ? tags.value.slice(0, props.maxCollapseTags) : tags.value;
+    });
+    const collapseTagList = computed(() => {
+      if (!props.props.multiple) {
+        return [];
+      }
+      return props.collapseTags ? tags.value.slice(props.maxCollapseTags) : [];
+    });
+    const cascaderStyle = computed(() => {
+      return attrs.style;
+    });
+    const inputPlaceholder = computed(() => {
+      var _a;
+      return (_a = props.placeholder) != null ? _a : t("el.cascader.placeholder");
+    });
+    const currentPlaceholder = computed(() => searchInputValue.value || tags.value.length > 0 || isComposing.value ? "" : inputPlaceholder.value);
+    const realSize = useFormSize();
+    const tagSize = computed(() => realSize.value === "small" ? "small" : "default");
+    const multiple = computed(() => !!props.props.multiple);
+    const readonly = computed(() => !props.filterable || multiple.value);
+    const searchKeyword = computed(() => multiple.value ? searchInputValue.value : inputValue.value);
+    const checkedNodes = computed(() => {
+      var _a;
+      return ((_a = cascaderPanelRef.value) == null ? void 0 : _a.checkedNodes) || [];
+    });
+    const { wrapperRef, isFocused, handleBlur } = useFocusController(inputRef, {
+      disabled: isDisabled,
+      beforeBlur(event) {
+        var _a, _b;
+        return ((_a = tooltipRef.value) == null ? void 0 : _a.isFocusInsideContent(event)) || ((_b = tagTooltipRef.value) == null ? void 0 : _b.isFocusInsideContent(event));
+      },
+      afterBlur() {
+        var _a;
+        if (props.validateEvent) {
+          (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn(err));
+        }
+      }
+    });
+    const clearBtnVisible = computed(() => {
+      if (!props.clearable || isDisabled.value || filtering.value || !inputHover.value && !isFocused.value)
+        return false;
+      return !!checkedNodes.value.length;
+    });
+    const presentText = computed(() => {
+      const { showAllLevels, separator } = props;
+      const nodes = checkedNodes.value;
+      return nodes.length ? multiple.value ? "" : nodes[0].calcText(showAllLevels, separator) : "";
+    });
+    const validateState = computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
+    const checkedValue = computed({
+      get() {
+        return cloneDeep(props.modelValue);
+      },
+      set(val) {
+        const value = val != null ? val : valueOnClear.value;
+        emit(UPDATE_MODEL_EVENT, value);
+        emit(CHANGE_EVENT, value);
+        if (props.validateEvent) {
+          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn(err));
+        }
+      }
+    });
+    const cascaderKls = computed(() => {
+      return [
+        nsCascader.b(),
+        nsCascader.m(realSize.value),
+        nsCascader.is("disabled", isDisabled.value),
+        attrs.class
+      ];
+    });
+    const cascaderIconKls = computed(() => {
+      return [
+        nsInput.e("icon"),
+        "icon-arrow-down",
+        nsCascader.is("reverse", popperVisible.value)
+      ];
+    });
+    const inputClass = computed(() => nsCascader.is("focus", isFocused.value));
+    const contentRef = computed(() => {
+      var _a, _b;
+      return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
+    });
+    const handleClickOutside = (event) => {
+      if (isFocused.value) {
+        const _event = new FocusEvent("blur", event);
+        handleBlur(_event);
+      }
+      togglePopperVisible(false);
+    };
+    const togglePopperVisible = (visible) => {
+      var _a, _b, _c;
+      if (isDisabled.value)
+        return;
+      visible = visible != null ? visible : !popperVisible.value;
+      if (visible !== popperVisible.value) {
+        popperVisible.value = visible;
+        (_b = (_a = inputRef.value) == null ? void 0 : _a.input) == null ? void 0 : _b.setAttribute("aria-expanded", `${visible}`);
+        if (visible) {
+          updatePopperPosition();
+          nextTick((_c = cascaderPanelRef.value) == null ? void 0 : _c.scrollToExpandingNode);
+        } else if (props.filterable) {
+          syncPresentTextValue();
+        }
+        emit("visibleChange", visible);
+      }
+    };
+    const updatePopperPosition = () => {
+      nextTick(() => {
+        var _a;
+        (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper();
+      });
+    };
+    const hideSuggestionPanel = () => {
+      filtering.value = false;
+    };
+    const genTag = (node) => {
+      const { showAllLevels, separator } = props;
+      return {
+        node,
+        key: node.uid,
+        text: node.calcText(showAllLevels, separator),
+        hitState: false,
+        closable: !isDisabled.value && !node.isDisabled
+      };
+    };
+    const deleteTag = (tag) => {
+      var _a;
+      const node = tag.node;
+      node.doCheck(false);
+      (_a = cascaderPanelRef.value) == null ? void 0 : _a.calculateCheckedValue();
+      emit("removeTag", node.valueByOption);
+    };
+    const getStrategyCheckedNodes = () => {
+      switch (props.showCheckedStrategy) {
+        case "child":
+          return checkedNodes.value;
+        case "parent": {
+          const clickedNodes = getCheckedNodes(false);
+          const clickedNodesValue = clickedNodes.map((o) => o.value);
+          const parentNodes = clickedNodes.filter((o) => !o.parent || !clickedNodesValue.includes(o.parent.value));
+          return parentNodes;
+        }
+        default:
+          return [];
+      }
+    };
+    const calculatePresentTags = () => {
+      if (!multiple.value)
+        return;
+      const nodes = getStrategyCheckedNodes();
+      const allTags = [];
+      nodes.forEach((node) => allTags.push(genTag(node)));
+      tags.value = allTags;
+    };
+    const calculateSuggestions = () => {
+      var _a, _b;
+      const { filterMethod, showAllLevels, separator } = props;
+      const res = (_b = (_a = cascaderPanelRef.value) == null ? void 0 : _a.getFlattedNodes(!props.props.checkStrictly)) == null ? void 0 : _b.filter((node) => {
+        if (node.isDisabled)
+          return false;
+        node.calcText(showAllLevels, separator);
+        return filterMethod(node, searchKeyword.value);
+      });
+      if (multiple.value) {
+        tags.value.forEach((tag) => {
+          tag.hitState = false;
+        });
+      }
+      filtering.value = true;
+      suggestions.value = res;
+      updatePopperPosition();
+    };
+    const focusFirstNode = () => {
+      var _a;
+      let firstNode;
+      if (filtering.value && suggestionPanel.value) {
+        firstNode = suggestionPanel.value.$el.querySelector(`.${nsCascader.e("suggestion-item")}`);
+      } else {
+        firstNode = (_a = cascaderPanelRef.value) == null ? void 0 : _a.$el.querySelector(`.${nsCascader.b("node")}[tabindex="-1"]`);
+      }
+      if (firstNode) {
+        firstNode.focus();
+        !filtering.value && firstNode.click();
+      }
+    };
+    const updateStyle = () => {
+      var _a, _b;
+      const inputInner = (_a = inputRef.value) == null ? void 0 : _a.input;
+      const tagWrapperEl = tagWrapper.value;
+      const suggestionPanelEl = (_b = suggestionPanel.value) == null ? void 0 : _b.$el;
+      if (!isClient || !inputInner)
+        return;
+      if (suggestionPanelEl) {
+        const suggestionList = suggestionPanelEl.querySelector(`.${nsCascader.e("suggestion-list")}`);
+        suggestionList.style.minWidth = `${inputInner.offsetWidth}px`;
+      }
+      if (tagWrapperEl) {
+        const { offsetHeight } = tagWrapperEl;
+        const height = tags.value.length > 0 ? `${Math.max(offsetHeight, inputInitialHeight) - 2}px` : `${inputInitialHeight}px`;
+        inputInner.style.height = height;
+        updatePopperPosition();
+      }
+    };
+    const getCheckedNodes = (leafOnly) => {
+      var _a;
+      return (_a = cascaderPanelRef.value) == null ? void 0 : _a.getCheckedNodes(leafOnly);
+    };
+    const handleExpandChange = (value) => {
+      updatePopperPosition();
+      emit("expandChange", value);
+    };
+    const handleKeyDown = (e) => {
+      if (isComposing.value)
+        return;
+      const code = getEventCode(e);
+      switch (code) {
+        case EVENT_CODE.enter:
+        case EVENT_CODE.numpadEnter:
+          togglePopperVisible();
+          break;
+        case EVENT_CODE.down:
+          togglePopperVisible(true);
+          nextTick(focusFirstNode);
+          e.preventDefault();
+          break;
+        case EVENT_CODE.esc:
+          if (popperVisible.value === true) {
+            e.preventDefault();
+            e.stopPropagation();
+            togglePopperVisible(false);
+          }
+          break;
+        case EVENT_CODE.tab:
+          togglePopperVisible(false);
+          break;
+      }
+    };
+    const handleClear = () => {
+      var _a;
+      (_a = cascaderPanelRef.value) == null ? void 0 : _a.clearCheckedNodes();
+      if (!popperVisible.value && props.filterable) {
+        syncPresentTextValue();
+      }
+      togglePopperVisible(false);
+      emit("clear");
+    };
+    const syncPresentTextValue = () => {
+      const { value } = presentText;
+      inputValue.value = value;
+      searchInputValue.value = value;
+    };
+    const handleSuggestionClick = (node) => {
+      var _a, _b;
+      const { checked } = node;
+      if (multiple.value) {
+        (_a = cascaderPanelRef.value) == null ? void 0 : _a.handleCheckChange(node, !checked, false);
+      } else {
+        !checked && ((_b = cascaderPanelRef.value) == null ? void 0 : _b.handleCheckChange(node, true, false));
+        togglePopperVisible(false);
+      }
+    };
+    const handleSuggestionKeyDown = (e) => {
+      const target = e.target;
+      const code = getEventCode(e);
+      switch (code) {
+        case EVENT_CODE.up:
+        case EVENT_CODE.down: {
+          e.preventDefault();
+          const distance = code === EVENT_CODE.up ? -1 : 1;
+          focusNode(getSibling(target, distance, `.${nsCascader.e("suggestion-item")}[tabindex="-1"]`));
+          break;
+        }
+        case EVENT_CODE.enter:
+        case EVENT_CODE.numpadEnter:
+          target.click();
+          break;
+      }
+    };
+    const handleDelete = () => {
+      const lastTag = tags.value[tags.value.length - 1];
+      pressDeleteCount = searchInputValue.value ? 0 : pressDeleteCount + 1;
+      if (!lastTag || !pressDeleteCount || props.collapseTags && tags.value.length > 1)
+        return;
+      if (lastTag.hitState) {
+        deleteTag(lastTag);
+      } else {
+        lastTag.hitState = true;
+      }
+    };
+    const debounce = computed(() => props.debounce);
+    const handleFilter = useDebounceFn(() => {
+      const { value } = searchKeyword;
+      if (!value)
+        return;
+      const passed = props.beforeFilter(value);
+      if (isPromise(passed)) {
+        passed.then(calculateSuggestions).catch(() => {
+        });
+      } else if (passed !== false) {
+        calculateSuggestions();
+      } else {
+        hideSuggestionPanel();
+      }
+    }, debounce);
+    const handleInput = (val, e) => {
+      !popperVisible.value && togglePopperVisible(true);
+      if (e == null ? void 0 : e.isComposing)
+        return;
+      val ? handleFilter() : hideSuggestionPanel();
+    };
+    const getInputInnerHeight = (inputInner) => Number.parseFloat(useCssVar(nsInput.cssVarName("input-height"), inputInner).value) - 2;
+    const focus = () => {
+      var _a;
+      (_a = inputRef.value) == null ? void 0 : _a.focus();
+    };
+    const blur = () => {
+      var _a;
+      (_a = inputRef.value) == null ? void 0 : _a.blur();
+    };
+    watch(filtering, updatePopperPosition);
+    watch([
+      checkedNodes,
+      isDisabled,
+      () => props.collapseTags,
+      () => props.maxCollapseTags
+    ], calculatePresentTags);
+    watch(tags, () => {
+      nextTick(() => updateStyle());
+    });
+    watch(realSize, async () => {
+      await nextTick();
+      const inputInner = inputRef.value.input;
+      inputInitialHeight = getInputInnerHeight(inputInner) || inputInitialHeight;
+      updateStyle();
+    });
+    watch(presentText, syncPresentTextValue, { immediate: true });
+    watch(() => popperVisible.value, (val) => {
+      var _a;
+      if (val && props.props.lazy && props.props.lazyLoad) {
+        (_a = cascaderPanelRef.value) == null ? void 0 : _a.loadLazyRootNodes();
+      }
+    });
+    onMounted(() => {
+      const inputInner = inputRef.value.input;
+      const inputInnerHeight = getInputInnerHeight(inputInner);
+      inputInitialHeight = inputInner.offsetHeight || inputInnerHeight;
+      useResizeObserver(inputInner, updateStyle);
+    });
+    expose({
+      getCheckedNodes,
+      cascaderPanelRef,
+      togglePopperVisible,
+      contentRef,
+      presentText,
+      focus,
+      blur
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ElTooltip), {
+        ref_key: "tooltipRef",
+        ref: tooltipRef,
+        visible: popperVisible.value,
+        teleported: _ctx.teleported,
+        "popper-class": [unref(nsCascader).e("dropdown"), _ctx.popperClass],
+        "popper-style": _ctx.popperStyle,
+        "popper-options": popperOptions,
+        "fallback-placements": _ctx.fallbackPlacements,
+        "stop-popper-mouse-event": false,
+        "gpu-acceleration": false,
+        placement: _ctx.placement,
+        transition: `${unref(nsCascader).namespace.value}-zoom-in-top`,
+        effect: _ctx.effect,
+        pure: "",
+        persistent: _ctx.persistent,
+        onHide: hideSuggestionPanel
+      }, {
+        default: withCtx(() => [
+          withDirectives((openBlock(), createElementBlock("div", {
+            ref_key: "wrapperRef",
+            ref: wrapperRef,
+            class: normalizeClass(unref(cascaderKls)),
+            style: normalizeStyle(unref(cascaderStyle)),
+            onClick: () => togglePopperVisible(unref(readonly) ? void 0 : true),
+            onKeydown: handleKeyDown,
+            onMouseenter: ($event) => inputHover.value = true,
+            onMouseleave: ($event) => inputHover.value = false
+          }, [
+            createVNode(unref(ElInput), {
+              ref_key: "inputRef",
+              ref: inputRef,
+              modelValue: inputValue.value,
+              "onUpdate:modelValue": ($event) => inputValue.value = $event,
+              placeholder: unref(currentPlaceholder),
+              readonly: unref(readonly),
+              disabled: unref(isDisabled),
+              "validate-event": false,
+              size: unref(realSize),
+              class: normalizeClass(unref(inputClass)),
+              tabindex: unref(multiple) && _ctx.filterable && !unref(isDisabled) ? -1 : void 0,
+              onCompositionstart: unref(handleComposition),
+              onCompositionupdate: unref(handleComposition),
+              onCompositionend: unref(handleComposition),
+              onInput: handleInput
+            }, createSlots({
+              suffix: withCtx(() => [
+                unref(clearBtnVisible) ? (openBlock(), createBlock(unref(ElIcon), {
+                  key: "clear",
+                  class: normalizeClass([unref(nsInput).e("icon"), "icon-circle-close"]),
+                  onClick: withModifiers(handleClear, ["stop"])
+                }, {
+                  default: withCtx(() => [
+                    (openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))
+                  ]),
+                  _: 1
+                }, 8, ["class", "onClick"])) : (openBlock(), createBlock(unref(ElIcon), {
+                  key: "arrow-down",
+                  class: normalizeClass(unref(cascaderIconKls)),
+                  onClick: withModifiers(($event) => togglePopperVisible(), ["stop"])
+                }, {
+                  default: withCtx(() => [
+                    createVNode(unref(ArrowDown))
+                  ]),
+                  _: 1
+                }, 8, ["class", "onClick"]))
+              ]),
+              _: 2
+            }, [
+              _ctx.$slots.prefix ? {
+                name: "prefix",
+                fn: withCtx(() => [
+                  renderSlot(_ctx.$slots, "prefix")
+                ])
+              } : void 0
+            ]), 1032, ["modelValue", "onUpdate:modelValue", "placeholder", "readonly", "disabled", "size", "class", "tabindex", "onCompositionstart", "onCompositionupdate", "onCompositionend"]),
+            unref(multiple) ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              ref_key: "tagWrapper",
+              ref: tagWrapper,
+              class: normalizeClass([
+                unref(nsCascader).e("tags"),
+                unref(nsCascader).is("validate", Boolean(unref(validateState)))
+              ])
+            }, [
+              renderSlot(_ctx.$slots, "tag", {
+                data: tags.value,
+                deleteTag
+              }, () => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(showTagList), (tag) => {
+                  return openBlock(), createBlock(unref(ElTag), {
+                    key: tag.key,
+                    type: _ctx.tagType,
+                    size: unref(tagSize),
+                    effect: _ctx.tagEffect,
+                    hit: tag.hitState,
+                    closable: tag.closable,
+                    "disable-transitions": "",
+                    onClose: ($event) => deleteTag(tag)
+                  }, {
+                    default: withCtx(() => [
+                      createElementVNode("span", null, toDisplayString(tag.text), 1)
+                    ]),
+                    _: 2
+                  }, 1032, ["type", "size", "effect", "hit", "closable", "onClose"]);
+                }), 128))
+              ]),
+              _ctx.collapseTags && tags.value.length > _ctx.maxCollapseTags ? (openBlock(), createBlock(unref(ElTooltip), {
+                key: 0,
+                ref_key: "tagTooltipRef",
+                ref: tagTooltipRef,
+                disabled: popperVisible.value || !_ctx.collapseTagsTooltip,
+                "fallback-placements": ["bottom", "top", "right", "left"],
+                placement: "bottom",
+                "popper-class": _ctx.popperClass,
+                "popper-style": _ctx.popperStyle,
+                effect: _ctx.effect,
+                persistent: _ctx.persistent
+              }, {
+                default: withCtx(() => [
+                  createVNode(unref(ElTag), {
+                    closable: false,
+                    size: unref(tagSize),
+                    type: _ctx.tagType,
+                    effect: _ctx.tagEffect,
+                    "disable-transitions": ""
+                  }, {
+                    default: withCtx(() => [
+                      createElementVNode("span", {
+                        class: normalizeClass(unref(nsCascader).e("tags-text"))
+                      }, " + " + toDisplayString(tags.value.length - _ctx.maxCollapseTags), 3)
+                    ]),
+                    _: 1
+                  }, 8, ["size", "type", "effect"])
+                ]),
+                content: withCtx(() => [
+                  createVNode(unref(ElScrollbar), { "max-height": _ctx.maxCollapseTagsTooltipHeight }, {
+                    default: withCtx(() => [
+                      createElementVNode("div", {
+                        class: normalizeClass(unref(nsCascader).e("collapse-tags"))
+                      }, [
+                        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(collapseTagList), (tag, idx) => {
+                          return openBlock(), createElementBlock("div", {
+                            key: idx,
+                            class: normalizeClass(unref(nsCascader).e("collapse-tag"))
+                          }, [
+                            (openBlock(), createBlock(unref(ElTag), {
+                              key: tag.key,
+                              class: "in-tooltip",
+                              type: _ctx.tagType,
+                              size: unref(tagSize),
+                              effect: _ctx.tagEffect,
+                              hit: tag.hitState,
+                              closable: tag.closable,
+                              "disable-transitions": "",
+                              onClose: ($event) => deleteTag(tag)
+                            }, {
+                              default: withCtx(() => [
+                                createElementVNode("span", null, toDisplayString(tag.text), 1)
+                              ]),
+                              _: 2
+                            }, 1032, ["type", "size", "effect", "hit", "closable", "onClose"]))
+                          ], 2);
+                        }), 128))
+                      ], 2)
+                    ]),
+                    _: 1
+                  }, 8, ["max-height"])
+                ]),
+                _: 1
+              }, 8, ["disabled", "popper-class", "popper-style", "effect", "persistent"])) : createCommentVNode("v-if", true),
+              _ctx.filterable && !unref(isDisabled) ? withDirectives((openBlock(), createElementBlock("input", {
+                key: 1,
+                "onUpdate:modelValue": ($event) => searchInputValue.value = $event,
+                type: "text",
+                class: normalizeClass(unref(nsCascader).e("search-input")),
+                placeholder: unref(presentText) ? "" : unref(inputPlaceholder),
+                onInput: (e) => handleInput(searchInputValue.value, e),
+                onClick: withModifiers(($event) => togglePopperVisible(true), ["stop"]),
+                onKeydown: withKeys(handleDelete, ["delete"]),
+                onCompositionstart: unref(handleComposition),
+                onCompositionupdate: unref(handleComposition),
+                onCompositionend: unref(handleComposition)
+              }, null, 42, ["onUpdate:modelValue", "placeholder", "onInput", "onClick", "onKeydown", "onCompositionstart", "onCompositionupdate", "onCompositionend"])), [
+                [vModelText, searchInputValue.value]
+              ]) : createCommentVNode("v-if", true)
+            ], 2)) : createCommentVNode("v-if", true)
+          ], 46, ["onClick", "onMouseenter", "onMouseleave"])), [
+            [unref(ClickOutside), handleClickOutside, unref(contentRef)]
+          ])
+        ]),
+        content: withCtx(() => [
+          _ctx.$slots.header ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: normalizeClass(unref(nsCascader).e("header")),
+            onClick: withModifiers(() => {
+            }, ["stop"])
+          }, [
+            renderSlot(_ctx.$slots, "header")
+          ], 10, ["onClick"])) : createCommentVNode("v-if", true),
+          withDirectives(createVNode(unref(ElCascaderPanel), {
+            ref_key: "cascaderPanelRef",
+            ref: cascaderPanelRef,
+            modelValue: unref(checkedValue),
+            "onUpdate:modelValue": ($event) => isRef(checkedValue) ? checkedValue.value = $event : null,
+            options: _ctx.options,
+            props: props.props,
+            border: false,
+            "render-label": _ctx.$slots.default,
+            onExpandChange: handleExpandChange,
+            onClose: ($event) => _ctx.$nextTick(() => togglePopperVisible(false))
+          }, {
+            empty: withCtx(() => [
+              renderSlot(_ctx.$slots, "empty")
+            ]),
+            _: 3
+          }, 8, ["modelValue", "onUpdate:modelValue", "options", "props", "render-label", "onClose"]), [
+            [vShow, !filtering.value]
+          ]),
+          _ctx.filterable ? withDirectives((openBlock(), createBlock(unref(ElScrollbar), {
+            key: 1,
+            ref_key: "suggestionPanel",
+            ref: suggestionPanel,
+            tag: "ul",
+            class: normalizeClass(unref(nsCascader).e("suggestion-panel")),
+            "view-class": unref(nsCascader).e("suggestion-list"),
+            onKeydown: handleSuggestionKeyDown
+          }, {
+            default: withCtx(() => [
+              suggestions.value.length ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(suggestions.value, (item) => {
+                return openBlock(), createElementBlock("li", {
+                  key: item.uid,
+                  class: normalizeClass([
+                    unref(nsCascader).e("suggestion-item"),
+                    unref(nsCascader).is("checked", item.checked)
+                  ]),
+                  tabindex: -1,
+                  onClick: ($event) => handleSuggestionClick(item)
+                }, [
+                  renderSlot(_ctx.$slots, "suggestion-item", { item }, () => [
+                    createElementVNode("span", null, toDisplayString(item.text), 1),
+                    item.checked ? (openBlock(), createBlock(unref(ElIcon), { key: 0 }, {
+                      default: withCtx(() => [
+                        createVNode(unref(Check))
+                      ]),
+                      _: 1
+                    })) : createCommentVNode("v-if", true)
+                  ])
+                ], 10, ["onClick"]);
+              }), 128)) : renderSlot(_ctx.$slots, "empty", { key: 1 }, () => [
+                createElementVNode("li", {
+                  class: normalizeClass(unref(nsCascader).e("empty-text"))
+                }, toDisplayString(unref(t)("el.cascader.noMatch")), 3)
+              ])
+            ]),
+            _: 3
+          }, 8, ["class", "view-class"])), [
+            [vShow, filtering.value]
+          ]) : createCommentVNode("v-if", true),
+          _ctx.$slots.footer ? (openBlock(), createElementBlock("div", {
+            key: 2,
+            class: normalizeClass(unref(nsCascader).e("footer")),
+            onClick: withModifiers(() => {
+            }, ["stop"])
+          }, [
+            renderSlot(_ctx.$slots, "footer")
+          ], 10, ["onClick"])) : createCommentVNode("v-if", true)
+        ]),
+        _: 3
+      }, 8, ["visible", "teleported", "popper-class", "popper-style", "fallback-placements", "placement", "transition", "effect", "persistent"]);
+    };
+  }
+});
+var Cascader = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__file", "cascader.vue"]]);
+
+const ElCascader = withInstall(Cascader);
+
+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;
+  let isEffectivelyChecked = 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;
+    }
+    if (!n.isEffectivelyChecked) {
+      isEffectivelyChecked = false;
+    }
+  }
+  return {
+    all,
+    none,
+    allWithoutDisable,
+    half: !all && !none,
+    isEffectivelyChecked
+  };
+};
+const reInitChecked = function(node) {
+  if (node.childNodes.length === 0 || node.loading) {
+    node.isEffectivelyChecked = node.disabled || node.checked;
+    return;
+  }
+  const { all, none, half, isEffectivelyChecked } = getChildState(node.childNodes);
+  node.isEffectivelyChecked = isEffectivelyChecked;
+  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.isEffectivelyChecked = false;
+    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 && (store.currentNode.isCurrent = false);
+      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, ref) {
+    let index;
+    if (ref) {
+      index = this.childNodes.indexOf(ref);
+    }
+    this.insertChild(child, index);
+  }
+  insertAfter(child, ref) {
+    let index;
+    if (ref) {
+      index = this.childNodes.indexOf(ref);
+      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) {
+    const targetNode = this.childNodes.find((child) => child.data === data);
+    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;
+      this.isEffectivelyChecked = this.isLeaf && this.disabled;
+      return;
+    }
+    const childNodes = this.childNodes;
+    if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
+      this.isLeaf = !childNodes || childNodes.length === 0;
+      this.isEffectivelyChecked = this.isLeaf && this.disabled;
+      return;
+    }
+    this.isLeaf = false;
+  }
+  setChecked(value, deep, recursion, passValue) {
+    this.indeterminate = value === "half";
+    this.checked = value === true;
+    this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked);
+    if (this.store.checkStrictly)
+      return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      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.isLeaf ? child.checked : passValue;
+            child.setChecked(isCheck, deep, true, passValue);
+          }
+          const { half, all, isEffectivelyChecked } = getChildState(childNodes);
+          if (!all) {
+            this.checked = all;
+            this.indeterminate = half;
+          }
+          this.isEffectivelyChecked = !this.childNodes.length ? this.disabled || this.checked : isEffectivelyChecked;
+        }
+      };
+      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.some((data) => (data == null ? void 0 : data[NODE_KEY]) === key);
+      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();
+    const treeScrollTop = el$.value.scrollTop;
+    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 + treeScrollTop;
+    } else if (dropType === "after") {
+      indicatorTop = iconPosition.bottom - treePosition.top + treeScrollTop;
+    }
+    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
+  },
+  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 (!tree) {
+      debugWarn("Tree", "Can not find node's tree.");
+    }
+    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) => {
+      const checkStrictly = tree == null ? void 0 : tree.props.checkStrictly;
+      const childNodes = props.node.childNodes;
+      if (!checkStrictly && childNodes.length) {
+        value = childNodes.some((node) => !node.isEffectivelyChecked);
+      }
+      props.node.setChecked(value, !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
+    };
+  }
+});
+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 = getEventCode(ev);
+    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 treeEmits = {
+  "check-change": (data, checked, indeterminate) => data && isBoolean(checked) && isBoolean(indeterminate),
+  "current-change": (data, node) => true,
+  "node-click": (data, node, nodeInstance, evt) => data && node && evt instanceof Event,
+  "node-contextmenu": (evt, data, node, nodeInstance) => evt instanceof Event && data && node,
+  "node-collapse": (data, node, nodeInstance) => data && node,
+  "node-expand": (data, node, nodeInstance) => data && node,
+  check: (data, checkedInfo) => data && checkedInfo,
+  "node-drag-start": (node, evt) => node && evt,
+  "node-drag-end": (draggingNode, dropNode, dropType, evt) => draggingNode && evt,
+  "node-drop": (draggingNode, dropNode, dropType, evt) => draggingNode && dropNode && evt,
+  "node-drag-leave": (draggingNode, oldDropNode, evt) => draggingNode && oldDropNode && evt,
+  "node-drag-enter": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt,
+  "node-drag-over": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt
+};
+
+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: treeEmits,
+  setup(props, ctx) {
+    const { t } = useLocale();
+    const ns = useNamespace("tree");
+    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 instance = getCurrentInstance();
+    const isSelectTree = computed(() => {
+      let parent = instance == null ? void 0 : instance.parent;
+      while (parent) {
+        if (parent.type.name === "ElTreeSelect") {
+          return true;
+        }
+        parent = parent.parent;
+      }
+      return false;
+    });
+    const isEmpty = computed(() => {
+      const { childNodes } = root.value;
+      return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !isSelectTree.value;
+    });
+    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 requireNodeKey = (methodName) => {
+      if (!props.nodeKey) {
+        throw new Error(`[Tree] nodeKey is required in ${methodName}`);
+      }
+    };
+    const getNodePath = (data) => {
+      requireNodeKey("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 = () => {
+      requireNodeKey("getCurrentKey");
+      const currentNode2 = getCurrentNode();
+      return currentNode2 ? currentNode2[props.nodeKey] : null;
+    };
+    const setCheckedNodes = (nodes, leafOnly) => {
+      requireNodeKey("setCheckedNodes");
+      store.value.setCheckedNodes(nodes, leafOnly);
+    };
+    const setCheckedKeys = (keys, leafOnly) => {
+      requireNodeKey("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) => {
+      requireNodeKey("setCurrentNode");
+      handleCurrentChange(store, ctx.emit, () => {
+        broadcastExpanded(node);
+        store.value.setUserCurrentNode(node, shouldAutoExpandParent);
+      });
+    };
+    const setCurrentKey = (key = null, shouldAutoExpandParent = true) => {
+      requireNodeKey("setCurrentKey");
+      handleCurrentChange(store, ctx.emit, () => {
+        broadcastExpanded();
+        store.value.setCurrentNodeKey(key, 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, instance2) => {
+      broadcastExpanded(node);
+      ctx.emit("node-expand", nodeData, node, instance2);
+    };
+    const updateKeyChildren = (key, data) => {
+      requireNodeKey("updateKeyChild");
+      store.value.updateChildren(key, data);
+    };
+    provide(ROOT_TREE_INJECTION_KEY, {
+      ctx,
+      props,
+      store,
+      root,
+      currentNode,
+      instance
+    });
+    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 _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "popover-cascader",
+  props: {
+    modelValue: {},
+    multiple: { type: Boolean },
+    emptyText: { default: "尚未选择" },
+    props: {},
+    options: {}
+  },
+  emits: ["update:modelValue", "change", "expandChange", "choiced"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const myValue = useVModel(props, "modelValue", emits);
+    const cascaderProps = computed(() => ({
+      label: props.props.label || "label",
+      value: props.props.value || "value",
+      children: props.props.children || "children",
+      multiple: props.multiple,
+      emitPath: false,
+      ...props.props
+    }));
+    const treeProps = computed(() => ({
+      label: props.props.label || "label",
+      children: props.props.children || "children"
+    }));
+    function filterNode(value, data) {
+      if (!value) {
+        return false;
+      }
+      return value.includes(data[cascaderProps.value.value]);
+    }
+    const treeRef = useTemplateRef("treeRef");
+    function filterTree(val) {
+      nextTick(() => treeRef.value?.filter(val));
+      emits("expandChange");
+    }
+    const cascaderPanelRef = useTemplateRef("cascaderPanelRef");
+    function handleCascaderChange(val) {
+      const node = cascaderPanelRef.value?.getCheckedNodes(true);
+      emits("change", val, node);
+      if (!props.multiple) {
+        emits("choiced");
+      } else {
+        filterTree(val);
+      }
+    }
+    const filterTreeWatch = watch(myValue, (val) => props.multiple && filterTree(val || ""), { immediate: true });
+    onBeforeUnmount(() => filterTreeWatch.stop());
+    return (_ctx, _cache) => {
+      const _component_ElTree = ElTree;
+      const _component_ElScrollbar = ElScrollbar;
+      const _component_ElCascaderPanel = ElCascaderPanel;
+      return openBlock(), createElementBlock(Fragment, null, [
+        __props.multiple ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: normalizeClass(_ctx.$style.selected)
+        }, [
+          createVNode(_component_ElScrollbar, null, {
+            default: withCtx(() => [
+              createVNode(_component_ElTree, {
+                ref_key: "treeRef",
+                ref: treeRef,
+                "default-expand-all": "",
+                "node-key": unref(cascaderProps).value,
+                props: unref(treeProps),
+                "empty-text": __props.emptyText,
+                data: __props.options,
+                "filter-node-method": filterNode
+              }, null, 8, ["node-key", "props", "empty-text", "data"])
+            ]),
+            _: 1
+          })
+        ], 2)) : createCommentVNode("", true),
+        createVNode(_component_ElCascaderPanel, mergeProps({
+          ref_key: "cascaderPanelRef",
+          ref: cascaderPanelRef,
+          modelValue: unref(myValue),
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(myValue) ? myValue.value = $event : null),
+          props: unref(cascaderProps),
+          options: __props.options
+        }, _ctx.$attrs, {
+          onExpandChange: _cache[1] || (_cache[1] = ($event) => emits("expandChange")),
+          onChange: handleCascaderChange
+        }), null, 16, ["modelValue", "props", "options"])
+      ], 64);
+    };
+  }
+});
+
+/* unplugin-vue-components disabled */const selected = "_selected_1r65k_1";
+const style0 = {
+	selected: selected
+};
+
+const cssModules = {
+  "$style": style0
+};
+const PopoverCascader = /* @__PURE__ */ _export_sfc$1(_sfc_main, [["__cssModules", cssModules]]);
+
+export { ElText as E, PopoverCascader as P, ElCascader as a };