@fecp/designer 5.5.34 → 5.5.36

package/lib/node_modules/element-plus/es/components/table-v2/src/composables/use-auto-resize.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const index = require("../../../../../node_modules/@vueuse/core/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const useAutoResize = (props) => {
-  const sizer = vue.ref();
-  const width$ = vue.ref(0);
-  const height$ = vue.ref(0);
+  const sizer = Vue.ref();
+  const width$ = Vue.ref(0);
+  const height$ = Vue.ref(0);
   let resizerStopper;
-  vue.onMounted(() => {
+  Vue.onMounted(() => {
     resizerStopper = index.useResizeObserver(sizer, ([entry]) => {
       const { width, height } = entry.contentRect;
       const { paddingLeft, paddingRight, paddingTop, paddingBottom } = getComputedStyle(entry.target);
@@ -19,10 +19,10 @@ const useAutoResize = (props) => {
       height$.value = height - top - bottom;
     }).stop;
   });
-  vue.onBeforeUnmount(() => {
+  Vue.onBeforeUnmount(() => {
     resizerStopper == null ? void 0 : resizerStopper();
   });
-  vue.watch([width$, height$], ([width, height]) => {
+  Vue.watch([width$, height$], ([width, height]) => {
     var _a;
     (_a = props.onResize) == null ? void 0 : _a.call(props, {
       width,

package/lib/node_modules/element-plus/es/components/table-v2/src/composables/use-columns.js

@@ -4,30 +4,30 @@ const shared_esmBundler = require("../../../../../../@vue/shared/dist/shared.esm
 const constants = require("../constants.js");
 const _private = require("../private.js");
 const utils = require("./utils.js");
-const vue = require("vue");
+const Vue = require("vue");
 function useColumns(props, columns, fixed) {
-  const _columns = vue.computed(() => vue.unref(columns).map((column, index) => ({
+  const _columns = Vue.computed(() => Vue.unref(columns).map((column, index) => ({
     ...column,
     key: column.key ?? column.dataKey ?? index
   })));
-  const visibleColumns = vue.computed(() => {
-    return vue.unref(_columns).filter((column) => !column.hidden);
+  const visibleColumns = Vue.computed(() => {
+    return Vue.unref(_columns).filter((column) => !column.hidden);
   });
-  const fixedColumnsOnLeft = vue.computed(() => vue.unref(visibleColumns).filter((column) => column.fixed === "left" || column.fixed === true));
-  const fixedColumnsOnRight = vue.computed(() => vue.unref(visibleColumns).filter((column) => column.fixed === "right"));
-  const normalColumns = vue.computed(() => vue.unref(visibleColumns).filter((column) => !column.fixed));
-  const mainColumns = vue.computed(() => {
+  const fixedColumnsOnLeft = Vue.computed(() => Vue.unref(visibleColumns).filter((column) => column.fixed === "left" || column.fixed === true));
+  const fixedColumnsOnRight = Vue.computed(() => Vue.unref(visibleColumns).filter((column) => column.fixed === "right"));
+  const normalColumns = Vue.computed(() => Vue.unref(visibleColumns).filter((column) => !column.fixed));
+  const mainColumns = Vue.computed(() => {
     const ret = [];
-    vue.unref(fixedColumnsOnLeft).forEach((column) => {
+    Vue.unref(fixedColumnsOnLeft).forEach((column) => {
       ret.push({
         ...column,
         placeholderSign: _private.placeholderSign
       });
     });
-    vue.unref(normalColumns).forEach((column) => {
+    Vue.unref(normalColumns).forEach((column) => {
       ret.push(column);
     });
-    vue.unref(fixedColumnsOnRight).forEach((column) => {
+    Vue.unref(fixedColumnsOnRight).forEach((column) => {
       ret.push({
         ...column,
         placeholderSign: _private.placeholderSign
@@ -35,23 +35,23 @@ function useColumns(props, columns, fixed) {
     });
     return ret;
   });
-  const hasFixedColumns = vue.computed(() => {
-    return vue.unref(fixedColumnsOnLeft).length || vue.unref(fixedColumnsOnRight).length;
+  const hasFixedColumns = Vue.computed(() => {
+    return Vue.unref(fixedColumnsOnLeft).length || Vue.unref(fixedColumnsOnRight).length;
   });
-  const columnsStyles = vue.computed(() => {
-    return vue.unref(_columns).reduce((style, column) => {
-      style[column.key] = utils.calcColumnStyle(column, vue.unref(fixed), props.fixed);
+  const columnsStyles = Vue.computed(() => {
+    return Vue.unref(_columns).reduce((style, column) => {
+      style[column.key] = utils.calcColumnStyle(column, Vue.unref(fixed), props.fixed);
       return style;
     }, {});
   });
-  const columnsTotalWidth = vue.computed(() => {
-    return vue.unref(visibleColumns).reduce((width, column) => width + column.width, 0);
+  const columnsTotalWidth = Vue.computed(() => {
+    return Vue.unref(visibleColumns).reduce((width, column) => width + column.width, 0);
   });
   const getColumn = (key) => {
-    return vue.unref(_columns).find((column) => column.key === key);
+    return Vue.unref(_columns).find((column) => column.key === key);
   };
   const getColumnStyle = (key) => {
-    return vue.unref(columnsStyles)[key];
+    return Vue.unref(columnsStyles)[key];
   };
   const updateColumnWidth = (column, width) => {
     column.width = width;

package/lib/node_modules/element-plus/es/components/table-v2/src/composables/use-data.js

@@ -1,13 +1,13 @@
 "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");
 const useData = (props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }) => {
-  const depthMap = vue.ref({});
-  const flattenedData = vue.computed(() => {
+  const depthMap = Vue.ref({});
+  const flattenedData = Vue.computed(() => {
     const depths = {};
     const { data: data2, rowKey } = props;
-    const _expandedRowKeys = vue.unref(expandedRowKeys);
+    const _expandedRowKeys = Vue.unref(expandedRowKeys);
     if (!_expandedRowKeys || !_expandedRowKeys.length) return data2;
     const array = [];
     const keysSet = /* @__PURE__ */ new Set();
@@ -25,11 +25,11 @@ const useData = (props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex
     depthMap.value = depths;
     return array;
   });
-  const data = vue.computed(() => {
+  const data = Vue.computed(() => {
     const { data: data2, expandColumnKey } = props;
-    return expandColumnKey ? vue.unref(flattenedData) : data2;
+    return expandColumnKey ? Vue.unref(flattenedData) : data2;
   });
-  vue.watch(data, (val, prev) => {
+  Vue.watch(data, (val, prev) => {
     if (val !== prev) {
       lastRenderedRowIndex.value = -1;
       resetAfterIndex(0, true);

package/lib/node_modules/element-plus/es/components/table-v2/src/composables/use-row.js

@@ -2,25 +2,25 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const types = require("../../../../utils/types.js");
 const constants = require("../constants.js");
-const vue = require("vue");
+const Vue = require("vue");
 const debounce = require("../../../../../../lodash-es/debounce.js");
 const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstance, ns, isScrolling }) => {
-  const vm = vue.getCurrentInstance();
+  const vm = Vue.getCurrentInstance();
   const { emit } = vm;
-  const isResetting = vue.shallowRef(false);
-  const expandedRowKeys = vue.ref(props.defaultExpandedRowKeys || []);
-  const lastRenderedRowIndex = vue.ref(-1);
-  const resetIndex = vue.shallowRef(null);
-  const rowHeights = vue.ref({});
-  const pendingRowHeights = vue.ref({});
-  const leftTableHeights = vue.shallowRef({});
-  const mainTableHeights = vue.shallowRef({});
-  const rightTableHeights = vue.shallowRef({});
-  const isDynamic = vue.computed(() => types.isNumber(props.estimatedRowHeight));
+  const isResetting = Vue.shallowRef(false);
+  const expandedRowKeys = Vue.ref(props.defaultExpandedRowKeys || []);
+  const lastRenderedRowIndex = Vue.ref(-1);
+  const resetIndex = Vue.shallowRef(null);
+  const rowHeights = Vue.ref({});
+  const pendingRowHeights = Vue.ref({});
+  const leftTableHeights = Vue.shallowRef({});
+  const mainTableHeights = Vue.shallowRef({});
+  const rightTableHeights = Vue.shallowRef({});
+  const isDynamic = Vue.computed(() => types.isNumber(props.estimatedRowHeight));
   function onRowsRendered(params) {
     var _a;
     (_a = props.onRowsRendered) == null ? void 0 : _a.call(props, params);
-    if (params.rowCacheEnd > vue.unref(lastRenderedRowIndex)) lastRenderedRowIndex.value = params.rowCacheEnd;
+    if (params.rowCacheEnd > Vue.unref(lastRenderedRowIndex)) lastRenderedRowIndex.value = params.rowCacheEnd;
   }
   function onRowHovered({ hovered, rowKey }) {
     if (isScrolling.value) return;
@@ -31,7 +31,7 @@ const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstanc
   }
   function onRowExpanded({ expanded, rowData, rowIndex, rowKey }) {
     var _a, _b;
-    const _expandedRowKeys = [...vue.unref(expandedRowKeys)];
+    const _expandedRowKeys = [...Vue.unref(expandedRowKeys)];
     const currentKeyIndex = _expandedRowKeys.indexOf(rowKey);
     if (expanded) {
       if (currentKeyIndex === -1) _expandedRowKeys.push(rowKey);
@@ -45,7 +45,7 @@ const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstanc
       rowKey
     });
     (_b = props.onExpandedRowsChange) == null ? void 0 : _b.call(props, _expandedRowKeys);
-    if (tableInstance.vnode.el.querySelector(`.${ns.is("hovered")}[rowkey="${String(rowKey)}"]`)) vue.nextTick(() => onRowHovered({
+    if (tableInstance.vnode.el.querySelector(`.${ns.is("hovered")}[rowkey="${String(rowKey)}"]`)) Vue.nextTick(() => onRowHovered({
       hovered: true,
       rowKey
     }));
@@ -54,10 +54,10 @@ const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstanc
     var _a, _b, _c, _d;
     isResetting.value = true;
     rowHeights.value = {
-      ...vue.unref(rowHeights),
-      ...vue.unref(pendingRowHeights)
+      ...Vue.unref(rowHeights),
+      ...Vue.unref(pendingRowHeights)
     };
-    resetAfterIndex(vue.unref(resetIndex), false);
+    resetAfterIndex(Vue.unref(resetIndex), false);
     pendingRowHeights.value = {};
     resetIndex.value = null;
     (_a = mainTableRef.value) == null ? void 0 : _a.forceUpdate();
@@ -67,18 +67,18 @@ const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstanc
     isResetting.value = false;
   }, 0);
   function resetAfterIndex(index, forceUpdate = false) {
-    if (!vue.unref(isDynamic)) return;
+    if (!Vue.unref(isDynamic)) return;
     [
       mainTableRef,
       leftTableRef,
       rightTableRef
     ].forEach((tableRef) => {
-      const table = vue.unref(tableRef);
+      const table = Vue.unref(tableRef);
       if (table) table.resetAfterRowIndex(index, forceUpdate);
     });
   }
   function resetHeights(rowKey, height, rowIdx) {
-    const resetIdx = vue.unref(resetIndex);
+    const resetIdx = Vue.unref(resetIndex);
     if (resetIdx === null) resetIndex.value = rowIdx;
     else if (resetIdx > rowIdx) resetIndex.value = rowIdx;
     pendingRowHeights.value[rowKey] = height;
@@ -92,7 +92,7 @@ const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstanc
       rightTableHeights,
       mainTableHeights
     ].map((records) => records.value[rowKey] || 0));
-    if (vue.unref(rowHeights)[rowKey] !== maximumHeight) {
+    if (Vue.unref(rowHeights)[rowKey] !== maximumHeight) {
       resetHeights(rowKey, maximumHeight, rowIndex);
       flushingRowHeights();
     }

package/lib/node_modules/element-plus/es/components/table-v2/src/composables/use-scrollbar.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
+const Vue = require("vue");
 const useScrollbar = (props, { mainTableRef, leftTableRef, rightTableRef, onMaybeEndReached }) => {
-  const scrollPos = vue.ref({
+  const scrollPos = Vue.ref({
     scrollLeft: 0,
     scrollTop: 0
   });
@@ -19,12 +19,12 @@ const useScrollbar = (props, { mainTableRef, leftTableRef, rightTableRef, onMayb
   }
   function scrollToTop(scrollTop) {
     scrollPos.value.scrollTop = scrollTop;
-    doScroll(vue.unref(scrollPos));
+    doScroll(Vue.unref(scrollPos));
   }
   function scrollToLeft(scrollLeft) {
     var _a, _b;
     scrollPos.value.scrollLeft = scrollLeft;
-    (_b = (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo) == null ? void 0 : _b.call(_a, vue.unref(scrollPos));
+    (_b = (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo) == null ? void 0 : _b.call(_a, Vue.unref(scrollPos));
   }
   function onScroll(params) {
     var _a;
@@ -32,14 +32,14 @@ const useScrollbar = (props, { mainTableRef, leftTableRef, rightTableRef, onMayb
     (_a = props.onScroll) == null ? void 0 : _a.call(props, params);
   }
   function onVerticalScroll({ scrollTop }) {
-    const { scrollTop: currentScrollTop } = vue.unref(scrollPos);
+    const { scrollTop: currentScrollTop } = Vue.unref(scrollPos);
     if (scrollTop !== currentScrollTop) scrollToTop(scrollTop);
   }
   function scrollToRow(row, strategy = "auto") {
     var _a;
     (_a = mainTableRef.value) == null ? void 0 : _a.scrollToRow(row, strategy);
   }
-  vue.watch(() => vue.unref(scrollPos).scrollTop, (cur, prev) => {
+  Vue.watch(() => Vue.unref(scrollPos).scrollTop, (cur, prev) => {
     if (cur > prev) onMaybeEndReached();
   });
   return {

package/lib/node_modules/element-plus/es/components/table-v2/src/composables/use-styles.js

@@ -3,42 +3,42 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const types = require("../../../../utils/types.js");
 const style = require("../../../../utils/dom/style.js");
 const utils = require("../utils.js");
-const vue = require("vue");
+const Vue = require("vue");
 const useStyles = (props, { columnsTotalWidth, rowsHeight, fixedColumnsOnLeft, fixedColumnsOnRight }) => {
-  const bodyWidth = vue.computed(() => {
+  const bodyWidth = Vue.computed(() => {
     const { fixed, width, vScrollbarSize } = props;
     const ret = width - vScrollbarSize;
-    return fixed ? Math.max(Math.round(vue.unref(columnsTotalWidth)), ret) : ret;
+    return fixed ? Math.max(Math.round(Vue.unref(columnsTotalWidth)), ret) : ret;
   });
-  const mainTableHeight = vue.computed(() => {
+  const mainTableHeight = Vue.computed(() => {
     const { height = 0, maxHeight = 0, footerHeight, hScrollbarSize } = props;
     if (maxHeight > 0) {
-      const _fixedRowsHeight = vue.unref(fixedRowsHeight);
-      const _rowsHeight = vue.unref(rowsHeight);
-      const total = vue.unref(headerHeight) + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
+      const _fixedRowsHeight = Vue.unref(fixedRowsHeight);
+      const _rowsHeight = Vue.unref(rowsHeight);
+      const total = Vue.unref(headerHeight) + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
       return Math.min(total, maxHeight - footerHeight);
     }
     return height - footerHeight;
   });
-  const fixedTableHeight = vue.computed(() => {
+  const fixedTableHeight = Vue.computed(() => {
     const { maxHeight } = props;
-    const tableHeight = vue.unref(mainTableHeight);
+    const tableHeight = Vue.unref(mainTableHeight);
     if (types.isNumber(maxHeight) && maxHeight > 0) return tableHeight;
-    const totalHeight = vue.unref(rowsHeight) + vue.unref(headerHeight) + vue.unref(fixedRowsHeight);
+    const totalHeight = Vue.unref(rowsHeight) + Vue.unref(headerHeight) + Vue.unref(fixedRowsHeight);
     return Math.min(tableHeight, totalHeight);
   });
   const mapColumn = (column) => column.width;
-  const leftTableWidth = vue.computed(() => utils.sum(vue.unref(fixedColumnsOnLeft).map(mapColumn)));
-  const rightTableWidth = vue.computed(() => utils.sum(vue.unref(fixedColumnsOnRight).map(mapColumn)));
-  const headerHeight = vue.computed(() => utils.sum(props.headerHeight));
-  const fixedRowsHeight = vue.computed(() => {
+  const leftTableWidth = Vue.computed(() => utils.sum(Vue.unref(fixedColumnsOnLeft).map(mapColumn)));
+  const rightTableWidth = Vue.computed(() => utils.sum(Vue.unref(fixedColumnsOnRight).map(mapColumn)));
+  const headerHeight = Vue.computed(() => utils.sum(props.headerHeight));
+  const fixedRowsHeight = Vue.computed(() => {
     var _a;
     return (((_a = props.fixedData) == null ? void 0 : _a.length) || 0) * props.rowHeight;
   });
-  const windowHeight = vue.computed(() => {
-    return vue.unref(mainTableHeight) - vue.unref(headerHeight) - vue.unref(fixedRowsHeight);
+  const windowHeight = Vue.computed(() => {
+    return Vue.unref(mainTableHeight) - Vue.unref(headerHeight) - Vue.unref(fixedRowsHeight);
   });
-  const rootStyle = vue.computed(() => {
+  const rootStyle = Vue.computed(() => {
     const { style: style2 = {}, height, width } = props;
     return utils.enforceUnit({
       ...style2,
@@ -53,9 +53,9 @@ const useStyles = (props, { columnsTotalWidth, rowsHeight, fixedColumnsOnLeft, f
     leftTableWidth,
     rightTableWidth,
     windowHeight,
-    footerHeight: vue.computed(() => utils.enforceUnit({ height: props.footerHeight })),
-    emptyStyle: vue.computed(() => ({
-      top: style.addUnit(vue.unref(headerHeight)),
+    footerHeight: Vue.computed(() => utils.enforceUnit({ height: props.footerHeight })),
+    emptyStyle: Vue.computed(() => ({
+      top: style.addUnit(Vue.unref(headerHeight)),
       bottom: style.addUnit(props.footerHeight),
       width: style.addUnit(props.width)
     })),

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/cell.js

@@ -6,11 +6,11 @@ const _private = require("../private.js");
 const utils = require("../utils.js");
 const cell = require("../components/cell.js");
 const expandIcon = require("../components/expand-icon.js");
-const vue = require("vue");
+const Vue = require("vue");
 const get = require("../../../../../../lodash-es/get.js");
 const CellRenderer = ({ columns, column, columnIndex, depth, expandIconProps, isScrolling, rowData, rowIndex, style, expandedRowKeys, ns, t, cellProps: _cellProps, expandColumnKey, indentSize, iconSize, rowKey }, { slots }) => {
   const cellStyle = utils.enforceUnit(style);
-  if (column.placeholderSign === _private.placeholderSign) return vue.createVNode("div", {
+  if (column.placeholderSign === _private.placeholderSign) return Vue.createVNode("div", {
     "class": ns.em("row-cell", "placeholder"),
     "style": cellStyle
   }, null);
@@ -41,7 +41,7 @@ const CellRenderer = ({ columns, column, columnIndex, depth, expandIconProps, is
     rowIndex
   };
   const columnCellRenderer = utils.componentToSlot(cellRenderer);
-  const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : vue.renderSlot(slots, "default", cellProps, () => [vue.createVNode(cell.default, cellProps, null)]);
+  const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : Vue.renderSlot(slots, "default", cellProps, () => [Vue.createVNode(cell.default, cellProps, null)]);
   const kls = [
     ns.e("row-cell"),
     column.class,
@@ -52,7 +52,7 @@ const CellRenderer = ({ columns, column, columnIndex, depth, expandIconProps, is
   const expanded = rowIndex >= 0 && expandedRowKeys.includes(rowData[rowKey]);
   let IconOrPlaceholder;
   const iconStyle = `margin-inline-start: ${depth * indentSize}px;`;
-  if (expandable) if (shared_esmBundler.isObject(expandIconProps)) IconOrPlaceholder = vue.createVNode(expandIcon.default, vue.mergeProps(expandIconProps, {
+  if (expandable) if (shared_esmBundler.isObject(expandIconProps)) IconOrPlaceholder = Vue.createVNode(expandIcon.default, Vue.mergeProps(expandIconProps, {
     "class": [ns.e("expand-icon"), ns.is("expanded", expanded)],
     "size": iconSize,
     "expanded": expanded,
@@ -60,8 +60,8 @@ const CellRenderer = ({ columns, column, columnIndex, depth, expandIconProps, is
     "style": iconStyle,
     "expandable": true
   }), null);
-  else IconOrPlaceholder = vue.createVNode("div", { "style": [iconStyle, `width: ${iconSize}px; height: ${iconSize}px;`].join(" ") }, null);
-  return vue.createVNode("div", vue.mergeProps({
+  else IconOrPlaceholder = Vue.createVNode("div", { "style": [iconStyle, `width: ${iconSize}px; height: ${iconSize}px;`].join(" ") }, null);
+  return Vue.createVNode("div", Vue.mergeProps({
     "class": kls,
     "style": cellStyle
   }, extraCellProps, { "role": "cell" }), [IconOrPlaceholder, Cell]);

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/empty.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const index = require("../../../empty/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const Footer = (props, { slots }) => {
-  const defaultSlot = vue.renderSlot(slots, "default", {}, () => [vue.createVNode(index.ElEmpty, null, null)]);
-  return vue.createVNode("div", {
+  const defaultSlot = Vue.renderSlot(slots, "default", {}, () => [Vue.createVNode(index.ElEmpty, null, null)]);
+  return Vue.createVNode("div", {
     "class": props.class,
     "style": props.style
   }, [defaultSlot]);

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/footer.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const vue = require("vue");
+const Vue = require("vue");
 const Footer = (props, { slots }) => {
   var _a;
-  return vue.createVNode("div", {
+  return Vue.createVNode("div", {
     "class": props.class,
     "style": props.style
   }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/header-cell.js

@@ -5,11 +5,11 @@ const _private = require("../private.js");
 const utils = require("../utils.js");
 const headerCell = require("../components/header-cell.js");
 const sortIcon = require("../components/sort-icon.js");
-const vue = require("vue");
+const Vue = require("vue");
 const HeaderCellRenderer = (props, { slots }) => {
   const { column, ns, t, style, onColumnSorted } = props;
   const cellStyle = utils.enforceUnit(style);
-  if (column.placeholderSign === _private.placeholderSign) return vue.createVNode("div", {
+  if (column.placeholderSign === _private.placeholderSign) return Vue.createVNode("div", {
     "class": ns.em("header-row-cell", "placeholder"),
     "style": cellStyle
   }, null);
@@ -19,7 +19,7 @@ const HeaderCellRenderer = (props, { slots }) => {
     class: ns.e("header-cell-text")
   };
   const columnCellRenderer = utils.componentToSlot(headerCellRenderer);
-  const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : vue.renderSlot(slots, "default", cellProps, () => [vue.createVNode(headerCell.default, cellProps, null)]);
+  const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : Vue.renderSlot(slots, "default", cellProps, () => [Vue.createVNode(headerCell.default, cellProps, null)]);
   const { sortBy, sortState, headerCellProps } = props;
   let sorting, sortOrder, ariaSort;
   if (sortState) {
@@ -40,14 +40,14 @@ const HeaderCellRenderer = (props, { slots }) => {
     column.align === constants.Alignment.RIGHT && ns.is("align-right"),
     sortable && ns.is("sortable")
   ];
-  return vue.createVNode("div", vue.mergeProps({
+  return Vue.createVNode("div", Vue.mergeProps({
     ...utils.tryCall(headerCellProps, props),
     onClick: column.sortable ? onColumnSorted : void 0,
     ariaSort: sortable ? ariaSort : void 0,
     class: cellKls,
     style: cellStyle,
     ["data-key"]: column.key
-  }, { "role": "columnheader" }), [Cell, sortable && vue.createVNode(sortIcon.default, {
+  }, { "role": "columnheader" }), [Cell, sortable && Vue.createVNode(sortIcon.default, {
     "class": [ns.e("sort-icon"), sorting && ns.is("sorting")],
     "sortOrder": sortOrder,
     "ariaLabel": t("el.table.sortLabel", { column: column.title || "" })

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/header.js

@@ -2,9 +2,9 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const utils = require("../utils.js");
 const headerRow = require("../components/header-row.js");
-const vue = require("vue");
+const Vue = require("vue");
 function _isSlot(s) {
-  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !Vue.isVNode(s);
 }
 const HeaderRenderer = ({ columns, columnsStyles, headerIndex, style, headerClass, headerProps, ns }, { slots }) => {
   const param = {
@@ -16,7 +16,7 @@ const HeaderRenderer = ({ columns, columnsStyles, headerIndex, style, headerClas
     utils.tryCall(headerClass, param, ""),
     ns.is("customized", Boolean(slots.header))
   ];
-  return vue.createVNode(headerRow.default, {
+  return Vue.createVNode(headerRow.default, {
     ...utils.tryCall(headerProps, param),
     columnsStyles,
     class: kls,

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/left-table.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const tableGrid = require("../table-grid.js");
-const vue = require("vue");
+const Vue = require("vue");
 function _isSlot(s) {
-  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !Vue.isVNode(s);
 }
 const LeftTable = (props, { slots }) => {
   if (!props.columns.length) return;
   const { leftTableRef, ...rest } = props;
-  return vue.createVNode(tableGrid.default, vue.mergeProps({ "ref": leftTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
+  return Vue.createVNode(tableGrid.default, Vue.mergeProps({ "ref": leftTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
 };
 exports.default = LeftTable;

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/main-table.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const tableGrid = require("../table-grid.js");
-const vue = require("vue");
+const Vue = require("vue");
 function _isSlot(s) {
-  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !Vue.isVNode(s);
 }
 const MainTable = (props, { slots }) => {
   const { mainTableRef, ...rest } = props;
-  return vue.createVNode(tableGrid.default, vue.mergeProps({ "ref": mainTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
+  return Vue.createVNode(tableGrid.default, Vue.mergeProps({ "ref": mainTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
 };
 exports.default = MainTable;

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/overlay.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const vue = require("vue");
+const Vue = require("vue");
 const Overlay = (props, { slots }) => {
   var _a;
-  return vue.createVNode("div", {
+  return Vue.createVNode("div", {
     "class": props.class,
     "style": props.style
   }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/right-table.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const tableGrid = require("../table-grid.js");
-const vue = require("vue");
+const Vue = require("vue");
 function _isSlot(s) {
-  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !Vue.isVNode(s);
 }
 const RightTable = (props, { slots }) => {
   if (!props.columns.length) return;
   const { rightTableRef, ...rest } = props;
-  return vue.createVNode(tableGrid.default, vue.mergeProps({ "ref": rightTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
+  return Vue.createVNode(tableGrid.default, Vue.mergeProps({ "ref": rightTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
 };
 exports.default = RightTable;

package/lib/node_modules/element-plus/es/components/table-v2/src/renderers/row.js

@@ -2,9 +2,9 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const utils = require("../utils.js");
 const row = require("../components/row.js");
-const vue = require("vue");
+const Vue = require("vue");
 function _isSlot(s) {
-  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !Vue.isVNode(s);
 }
 const RowRenderer = (props, { slots }) => {
   const { columns, columnsStyles, depthMap, expandColumnKey, expandedRowKeys, estimatedRowHeight, hasFixedColumns, rowData, rowIndex, style, isScrolling, rowProps, rowClass, rowKey, rowEventHandlers, ns, onRowHovered, onRowExpanded } = props;
@@ -64,7 +64,7 @@ const RowRenderer = (props, { slots }) => {
       rowIndex
     });
   };
-  return vue.createVNode(row.default, vue.mergeProps(_rowProps, {
+  return Vue.createVNode(row.default, Vue.mergeProps(_rowProps, {
     "onRowExpand": onRowExpanded,
     "onMouseenter": handlerMouseEnter,
     "onMouseleave": handlerMouseLeave,