@fecp/mobile-designer 1.0.8 → 1.0.9

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 require$$1 = 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 = require$$1.ref();
+  const bodyRef = require$$1.ref();
+  const scrollLeft = require$$1.ref(0);
+  const totalHeight = require$$1.computed(() => {
     const { data, rowHeight, estimatedRowHeight } = props;
     if (estimatedRowHeight) return;
     return data.length * rowHeight;
   });
-  const fixedRowHeight = Vue.computed(() => {
+  const fixedRowHeight = require$$1.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 = require$$1.computed(() => utils.sum(props.headerHeight));
+  const gridHeight = require$$1.computed(() => {
     const { height } = props;
-    return Math.max(0, height - Vue.unref(headerHeight) - Vue.unref(fixedRowHeight));
+    return Math.max(0, height - require$$1.unref(headerHeight) - require$$1.unref(fixedRowHeight));
   });
-  const hasHeader = Vue.computed(() => {
-    return Vue.unref(headerHeight) + Vue.unref(fixedRowHeight) > 0;
+  const hasHeader = require$$1.computed(() => {
+    return require$$1.unref(headerHeight) + require$$1.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$ = require$$1.unref(headerRef);
+    const body$ = require$$1.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 = require$$1.unref(bodyRef)) == null ? void 0 : _a.scrollTo({ scrollTop });
   }
   function scrollToRow(row, strategy) {
-    const body = Vue.unref(bodyRef);
+    const body = require$$1.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 = require$$1.unref(bodyRef)) == null ? void 0 : _a.$forceUpdate();
+    (_b = require$$1.unref(headerRef)) == null ? void 0 : _b.$forceUpdate();
   }
-  Vue.watch(() => props.bodyWidth, () => {
+  require$$1.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__ */ require$$1.defineComponent({
   name: COMPONENT_NAME,
   props: grid.tableV2GridProps,
   setup(props, { slots, expose }) {
-    const { ns } = Vue.inject(tokens.TableV2InjectionKey);
+    const { ns } = require$$1.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 () => {
+    require$$1.provide(tokens.TABLE_V2_GRID_INJECTION_KEY, scrollLeft);
+    require$$1.onActivated(async () => {
       var _a;
-      await Vue.nextTick();
+      await require$$1.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 = require$$1.unref(headerHeight);
+      return require$$1.createVNode("div", {
         "role": "table",
         "class": [ns.e("table"), props.class],
         "style": style
-      }, [Vue.createVNode(Grid, {
+      }, [require$$1.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": require$$1.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, {
+      } }), require$$1.unref(hasHeader) && require$$1.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 + require$$1.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 require$$1 = 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]" && !require$$1.isVNode(s);
 }
-const TableV2 = /* @__PURE__ */ Vue.defineComponent({
+const TableV2 = /* @__PURE__ */ require$$1.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, {
+    require$$1.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 = require$$1.unref(data);
       const mainTableProps = {
         cache,
         class: ns.e("main"),
-        columns: Vue.unref(mainColumns),
+        columns: require$$1.unref(mainColumns),
         data: _data,
         fixedData,
         estimatedRowHeight,
-        bodyWidth: Vue.unref(bodyWidth),
+        bodyWidth: require$$1.unref(bodyWidth),
         headerHeight,
-        headerWidth: Vue.unref(bodyWidth),
-        height: Vue.unref(mainTableHeight),
+        headerWidth: require$$1.unref(bodyWidth),
+        height: require$$1.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 = require$$1.unref(leftTableWidth);
+      const _fixedTableHeight = require$$1.unref(fixedTableHeight);
       const leftTableProps = {
         cache,
         class: ns.e("left"),
-        columns: Vue.unref(fixedColumnsOnLeft),
+        columns: require$$1.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 = require$$1.unref(rightTableWidth);
       const rightTableProps = {
         cache,
         class: ns.e("right"),
-        columns: Vue.unref(fixedColumnsOnRight),
+        columns: require$$1.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 = require$$1.unref(columnsStyles);
       const tableRowProps = {
         ns,
-        depthMap: Vue.unref(depthMap),
+        depthMap: require$$1.unref(depthMap),
         columnsStyles: _columnsStyles,
         expandColumnKey,
-        expandedRowKeys: Vue.unref(expandedRowKeys),
+        expandedRowKeys: require$$1.unref(expandedRowKeys),
         estimatedRowHeight,
-        hasFixedColumns: Vue.unref(hasFixedColumns),
+        hasFixedColumns: require$$1.unref(hasFixedColumns),
         rowProps,
         rowClass,
         rowKey,
@@ -134,7 +134,7 @@ const TableV2 = /* @__PURE__ */ Vue.defineComponent({
         indentSize,
         iconSize,
         rowKey,
-        expandedRowKeys: Vue.unref(expandedRowKeys),
+        expandedRowKeys: require$$1.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) => require$$1.createVNode(row.default, require$$1.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 ? require$$1.createVNode(cell.default, require$$1.mergeProps(props3, tableCellProps, { "style": _columnsStyles[props3.column.key] }), _isSlot(_slot = slots.cell(props3)) ? _slot : { default: () => [_slot] }) : require$$1.createVNode(cell.default, require$$1.mergeProps(props3, tableCellProps, { "style": _columnsStyles[props3.column.key] }), null);
           }
         }),
-        header: (props2) => Vue.createVNode(header.default, Vue.mergeProps(props2, tableHeaderProps), {
+        header: (props2) => require$$1.createVNode(header.default, require$$1.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"] ? require$$1.createVNode(headerCell.default, require$$1.mergeProps(props3, tableHeaderCellProps, { "style": _columnsStyles[props3.column.key] }), _isSlot(_slot2 = slots["header-cell"](props3)) ? _slot2 : { default: () => [_slot2] }) : require$$1.createVNode(headerCell.default, require$$1.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", require$$1.unref(isDynamic))
       ];
       const footerProps = {
         class: ns.e("footer"),
-        style: Vue.unref(footerHeight)
+        style: require$$1.unref(footerHeight)
       };
-      return Vue.createVNode("div", {
+      return require$$1.createVNode("div", {
         "class": rootKls,
-        "style": Vue.unref(rootStyle)
+        "style": require$$1.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, {
+        require$$1.createVNode(mainTable.default, mainTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
+        require$$1.createVNode(leftTable.default, leftTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
+        require$$1.createVNode(rightTable.default, rightTableProps, _isSlot(tableSlots) ? tableSlots : { default: () => [tableSlots] }),
+        slots.footer && require$$1.createVNode(footer.default, footerProps, { default: slots.footer }),
+        require$$1.unref(showEmpty) && require$$1.createVNode(empty.default, {
           "class": ns.e("empty"),
-          "style": Vue.unref(emptyStyle)
+          "style": require$$1.unref(emptyStyle)
         }, { default: slots.empty }),
-        slots.overlay && Vue.createVNode(overlay.default, { "class": ns.e("overlay") }, { default: slots.overlay })
+        slots.overlay && require$$1.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 require$$1 = 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 = require$$1.ref();
+  const leftTableRef = require$$1.ref();
+  const rightTableRef = require$$1.ref();
+  const { columns, columnsStyles, columnsTotalWidth, fixedColumnsOnLeft, fixedColumnsOnRight, hasFixedColumns, mainColumns, onColumnSorted } = useColumns.useColumns(props, require$$1.toRef(props, "columns"), require$$1.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 = require$$1.getCurrentInstance();
+  const isScrolling = require$$1.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 = require$$1.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 = require$$1.unref(data);
+    if (types.isNumber(estimatedRowHeight)) return Object.values(require$$1.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 = require$$1.ref();
+  const showEmpty = require$$1.computed(() => {
+    const noData = require$$1.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 require$$1.unref(rowHeights)[require$$1.unref(data)[rowIndex][rowKey]] || estimatedRowHeight;
   }
-  const isEndReached = Vue.ref(false);
+  const isEndReached = require$$1.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 } = require$$1.unref(scrollPos);
+    const _totalHeight = require$$1.unref(rowsHeight);
+    const remainDistance = _totalHeight - (scrollTop + require$$1.unref(windowHeight)) + props.hScrollbarSize;
+    if (!isEndReached.value && require$$1.unref(lastRenderedRowIndex) >= 0 && _totalHeight <= scrollTop + require$$1.unref(mainTableHeight) - require$$1.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 });
+  require$$1.watch(() => require$$1.unref(rowsHeight), () => isEndReached.value = false);
+  require$$1.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 require$$1 = 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) => require$$1.isVNode(ComponentLike) ? (props) => require$$1.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 require$$1 = 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__ */ require$$1.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 = require$$1.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 = require$$1.ref();
+    const barStyle = require$$1.ref();
+    const renderActiveBar = require$$1.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();
+    require$$1.watch(() => props.tabs, async () => {
+      await require$$1.nextTick();
       update();
       observerTabs();
     }, { immediate: true });
     const barObserver = index$1.useResizeObserver(barRef, () => update());
-    Vue.onBeforeUnmount(() => {
+    require$$1.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 ? (require$$1.openBlock(), require$$1.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: require$$1.normalizeClass([require$$1.unref(ns).e("active-bar"), require$$1.unref(ns).is(require$$1.unref(rootTabs).props.tabPosition)]),
+        style: require$$1.normalizeStyle(barStyle.value)
+      }, null, 6)) : require$$1.createCommentVNode("v-if", true);
     };
   }
 });