@fecp/designer 5.5.35 → 5.5.37

package/lib/node_modules/element-plus/es/components/virtual-list/src/components/scrollbar.js

@@ -6,8 +6,8 @@ const util = require("../../../scrollbar/src/util.js");
 const defaults = require("../defaults.js");
 const props = require("../props.js");
 const utils = require("../utils.js");
-const vue = require("vue");
-const ScrollBar = vue.defineComponent({
+const Vue = require("vue");
+const ScrollBar = Vue.defineComponent({
   name: "ElVirtualScrollBar",
   props: props.virtualizedScrollbarProps,
   emits: [
@@ -16,20 +16,20 @@ const ScrollBar = vue.defineComponent({
     "stop-move"
   ],
   setup(props2, { emit }) {
-    const GAP = vue.computed(() => props2.startGap + props2.endGap);
+    const GAP = Vue.computed(() => props2.startGap + props2.endGap);
     const nsVirtualScrollbar = index.useNamespace("virtual-scrollbar");
     const nsScrollbar = index.useNamespace("scrollbar");
-    const trackRef = vue.ref();
-    const thumbRef = vue.ref();
+    const trackRef = Vue.ref();
+    const thumbRef = Vue.ref();
     let frameHandle = null;
     let onselectstartStore = null;
-    const state = vue.reactive({
+    const state = Vue.reactive({
       isDragging: false,
       traveled: 0
     });
-    const bar = vue.computed(() => util.BAR_MAP[props2.layout]);
-    const trackSize = vue.computed(() => props2.clientSize - vue.unref(GAP));
-    const trackStyle = vue.computed(() => ({
+    const bar = Vue.computed(() => util.BAR_MAP[props2.layout]);
+    const trackSize = Vue.computed(() => props2.clientSize - Vue.unref(GAP));
+    const trackStyle = Vue.computed(() => ({
       position: "absolute",
       width: `${defaults.HORIZONTAL === props2.layout ? trackSize.value : props2.scrollbarSize}px`,
       height: `${defaults.HORIZONTAL === props2.layout ? props2.scrollbarSize : trackSize.value}px`,
@@ -38,14 +38,14 @@ const ScrollBar = vue.defineComponent({
       bottom: "2px",
       borderRadius: "4px"
     }));
-    const thumbSize = vue.computed(() => {
+    const thumbSize = Vue.computed(() => {
       const ratio = props2.ratio;
       if (ratio >= 100) return Number.POSITIVE_INFINITY;
       if (ratio >= 50) return ratio * trackSize.value / 100;
       const SCROLLBAR_MAX_SIZE = trackSize.value / 3;
       return Math.floor(Math.min(Math.max(ratio * trackSize.value / 100, defaults.SCROLLBAR_MIN_SIZE), SCROLLBAR_MAX_SIZE));
     });
-    const thumbStyle = vue.computed(() => {
+    const thumbStyle = Vue.computed(() => {
       if (!Number.isFinite(thumbSize.value)) return { display: "none" };
       const thumb = `${thumbSize.value}px`;
       return utils.renderThumbStyle({
@@ -54,11 +54,11 @@ const ScrollBar = vue.defineComponent({
         move: state.traveled
       }, props2.layout);
     });
-    const totalSteps = vue.computed(() => Math.ceil(props2.clientSize - thumbSize.value - vue.unref(GAP)));
+    const totalSteps = Vue.computed(() => Math.ceil(props2.clientSize - thumbSize.value - Vue.unref(GAP)));
     const attachEvents = () => {
       window.addEventListener("mousemove", onMouseMove);
       window.addEventListener("mouseup", onMouseUp);
-      const thumbEl = vue.unref(thumbRef);
+      const thumbEl = Vue.unref(thumbRef);
       if (!thumbEl) return;
       onselectstartStore = document.onselectstart;
       document.onselectstart = () => false;
@@ -70,7 +70,7 @@ const ScrollBar = vue.defineComponent({
       window.removeEventListener("mouseup", onMouseUp);
       document.onselectstart = onselectstartStore;
       onselectstartStore = null;
-      const thumbEl = vue.unref(thumbRef);
+      const thumbEl = Vue.unref(thumbRef);
       if (!thumbEl) return;
       thumbEl.removeEventListener("touchmove", onMouseMove);
       thumbEl.removeEventListener("touchend", onMouseUp);
@@ -107,15 +107,15 @@ const ScrollBar = vue.defineComponent({
       state.traveled = Math.max(0, Math.min(distance, totalSteps.value));
       emit("scroll", distance, totalSteps.value);
     };
-    vue.watch(() => props2.scrollFrom, (v) => {
+    Vue.watch(() => props2.scrollFrom, (v) => {
       if (state.isDragging) return;
       state.traveled = Math.ceil(v * totalSteps.value);
     });
-    vue.onBeforeUnmount(() => {
+    Vue.onBeforeUnmount(() => {
       detachEvents();
     });
     return () => {
-      return vue.h("div", {
+      return Vue.h("div", {
         role: "presentation",
         ref: trackRef,
         class: [
@@ -124,9 +124,9 @@ const ScrollBar = vue.defineComponent({
           (props2.alwaysOn || state.isDragging) && "always-on"
         ],
         style: trackStyle.value,
-        onMousedown: vue.withModifiers(clickTrackHandler, ["stop", "prevent"]),
+        onMousedown: Vue.withModifiers(clickTrackHandler, ["stop", "prevent"]),
         onTouchstartPrevent: onThumbMouseDown
-      }, vue.h("div", {
+      }, Vue.h("div", {
         ref: thumbRef,
         class: nsScrollbar.e("thumb"),
         style: thumbStyle.value,

package/lib/node_modules/element-plus/es/components/virtual-list/src/hooks/use-cache.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
+const Vue = require("vue");
 const memoizeOne_esm = require("../../../../../../memoize-one/dist/memoize-one.esm.js");
 const memoize = require("../../../../../../lodash-es/memoize.js");
 const useCache = () => {
-  const props = vue.getCurrentInstance().proxy.$props;
-  return vue.computed(() => {
+  const props = Vue.getCurrentInstance().proxy.$props;
+  return Vue.computed(() => {
     const _getItemStyleCache = (_, __, ___) => ({});
     return props.perfMode ? memoize.default(_getItemStyleCache) : memoizeOne_esm.default(_getItemStyleCache);
   });

package/lib/node_modules/element-plus/es/components/virtual-list/src/hooks/use-grid-touch.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const raf = require("../../../../utils/raf.js");
 const index = require("../../../../../node_modules/@vueuse/core/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const useGridTouch = (windowRef, states, scrollTo, estimatedTotalWidth, estimatedTotalHeight, parsedWidth, parsedHeight) => {
-  const touchStartX = vue.ref(0);
-  const touchStartY = vue.ref(0);
+  const touchStartX = Vue.ref(0);
+  const touchStartY = Vue.ref(0);
   let frameHandle;
   let deltaX = 0;
   let deltaY = 0;
@@ -24,8 +24,8 @@ const useGridTouch = (windowRef, states, scrollTo, estimatedTotalWidth, estimate
     touchStartX.value = event.touches[0].clientX;
     touchStartY.value = event.touches[0].clientY;
     frameHandle = raf.rAF(() => {
-      const maxScrollLeft = estimatedTotalWidth.value - vue.unref(parsedWidth);
-      const maxScrollTop = estimatedTotalHeight.value - vue.unref(parsedHeight);
+      const maxScrollLeft = estimatedTotalWidth.value - Vue.unref(parsedWidth);
+      const maxScrollTop = estimatedTotalHeight.value - Vue.unref(parsedHeight);
       scrollTo({
         scrollLeft: Math.min(states.value.scrollLeft + deltaX, maxScrollLeft),
         scrollTop: Math.min(states.value.scrollTop + deltaY, maxScrollTop)

package/lib/node_modules/element-plus/es/components/watermark/src/watermark.vue_vue_type_script_setup_true_lang.js

@@ -5,56 +5,56 @@ const watermark = require("./watermark.js");
 const utils = require("./utils.js");
 const useClips = require("./useClips.js");
 const index = require("../../../../node_modules/@vueuse/core/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const shared_esmBundler = require("../../../../../@vue/shared/dist/shared.esm-bundler.js");
-var watermark_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.defineComponent({
+var watermark_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ Vue.defineComponent({
   name: "ElWatermark",
   __name: "watermark",
   props: watermark.watermarkProps,
   setup(__props) {
     const style = { position: "relative" };
     const props = __props;
-    const fontGap = vue.computed(() => {
+    const fontGap = Vue.computed(() => {
       var _a;
       return ((_a = props.font) == null ? void 0 : _a.fontGap) ?? 3;
     });
-    const color = vue.computed(() => {
+    const color = Vue.computed(() => {
       var _a;
       return ((_a = props.font) == null ? void 0 : _a.color) ?? "rgba(0,0,0,.15)";
     });
-    const fontSize = vue.computed(() => {
+    const fontSize = Vue.computed(() => {
       var _a;
       return ((_a = props.font) == null ? void 0 : _a.fontSize) ?? 16;
     });
-    const fontWeight = vue.computed(() => {
+    const fontWeight = Vue.computed(() => {
       var _a;
       return ((_a = props.font) == null ? void 0 : _a.fontWeight) ?? "normal";
     });
-    const fontStyle = vue.computed(() => {
+    const fontStyle = Vue.computed(() => {
       var _a;
       return ((_a = props.font) == null ? void 0 : _a.fontStyle) ?? "normal";
     });
-    const fontFamily = vue.computed(() => {
+    const fontFamily = Vue.computed(() => {
       var _a;
       return ((_a = props.font) == null ? void 0 : _a.fontFamily) ?? "sans-serif";
     });
-    const textAlign = vue.computed(() => {
+    const textAlign = Vue.computed(() => {
       var _a;
       return ((_a = props.font) == null ? void 0 : _a.textAlign) ?? "center";
     });
-    const textBaseline = vue.computed(() => {
+    const textBaseline = Vue.computed(() => {
       var _a;
       return ((_a = props.font) == null ? void 0 : _a.textBaseline) ?? "hanging";
     });
-    const gapX = vue.computed(() => props.gap[0]);
-    const gapY = vue.computed(() => props.gap[1]);
-    const gapXCenter = vue.computed(() => gapX.value / 2);
-    const gapYCenter = vue.computed(() => gapY.value / 2);
-    const offsetLeft = vue.computed(() => {
+    const gapX = Vue.computed(() => props.gap[0]);
+    const gapY = Vue.computed(() => props.gap[1]);
+    const gapXCenter = Vue.computed(() => gapX.value / 2);
+    const gapYCenter = Vue.computed(() => gapY.value / 2);
+    const offsetLeft = Vue.computed(() => {
       var _a;
       return ((_a = props.offset) == null ? void 0 : _a[0]) ?? gapXCenter.value;
     });
-    const offsetTop = vue.computed(() => {
+    const offsetTop = Vue.computed(() => {
       var _a;
       return ((_a = props.offset) == null ? void 0 : _a[1]) ?? gapYCenter.value;
     });
@@ -84,9 +84,9 @@ var watermark_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.
       markStyle.backgroundPosition = `${positionLeft}px ${positionTop}px`;
       return markStyle;
     };
-    const containerRef = vue.shallowRef(null);
-    const watermarkRef = vue.shallowRef();
-    const stopObservation = vue.ref(false);
+    const containerRef = Vue.shallowRef(null);
+    const watermarkRef = Vue.shallowRef();
+    const stopObservation = Vue.ref(false);
     const destroyWatermark = () => {
       if (watermarkRef.value) {
         watermarkRef.value.remove();
@@ -173,16 +173,16 @@ var watermark_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.
         } else drawCanvas(content);
       }
     };
-    vue.onMounted(() => {
+    Vue.onMounted(() => {
       renderWatermark();
     });
-    vue.watch(() => props, () => {
+    Vue.watch(() => props, () => {
       renderWatermark();
     }, {
       deep: true,
       flush: "post"
     });
-    vue.onBeforeUnmount(() => {
+    Vue.onBeforeUnmount(() => {
       destroyWatermark();
     });
     const onMutate = (mutations) => {
@@ -200,11 +200,11 @@ var watermark_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.
       childList: true
     });
     return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", {
+      return Vue.openBlock(), Vue.createElementBlock("div", {
         ref_key: "containerRef",
         ref: containerRef,
-        style: vue.normalizeStyle([style])
-      }, [vue.renderSlot(_ctx.$slots, "default")], 4);
+        style: Vue.normalizeStyle([style])
+      }, [Vue.renderSlot(_ctx.$slots, "default")], 4);
     };
   }
 });

package/lib/node_modules/element-plus/es/directives/trap-focus/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 const aria = require("../../utils/dom/aria.js");
 const aria$1 = require("../../constants/aria.js");
 const event = require("../../utils/dom/event.js");
-const vue = require("vue");
+const Vue = require("vue");
 const FOCUSABLE_CHILDREN = "_trap-focus-children";
 const FOCUS_STACK = [];
 const FOCUS_HANDLER = (e) => {
@@ -36,7 +36,7 @@ const TrapFocus = {
     if (FOCUS_STACK.length <= 1) document.addEventListener("keydown", FOCUS_HANDLER);
   },
   updated(el) {
-    vue.nextTick(() => {
+    Vue.nextTick(() => {
       el[FOCUSABLE_CHILDREN] = aria.obtainAllFocusableElements(el);
     });
   },

package/lib/node_modules/element-plus/es/hooks/use-attrs/index.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const error = require("../../utils/error.js");
-const vue = require("vue");
+const Vue = require("vue");
 const fromPairs = require("../../../../lodash-es/fromPairs.js");
 const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
 const LISTENER_PREFIX = /^on[A-Z]/;
 const useAttrs = (params = {}) => {
   const { excludeListeners = false, excludeKeys } = params;
-  const allExcludeKeys = vue.computed(() => {
+  const allExcludeKeys = Vue.computed(() => {
     return ((excludeKeys == null ? void 0 : excludeKeys.value) || []).concat(DEFAULT_EXCLUDE_KEYS);
   });
-  const instance = vue.getCurrentInstance();
+  const instance = Vue.getCurrentInstance();
   if (!instance) {
     error.debugWarn("use-attrs", "getCurrentInstance() returned null. useAttrs() must be called at the top of a setup function");
-    return vue.computed(() => ({}));
+    return Vue.computed(() => ({}));
   }
-  return vue.computed(() => {
+  return Vue.computed(() => {
     var _a;
     return fromPairs.default(Object.entries((_a = instance.proxy) == null ? void 0 : _a.$attrs).filter(([key]) => !allExcludeKeys.value.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))));
   });

package/lib/node_modules/element-plus/es/hooks/use-calc-input-width/index.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const form = require("../../constants/form.js");
 const index = require("../../../node_modules/@vueuse/core/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 function useCalcInputWidth() {
-  const calculatorRef = vue.shallowRef();
-  const calculatorWidth = vue.ref(0);
-  const inputStyle = vue.computed(() => ({ minWidth: `${Math.max(calculatorWidth.value, form.MINIMUM_INPUT_WIDTH)}px` }));
+  const calculatorRef = Vue.shallowRef();
+  const calculatorWidth = Vue.ref(0);
+  const inputStyle = Vue.computed(() => ({ minWidth: `${Math.max(calculatorWidth.value, form.MINIMUM_INPUT_WIDTH)}px` }));
   const resetCalculatorWidth = () => {
     var _a;
     calculatorWidth.value = ((_a = calculatorRef.value) == null ? void 0 : _a.getBoundingClientRect().width) ?? 0;

package/lib/node_modules/element-plus/es/hooks/use-composition/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
+const Vue = require("vue");
 function useComposition({ afterComposition, emit }) {
-  const isComposing = vue.ref(false);
+  const isComposing = Vue.ref(false);
   const handleCompositionStart = (event) => {
     emit == null ? void 0 : emit("compositionstart", event);
     isComposing.value = true;
@@ -15,7 +15,7 @@ function useComposition({ afterComposition, emit }) {
     emit == null ? void 0 : emit("compositionend", event);
     if (isComposing.value) {
       isComposing.value = false;
-      vue.nextTick(() => afterComposition(event));
+      Vue.nextTick(() => afterComposition(event));
     }
   };
   const handleComposition = (event) => {

package/lib/node_modules/element-plus/es/hooks/use-delayed-toggle/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const types = require("../../utils/types.js");
 const runtime = require("../../utils/vue/props/runtime.js");
 const index = require("../use-timeout/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const useDelayedToggleProps = runtime.buildProps({
   showAfter: {
     type: Number,
@@ -21,16 +21,16 @@ const useDelayedToggleProps = runtime.buildProps({
 const useDelayedToggle = ({ showAfter, hideAfter, autoClose, open, close }) => {
   const { registerTimeout } = index.useTimeout();
   const { registerTimeout: registerTimeoutForAutoClose, cancelTimeout: cancelTimeoutForAutoClose } = index.useTimeout();
-  const onOpen = (event, delay = vue.unref(showAfter)) => {
+  const onOpen = (event, delay = Vue.unref(showAfter)) => {
     registerTimeout(() => {
       open(event);
-      const _autoClose = vue.unref(autoClose);
+      const _autoClose = Vue.unref(autoClose);
       if (types.isNumber(_autoClose) && _autoClose > 0) registerTimeoutForAutoClose(() => {
         close(event);
       }, _autoClose);
     }, delay);
   };
-  const onClose = (event, delay = vue.unref(hideAfter)) => {
+  const onClose = (event, delay = Vue.unref(hideAfter)) => {
     cancelTimeoutForAutoClose();
     registerTimeout(() => {
       close(event);

package/lib/node_modules/element-plus/es/hooks/use-deprecated/index.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const error = require("../../utils/error.js");
-const vue = require("vue");
+const Vue = require("vue");
 const useDeprecated = ({ from, replacement, scope, version, ref, type = "API" }, condition) => {
-  vue.watch(() => vue.unref(condition), (val) => {
+  Vue.watch(() => Vue.unref(condition), (val) => {
     if (val) error.debugWarn(scope, `[${type}] ${from} is about to be deprecated in version ${version}, please use ${replacement} instead.
 For more detail, please visit: ${ref}
 `);

package/lib/node_modules/element-plus/es/hooks/use-draggable/index.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const style = require("../../utils/dom/style.js");
-const vue = require("vue");
+const Vue = require("vue");
 const useDraggable = (targetRef, dragRef, draggable, overflow) => {
   const transform = {
     offsetX: 0,
     offsetY: 0
   };
-  const isDragging = vue.ref(false);
+  const isDragging = Vue.ref(false);
   const adjustPosition = (moveX, moveY) => {
     if (targetRef.value) {
       const { offsetX, offsetY } = transform;
@@ -68,13 +68,13 @@ const useDraggable = (targetRef, dragRef, draggable, overflow) => {
     const { offsetX, offsetY } = transform;
     adjustPosition(offsetX, offsetY);
   };
-  vue.onMounted(() => {
-    vue.watchEffect(() => {
+  Vue.onMounted(() => {
+    Vue.watchEffect(() => {
       if (draggable.value) onDraggable();
       else offDraggable();
     });
   });
-  vue.onBeforeUnmount(() => {
+  Vue.onBeforeUnmount(() => {
     offDraggable();
   });
   return {

package/lib/node_modules/element-plus/es/hooks/use-empty-values/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const shared_esmBundler = require("../../../../@vue/shared/dist/shared.esm-bundler.js");
 const error = require("../../utils/error.js");
 const runtime = require("../../utils/vue/props/runtime.js");
-const vue = require("vue");
+const Vue = require("vue");
 const isEqual = require("../../../../lodash-es/isEqual.js");
 const emptyValuesContextKey = Symbol("emptyValuesContextKey");
 const SCOPE = "use-empty-values";
@@ -31,9 +31,9 @@ const useEmptyValuesProps = runtime.buildProps({
   }
 });
 const useEmptyValues = (props, defaultValue) => {
-  const config = vue.getCurrentInstance() ? vue.inject(emptyValuesContextKey, vue.ref({})) : vue.ref({});
-  const emptyValues = vue.computed(() => props.emptyValues || config.value.emptyValues || DEFAULT_EMPTY_VALUES);
-  const valueOnClear = vue.computed(() => {
+  const config = Vue.getCurrentInstance() ? Vue.inject(emptyValuesContextKey, Vue.ref({})) : Vue.ref({});
+  const emptyValues = Vue.computed(() => props.emptyValues || config.value.emptyValues || DEFAULT_EMPTY_VALUES);
+  const valueOnClear = Vue.computed(() => {
     if (shared_esmBundler.isFunction(props.valueOnClear)) return props.valueOnClear();
     else if (props.valueOnClear !== void 0) return props.valueOnClear;
     else if (shared_esmBundler.isFunction(config.value.valueOnClear)) return config.value.valueOnClear();

package/lib/node_modules/element-plus/es/hooks/use-escape-keydown/index.js

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const aria = require("../../constants/aria.js");
 const event = require("../../utils/dom/event.js");
-const vue = require("vue");
+const Vue = require("vue");
 const index = require("../../../node_modules/@vueuse/shared/index.js");
 let registeredEscapeHandlers = [];
 const cachedHandler = (event$1) => {
   if (event.getEventCode(event$1) === aria.EVENT_CODE.esc) registeredEscapeHandlers.forEach((registeredHandler) => registeredHandler(event$1));
 };
 const useEscapeKeydown = (handler) => {
-  vue.onMounted(() => {
+  Vue.onMounted(() => {
     if (registeredEscapeHandlers.length === 0) document.addEventListener("keydown", cachedHandler);
     if (index.isClient) registeredEscapeHandlers.push(handler);
   });
-  vue.onBeforeUnmount(() => {
+  Vue.onBeforeUnmount(() => {
     registeredEscapeHandlers = registeredEscapeHandlers.filter((registeredHandler) => registeredHandler !== handler);
     if (registeredEscapeHandlers.length === 0) {
       if (index.isClient) document.removeEventListener("keydown", cachedHandler);

package/lib/node_modules/element-plus/es/hooks/use-focus-controller/index.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const aria = require("../../utils/dom/aria.js");
 const shared_esmBundler = require("../../../../@vue/shared/dist/shared.esm-bundler.js");
 const index = require("../../../node_modules/@vueuse/core/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 function useFocusController(target, { disabled, beforeFocus, afterFocus, beforeBlur, afterBlur } = {}) {
-  const { emit } = vue.getCurrentInstance();
-  const wrapperRef = vue.shallowRef();
-  const isFocused = vue.ref(false);
+  const { emit } = Vue.getCurrentInstance();
+  const wrapperRef = Vue.shallowRef();
+  const isFocused = Vue.ref(false);
   const handleFocus = (event) => {
     const cancelFocus = shared_esmBundler.isFunction(beforeFocus) ? beforeFocus(event) : false;
-    if (vue.unref(disabled) || isFocused.value || cancelFocus) return;
+    if (Vue.unref(disabled) || isFocused.value || cancelFocus) return;
     isFocused.value = true;
     emit("focus", event);
     afterFocus == null ? void 0 : afterFocus();
@@ -18,17 +18,17 @@ function useFocusController(target, { disabled, beforeFocus, afterFocus, beforeB
   const handleBlur = (event) => {
     var _a;
     const cancelBlur = shared_esmBundler.isFunction(beforeBlur) ? beforeBlur(event) : false;
-    if (vue.unref(disabled) || event.relatedTarget && ((_a = wrapperRef.value) == null ? void 0 : _a.contains(event.relatedTarget)) || cancelBlur) return;
+    if (Vue.unref(disabled) || event.relatedTarget && ((_a = wrapperRef.value) == null ? void 0 : _a.contains(event.relatedTarget)) || cancelBlur) return;
     isFocused.value = false;
     emit("blur", event);
     afterBlur == null ? void 0 : afterBlur();
   };
   const handleClick = (event) => {
     var _a, _b;
-    if (vue.unref(disabled) || aria.isFocusable(event.target) || ((_a = wrapperRef.value) == null ? void 0 : _a.contains(document.activeElement)) && wrapperRef.value !== document.activeElement) return;
+    if (Vue.unref(disabled) || aria.isFocusable(event.target) || ((_a = wrapperRef.value) == null ? void 0 : _a.contains(document.activeElement)) && wrapperRef.value !== document.activeElement) return;
     (_b = target.value) == null ? void 0 : _b.focus();
   };
-  vue.watch([wrapperRef, () => vue.unref(disabled)], ([el, disabled2]) => {
+  Vue.watch([wrapperRef, () => Vue.unref(disabled)], ([el, disabled2]) => {
     if (!el) return;
     if (disabled2) el.removeAttribute("tabindex");
     else el.setAttribute("tabindex", "-1");

package/lib/node_modules/element-plus/es/hooks/use-forward-ref/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
+const Vue = require("vue");
 const FORWARD_REF_INJECTION_KEY = Symbol("elForwardRef");
 const useForwardRef = (forwardRef) => {
   const setForwardRef = (el) => {
     forwardRef.value = el;
   };
-  vue.provide(FORWARD_REF_INJECTION_KEY, { setForwardRef });
+  Vue.provide(FORWARD_REF_INJECTION_KEY, { setForwardRef });
 };
 const useForwardRefDirective = (setForwardRef) => {
   return {

package/lib/node_modules/element-plus/es/hooks/use-id/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const error = require("../../utils/error.js");
 const index$1 = require("../use-namespace/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const index = require("../../../node_modules/@vueuse/shared/index.js");
 const defaultIdInjection = {
   prefix: Math.floor(Math.random() * 1e4),
@@ -10,7 +10,7 @@ const defaultIdInjection = {
 };
 const ID_INJECTION_KEY = Symbol("elIdInjection");
 const useIdInjection = () => {
-  return vue.getCurrentInstance() ? vue.inject(ID_INJECTION_KEY, defaultIdInjection) : defaultIdInjection;
+  return Vue.getCurrentInstance() ? Vue.inject(ID_INJECTION_KEY, defaultIdInjection) : defaultIdInjection;
 };
 const useId = (deterministicId) => {
   const idInjection = useIdInjection();
@@ -20,7 +20,7 @@ usage: app.provide(ID_INJECTION_KEY, {
   current: number,
 })`);
   const namespace = index$1.useGetDerivedNamespace();
-  return index.computedEager(() => vue.unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`);
+  return index.computedEager(() => Vue.unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`);
 };
 exports.ID_INJECTION_KEY = ID_INJECTION_KEY;
 exports.useId = useId;

package/lib/node_modules/element-plus/es/hooks/use-locale/index.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const en = require("../../locale/lang/en.js");
-const vue = require("vue");
+const Vue = require("vue");
 const get = require("../../../../lodash-es/get.js");
-const buildTranslator = (locale) => (path, option) => translate(path, option, vue.unref(locale));
+const buildTranslator = (locale) => (path, option) => translate(path, option, Vue.unref(locale));
 const translate = (path, option, locale) => get.default(locale, path, path).replace(/\{(\w+)\}/g, (_, key) => `${(option == null ? void 0 : option[key]) ?? `{${key}}`}`);
 const buildLocaleContext = (locale) => {
   return {
-    lang: vue.computed(() => vue.unref(locale).name),
-    locale: vue.isRef(locale) ? locale : vue.ref(locale),
+    lang: Vue.computed(() => Vue.unref(locale).name),
+    locale: Vue.isRef(locale) ? locale : Vue.ref(locale),
     t: buildTranslator(locale)
   };
 };
 const localeContextKey = Symbol("localeContextKey");
 const useLocale = (localeOverrides) => {
-  const locale = localeOverrides || vue.inject(localeContextKey, vue.ref());
-  return buildLocaleContext(vue.computed(() => locale.value || en.default));
+  const locale = localeOverrides || Vue.inject(localeContextKey, Vue.ref());
+  return buildLocaleContext(Vue.computed(() => locale.value || en.default));
 };
 exports.buildLocaleContext = buildLocaleContext;
 exports.buildTranslator = buildTranslator;

package/lib/node_modules/element-plus/es/hooks/use-lockscreen/index.js

@@ -4,11 +4,11 @@ const error = require("../../utils/error.js");
 const style = require("../../utils/dom/style.js");
 const scroll = require("../../utils/dom/scroll.js");
 const index = require("../use-namespace/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const useLockscreen = (trigger, options = {}) => {
-  if (!vue.isRef(trigger)) error.throwError("[useLockscreen]", "You need to pass a ref param to this function");
+  if (!Vue.isRef(trigger)) error.throwError("[useLockscreen]", "You need to pass a ref param to this function");
   const ns = options.ns || index.useNamespace("popup");
-  const hiddenCls = vue.computed(() => ns.bm("parent", "hidden"));
+  const hiddenCls = Vue.computed(() => ns.bm("parent", "hidden"));
   let scrollBarWidth = 0;
   let withoutHiddenClass = false;
   let bodyWidth = "0";
@@ -24,7 +24,7 @@ const useLockscreen = (trigger, options = {}) => {
       }
     }, 200);
   };
-  vue.watch(trigger, (val) => {
+  Vue.watch(trigger, (val) => {
     if (!val) {
       cleanup();
       return;
@@ -40,6 +40,6 @@ const useLockscreen = (trigger, options = {}) => {
     const bodyOverflowY = style.getStyle(document.body, "overflowY");
     if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) document.body.style.width = `calc(100% - ${scrollBarWidth}px)`;
   });
-  vue.onScopeDispose(() => cleanup());
+  Vue.onScopeDispose(() => cleanup());
 };
 exports.useLockscreen = useLockscreen;