@fecp/designer 5.5.34 → 5.5.36

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

@@ -2,7 +2,7 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
 const treeNode_vue_vue_type_script_lang = require("./tree-node.vue_vue_type_script_lang.js");
-const vue = require("vue");
+const Vue = require("vue");
 const _hoisted_1 = [
   "aria-expanded",
   "aria-disabled",
@@ -12,15 +12,15 @@ const _hoisted_1 = [
 ];
 const _hoisted_2 = ["aria-expanded"];
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_el_icon = vue.resolveComponent("el-icon");
-  const _component_el_checkbox = vue.resolveComponent("el-checkbox");
-  const _component_loading = vue.resolveComponent("loading");
-  const _component_node_content = vue.resolveComponent("node-content");
-  const _component_el_tree_node = vue.resolveComponent("el-tree-node");
-  const _component_el_collapse_transition = vue.resolveComponent("el-collapse-transition");
-  return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
+  const _component_el_icon = Vue.resolveComponent("el-icon");
+  const _component_el_checkbox = Vue.resolveComponent("el-checkbox");
+  const _component_loading = Vue.resolveComponent("loading");
+  const _component_node_content = Vue.resolveComponent("node-content");
+  const _component_el_tree_node = Vue.resolveComponent("el-tree-node");
+  const _component_el_collapse_transition = Vue.resolveComponent("el-collapse-transition");
+  return Vue.withDirectives((Vue.openBlock(), Vue.createElementBlock("div", {
     ref: "node$",
-    class: vue.normalizeClass([
+    class: Vue.normalizeClass([
       _ctx.ns.b("node"),
       _ctx.ns.is("expanded", _ctx.expanded),
       _ctx.ns.is("current", _ctx.node.isCurrent),
@@ -36,34 +36,34 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     "aria-checked": _ctx.node.checked,
     draggable: _ctx.tree.props.draggable,
     "data-key": _ctx.getNodeKey(_ctx.node),
-    onClick: _cache[2] || (_cache[2] = vue.withModifiers((...args) => _ctx.handleClick && _ctx.handleClick(...args), ["stop"])),
+    onClick: _cache[2] || (_cache[2] = Vue.withModifiers((...args) => _ctx.handleClick && _ctx.handleClick(...args), ["stop"])),
     onContextmenu: _cache[3] || (_cache[3] = (...args) => _ctx.handleContextMenu && _ctx.handleContextMenu(...args)),
-    onDragstart: _cache[4] || (_cache[4] = vue.withModifiers((...args) => _ctx.handleDragStart && _ctx.handleDragStart(...args), ["stop"])),
-    onDragover: _cache[5] || (_cache[5] = vue.withModifiers((...args) => _ctx.handleDragOver && _ctx.handleDragOver(...args), ["stop"])),
-    onDragend: _cache[6] || (_cache[6] = vue.withModifiers((...args) => _ctx.handleDragEnd && _ctx.handleDragEnd(...args), ["stop"])),
-    onDrop: _cache[7] || (_cache[7] = vue.withModifiers((...args) => _ctx.handleDrop && _ctx.handleDrop(...args), ["stop"]))
-  }, [vue.createElementVNode("div", {
-    class: vue.normalizeClass(_ctx.ns.be("node", "content")),
-    style: vue.normalizeStyle({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
+    onDragstart: _cache[4] || (_cache[4] = Vue.withModifiers((...args) => _ctx.handleDragStart && _ctx.handleDragStart(...args), ["stop"])),
+    onDragover: _cache[5] || (_cache[5] = Vue.withModifiers((...args) => _ctx.handleDragOver && _ctx.handleDragOver(...args), ["stop"])),
+    onDragend: _cache[6] || (_cache[6] = Vue.withModifiers((...args) => _ctx.handleDragEnd && _ctx.handleDragEnd(...args), ["stop"])),
+    onDrop: _cache[7] || (_cache[7] = Vue.withModifiers((...args) => _ctx.handleDrop && _ctx.handleDrop(...args), ["stop"]))
+  }, [Vue.createElementVNode("div", {
+    class: Vue.normalizeClass(_ctx.ns.be("node", "content")),
+    style: Vue.normalizeStyle({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
   }, [
-    _ctx.tree.props.icon || _ctx.CaretRight ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
+    _ctx.tree.props.icon || _ctx.CaretRight ? (Vue.openBlock(), Vue.createBlock(_component_el_icon, {
       key: 0,
-      class: vue.normalizeClass([
+      class: Vue.normalizeClass([
         _ctx.ns.be("node", "expand-icon"),
         _ctx.ns.is("leaf", _ctx.node.isLeaf),
         { expanded: !_ctx.node.isLeaf && _ctx.expanded }
       ]),
-      onClick: vue.withModifiers(_ctx.handleExpandIconClick, ["stop"])
+      onClick: Vue.withModifiers(_ctx.handleExpandIconClick, ["stop"])
     }, {
-      default: vue.withCtx(() => [(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tree.props.icon || _ctx.CaretRight)))]),
+      default: Vue.withCtx(() => [(Vue.openBlock(), Vue.createBlock(Vue.resolveDynamicComponent(_ctx.tree.props.icon || _ctx.CaretRight)))]),
       _: 1
-    }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
-    _ctx.showCheckbox ? (vue.openBlock(), vue.createBlock(_component_el_checkbox, {
+    }, 8, ["class", "onClick"])) : Vue.createCommentVNode("v-if", true),
+    _ctx.showCheckbox ? (Vue.openBlock(), Vue.createBlock(_component_el_checkbox, {
       key: 1,
       "model-value": _ctx.node.checked,
       indeterminate: _ctx.node.indeterminate,
       disabled: !!_ctx.node.disabled,
-      onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
+      onClick: _cache[0] || (_cache[0] = Vue.withModifiers(() => {
       }, ["stop"])),
       onChange: _ctx.handleCheckChange
     }, null, 8, [
@@ -71,28 +71,28 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
       "indeterminate",
       "disabled",
       "onChange"
-    ])) : vue.createCommentVNode("v-if", true),
-    _ctx.node.loading ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
+    ])) : Vue.createCommentVNode("v-if", true),
+    _ctx.node.loading ? (Vue.openBlock(), Vue.createBlock(_component_el_icon, {
       key: 2,
-      class: vue.normalizeClass([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
+      class: Vue.normalizeClass([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
     }, {
-      default: vue.withCtx(() => [vue.createVNode(_component_loading)]),
+      default: Vue.withCtx(() => [Vue.createVNode(_component_loading)]),
       _: 1
-    }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
-    vue.createVNode(_component_node_content, {
+    }, 8, ["class"])) : Vue.createCommentVNode("v-if", true),
+    Vue.createVNode(_component_node_content, {
       node: _ctx.node,
       "render-content": _ctx.renderContent
     }, null, 8, ["node", "render-content"])
-  ], 6), vue.createVNode(_component_el_collapse_transition, null, {
-    default: vue.withCtx(() => [!_ctx.renderAfterExpand || _ctx.childNodeRendered ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
+  ], 6), Vue.createVNode(_component_el_collapse_transition, null, {
+    default: Vue.withCtx(() => [!_ctx.renderAfterExpand || _ctx.childNodeRendered ? Vue.withDirectives((Vue.openBlock(), Vue.createElementBlock("div", {
       key: 0,
-      class: vue.normalizeClass(_ctx.ns.be("node", "children")),
+      class: Vue.normalizeClass(_ctx.ns.be("node", "children")),
       role: "group",
       "aria-expanded": _ctx.expanded,
-      onClick: _cache[1] || (_cache[1] = vue.withModifiers(() => {
+      onClick: _cache[1] || (_cache[1] = Vue.withModifiers(() => {
       }, ["stop"]))
-    }, [(vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.node.childNodes, (child) => {
-      return vue.openBlock(), vue.createBlock(_component_el_tree_node, {
+    }, [(Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(_ctx.node.childNodes, (child) => {
+      return Vue.openBlock(), Vue.createBlock(_component_el_tree_node, {
         key: _ctx.getNodeKey(child),
         "render-content": _ctx.renderContent,
         "render-after-expand": _ctx.renderAfterExpand,
@@ -110,9 +110,9 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         "props",
         "onNodeExpand"
       ]);
-    }), 128))], 10, _hoisted_2)), [[vue.vShow, _ctx.expanded]]) : vue.createCommentVNode("v-if", true)]),
+    }), 128))], 10, _hoisted_2)), [[Vue.vShow, _ctx.expanded]]) : Vue.createCommentVNode("v-if", true)]),
     _: 1
-  })], 42, _hoisted_1)), [[vue.vShow, _ctx.node.visible]]);
+  })], 42, _hoisted_1)), [[Vue.vShow, _ctx.node.visible]]);
 }
 var tree_node_default = /* @__PURE__ */ _pluginVue_exportHelper.default(treeNode_vue_vue_type_script_lang.default, [["render", _sfc_render]]);
 exports.default = tree_node_default;

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

@@ -13,8 +13,8 @@ const treeNodeContent = require("./tree-node-content.js");
 const useNodeExpandEventBroadcast = require("./model/useNodeExpandEventBroadcast.js");
 const useDragNode = require("./model/useDragNode.js");
 const index = require("../../../../../@element-plus/icons-vue/dist/index.js");
-const vue = require("vue");
-var tree_node_vue_vue_type_script_lang_default = vue.defineComponent({
+const Vue = require("vue");
+var tree_node_vue_vue_type_script_lang_default = Vue.defineComponent({
   name: "ElTreeNode",
   components: {
     ElCollapseTransition: index$3.ElCollapseTransition,
@@ -41,37 +41,37 @@ var tree_node_vue_vue_type_script_lang_default = vue.defineComponent({
   setup(props, ctx) {
     const ns = index$4.useNamespace("tree");
     const { broadcastExpanded } = useNodeExpandEventBroadcast.useNodeExpandEventBroadcast(props);
-    const tree = vue.inject(tokens.ROOT_TREE_INJECTION_KEY);
-    const expanded = vue.ref(false);
-    const childNodeRendered = vue.ref(false);
-    const oldChecked = vue.ref();
-    const oldIndeterminate = vue.ref();
-    const node$ = vue.ref();
-    const dragEvents = vue.inject(useDragNode.dragEventsKey);
-    const instance = vue.getCurrentInstance();
-    vue.provide(tokens.NODE_INSTANCE_INJECTION_KEY, instance);
+    const tree = Vue.inject(tokens.ROOT_TREE_INJECTION_KEY);
+    const expanded = Vue.ref(false);
+    const childNodeRendered = Vue.ref(false);
+    const oldChecked = Vue.ref();
+    const oldIndeterminate = Vue.ref();
+    const node$ = Vue.ref();
+    const dragEvents = Vue.inject(useDragNode.dragEventsKey);
+    const instance = Vue.getCurrentInstance();
+    Vue.provide(tokens.NODE_INSTANCE_INJECTION_KEY, instance);
     if (!tree) error.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";
-    vue.watch(() => {
+    Vue.watch(() => {
       var _a;
       const children = (_a = props.node.data) == null ? void 0 : _a[childrenKey];
       return children && [...children];
     }, () => {
       props.node.updateChildren();
     });
-    vue.watch(() => props.node.indeterminate, (val) => {
+    Vue.watch(() => props.node.indeterminate, (val) => {
       handleSelectChange(props.node.checked, val);
     });
-    vue.watch(() => props.node.checked, (val) => {
+    Vue.watch(() => props.node.checked, (val) => {
       handleSelectChange(val, props.node.indeterminate);
     });
-    vue.watch(() => props.node.childNodes.length, () => props.node.reInitChecked());
-    vue.watch(() => props.node.expanded, (val) => {
-      vue.nextTick(() => expanded.value = val);
+    Vue.watch(() => props.node.childNodes.length, () => props.node.reInitChecked());
+    Vue.watch(() => props.node.expanded, (val) => {
+      Vue.nextTick(() => expanded.value = val);
       if (val) childNodeRendered.value = true;
     });
     const getNodeKey$1 = (node2) => {
@@ -128,7 +128,7 @@ var tree_node_vue_vue_type_script_lang_default = vue.defineComponent({
       const childNodes = props.node.childNodes;
       if (!checkStrictly && childNodes.length) value = childNodes.some((node2) => !node2.isEffectivelyChecked);
       props.node.setChecked(value, !checkStrictly);
-      vue.nextTick(() => {
+      Vue.nextTick(() => {
         const store = tree.store.value;
         tree.ctx.emit("check", props.node.data, {
           checkedNodes: store.getCheckedNodes(),

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

@@ -11,9 +11,9 @@ const useDragNode = require("./model/useDragNode.js");
 const treeNode = require("./tree-node.js");
 const useKeydown = require("./model/useKeydown.js");
 const tree = require("./tree.js");
-const vue = require("vue");
+const Vue = require("vue");
 const isEqual = require("../../../../../lodash-es/isEqual.js");
-var tree_vue_vue_type_script_lang_default = vue.defineComponent({
+var tree_vue_vue_type_script_lang_default = Vue.defineComponent({
   name: "ElTree",
   components: { ElTreeNode: treeNode.default },
   props: tree.treeProps,
@@ -21,7 +21,7 @@ var tree_vue_vue_type_script_lang_default = vue.defineComponent({
   setup(props, ctx) {
     const { t } = index.useLocale();
     const ns = index$1.useNamespace("tree");
-    const store = vue.ref(new treeStore.default({
+    const store = Vue.ref(new treeStore.default({
       key: props.nodeKey,
       data: props.data,
       lazy: props.lazy,
@@ -37,10 +37,10 @@ var tree_vue_vue_type_script_lang_default = vue.defineComponent({
       filterNodeMethod: props.filterNodeMethod
     }));
     store.value.initialize();
-    const root = vue.ref(store.value.root);
-    const currentNode = vue.ref(null);
-    const el$ = vue.ref(null);
-    const dropIndicator$ = vue.ref(null);
+    const root = Vue.ref(store.value.root);
+    const currentNode = Vue.ref(null);
+    const el$ = Vue.ref(null);
+    const dropIndicator$ = Vue.ref(null);
     const { broadcastExpanded } = useNodeExpandEventBroadcast.useNodeExpandEventBroadcast(props);
     const { dragState } = useDragNode.useDragNodeHandler({
       props,
@@ -50,8 +50,8 @@ var tree_vue_vue_type_script_lang_default = vue.defineComponent({
       store
     });
     useKeydown.useKeydown({ el$ }, store);
-    const instance = vue.getCurrentInstance();
-    const isSelectTree = vue.computed(() => {
+    const instance = Vue.getCurrentInstance();
+    const isSelectTree = Vue.computed(() => {
       let parent = instance == null ? void 0 : instance.parent;
       while (parent) {
         if (parent.type.name === "ElTreeSelect") return true;
@@ -59,24 +59,24 @@ var tree_vue_vue_type_script_lang_default = vue.defineComponent({
       }
       return false;
     });
-    const isEmpty = vue.computed(() => {
+    const isEmpty = Vue.computed(() => {
       const { childNodes } = root.value;
       return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !isSelectTree.value;
     });
-    vue.watch(() => props.currentNodeKey, (newVal) => {
+    Vue.watch(() => props.currentNodeKey, (newVal) => {
       store.value.setCurrentNodeKey(newVal ?? null);
     });
-    vue.watch(() => props.defaultCheckedKeys, (newVal, oldVal) => {
+    Vue.watch(() => props.defaultCheckedKeys, (newVal, oldVal) => {
       if (isEqual.default(newVal, oldVal)) return;
       store.value.setDefaultCheckedKey(newVal ?? []);
     });
-    vue.watch(() => props.defaultExpandedKeys, (newVal) => {
+    Vue.watch(() => props.defaultExpandedKeys, (newVal) => {
       store.value.setDefaultExpandedKeys(newVal ?? []);
     });
-    vue.watch(() => props.data, (newVal) => {
+    Vue.watch(() => props.data, (newVal) => {
       store.value.setData(newVal);
     }, { deep: true });
-    vue.watch(() => props.checkStrictly, (newVal) => {
+    Vue.watch(() => props.checkStrictly, (newVal) => {
       store.value.checkStrictly = newVal;
     });
     const filter = (value) => {
@@ -170,7 +170,7 @@ var tree_vue_vue_type_script_lang_default = vue.defineComponent({
       requireNodeKey("updateKeyChildren");
       store.value.updateChildren(key, data);
     };
-    vue.provide(tokens.ROOT_TREE_INJECTION_KEY, {
+    Vue.provide(tokens.ROOT_TREE_INJECTION_KEY, {
       ctx,
       props,
       store,
@@ -178,7 +178,7 @@ var tree_vue_vue_type_script_lang_default = vue.defineComponent({
       currentNode,
       instance
     });
-    vue.provide(constants.formItemContextKey, void 0);
+    Vue.provide(constants.formItemContextKey, void 0);
     return {
       ns,
       store,

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

@@ -2,12 +2,12 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
 const tree_vue_vue_type_script_lang = require("./tree.vue_vue_type_script_lang.js");
-const vue = require("vue");
+const Vue = require("vue");
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_el_tree_node = vue.resolveComponent("el-tree-node");
-  return vue.openBlock(), vue.createElementBlock("div", {
+  const _component_el_tree_node = Vue.resolveComponent("el-tree-node");
+  return Vue.openBlock(), Vue.createElementBlock("div", {
     ref: "el$",
-    class: vue.normalizeClass([
+    class: Vue.normalizeClass([
       _ctx.ns.b(),
       _ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
       _ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
@@ -16,8 +16,8 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     ]),
     role: "tree"
   }, [
-    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.root.childNodes, (child) => {
-      return vue.openBlock(), vue.createBlock(_component_el_tree_node, {
+    (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(_ctx.root.childNodes, (child) => {
+      return Vue.openBlock(), Vue.createBlock(_component_el_tree_node, {
         key: _ctx.getNodeKey(child),
         node: child,
         props: _ctx.props,
@@ -36,14 +36,14 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         "onNodeExpand"
       ]);
     }), 128)),
-    _ctx.isEmpty ? (vue.openBlock(), vue.createElementBlock("div", {
+    _ctx.isEmpty ? (Vue.openBlock(), Vue.createElementBlock("div", {
       key: 0,
-      class: vue.normalizeClass(_ctx.ns.e("empty-block"))
-    }, [vue.renderSlot(_ctx.$slots, "empty", {}, () => [vue.createElementVNode("span", { class: vue.normalizeClass(_ctx.ns.e("empty-text")) }, vue.toDisplayString(_ctx.emptyText ?? _ctx.t("el.tree.emptyText")), 3)])], 2)) : vue.createCommentVNode("v-if", true),
-    vue.withDirectives(vue.createElementVNode("div", {
+      class: Vue.normalizeClass(_ctx.ns.e("empty-block"))
+    }, [Vue.renderSlot(_ctx.$slots, "empty", {}, () => [Vue.createElementVNode("span", { class: Vue.normalizeClass(_ctx.ns.e("empty-text")) }, Vue.toDisplayString(_ctx.emptyText ?? _ctx.t("el.tree.emptyText")), 3)])], 2)) : Vue.createCommentVNode("v-if", true),
+    Vue.withDirectives(Vue.createElementVNode("div", {
       ref: "dropIndicator$",
-      class: vue.normalizeClass(_ctx.ns.e("drop-indicator"))
-    }, null, 2), [[vue.vShow, _ctx.dragState.showDropIndicator]])
+      class: Vue.normalizeClass(_ctx.ns.e("drop-indicator"))
+    }, null, 2), [[Vue.vShow, _ctx.dragState.showDropIndicator]])
   ], 2);
 }
 var tree_default = /* @__PURE__ */ _pluginVue_exportHelper.default(tree_vue_vue_type_script_lang.default, [["render", _sfc_render]]);

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const token = require("../../select/src/token.js");
-const vue = require("vue");
+const Vue = require("vue");
 const index = require("../../../../node_modules/@vueuse/shared/index.js");
-var cache_options_default = vue.defineComponent({
+var cache_options_default = Vue.defineComponent({
   props: { data: {
     type: Array,
     default: () => []
   } },
   setup(props) {
-    const select = vue.inject(token.selectKey);
-    vue.watch(() => props.data, () => {
+    const select = Vue.inject(token.selectKey);
+    Vue.watch(() => props.data, () => {
       var _a;
       props.data.forEach((item) => {
         if (!select.states.cachedOptions.has(item.value)) select.states.cachedOptions.set(item.value, item);

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

@@ -6,12 +6,12 @@ const event = require("../../../utils/dom/event.js");
 const index = require("../../../hooks/use-namespace/index.js");
 const index$2 = require("../../select/index.js");
 const index$1 = require("../../../../node_modules/@vueuse/core/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const pick = require("../../../../../lodash-es/pick.js");
 const useSelect = (props, { attrs, emit }, { select, tree, key }) => {
   const ns = index.useNamespace("tree-select");
-  vue.watch(() => props.data, () => {
-    if (props.filterable) vue.nextTick(() => {
+  Vue.watch(() => props.data, () => {
+    if (props.filterable) Vue.nextTick(() => {
       var _a, _b;
       (_b = tree.value) == null ? void 0 : _b.filter((_a = select.value) == null ? void 0 : _a.states.inputValue);
     });
@@ -25,7 +25,7 @@ const useSelect = (props, { attrs, emit }, { select, tree, key }) => {
       return;
     }
   };
-  vue.onMounted(() => {
+  Vue.onMounted(() => {
     index$1.useEventListener(() => {
       var _a;
       return (_a = select.value) == null ? void 0 : _a.$el;
@@ -33,7 +33,7 @@ const useSelect = (props, { attrs, emit }, { select, tree, key }) => {
       const code = event.getEventCode(evt);
       const { dropdownMenuVisible } = select.value;
       if ([aria.EVENT_CODE.down, aria.EVENT_CODE.up].includes(code) && dropdownMenuVisible) {
-        await vue.nextTick();
+        await Vue.nextTick();
         setTimeout(() => {
           var _a, _b, _c;
           if (aria.EVENT_CODE.up === code) {
@@ -47,13 +47,13 @@ const useSelect = (props, { attrs, emit }, { select, tree, key }) => {
     }, { capture: true });
   });
   return {
-    ...pick.default(vue.toRefs(props), Object.keys(index$2.ElSelect.props)),
+    ...pick.default(Vue.toRefs(props), Object.keys(index$2.ElSelect.props)),
     ...attrs,
-    class: vue.computed(() => attrs.class),
-    style: vue.computed(() => attrs.style),
+    class: Vue.computed(() => attrs.class),
+    style: Vue.computed(() => attrs.style),
     "onUpdate:modelValue": (value) => emit(event$1.UPDATE_MODEL_EVENT, value),
     valueKey: key,
-    popperClass: vue.computed(() => {
+    popperClass: Vue.computed(() => {
       const classes = [ns.e("popper")];
       if (props.popperClass) classes.push(props.popperClass);
       return classes.join(" ");

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

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const index = require("../../select/index.js");
-const vue = require("vue");
-const component = vue.defineComponent({
+const Vue = require("vue");
+const component = Vue.defineComponent({
   extends: index.ElOption,
   setup(props, ctx) {
     const result = index.ElOption.setup(props, ctx);
     delete result.selectOptionClick;
-    const vm = vue.getCurrentInstance().proxy;
-    vue.nextTick(() => {
+    const vm = Vue.getCurrentInstance().proxy;
+    Vue.nextTick(() => {
       if (!result.select.states.cachedOptions.get(vm.value)) result.select.onOptionCreate(vm);
     });
-    vue.watch(() => ctx.attrs.visible, (val) => {
-      vue.nextTick(() => {
+    Vue.watch(() => ctx.attrs.visible, (val) => {
+      Vue.nextTick(() => {
         result.states.visible = val;
       });
     }, { immediate: true });

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

@@ -7,9 +7,9 @@ const index$1 = require("../../tree/index.js");
 const select$1 = require("./select.js");
 const tree$1 = require("./tree.js");
 const cacheOptions = require("./cache-options.js");
-const vue = require("vue");
+const Vue = require("vue");
 const pick = require("../../../../../lodash-es/pick.js");
-var tree_select_vue_vue_type_script_lang_default = vue.defineComponent({
+var tree_select_vue_vue_type_script_lang_default = Vue.defineComponent({
   name: "ElTreeSelect",
   inheritAttrs: false,
   props: {
@@ -26,9 +26,9 @@ var tree_select_vue_vue_type_script_lang_default = vue.defineComponent({
       ...attrs,
       onChange: void 0
     };
-    const select2 = vue.ref();
-    const tree2 = vue.ref();
-    const key = vue.computed(() => props.nodeKey || props.valueKey || "value");
+    const select2 = Vue.ref();
+    const tree2 = Vue.ref();
+    const key = Vue.computed(() => props.nodeKey || props.valueKey || "value");
     const selectProps = select$1.useSelect(props, {
       attrs,
       emit
@@ -46,9 +46,9 @@ var tree_select_vue_vue_type_script_lang_default = vue.defineComponent({
       tree: tree2,
       key
     });
-    const methods = vue.reactive({});
+    const methods = Vue.reactive({});
     expose(methods);
-    vue.onMounted(() => {
+    Vue.onMounted(() => {
       Object.assign(methods, {
         ...pick.default(tree2.value, [
           "filter",
@@ -79,7 +79,7 @@ var tree_select_vue_vue_type_script_lang_default = vue.defineComponent({
         selectRef: select2.value
       });
     });
-    return () => vue.h(
+    return () => Vue.h(
       index.ElSelect,
       /**
       * 1. The `props` is processed into `Refs`, but `v-bind` and
@@ -88,13 +88,13 @@ var tree_select_vue_vue_type_script_lang_default = vue.defineComponent({
       * 2. The keyword `ref` requires `Ref`, but `reactive` broke it,
       * so use function.
       */
-      vue.reactive({
+      Vue.reactive({
         ...selectProps,
         ref: (ref) => select2.value = ref
       }),
       {
         ...slots,
-        default: () => [vue.h(cacheOptions.default, { data: cacheOptions$1.value }), vue.h(index$1.ElTree, vue.reactive({
+        default: () => [Vue.h(cacheOptions.default, { data: cacheOptions$1.value }), Vue.h(index$1.ElTree, Vue.reactive({
           ...treeProps,
           ref: (ref) => tree2.value = ref
         }))]

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

@@ -6,14 +6,14 @@ const strings = require("../../../utils/strings.js");
 const index = require("../../tree/index.js");
 const treeSelectOption = require("./tree-select-option.js");
 const utils = require("./utils.js");
-const vue = require("vue");
+const Vue = require("vue");
 const isEqual = require("../../../../../lodash-es/isEqual.js");
 const pick = require("../../../../../lodash-es/pick.js");
 const isNil = require("../../../../../lodash-es/isNil.js");
 const shared_esmBundler = require("../../../../../@vue/shared/dist/shared.esm-bundler.js");
 const useTree = (props, { attrs, slots, emit }, { select, tree, key }) => {
-  vue.watch([() => props.modelValue, tree], () => {
-    if (props.showCheckbox) vue.nextTick(() => {
+  Vue.watch([() => props.modelValue, tree], () => {
+    if (props.showCheckbox) Vue.nextTick(() => {
       const treeInstance = tree.value;
       if (treeInstance && !isEqual.default(treeInstance.getCheckedKeys(), utils.toValidArray(props.modelValue))) treeInstance.setCheckedKeys(utils.toValidArray(props.modelValue));
     });
@@ -21,7 +21,7 @@ const useTree = (props, { attrs, slots, emit }, { select, tree, key }) => {
     immediate: true,
     deep: true
   });
-  const propsMap = vue.computed(() => ({
+  const propsMap = Vue.computed(() => ({
     value: key.value,
     label: "label",
     children: "children",
@@ -38,7 +38,7 @@ const useTree = (props, { attrs, slots, emit }, { select, tree, key }) => {
   const defaultExpandedParentKeys = utils.toValidArray(props.modelValue).map((value) => {
     return utils.treeFind(props.data || [], (data) => getNodeValByProp("value", data) === value, (data) => getNodeValByProp("children", data), (data, index2, array, parent) => parent && getNodeValByProp("value", parent));
   }).filter((item) => utils.isValidValue(item));
-  const cacheOptions = vue.computed(() => {
+  const cacheOptions = Vue.computed(() => {
     if (!props.renderAfterExpand && !props.lazy) return [];
     const options = [];
     utils.treeEach(props.data.concat(props.cacheData), (node) => {
@@ -67,13 +67,13 @@ const useTree = (props, { attrs, slots, emit }, { select, tree, key }) => {
     emitChange(val);
   }
   return {
-    ...pick.default(vue.toRefs(props), Object.keys(index.ElTree.props)),
+    ...pick.default(Vue.toRefs(props), Object.keys(index.ElTree.props)),
     ...attrs,
     nodeKey: key,
-    expandOnClickNode: vue.computed(() => {
+    expandOnClickNode: Vue.computed(() => {
       return !props.checkStrictly && props.expandOnClickNode;
     }),
-    defaultExpandedKeys: vue.computed(() => {
+    defaultExpandedKeys: Vue.computed(() => {
       return props.defaultExpandedKeys ? props.defaultExpandedKeys.concat(defaultExpandedParentKeys) : defaultExpandedParentKeys;
     }),
     renderContent: (h, { node, data, store }) => {
@@ -127,7 +127,7 @@ const useTree = (props, { attrs, slots, emit }, { select, tree, key }) => {
         const hasCheckedChild = utils.isValidValue(props.modelValue) && !!utils.treeFind([data], (data2) => getNodeValByProp("value", data2) === props.modelValue, (data2) => getNodeValByProp("children", data2));
         update(firstLeafKey === props.modelValue || hasCheckedChild ? void 0 : firstLeafKey);
       }
-      vue.nextTick(() => {
+      Vue.nextTick(() => {
         var _a2;
         const checkedKeys2 = utils.toValidArray(props.modelValue);
         tree.value.setCheckedKeys(checkedKeys2);
@@ -143,7 +143,7 @@ const useTree = (props, { attrs, slots, emit }, { select, tree, key }) => {
     onNodeExpand: (data, node, e) => {
       var _a;
       (_a = attrs.onNodeExpand) == null ? void 0 : _a.call(attrs, data, node, e);
-      vue.nextTick(() => {
+      Vue.nextTick(() => {
         if (!props.checkStrictly && props.lazy && props.multiple && node.checked) {
           const dataMap = {};
           const uncachedCheckedKeys = tree.value.getCheckedKeys();

package/lib/node_modules/element-plus/es/components/tree-v2/src/composables/useCheck.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const virtualTree = require("../virtual-tree.js");
-const vue = require("vue");
+const Vue = require("vue");
 function useCheck(props, tree) {
-  const checkedKeys = vue.ref(/* @__PURE__ */ new Set());
-  const indeterminateKeys = vue.ref(/* @__PURE__ */ new Set());
-  const { emit } = vue.getCurrentInstance();
-  vue.watch([() => tree.value, () => props.defaultCheckedKeys], () => {
-    return vue.nextTick(() => {
+  const checkedKeys = Vue.ref(/* @__PURE__ */ new Set());
+  const indeterminateKeys = Vue.ref(/* @__PURE__ */ new Set());
+  const { emit } = Vue.getCurrentInstance();
+  Vue.watch([() => tree.value, () => props.defaultCheckedKeys], () => {
+    return Vue.nextTick(() => {
       _setCheckedKeys(props.defaultCheckedKeys);
     });
   }, { immediate: true });
@@ -128,7 +128,7 @@ function useCheck(props, tree) {
   function setCheckedKeys(keys) {
     checkedKeys.value.clear();
     indeterminateKeys.value.clear();
-    vue.nextTick(() => {
+    Vue.nextTick(() => {
       _setCheckedKeys(keys);
     });
   }

package/lib/node_modules/element-plus/es/components/tree-v2/src/composables/useFilter.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const shared_esmBundler = require("../../../../../../@vue/shared/dist/shared.esm-bundler.js");
-const vue = require("vue");
+const Vue = require("vue");
 function useFilter(props, tree) {
-  const hiddenNodeKeySet = vue.ref(/* @__PURE__ */ new Set([]));
-  const hiddenExpandIconKeySet = vue.ref(/* @__PURE__ */ new Set([]));
-  const filterable = vue.computed(() => {
+  const hiddenNodeKeySet = Vue.ref(/* @__PURE__ */ new Set([]));
+  const hiddenExpandIconKeySet = Vue.ref(/* @__PURE__ */ new Set([]));
+  const filterable = Vue.computed(() => {
     return shared_esmBundler.isFunction(props.filterMethod);
   });
   function doFilter(query) {