@fecp/designer 5.5.35 → 5.5.36

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

@@ -7,29 +7,29 @@ const utils = require("./utils.js");
 const tokens = require("./tokens.js");
 const grid = require("./grid.js");
 const header = require("./components/header.js");
-const vue = require("vue");
+const Vue = require("vue");
 const shared_esmBundler = require("../../../../../@vue/shared/dist/shared.esm-bundler.js");
 const COMPONENT_NAME = "ElTableV2Grid";
 const useTableGrid = (props) => {
-  const headerRef = vue.ref();
-  const bodyRef = vue.ref();
-  const scrollLeft = vue.ref(0);
-  const totalHeight = vue.computed(() => {
+  const headerRef = Vue.ref();
+  const bodyRef = Vue.ref();
+  const scrollLeft = Vue.ref(0);
+  const totalHeight = Vue.computed(() => {
     const { data, rowHeight, estimatedRowHeight } = props;
     if (estimatedRowHeight) return;
     return data.length * rowHeight;
   });
-  const fixedRowHeight = vue.computed(() => {
+  const fixedRowHeight = Vue.computed(() => {
     const { fixedData, rowHeight } = props;
     return ((fixedData == null ? void 0 : fixedData.length) || 0) * rowHeight;
   });
-  const headerHeight = vue.computed(() => utils.sum(props.headerHeight));
-  const gridHeight = vue.computed(() => {
+  const headerHeight = Vue.computed(() => utils.sum(props.headerHeight));
+  const gridHeight = Vue.computed(() => {
     const { height } = props;
-    return Math.max(0, height - vue.unref(headerHeight) - vue.unref(fixedRowHeight));
+    return Math.max(0, height - Vue.unref(headerHeight) - Vue.unref(fixedRowHeight));
   });
-  const hasHeader = vue.computed(() => {
-    return vue.unref(headerHeight) + vue.unref(fixedRowHeight) > 0;
+  const hasHeader = Vue.computed(() => {
+    return Vue.unref(headerHeight) + Vue.unref(fixedRowHeight) > 0;
   });
   const itemKey = ({ data, rowIndex }) => data[rowIndex][props.rowKey];
   function onItemRendered({ rowCacheStart, rowCacheEnd, rowVisibleStart, rowVisibleEnd }) {
@@ -46,8 +46,8 @@ const useTableGrid = (props) => {
     (_a = bodyRef.value) == null ? void 0 : _a.resetAfterRowIndex(index, forceUpdate2);
   }
   function scrollTo(leftOrOptions, top) {
-    const header$ = vue.unref(headerRef);
-    const body$ = vue.unref(bodyRef);
+    const header$ = Vue.unref(headerRef);
+    const body$ = Vue.unref(bodyRef);
     if (shared_esmBundler.isObject(leftOrOptions)) {
       header$ == null ? void 0 : header$.scrollToLeft(leftOrOptions.scrollLeft);
       scrollLeft.value = leftOrOptions.scrollLeft;
@@ -63,10 +63,10 @@ const useTableGrid = (props) => {
   }
   function scrollToTop(scrollTop) {
     var _a;
-    (_a = vue.unref(bodyRef)) == null ? void 0 : _a.scrollTo({ scrollTop });
+    (_a = Vue.unref(bodyRef)) == null ? void 0 : _a.scrollTo({ scrollTop });
   }
   function scrollToRow(row, strategy) {
-    const body = vue.unref(bodyRef);
+    const body = Vue.unref(bodyRef);
     if (!body) return;
     const prevScrollLeft = scrollLeft.value;
     body.scrollToItem(row, 0, strategy);
@@ -74,10 +74,10 @@ const useTableGrid = (props) => {
   }
   function forceUpdate() {
     var _a, _b;
-    (_a = vue.unref(bodyRef)) == null ? void 0 : _a.$forceUpdate();
-    (_b = vue.unref(headerRef)) == null ? void 0 : _b.$forceUpdate();
+    (_a = Vue.unref(bodyRef)) == null ? void 0 : _a.$forceUpdate();
+    (_b = Vue.unref(headerRef)) == null ? void 0 : _b.$forceUpdate();
   }
-  vue.watch(() => props.bodyWidth, () => {
+  Vue.watch(() => props.bodyWidth, () => {
     var _a;
     if (types.isNumber(props.estimatedRowHeight)) (_a = bodyRef.value) == null ? void 0 : _a.resetAfter({ columnIndex: 0 }, false);
   });
@@ -99,16 +99,16 @@ const useTableGrid = (props) => {
     scrollLeft
   };
 };
-const TableGrid = /* @__PURE__ */ vue.defineComponent({
+const TableGrid = /* @__PURE__ */ Vue.defineComponent({
   name: COMPONENT_NAME,
   props: grid.tableV2GridProps,
   setup(props, { slots, expose }) {
-    const { ns } = vue.inject(tokens.TableV2InjectionKey);
+    const { ns } = Vue.inject(tokens.TableV2InjectionKey);
     const { bodyRef, fixedRowHeight, gridHeight, hasHeader, headerRef, headerHeight, totalHeight, forceUpdate, itemKey, onItemRendered, resetAfterRowIndex, scrollTo, scrollToTop, scrollToRow, scrollLeft } = useTableGrid(props);
-    vue.provide(tokens.TABLE_V2_GRID_INJECTION_KEY, scrollLeft);
-    vue.onActivated(async () => {
+    Vue.provide(tokens.TABLE_V2_GRID_INJECTION_KEY, scrollLeft);
+    Vue.onActivated(async () => {
       var _a;
-      await vue.nextTick();
+      await Vue.nextTick();
       const scrollTop = (_a = bodyRef.value) == null ? void 0 : _a.states.scrollTop;
       scrollTop && scrollToTop(Math.round(scrollTop) + 1);
     });
@@ -125,12 +125,12 @@ const TableGrid = /* @__PURE__ */ vue.defineComponent({
       const { cache, columns, data, fixedData, useIsScrolling, scrollbarAlwaysOn, scrollbarEndGap, scrollbarStartGap, style, rowHeight, bodyWidth, estimatedRowHeight, headerWidth, height, width, getRowHeight, onScroll } = props;
       const isDynamicRowEnabled = types.isNumber(estimatedRowHeight);
       const Grid = isDynamicRowEnabled ? dynamicSizeGrid.default : fixedSizeGrid.default;
-      const _headerHeight = vue.unref(headerHeight);
-      return vue.createVNode("div", {
+      const _headerHeight = Vue.unref(headerHeight);
+      return Vue.createVNode("div", {
         "role": "table",
         "class": [ns.e("table"), props.class],
         "style": style
-      }, [vue.createVNode(Grid, {
+      }, [Vue.createVNode(Grid, {
         "ref": bodyRef,
         "data": data,
         "useIsScrolling": useIsScrolling,
@@ -142,7 +142,7 @@ const TableGrid = /* @__PURE__ */ vue.defineComponent({
         "rowCache": cache,
         "rowHeight": isDynamicRowEnabled ? getRowHeight : rowHeight,
         "width": width,
-        "height": vue.unref(gridHeight),
+        "height": Vue.unref(gridHeight),
         "class": ns.e("body"),
         "role": "rowgroup",
         "scrollbarStartGap": scrollbarStartGap,
@@ -159,7 +159,7 @@ const TableGrid = /* @__PURE__ */ vue.defineComponent({
           columns,
           rowData
         });
-      } }), vue.unref(hasHeader) && vue.createVNode(header.default, {
+      } }), Vue.unref(hasHeader) && Vue.createVNode(header.default, {
         "ref": headerRef,
         "class": ns.e("header-wrapper"),
         "columns": columns,
@@ -169,7 +169,7 @@ const TableGrid = /* @__PURE__ */ vue.defineComponent({
         "rowWidth": headerWidth,
         "rowHeight": rowHeight,
         "width": width,
-        "height": Math.min(_headerHeight + vue.unref(fixedRowHeight), height)
+        "height": Math.min(_headerHeight + Vue.unref(fixedRowHeight), height)
       }, {
         dynamic: slots.header,
         fixed: slots.row

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

@@ -15,11 +15,11 @@ const headerCell = require("./renderers/header-cell.js");
 const footer = require("./renderers/footer.js");
 const empty = require("./renderers/empty.js");
 const overlay = require("./renderers/overlay.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 TableV2 = /* @__PURE__ */ vue.defineComponent({
+const TableV2 = /* @__PURE__ */ Vue.defineComponent({
   name: "ElTableV2",
   props: table.tableV2Props,
   setup(props, { slots, expose }) {
@@ -32,25 +32,25 @@ const TableV2 = /* @__PURE__ */ vue.defineComponent({
       scrollToTop,
       scrollToRow
     });
-    vue.provide(tokens.TableV2InjectionKey, {
+    Vue.provide(tokens.TableV2InjectionKey, {
       ns,
       isResetting,
       isScrolling
     });
     return () => {
       const { cache, cellProps, estimatedRowHeight, expandColumnKey, fixedData, headerHeight, headerClass, headerProps, headerCellProps, sortBy, sortState, rowHeight, rowClass, rowEventHandlers, rowKey, rowProps, scrollbarAlwaysOn, indentSize, iconSize, useIsScrolling, vScrollbarSize, width } = props;
-      const _data = vue.unref(data);
+      const _data = Vue.unref(data);
       const mainTableProps = {
         cache,
         class: ns.e("main"),
-        columns: vue.unref(mainColumns),
+        columns: Vue.unref(mainColumns),
         data: _data,
         fixedData,
         estimatedRowHeight,
-        bodyWidth: vue.unref(bodyWidth),
+        bodyWidth: Vue.unref(bodyWidth),
         headerHeight,
-        headerWidth: vue.unref(bodyWidth),
-        height: vue.unref(mainTableHeight),
+        headerWidth: Vue.unref(bodyWidth),
+        height: Vue.unref(mainTableHeight),
         mainTableRef,
         rowKey,
         rowHeight,
@@ -63,12 +63,12 @@ const TableV2 = /* @__PURE__ */ vue.defineComponent({
         onRowsRendered,
         onScroll
       };
-      const leftColumnsWidth = vue.unref(leftTableWidth);
-      const _fixedTableHeight = vue.unref(fixedTableHeight);
+      const leftColumnsWidth = Vue.unref(leftTableWidth);
+      const _fixedTableHeight = Vue.unref(fixedTableHeight);
       const leftTableProps = {
         cache,
         class: ns.e("left"),
-        columns: vue.unref(fixedColumnsOnLeft),
+        columns: Vue.unref(fixedColumnsOnLeft),
         data: _data,
         fixedData,
         estimatedRowHeight,
@@ -87,11 +87,11 @@ const TableV2 = /* @__PURE__ */ vue.defineComponent({
         getRowHeight,
         onScroll: onVerticalScroll
       };
-      const rightColumnsWidth = vue.unref(rightTableWidth);
+      const rightColumnsWidth = Vue.unref(rightTableWidth);
       const rightTableProps = {
         cache,
         class: ns.e("right"),
-        columns: vue.unref(fixedColumnsOnRight),
+        columns: Vue.unref(fixedColumnsOnRight),
         data: _data,
         fixedData,
         estimatedRowHeight,
@@ -111,15 +111,15 @@ const TableV2 = /* @__PURE__ */ vue.defineComponent({
         getRowHeight,
         onScroll: onVerticalScroll
       };
-      const _columnsStyles = vue.unref(columnsStyles);
+      const _columnsStyles = Vue.unref(columnsStyles);
       const tableRowProps = {
         ns,
-        depthMap: vue.unref(depthMap),
+        depthMap: Vue.unref(depthMap),
         columnsStyles: _columnsStyles,
         expandColumnKey,
-        expandedRowKeys: vue.unref(expandedRowKeys),
+        expandedRowKeys: Vue.unref(expandedRowKeys),
         estimatedRowHeight,
-        hasFixedColumns: vue.unref(hasFixedColumns),
+        hasFixedColumns: Vue.unref(hasFixedColumns),
         rowProps,
         rowClass,
         rowKey,
@@ -134,7 +134,7 @@ const TableV2 = /* @__PURE__ */ vue.defineComponent({
         indentSize,
         iconSize,
         rowKey,
-        expandedRowKeys: vue.unref(expandedRowKeys),
+        expandedRowKeys: Vue.unref(expandedRowKeys),
         ns,
         t
       };
@@ -153,18 +153,18 @@ const TableV2 = /* @__PURE__ */ vue.defineComponent({
         onColumnSorted
       };
       const tableSlots = {
-        row: (props2) => vue.createVNode(row.default, vue.mergeProps(props2, tableRowProps), {
+        row: (props2) => Vue.createVNode(row.default, Vue.mergeProps(props2, tableRowProps), {
           row: slots.row,
           cell: (props3) => {
             let _slot;
-            return slots.cell ? vue.createVNode(cell.default, vue.mergeProps(props3, tableCellProps, { "style": _columnsStyles[props3.column.key] }), _isSlot(_slot = slots.cell(props3)) ? _slot : { default: () => [_slot] }) : vue.createVNode(cell.default, vue.mergeProps(props3, tableCellProps, { "style": _columnsStyles[props3.column.key] }), null);
+            return slots.cell ? Vue.createVNode(cell.default, Vue.mergeProps(props3, tableCellProps, { "style": _columnsStyles[props3.column.key] }), _isSlot(_slot = slots.cell(props3)) ? _slot : { default: () => [_slot] }) : Vue.createVNode(cell.default, Vue.mergeProps(props3, tableCellProps, { "style": _columnsStyles[props3.column.key] }), null);
           }
         }),
-        header: (props2) => vue.createVNode(header.default, vue.mergeProps(props2, tableHeaderProps), {
+        header: (props2) => Vue.createVNode(header.default, Vue.mergeProps(props2, tableHeaderProps), {
           header: slots.header,
           cell: (props3) => {
             let _slot2;
-            return slots["header-cell"] ? vue.createVNode(headerCell.default, vue.mergeProps(props3, tableHeaderCellProps, { "style": _columnsStyles[props3.column.key] }), _isSlot(_slot2 = slots["header-cell"](props3)) ? _slot2 : { default: () => [_slot2] }) : vue.createVNode(headerCell.default, vue.mergeProps(props3, tableHeaderCellProps, { "style": _columnsStyles[props3.column.key] }), null);
+            return slots["header-cell"] ? Vue.createVNode(headerCell.default, Vue.mergeProps(props3, tableHeaderCellProps, { "style": _columnsStyles[props3.column.key] }), _isSlot(_slot2 = slots["header-cell"](props3)) ? _slot2 : { default: () => [_slot2] }) : Vue.createVNode(headerCell.default, Vue.mergeProps(props3, tableHeaderCellProps, { "style": _columnsStyles[props3.column.key] }), null);
           }
         })
       };
@@ -172,25 +172,25 @@ const TableV2 = /* @__PURE__ */ vue.defineComponent({
         props.class,
         ns.b(),
         ns.e("root"),
-        ns.is("dynamic", vue.unref(isDynamic))
+        ns.is("dynamic", Vue.unref(isDynamic))
       ];
       const footerProps = {
         class: ns.e("footer"),
-        style: vue.unref(footerHeight)
+        style: Vue.unref(footerHeight)
       };
-      return vue.createVNode("div", {
+      return Vue.createVNode("div", {
         "class": rootKls,
-        "style": vue.unref(rootStyle)
+        "style": Vue.unref(rootStyle)
       }, [
-        vue.createVNode(mainTable.default, mainTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
-        vue.createVNode(leftTable.default, leftTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
-        vue.createVNode(rightTable.default, rightTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
-        slots.footer && vue.createVNode(footer.default, footerProps, { default: slots.footer }),
-        vue.unref(showEmpty) && vue.createVNode(empty.default, {
+        Vue.createVNode(mainTable.default, mainTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
+        Vue.createVNode(leftTable.default, leftTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
+        Vue.createVNode(rightTable.default, rightTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
+        slots.footer && Vue.createVNode(footer.default, footerProps, { default: slots.footer }),
+        Vue.unref(showEmpty) && Vue.createVNode(empty.default, {
           "class": ns.e("empty"),
-          "style": vue.unref(emptyStyle)
+          "style": Vue.unref(emptyStyle)
         }, { default: slots.empty }),
-        slots.overlay && vue.createVNode(overlay.default, { "class": ns.e("overlay") }, { default: slots.overlay })
+        slots.overlay && Vue.createVNode(overlay.default, { "class": ns.e("overlay") }, { default: slots.overlay })
       ]);
     };
   }

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

@@ -7,13 +7,13 @@ const useScrollbar = require("./composables/use-scrollbar.js");
 const useRow = require("./composables/use-row.js");
 const useData = require("./composables/use-data.js");
 const useStyles = require("./composables/use-styles.js");
-const vue = require("vue");
+const Vue = require("vue");
 const shared_esmBundler = require("../../../../../@vue/shared/dist/shared.esm-bundler.js");
 function useTable(props) {
-  const mainTableRef = vue.ref();
-  const leftTableRef = vue.ref();
-  const rightTableRef = vue.ref();
-  const { columns, columnsStyles, columnsTotalWidth, fixedColumnsOnLeft, fixedColumnsOnRight, hasFixedColumns, mainColumns, onColumnSorted } = useColumns.useColumns(props, vue.toRef(props, "columns"), vue.toRef(props, "fixed"));
+  const mainTableRef = Vue.ref();
+  const leftTableRef = Vue.ref();
+  const rightTableRef = Vue.ref();
+  const { columns, columnsStyles, columnsTotalWidth, fixedColumnsOnLeft, fixedColumnsOnRight, hasFixedColumns, mainColumns, onColumnSorted } = useColumns.useColumns(props, Vue.toRef(props, "columns"), Vue.toRef(props, "fixed"));
   const { scrollTo, scrollToLeft, scrollToTop, scrollToRow, onScroll, onVerticalScroll, scrollPos } = useScrollbar.useScrollbar(props, {
     mainTableRef,
     leftTableRef,
@@ -21,8 +21,8 @@ function useTable(props) {
     onMaybeEndReached
   });
   const ns = index.useNamespace("table-v2");
-  const instance = vue.getCurrentInstance();
-  const isScrolling = vue.shallowRef(false);
+  const instance = Vue.getCurrentInstance();
+  const isScrolling = Vue.shallowRef(false);
   const { expandedRowKeys, lastRenderedRowIndex, isDynamic, isResetting, rowHeights, resetAfterIndex, onRowExpanded, onRowHeightChange, onRowHovered, onRowsRendered } = useRow.useRow(props, {
     mainTableRef,
     leftTableRef,
@@ -36,10 +36,10 @@ function useTable(props) {
     lastRenderedRowIndex,
     resetAfterIndex
   });
-  const rowsHeight = vue.computed(() => {
+  const rowsHeight = Vue.computed(() => {
     const { estimatedRowHeight, rowHeight } = props;
-    const _data = vue.unref(data);
-    if (types.isNumber(estimatedRowHeight)) return Object.values(vue.unref(rowHeights)).reduce((acc, curr) => acc + curr, 0);
+    const _data = Vue.unref(data);
+    if (types.isNumber(estimatedRowHeight)) return Object.values(Vue.unref(rowHeights)).reduce((acc, curr) => acc + curr, 0);
     return _data.length * rowHeight;
   });
   const { bodyWidth, fixedTableHeight, mainTableHeight, leftTableWidth, rightTableWidth, windowHeight, footerHeight, emptyStyle, rootStyle, headerHeight } = useStyles.useStyles(props, {
@@ -48,30 +48,30 @@ function useTable(props) {
     fixedColumnsOnRight,
     rowsHeight
   });
-  const containerRef = vue.ref();
-  const showEmpty = vue.computed(() => {
-    const noData = vue.unref(data).length === 0;
+  const containerRef = Vue.ref();
+  const showEmpty = Vue.computed(() => {
+    const noData = Vue.unref(data).length === 0;
     return shared_esmBundler.isArray(props.fixedData) ? props.fixedData.length === 0 && noData : noData;
   });
   function getRowHeight(rowIndex) {
     const { estimatedRowHeight, rowHeight, rowKey } = props;
     if (!estimatedRowHeight) return rowHeight;
-    return vue.unref(rowHeights)[vue.unref(data)[rowIndex][rowKey]] || estimatedRowHeight;
+    return Vue.unref(rowHeights)[Vue.unref(data)[rowIndex][rowKey]] || estimatedRowHeight;
   }
-  const isEndReached = vue.ref(false);
+  const isEndReached = Vue.ref(false);
   function onMaybeEndReached() {
     const { onEndReached } = props;
     if (!onEndReached) return;
-    const { scrollTop } = vue.unref(scrollPos);
-    const _totalHeight = vue.unref(rowsHeight);
-    const remainDistance = _totalHeight - (scrollTop + vue.unref(windowHeight)) + props.hScrollbarSize;
-    if (!isEndReached.value && vue.unref(lastRenderedRowIndex) >= 0 && _totalHeight <= scrollTop + vue.unref(mainTableHeight) - vue.unref(headerHeight)) {
+    const { scrollTop } = Vue.unref(scrollPos);
+    const _totalHeight = Vue.unref(rowsHeight);
+    const remainDistance = _totalHeight - (scrollTop + Vue.unref(windowHeight)) + props.hScrollbarSize;
+    if (!isEndReached.value && Vue.unref(lastRenderedRowIndex) >= 0 && _totalHeight <= scrollTop + Vue.unref(mainTableHeight) - Vue.unref(headerHeight)) {
       isEndReached.value = true;
       onEndReached(remainDistance);
     } else isEndReached.value = false;
   }
-  vue.watch(() => vue.unref(rowsHeight), () => isEndReached.value = false);
-  vue.watch(() => props.expandedRowKeys, (val) => expandedRowKeys.value = val, { deep: true });
+  Vue.watch(() => Vue.unref(rowsHeight), () => isEndReached.value = false);
+  Vue.watch(() => props.expandedRowKeys, (val) => expandedRowKeys.value = val, { deep: true });
   return {
     columns,
     containerRef,

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const shared_esmBundler = require("../../../../../@vue/shared/dist/shared.esm-bundler.js");
 const style = require("../../../utils/dom/style.js");
-const vue = require("vue");
+const Vue = require("vue");
 const sumReducer = (sum2, num) => sum2 + num;
 const sum = (listLike) => {
   return shared_esmBundler.isArray(listLike) ? listLike.reduce(sumReducer, 0) : listLike;
@@ -21,7 +21,7 @@ const enforceUnit = (style$1) => {
   });
   return style$1;
 };
-const componentToSlot = (ComponentLike) => vue.isVNode(ComponentLike) ? (props) => vue.h(ComponentLike, props) : ComponentLike;
+const componentToSlot = (ComponentLike) => Vue.isVNode(ComponentLike) ? (props) => Vue.h(ComponentLike, props) : ComponentLike;
 exports.componentToSlot = componentToSlot;
 exports.enforceUnit = enforceUnit;
 exports.sum = sum;

package/lib/node_modules/element-plus/es/components/tabs/src/tab-bar.vue_vue_type_script_setup_true_lang.js

@@ -7,20 +7,20 @@ const index = require("../../../hooks/use-namespace/index.js");
 const constants = require("./constants.js");
 const tabBar = require("./tab-bar.js");
 const index$1 = require("../../../../node_modules/@vueuse/core/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const COMPONENT_NAME = "ElTabBar";
-var tab_bar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.defineComponent({
+var tab_bar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ Vue.defineComponent({
   name: COMPONENT_NAME,
   __name: "tab-bar",
   props: tabBar.tabBarProps,
   setup(__props, { expose: __expose }) {
     const props = __props;
-    const rootTabs = vue.inject(constants.tabsRootContextKey);
+    const rootTabs = Vue.inject(constants.tabsRootContextKey);
     if (!rootTabs) error.throwError(COMPONENT_NAME, "<el-tabs><el-tab-bar /></el-tabs>");
     const ns = index.useNamespace("tabs");
-    const barRef = vue.ref();
-    const barStyle = vue.ref();
-    const renderActiveBar = vue.computed(() => {
+    const barRef = Vue.ref();
+    const barStyle = Vue.ref();
+    const renderActiveBar = Vue.computed(() => {
       var _a;
       return types.isUndefined(rootTabs.props.defaultValue) || Boolean((_a = barStyle.value) == null ? void 0 : _a.transform);
     });
@@ -58,13 +58,13 @@ var tab_bar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.de
         tabObservers.push(index$1.useResizeObserver(tab, update));
       });
     };
-    vue.watch(() => props.tabs, async () => {
-      await vue.nextTick();
+    Vue.watch(() => props.tabs, async () => {
+      await Vue.nextTick();
       update();
       observerTabs();
     }, { immediate: true });
     const barObserver = index$1.useResizeObserver(barRef, () => update());
-    vue.onBeforeUnmount(() => {
+    Vue.onBeforeUnmount(() => {
       tabObservers.forEach((observer) => observer.stop());
       tabObservers.length = 0;
       barObserver.stop();
@@ -74,13 +74,13 @@ var tab_bar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.de
       update
     });
     return (_ctx, _cache) => {
-      return renderActiveBar.value ? (vue.openBlock(), vue.createElementBlock("div", {
+      return renderActiveBar.value ? (Vue.openBlock(), Vue.createElementBlock("div", {
         key: 0,
         ref_key: "barRef",
         ref: barRef,
-        class: vue.normalizeClass([vue.unref(ns).e("active-bar"), vue.unref(ns).is(vue.unref(rootTabs).props.tabPosition)]),
-        style: vue.normalizeStyle(barStyle.value)
-      }, null, 6)) : vue.createCommentVNode("v-if", true);
+        class: Vue.normalizeClass([Vue.unref(ns).e("active-bar"), Vue.unref(ns).is(Vue.unref(rootTabs).props.tabPosition)]),
+        style: Vue.normalizeStyle(barStyle.value)
+      }, null, 6)) : Vue.createCommentVNode("v-if", true);
     };
   }
 });

package/lib/node_modules/element-plus/es/components/tabs/src/tab-nav.js

@@ -14,7 +14,7 @@ const constants = require("./constants.js");
 const tabBar2 = require("./tab-bar2.js");
 const index$1 = require("../../../../node_modules/@vueuse/core/index.js");
 const index$3 = require("../../../../../@element-plus/icons-vue/dist/index.js");
-const vue = require("vue");
+const Vue = require("vue");
 const clamp = require("../../../../../lodash-es/clamp.js");
 const tabNavProps = runtime.buildProps({
   panes: {
@@ -46,30 +46,30 @@ const tabNavEmits = {
   tabRemove: (tab, ev) => ev instanceof Event
 };
 const COMPONENT_NAME = "ElTabNav";
-const TabNav = /* @__PURE__ */ vue.defineComponent({
+const TabNav = /* @__PURE__ */ Vue.defineComponent({
   name: COMPONENT_NAME,
   props: tabNavProps,
   emits: tabNavEmits,
   setup(props, { expose, emit }) {
-    const rootTabs = vue.inject(constants.tabsRootContextKey);
+    const rootTabs = Vue.inject(constants.tabsRootContextKey);
     if (!rootTabs) error.throwError(COMPONENT_NAME, `<el-tabs><tab-nav /></el-tabs>`);
     const ns = index.useNamespace("tabs");
     const visibility = index$1.useDocumentVisibility();
     const focused = index$1.useWindowFocus();
-    const navScroll$ = vue.ref();
-    const nav$ = vue.ref();
-    const el$ = vue.ref();
-    const tabRefsMap = vue.ref({});
-    const tabBarRef = vue.ref();
-    const scrollable = vue.ref(false);
-    const navOffset = vue.ref(0);
-    const isFocus = vue.ref(false);
-    const focusable = vue.ref(true);
-    const isWheelScrolling = vue.ref(false);
-    const tracker = vue.shallowRef();
-    const isHorizontal = vue.computed(() => ["top", "bottom"].includes(rootTabs.props.tabPosition));
-    const sizeName = vue.computed(() => isHorizontal.value ? "width" : "height");
-    const navStyle = vue.computed(() => {
+    const navScroll$ = Vue.ref();
+    const nav$ = Vue.ref();
+    const el$ = Vue.ref();
+    const tabRefsMap = Vue.ref({});
+    const tabBarRef = Vue.ref();
+    const scrollable = Vue.ref(false);
+    const navOffset = Vue.ref(0);
+    const isFocus = Vue.ref(false);
+    const focusable = Vue.ref(true);
+    const isWheelScrolling = Vue.ref(false);
+    const tracker = Vue.shallowRef();
+    const isHorizontal = Vue.computed(() => ["top", "bottom"].includes(rootTabs.props.tabPosition));
+    const sizeName = Vue.computed(() => isHorizontal.value ? "width" : "height");
+    const navStyle = Vue.computed(() => {
       const dir = sizeName.value === "width" ? "X" : "Y";
       return {
         transition: isWheelScrolling.value ? "none" : void 0,
@@ -81,12 +81,12 @@ const TabNav = /* @__PURE__ */ vue.defineComponent({
       width: 0,
       height: 0
     }, { box: "border-box" });
-    const navContainerSize = vue.computed(() => isHorizontal.value ? navContainerWidth.value : navContainerHeight.value);
-    const navSize = vue.computed(() => isHorizontal.value ? navWidth.value : navHeight.value);
+    const navContainerSize = Vue.computed(() => isHorizontal.value ? navContainerWidth.value : navContainerHeight.value);
+    const navSize = Vue.computed(() => isHorizontal.value ? navWidth.value : navHeight.value);
     const { onWheel } = useWheel.default({
-      atStartEdge: vue.computed(() => navOffset.value <= 0),
-      atEndEdge: vue.computed(() => navSize.value - navOffset.value <= navContainerSize.value),
-      layout: vue.computed(() => isHorizontal.value ? "horizontal" : "vertical")
+      atStartEdge: Vue.computed(() => navOffset.value <= 0),
+      atEndEdge: Vue.computed(() => navSize.value - navOffset.value <= navContainerSize.value),
+      layout: Vue.computed(() => isHorizontal.value ? "horizontal" : "vertical")
     }, (offset) => {
       navOffset.value = clamp.default(navOffset.value + offset, 0, navSize.value - navContainerSize.value);
     });
@@ -115,7 +115,7 @@ const TabNav = /* @__PURE__ */ vue.defineComponent({
     const scrollToActiveTab = async () => {
       const nav = nav$.value;
       if (!scrollable.value || !el$.value || !navScroll$.value || !nav) return;
-      await vue.nextTick();
+      await Vue.nextTick();
       const activeTab = tabRefsMap.value[props.currentName];
       if (!activeTab) return;
       const navScroll = navScroll$.value;
@@ -186,38 +186,38 @@ const TabNav = /* @__PURE__ */ vue.defineComponent({
     };
     const focusActiveTab = async () => {
       var _a;
-      await vue.nextTick();
+      await Vue.nextTick();
       (_a = tabRefsMap.value[props.currentName]) == null ? void 0 : _a.focus({ preventScroll: true });
     };
-    vue.watch(visibility, (visibility2) => {
+    Vue.watch(visibility, (visibility2) => {
       if (visibility2 === "hidden") focusable.value = false;
       else if (visibility2 === "visible") setTimeout(() => focusable.value = true, 50);
     });
-    vue.watch(focused, (focused2) => {
+    Vue.watch(focused, (focused2) => {
       if (focused2) setTimeout(() => focusable.value = true, 50);
       else focusable.value = false;
     });
     index$1.useResizeObserver(el$, () => {
       raf.rAF(update);
     });
-    vue.onMounted(() => setTimeout(() => scrollToActiveTab(), 0));
-    vue.onUpdated(() => update());
+    Vue.onMounted(() => setTimeout(() => scrollToActiveTab(), 0));
+    Vue.onUpdated(() => update());
     expose({
       scrollToActiveTab,
       removeFocus,
       focusActiveTab,
       tabListRef: nav$,
       tabBarRef,
-      scheduleRender: () => vue.triggerRef(tracker)
+      scheduleRender: () => Vue.triggerRef(tracker)
     });
     return () => {
-      const scrollBtn = scrollable.value ? [vue.createVNode("span", {
+      const scrollBtn = scrollable.value ? [Vue.createVNode("span", {
         "class": [ns.e("nav-prev"), ns.is("disabled", !scrollable.value.prev)],
         "onClick": scrollPrev
-      }, [vue.createVNode(index$2.ElIcon, null, { default: () => [vue.createVNode(index$3.ArrowLeft, null, null)] })]), vue.createVNode("span", {
+      }, [Vue.createVNode(index$2.ElIcon, null, { default: () => [Vue.createVNode(index$3.ArrowLeft, null, null)] })]), Vue.createVNode("span", {
         "class": [ns.e("nav-next"), ns.is("disabled", !scrollable.value.next)],
         "onClick": scrollNext
-      }, [vue.createVNode(index$2.ElIcon, null, { default: () => [vue.createVNode(index$3.ArrowRight, null, null)] })])] : null;
+      }, [Vue.createVNode(index$2.ElIcon, null, { default: () => [Vue.createVNode(index$3.ArrowRight, null, null)] })])] : null;
       const tabs = props.panes.map((pane, index2) => {
         var _a, _b;
         const uid = pane.uid;
@@ -225,13 +225,13 @@ const TabNav = /* @__PURE__ */ vue.defineComponent({
         const tabName = pane.props.name ?? pane.index ?? `${index2}`;
         const closable = !disabled && (pane.isClosable || pane.props.closable !== false && props.editable);
         pane.index = `${index2}`;
-        const btnClose = closable ? vue.createVNode(index$2.ElIcon, {
+        const btnClose = closable ? Vue.createVNode(index$2.ElIcon, {
           "class": "is-icon-close",
           "onClick": (ev) => emit("tabRemove", pane, ev)
-        }, { default: () => [vue.createVNode(index$3.Close, null, null)] }) : null;
+        }, { default: () => [Vue.createVNode(index$3.Close, null, null)] }) : null;
         const tabLabelContent = ((_b = (_a = pane.slots).label) == null ? void 0 : _b.call(_a)) || pane.props.label;
         const tabindex = !disabled && pane.active ? props.tabindex ?? rootTabs.props.tabindex : -1;
-        return vue.createVNode("div", {
+        return Vue.createVNode("div", {
           "ref": (el) => setRefs(el, tabName),
           "class": [
             ns.e("item"),
@@ -260,17 +260,17 @@ const TabNav = /* @__PURE__ */ vue.defineComponent({
         }, [...[tabLabelContent, btnClose]]);
       });
       tracker.value;
-      return vue.createVNode("div", {
+      return Vue.createVNode("div", {
         "ref": el$,
         "class": [
           ns.e("nav-wrap"),
           ns.is("scrollable", !!scrollable.value),
           ns.is(rootTabs.props.tabPosition)
         ]
-      }, [scrollBtn, vue.createVNode("div", {
+      }, [scrollBtn, Vue.createVNode("div", {
         "class": ns.e("nav-scroll"),
         "ref": navScroll$
-      }, [props.panes.length > 0 ? vue.createVNode("div", {
+      }, [props.panes.length > 0 ? Vue.createVNode("div", {
         "class": [
           ns.e("nav"),
           ns.is(rootTabs.props.tabPosition),
@@ -281,7 +281,7 @@ const TabNav = /* @__PURE__ */ vue.defineComponent({
         "role": "tablist",
         "onKeydown": changeTab,
         "onWheel": handleWheel
-      }, [...[!props.type ? vue.createVNode(tabBar2.default, {
+      }, [...[!props.type ? Vue.createVNode(tabBar2.default, {
         "ref": tabBarRef,
         "tabs": [...props.panes],
         "tabRefs": tabRefsMap.value