agentworkshop 0.8.2 → 0.8.4

package/.output/server/chunks/build/tabs-BCwBXjNt.mjs

@@ -0,0 +1,1838 @@
+import { aT as Icon, m as flattenChildren, r as _objectSpread2, Z as omit, v as initDefaultProps, S as isValidElement, o as _extends, bd as camelize, A as devWarning_default, k as useConfigInject_default, be as useState, B as CloseOutlined, q as classNames, $ as arrayType, P as PropTypes, J as functionType, G as objectType, E as stringType, I as booleanType, F as someType, x as genComponentStyleHook, bf as toPx, p as cloneElement, ag as KeyCode, y as merge, K as resetComponent, ak as textEllipsis, Q as genFocusStyle, a1 as isObject } from '../virtual/entry.mjs';
+import { u as useMergedState, w as wrapperRaf } from './firstNotUndefined-laiThpLD.mjs';
+import { o as vc_resize_observer_default, i as initSlideMotion } from '../_/SearchOutlined.mjs';
+import { f as flatRest, e as baseGet, c as castPath, t as toKey, j as isIndex, b as assignValue, h as hasIn } from './hasIn-RYRGomyg.mjs';
+import { u as useProvideOverride, E as EllipsisOutlined, v as vc_dropdown_default, m as menu_default, M as MenuItem_default } from './menu-xO8ocVtL.mjs';
+import { createVNode, defineComponent, ref, watch, computed, watchEffect, provide, shallowRef, inject, toRefs } from 'vue';
+
+// This icon file is generated automatically.
+var PlusOutlined$1 = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M482 152h60q8 0 8 8v704q0 8-8 8h-60q-8 0-8-8V160q0-8 8-8z" } }, { "tag": "path", "attrs": { "d": "M192 474h672q8 0 8 8v60q0 8-8 8H160q-8 0-8-8v-60q0-8 8-8z" } }] }, "name": "plus", "theme": "outlined" };
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var PlusOutlined = function PlusOutlined(props, context) {
+  var p = _objectSpread({}, props, context.attrs);
+
+  return createVNode(Icon, _objectSpread({}, p, {
+    "icon": PlusOutlined$1
+  }), null);
+};
+
+PlusOutlined.displayName = 'PlusOutlined';
+PlusOutlined.inheritAttrs = false;
+
+function baseSet(object, path, value, customizer) {
+  if (!isObject(object)) return object;
+  path = castPath(path, object);
+  var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+  while (nested != null && ++index < length) {
+    var key = toKey(path[index]), newValue = value;
+    if (key === "__proto__" || key === "constructor" || key === "prototype") return object;
+    if (index != lastIndex) {
+      var objValue = nested[key];
+      newValue = void 0;
+      if (newValue === void 0) newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+    }
+    assignValue(nested, key, newValue);
+    nested = nested[key];
+  }
+  return object;
+}
+function basePickBy(object, paths, predicate) {
+  var index = -1, length = paths.length, result = {};
+  while (++index < length) {
+    var path = paths[index], value = baseGet(object, path);
+    if (predicate(value, path)) baseSet(result, castPath(path, object), value);
+  }
+  return result;
+}
+function basePick(object, paths) {
+  return basePickBy(object, paths, function(value, path) {
+    return hasIn(object, path);
+  });
+}
+var pick = flatRest(function(object, paths) {
+  return object == null ? {} : basePick(object, paths);
+});
+function useRaf(callback) {
+  const rafRef = shallowRef();
+  const removedRef = shallowRef(false);
+  function trigger() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+    if (!removedRef.value) {
+      wrapperRaf.cancel(rafRef.value);
+      rafRef.value = wrapperRaf(() => {
+        callback(...args);
+      });
+    }
+  }
+  return trigger;
+}
+function useRafState(defaultState) {
+  const batchRef = shallowRef([]);
+  const state = shallowRef(typeof defaultState === "function" ? defaultState() : defaultState);
+  const flushUpdate = useRaf(() => {
+    let value = state.value;
+    batchRef.value.forEach((callback) => {
+      value = callback(value);
+    });
+    batchRef.value = [];
+    state.value = value;
+  });
+  function updater(callback) {
+    batchRef.value.push(callback);
+    flushUpdate();
+  }
+  return [state, updater];
+}
+var TabNode_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "TabNode",
+  props: {
+    id: { type: String },
+    prefixCls: { type: String },
+    tab: { type: Object },
+    active: { type: Boolean },
+    closable: { type: Boolean },
+    editable: { type: Object },
+    onClick: { type: Function },
+    onResize: { type: Function },
+    renderWrapper: { type: Function },
+    removeAriaLabel: { type: String },
+    onFocus: { type: Function }
+  },
+  emits: [
+    "click",
+    "resize",
+    "remove",
+    "focus"
+  ],
+  setup(props, _ref) {
+    let { expose, attrs } = _ref;
+    const domRef = ref();
+    function onInternalClick(e) {
+      var _a;
+      if ((_a = props.tab) === null || _a === void 0 ? void 0 : _a.disabled) return;
+      props.onClick(e);
+    }
+    expose({ domRef });
+    function onRemoveTab(event) {
+      var _a;
+      event.preventDefault();
+      event.stopPropagation();
+      props.editable.onEdit("remove", {
+        key: (_a = props.tab) === null || _a === void 0 ? void 0 : _a.key,
+        event
+      });
+    }
+    const removable = computed(() => {
+      var _a;
+      return props.editable && props.closable !== false && !((_a = props.tab) === null || _a === void 0 ? void 0 : _a.disabled);
+    });
+    return () => {
+      var _a;
+      const { prefixCls, id, active, tab: { key, tab, disabled, closeIcon }, renderWrapper, removeAriaLabel, editable, onFocus } = props;
+      const tabPrefix = `${prefixCls}-tab`;
+      const node = createVNode("div", {
+        "key": key,
+        "ref": domRef,
+        "class": classNames(tabPrefix, {
+          [`${tabPrefix}-with-remove`]: removable.value,
+          [`${tabPrefix}-active`]: active,
+          [`${tabPrefix}-disabled`]: disabled
+        }),
+        "style": attrs.style,
+        "onClick": onInternalClick
+      }, [createVNode("div", {
+        "role": "tab",
+        "aria-selected": active,
+        "id": id && `${id}-tab-${key}`,
+        "class": `${tabPrefix}-btn`,
+        "aria-controls": id && `${id}-panel-${key}`,
+        "aria-disabled": disabled,
+        "tabindex": disabled ? null : 0,
+        "onClick": (e) => {
+          e.stopPropagation();
+          onInternalClick(e);
+        },
+        "onKeydown": (e) => {
+          if ([KeyCode.SPACE, KeyCode.ENTER].includes(e.which)) {
+            e.preventDefault();
+            onInternalClick(e);
+          }
+        },
+        "onFocus": onFocus
+      }, [typeof tab === "function" ? tab() : tab]), removable.value && createVNode("button", {
+        "type": "button",
+        "aria-label": removeAriaLabel || "remove",
+        "tabindex": 0,
+        "class": `${tabPrefix}-remove`,
+        "onClick": (e) => {
+          e.stopPropagation();
+          onRemoveTab(e);
+        }
+      }, [(closeIcon === null || closeIcon === void 0 ? void 0 : closeIcon()) || ((_a = editable.removeIcon) === null || _a === void 0 ? void 0 : _a.call(editable)) || "\xD7"])]);
+      return renderWrapper ? renderWrapper(node) : node;
+    };
+  }
+});
+var DEFAULT_SIZE$1 = {
+  width: 0,
+  height: 0,
+  left: 0,
+  top: 0
+};
+function useOffsets(tabs, tabSizes) {
+  const offsetMap = ref(/* @__PURE__ */ new Map());
+  watchEffect(() => {
+    var _a, _b;
+    const map = /* @__PURE__ */ new Map();
+    const tabsValue = tabs.value;
+    const lastOffset = tabSizes.value.get((_a = tabsValue[0]) === null || _a === void 0 ? void 0 : _a.key) || DEFAULT_SIZE$1;
+    const rightOffset = lastOffset.left + lastOffset.width;
+    for (let i = 0; i < tabsValue.length; i += 1) {
+      const { key } = tabsValue[i];
+      let data = tabSizes.value.get(key);
+      if (!data) data = tabSizes.value.get((_b = tabsValue[i - 1]) === null || _b === void 0 ? void 0 : _b.key) || DEFAULT_SIZE$1;
+      const entity = map.get(key) || _extends({}, data);
+      entity.right = rightOffset - entity.left - entity.width;
+      map.set(key, entity);
+    }
+    offsetMap.value = new Map(map);
+  });
+  return offsetMap;
+}
+var AddButton_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "AddButton",
+  inheritAttrs: false,
+  props: {
+    prefixCls: String,
+    editable: { type: Object },
+    locale: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props, _ref) {
+    let { expose, attrs } = _ref;
+    const domRef = ref();
+    expose({ domRef });
+    return () => {
+      const { prefixCls, editable, locale } = props;
+      if (!editable || editable.showAdd === false) return null;
+      return createVNode("button", {
+        "ref": domRef,
+        "type": "button",
+        "class": `${prefixCls}-nav-add`,
+        "style": attrs.style,
+        "aria-label": (locale === null || locale === void 0 ? void 0 : locale.addAriaLabel) || "Add tab",
+        "onClick": (event) => {
+          editable.onEdit("add", { event });
+        }
+      }, [editable.addIcon ? editable.addIcon() : "+"]);
+    };
+  }
+});
+var operationNodeProps = {
+  prefixCls: { type: String },
+  id: { type: String },
+  tabs: { type: Object },
+  rtl: { type: Boolean },
+  tabBarGutter: { type: Number },
+  activeKey: { type: [String, Number] },
+  mobile: { type: Boolean },
+  moreIcon: PropTypes.any,
+  moreTransitionName: { type: String },
+  editable: { type: Object },
+  locale: {
+    type: Object,
+    default: void 0
+  },
+  removeAriaLabel: String,
+  onTabClick: { type: Function },
+  popupClassName: String,
+  getPopupContainer: functionType()
+};
+var OperationNode_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "OperationNode",
+  inheritAttrs: false,
+  props: operationNodeProps,
+  emits: ["tabClick"],
+  slots: Object,
+  setup(props, _ref) {
+    let { attrs, slots } = _ref;
+    const [open, setOpen] = useState(false);
+    const [selectedKey, setSelectedKey] = useState(null);
+    const selectOffset = (offset) => {
+      const enabledTabs = props.tabs.filter((tab) => !tab.disabled);
+      let selectedIndex = enabledTabs.findIndex((tab) => tab.key === selectedKey.value) || 0;
+      const len = enabledTabs.length;
+      for (let i = 0; i < len; i += 1) {
+        selectedIndex = (selectedIndex + offset + len) % len;
+        const tab = enabledTabs[selectedIndex];
+        if (!tab.disabled) {
+          setSelectedKey(tab.key);
+          return;
+        }
+      }
+    };
+    const onKeyDown = (e) => {
+      const { which } = e;
+      if (!open.value) {
+        if ([
+          KeyCode.DOWN,
+          KeyCode.SPACE,
+          KeyCode.ENTER
+        ].includes(which)) {
+          setOpen(true);
+          e.preventDefault();
+        }
+        return;
+      }
+      switch (which) {
+        case KeyCode.UP:
+          selectOffset(-1);
+          e.preventDefault();
+          break;
+        case KeyCode.DOWN:
+          selectOffset(1);
+          e.preventDefault();
+          break;
+        case KeyCode.ESC:
+          setOpen(false);
+          break;
+        case KeyCode.SPACE:
+        case KeyCode.ENTER:
+          if (selectedKey.value !== null) props.onTabClick(selectedKey.value, e);
+      }
+    };
+    const popupId = computed(() => `${props.id}-more-popup`);
+    const selectedItemId = computed(() => selectedKey.value !== null ? `${popupId.value}-${selectedKey.value}` : null);
+    const onRemoveTab = (event, key) => {
+      event.preventDefault();
+      event.stopPropagation();
+      props.editable.onEdit("remove", {
+        key,
+        event
+      });
+    };
+    watch(open, () => {
+      if (!open.value) setSelectedKey(null);
+    });
+    useProvideOverride({});
+    return () => {
+      var _a;
+      const { prefixCls, id, tabs, locale, mobile, moreIcon = ((_a = slots.moreIcon) === null || _a === void 0 ? void 0 : _a.call(slots)) || createVNode(EllipsisOutlined, null, null), moreTransitionName, editable, tabBarGutter, rtl, onTabClick, popupClassName } = props;
+      if (!tabs.length) return null;
+      const dropdownPrefix = `${prefixCls}-dropdown`;
+      const dropdownAriaLabel = locale === null || locale === void 0 ? void 0 : locale.dropdownAriaLabel;
+      const moreStyle = { [rtl ? "marginRight" : "marginLeft"]: tabBarGutter };
+      if (!tabs.length) {
+        moreStyle.visibility = "hidden";
+        moreStyle.order = 1;
+      }
+      const overlayClassName = classNames({
+        [`${dropdownPrefix}-rtl`]: rtl,
+        [`${popupClassName}`]: true
+      });
+      const moreNode = mobile ? null : createVNode(vc_dropdown_default, {
+        "prefixCls": dropdownPrefix,
+        "trigger": ["hover"],
+        "visible": open.value,
+        "transitionName": moreTransitionName,
+        "onVisibleChange": setOpen,
+        "overlayClassName": overlayClassName,
+        "mouseEnterDelay": 0.1,
+        "mouseLeaveDelay": 0.1,
+        "getPopupContainer": props.getPopupContainer
+      }, {
+        overlay: () => createVNode(menu_default, {
+          "onClick": (_ref2) => {
+            let { key, domEvent } = _ref2;
+            onTabClick(key, domEvent);
+            setOpen(false);
+          },
+          "id": popupId.value,
+          "tabindex": -1,
+          "role": "listbox",
+          "aria-activedescendant": selectedItemId.value,
+          "selectedKeys": [selectedKey.value],
+          "aria-label": dropdownAriaLabel !== void 0 ? dropdownAriaLabel : "expanded dropdown"
+        }, { default: () => [tabs.map((tab) => {
+          var _a2, _b;
+          const removable = editable && tab.closable !== false && !tab.disabled;
+          return createVNode(MenuItem_default, {
+            "key": tab.key,
+            "id": `${popupId.value}-${tab.key}`,
+            "role": "option",
+            "aria-controls": id && `${id}-panel-${tab.key}`,
+            "disabled": tab.disabled
+          }, { default: () => [createVNode("span", null, [typeof tab.tab === "function" ? tab.tab() : tab.tab]), removable && createVNode("button", {
+            "type": "button",
+            "aria-label": props.removeAriaLabel || "remove",
+            "tabindex": 0,
+            "class": `${dropdownPrefix}-menu-item-remove`,
+            "onClick": (e) => {
+              e.stopPropagation();
+              onRemoveTab(e, tab.key);
+            }
+          }, [((_a2 = tab.closeIcon) === null || _a2 === void 0 ? void 0 : _a2.call(tab)) || ((_b = editable.removeIcon) === null || _b === void 0 ? void 0 : _b.call(editable)) || "\xD7"])] });
+        })] }),
+        default: () => createVNode("button", {
+          "type": "button",
+          "class": `${prefixCls}-nav-more`,
+          "style": moreStyle,
+          "tabindex": -1,
+          "aria-hidden": "true",
+          "aria-haspopup": "listbox",
+          "aria-controls": popupId.value,
+          "id": `${id}-more`,
+          "aria-expanded": open.value,
+          "onKeydown": onKeyDown
+        }, [moreIcon])
+      });
+      return createVNode("div", {
+        "class": classNames(`${prefixCls}-nav-operations`, attrs.class),
+        "style": attrs.style
+      }, [moreNode, createVNode(AddButton_default, {
+        "prefixCls": prefixCls,
+        "locale": locale,
+        "editable": editable
+      }, null)]);
+    };
+  }
+});
+var TabsContextKey = /* @__PURE__ */ Symbol("tabsContextKey");
+var useProvideTabs = (props) => {
+  provide(TabsContextKey, props);
+};
+var useInjectTabs = () => {
+  return inject(TabsContextKey, {
+    tabs: ref([]),
+    prefixCls: ref()
+  });
+};
+defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "TabsContextProvider",
+  inheritAttrs: false,
+  props: {
+    tabs: {
+      type: Object,
+      default: void 0
+    },
+    prefixCls: {
+      type: String,
+      default: void 0
+    }
+  },
+  setup(props, _ref) {
+    let { slots } = _ref;
+    useProvideTabs(toRefs(props));
+    return () => {
+      var _a;
+      return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
+    };
+  }
+});
+var MIN_SWIPE_DISTANCE = 0.1;
+var STOP_SWIPE_DISTANCE = 0.01;
+var REFRESH_INTERVAL = 20;
+var SPEED_OFF_MULTIPLE = Math.pow(0.995, REFRESH_INTERVAL);
+function useTouchMove(domRef, onOffset) {
+  const [touchPosition, setTouchPosition] = useState();
+  const [lastTimestamp, setLastTimestamp] = useState(0);
+  const [lastTimeDiff, setLastTimeDiff] = useState(0);
+  const [lastOffset, setLastOffset] = useState();
+  const motionInterval = ref();
+  function onTouchStart(e) {
+    const { screenX, screenY } = e.touches[0];
+    setTouchPosition({
+      x: screenX,
+      y: screenY
+    });
+    clearInterval(motionInterval.value);
+  }
+  function onTouchMove(e) {
+    if (!touchPosition.value) return;
+    e.preventDefault();
+    const { screenX, screenY } = e.touches[0];
+    const offsetX = screenX - touchPosition.value.x;
+    const offsetY = screenY - touchPosition.value.y;
+    onOffset(offsetX, offsetY);
+    setTouchPosition({
+      x: screenX,
+      y: screenY
+    });
+    const now = Date.now();
+    setLastTimeDiff(now - lastTimestamp.value);
+    setLastTimestamp(now);
+    setLastOffset({
+      x: offsetX,
+      y: offsetY
+    });
+  }
+  function onTouchEnd() {
+    if (!touchPosition.value) return;
+    const lastOffsetValue = lastOffset.value;
+    setTouchPosition(null);
+    setLastOffset(null);
+    if (lastOffsetValue) {
+      const distanceX = lastOffsetValue.x / lastTimeDiff.value;
+      const distanceY = lastOffsetValue.y / lastTimeDiff.value;
+      if (Math.max(Math.abs(distanceX), Math.abs(distanceY)) < MIN_SWIPE_DISTANCE) return;
+      let currentX = distanceX;
+      let currentY = distanceY;
+      motionInterval.value = setInterval(() => {
+        if (Math.abs(currentX) < STOP_SWIPE_DISTANCE && Math.abs(currentY) < STOP_SWIPE_DISTANCE) {
+          clearInterval(motionInterval.value);
+          return;
+        }
+        currentX *= SPEED_OFF_MULTIPLE;
+        currentY *= SPEED_OFF_MULTIPLE;
+        onOffset(currentX * REFRESH_INTERVAL, currentY * REFRESH_INTERVAL);
+      }, REFRESH_INTERVAL);
+    }
+  }
+  const lastWheelDirectionRef = ref();
+  function onWheel(e) {
+    const { deltaX, deltaY } = e;
+    let mixed = 0;
+    const absX = Math.abs(deltaX);
+    const absY = Math.abs(deltaY);
+    if (absX === absY) mixed = lastWheelDirectionRef.value === "x" ? deltaX : deltaY;
+    else if (absX > absY) {
+      mixed = deltaX;
+      lastWheelDirectionRef.value = "x";
+    } else {
+      mixed = deltaY;
+      lastWheelDirectionRef.value = "y";
+    }
+    if (onOffset(-mixed, -mixed)) e.preventDefault();
+  }
+  ref({
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+    onWheel
+  });
+}
+function useSyncState(defaultState, onChange) {
+  const stateRef = ref(defaultState);
+  function setState(updater) {
+    const newValue = typeof updater === "function" ? updater(stateRef.value) : updater;
+    if (newValue !== stateRef.value) onChange(newValue, stateRef.value);
+    stateRef.value = newValue;
+  }
+  return [stateRef, setState];
+}
+var useRefs = () => {
+  const refs = ref(/* @__PURE__ */ new Map());
+  const setRef = (key) => (el) => {
+    refs.value.set(key, el);
+  };
+  return [setRef, refs];
+};
+var DEFAULT_SIZE = {
+  width: 0,
+  height: 0,
+  left: 0,
+  top: 0,
+  right: 0
+};
+var tabNavListProps = () => {
+  return {
+    id: { type: String },
+    tabPosition: { type: String },
+    activeKey: { type: [String, Number] },
+    rtl: { type: Boolean },
+    animated: objectType(),
+    editable: objectType(),
+    moreIcon: PropTypes.any,
+    moreTransitionName: { type: String },
+    mobile: { type: Boolean },
+    tabBarGutter: { type: Number },
+    renderTabBar: { type: Function },
+    locale: objectType(),
+    popupClassName: String,
+    getPopupContainer: functionType(),
+    onTabClick: { type: Function },
+    onTabScroll: { type: Function }
+  };
+};
+var getTabSize = (tab, containerRect) => {
+  const { offsetWidth, offsetHeight, offsetTop, offsetLeft } = tab;
+  const { width, height, x, y } = tab.getBoundingClientRect();
+  if (Math.abs(width - offsetWidth) < 1) return [
+    width,
+    height,
+    x - containerRect.x,
+    y - containerRect.y
+  ];
+  return [
+    offsetWidth,
+    offsetHeight,
+    offsetLeft,
+    offsetTop
+  ];
+};
+var TabNavList_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "TabNavList",
+  inheritAttrs: false,
+  props: tabNavListProps(),
+  slots: Object,
+  emits: ["tabClick", "tabScroll"],
+  setup(props, _ref) {
+    let { attrs, slots } = _ref;
+    const { tabs, prefixCls } = useInjectTabs();
+    const tabsWrapperRef = shallowRef();
+    const tabListRef = shallowRef();
+    const operationsRef = shallowRef();
+    const innerAddButtonRef = shallowRef();
+    const [setRef, btnRefs] = useRefs();
+    const tabPositionTopOrBottom = computed(() => props.tabPosition === "top" || props.tabPosition === "bottom");
+    const [transformLeft, setTransformLeft] = useSyncState(0, (next, prev) => {
+      if (tabPositionTopOrBottom.value && props.onTabScroll) props.onTabScroll({ direction: next > prev ? "left" : "right" });
+    });
+    const [transformTop, setTransformTop] = useSyncState(0, (next, prev) => {
+      if (!tabPositionTopOrBottom.value && props.onTabScroll) props.onTabScroll({ direction: next > prev ? "top" : "bottom" });
+    });
+    const [wrapperScrollWidth, setWrapperScrollWidth] = useState(0);
+    const [wrapperScrollHeight, setWrapperScrollHeight] = useState(0);
+    const [wrapperWidth, setWrapperWidth] = useState(null);
+    const [wrapperHeight, setWrapperHeight] = useState(null);
+    const [addWidth, setAddWidth] = useState(0);
+    const [addHeight, setAddHeight] = useState(0);
+    const [tabSizes, setTabSizes] = useRafState(/* @__PURE__ */ new Map());
+    const tabOffsets = useOffsets(tabs, tabSizes);
+    const operationsHiddenClassName = computed(() => `${prefixCls.value}-nav-operations-hidden`);
+    const transformMin = shallowRef(0);
+    const transformMax = shallowRef(0);
+    watchEffect(() => {
+      if (!tabPositionTopOrBottom.value) {
+        transformMin.value = Math.min(0, wrapperHeight.value - wrapperScrollHeight.value);
+        transformMax.value = 0;
+      } else if (props.rtl) {
+        transformMin.value = 0;
+        transformMax.value = Math.max(0, wrapperScrollWidth.value - wrapperWidth.value);
+      } else {
+        transformMin.value = Math.min(0, wrapperWidth.value - wrapperScrollWidth.value);
+        transformMax.value = 0;
+      }
+    });
+    const alignInRange = (value) => {
+      if (value < transformMin.value) return transformMin.value;
+      if (value > transformMax.value) return transformMax.value;
+      return value;
+    };
+    const touchMovingRef = shallowRef();
+    const [lockAnimation, setLockAnimation] = useState();
+    const doLockAnimation = () => {
+      setLockAnimation(Date.now());
+    };
+    const clearTouchMoving = () => {
+      clearTimeout(touchMovingRef.value);
+    };
+    const doMove = (setState, offset) => {
+      setState((value) => {
+        return alignInRange(value + offset);
+      });
+    };
+    useTouchMove(tabsWrapperRef, (offsetX, offsetY) => {
+      if (tabPositionTopOrBottom.value) {
+        if (wrapperWidth.value >= wrapperScrollWidth.value) return false;
+        doMove(setTransformLeft, offsetX);
+      } else {
+        if (wrapperHeight.value >= wrapperScrollHeight.value) return false;
+        doMove(setTransformTop, offsetY);
+      }
+      clearTouchMoving();
+      doLockAnimation();
+      return true;
+    });
+    watch(lockAnimation, () => {
+      clearTouchMoving();
+      if (lockAnimation.value) touchMovingRef.value = setTimeout(() => {
+        setLockAnimation(0);
+      }, 100);
+    });
+    const scrollToTab = function() {
+      let key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : props.activeKey;
+      const tabOffset = tabOffsets.value.get(key) || {
+        width: 0,
+        height: 0,
+        left: 0,
+        right: 0,
+        top: 0
+      };
+      if (tabPositionTopOrBottom.value) {
+        let newTransform = transformLeft.value;
+        if (props.rtl) {
+          if (tabOffset.right < transformLeft.value) newTransform = tabOffset.right;
+          else if (tabOffset.right + tabOffset.width > transformLeft.value + wrapperWidth.value) newTransform = tabOffset.right + tabOffset.width - wrapperWidth.value;
+        } else if (tabOffset.left < -transformLeft.value) newTransform = -tabOffset.left;
+        else if (tabOffset.left + tabOffset.width > -transformLeft.value + wrapperWidth.value) newTransform = -(tabOffset.left + tabOffset.width - wrapperWidth.value);
+        setTransformTop(0);
+        setTransformLeft(alignInRange(newTransform));
+      } else {
+        let newTransform = transformTop.value;
+        if (tabOffset.top < -transformTop.value) newTransform = -tabOffset.top;
+        else if (tabOffset.top + tabOffset.height > -transformTop.value + wrapperHeight.value) newTransform = -(tabOffset.top + tabOffset.height - wrapperHeight.value);
+        setTransformLeft(0);
+        setTransformTop(alignInRange(newTransform));
+      }
+    };
+    const visibleStart = shallowRef(0);
+    const visibleEnd = shallowRef(0);
+    watchEffect(() => {
+      let unit;
+      let position;
+      let transformSize;
+      let basicSize;
+      let tabContentSize;
+      let addSize;
+      const tabOffsetsValue = tabOffsets.value;
+      if (["top", "bottom"].includes(props.tabPosition)) {
+        unit = "width";
+        basicSize = wrapperWidth.value;
+        tabContentSize = wrapperScrollWidth.value;
+        addSize = addWidth.value;
+        position = props.rtl ? "right" : "left";
+        transformSize = Math.abs(transformLeft.value);
+      } else {
+        unit = "height";
+        basicSize = wrapperHeight.value;
+        tabContentSize = wrapperScrollWidth.value;
+        addSize = addHeight.value;
+        position = "top";
+        transformSize = -transformTop.value;
+      }
+      let mergedBasicSize = basicSize;
+      if (tabContentSize + addSize > basicSize && tabContentSize < basicSize) mergedBasicSize = basicSize - addSize;
+      const tabsVal = tabs.value;
+      if (!tabsVal.length) return [visibleStart.value, visibleEnd.value] = [0, 0];
+      const len = tabsVal.length;
+      let endIndex = len;
+      for (let i = 0; i < len; i += 1) {
+        const offset = tabOffsetsValue.get(tabsVal[i].key) || DEFAULT_SIZE;
+        if (offset[position] + offset[unit] > transformSize + mergedBasicSize) {
+          endIndex = i - 1;
+          break;
+        }
+      }
+      let startIndex = 0;
+      for (let i = len - 1; i >= 0; i -= 1) if ((tabOffsetsValue.get(tabsVal[i].key) || DEFAULT_SIZE)[position] < transformSize) {
+        startIndex = i + 1;
+        break;
+      }
+      return [visibleStart.value, visibleEnd.value] = [startIndex, endIndex];
+    });
+    const updateTabSizes = () => {
+      setTabSizes(() => {
+        var _a;
+        const newSizes = /* @__PURE__ */ new Map();
+        const listRect = (_a = tabListRef.value) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+        tabs.value.forEach((_ref2) => {
+          let { key } = _ref2;
+          const btnRef = btnRefs.value.get(key);
+          const btnNode = (btnRef === null || btnRef === void 0 ? void 0 : btnRef.$el) || btnRef;
+          if (btnNode) {
+            const [width, height, left, top] = getTabSize(btnNode, listRect);
+            newSizes.set(key, {
+              width,
+              height,
+              left,
+              top
+            });
+          }
+        });
+        return newSizes;
+      });
+    };
+    watch(() => tabs.value.map((tab) => tab.key).join("%%"), () => {
+      updateTabSizes();
+    }, { flush: "post" });
+    const onListHolderResize = () => {
+      var _a, _b, _c, _d, _e;
+      const offsetWidth = ((_a = tabsWrapperRef.value) === null || _a === void 0 ? void 0 : _a.offsetWidth) || 0;
+      const offsetHeight = ((_b = tabsWrapperRef.value) === null || _b === void 0 ? void 0 : _b.offsetHeight) || 0;
+      const addDom = ((_c = innerAddButtonRef.value) === null || _c === void 0 ? void 0 : _c.$el) || {};
+      const newAddWidth = addDom.offsetWidth || 0;
+      const newAddHeight = addDom.offsetHeight || 0;
+      setWrapperWidth(offsetWidth);
+      setWrapperHeight(offsetHeight);
+      setAddWidth(newAddWidth);
+      setAddHeight(newAddHeight);
+      const newWrapperScrollWidth = (((_d = tabListRef.value) === null || _d === void 0 ? void 0 : _d.offsetWidth) || 0) - newAddWidth;
+      const newWrapperScrollHeight = (((_e = tabListRef.value) === null || _e === void 0 ? void 0 : _e.offsetHeight) || 0) - newAddHeight;
+      setWrapperScrollWidth(newWrapperScrollWidth);
+      setWrapperScrollHeight(newWrapperScrollHeight);
+      updateTabSizes();
+    };
+    const hiddenTabs = computed(() => [...tabs.value.slice(0, visibleStart.value), ...tabs.value.slice(visibleEnd.value + 1)]);
+    const [inkStyle, setInkStyle] = useState();
+    const activeTabOffset = computed(() => tabOffsets.value.get(props.activeKey));
+    const inkBarRafRef = shallowRef();
+    const cleanInkBarRaf = () => {
+      wrapperRaf.cancel(inkBarRafRef.value);
+    };
+    watch([
+      activeTabOffset,
+      tabPositionTopOrBottom,
+      () => props.rtl
+    ], () => {
+      const newInkStyle = {};
+      if (activeTabOffset.value) {
+        if (tabPositionTopOrBottom.value) {
+          if (props.rtl) newInkStyle.right = toPx(activeTabOffset.value.right);
+          else newInkStyle.left = toPx(activeTabOffset.value.left);
+          newInkStyle.width = toPx(activeTabOffset.value.width);
+        } else {
+          newInkStyle.top = toPx(activeTabOffset.value.top);
+          newInkStyle.height = toPx(activeTabOffset.value.height);
+        }
+      }
+      cleanInkBarRaf();
+      inkBarRafRef.value = wrapperRaf(() => {
+        setInkStyle(newInkStyle);
+      });
+    });
+    watch([
+      () => props.activeKey,
+      activeTabOffset,
+      tabOffsets,
+      tabPositionTopOrBottom
+    ], () => {
+      scrollToTab();
+    }, { flush: "post" });
+    watch([
+      () => props.rtl,
+      () => props.tabBarGutter,
+      () => props.activeKey,
+      () => tabs.value
+    ], () => {
+      onListHolderResize();
+    }, { flush: "post" });
+    const ExtraContent = (_ref3) => {
+      let { position, prefixCls: prefixCls2, extra } = _ref3;
+      if (!extra) return null;
+      const content = extra === null || extra === void 0 ? void 0 : extra({ position });
+      return content ? createVNode("div", { "class": `${prefixCls2}-extra-content` }, [content]) : null;
+    };
+    return () => {
+      const { id, animated, activeKey, rtl, editable, locale, tabPosition, tabBarGutter, onTabClick } = props;
+      const { class: className, style } = attrs;
+      const pre = prefixCls.value;
+      const hasDropdown = !!hiddenTabs.value.length;
+      const wrapPrefix = `${pre}-nav-wrap`;
+      let pingLeft;
+      let pingRight;
+      let pingTop;
+      let pingBottom;
+      if (tabPositionTopOrBottom.value) {
+        if (rtl) {
+          pingRight = transformLeft.value > 0;
+          pingLeft = transformLeft.value + wrapperWidth.value < wrapperScrollWidth.value;
+        } else {
+          pingLeft = transformLeft.value < 0;
+          pingRight = -transformLeft.value + wrapperWidth.value < wrapperScrollWidth.value;
+        }
+      } else {
+        pingTop = transformTop.value < 0;
+        pingBottom = -transformTop.value + wrapperHeight.value < wrapperScrollHeight.value;
+      }
+      const tabNodeStyle = {};
+      if (tabPosition === "top" || tabPosition === "bottom") tabNodeStyle[rtl ? "marginRight" : "marginLeft"] = typeof tabBarGutter === "number" ? `${tabBarGutter}px` : tabBarGutter;
+      else tabNodeStyle.marginTop = typeof tabBarGutter === "number" ? `${tabBarGutter}px` : tabBarGutter;
+      const tabNodes = tabs.value.map((tab, i) => {
+        const { key } = tab;
+        return createVNode(TabNode_default, {
+          "id": id,
+          "prefixCls": pre,
+          "key": key,
+          "tab": tab,
+          "style": i === 0 ? void 0 : tabNodeStyle,
+          "closable": tab.closable,
+          "editable": editable,
+          "active": key === activeKey,
+          "removeAriaLabel": locale === null || locale === void 0 ? void 0 : locale.removeAriaLabel,
+          "ref": setRef(key),
+          "onClick": (e) => {
+            onTabClick(key, e);
+          },
+          "onFocus": () => {
+            scrollToTab(key);
+            doLockAnimation();
+            if (!tabsWrapperRef.value) return;
+            if (!rtl) tabsWrapperRef.value.scrollLeft = 0;
+            tabsWrapperRef.value.scrollTop = 0;
+          }
+        }, slots);
+      });
+      return createVNode("div", {
+        "role": "tablist",
+        "class": classNames(`${pre}-nav`, className),
+        "style": style,
+        "onKeydown": () => {
+          doLockAnimation();
+        }
+      }, [
+        createVNode(ExtraContent, {
+          "position": "left",
+          "prefixCls": pre,
+          "extra": slots.leftExtra
+        }, null),
+        createVNode(vc_resize_observer_default, { "onResize": onListHolderResize }, { default: () => [createVNode("div", {
+          "class": classNames(wrapPrefix, {
+            [`${wrapPrefix}-ping-left`]: pingLeft,
+            [`${wrapPrefix}-ping-right`]: pingRight,
+            [`${wrapPrefix}-ping-top`]: pingTop,
+            [`${wrapPrefix}-ping-bottom`]: pingBottom
+          }),
+          "ref": tabsWrapperRef
+        }, [createVNode(vc_resize_observer_default, { "onResize": onListHolderResize }, { default: () => [createVNode("div", {
+          "ref": tabListRef,
+          "class": `${pre}-nav-list`,
+          "style": {
+            transform: `translate(${transformLeft.value}px, ${transformTop.value}px)`,
+            transition: lockAnimation.value ? "none" : void 0
+          }
+        }, [
+          tabNodes,
+          createVNode(AddButton_default, {
+            "ref": innerAddButtonRef,
+            "prefixCls": pre,
+            "locale": locale,
+            "editable": editable,
+            "style": _extends(_extends({}, tabNodes.length === 0 ? void 0 : tabNodeStyle), { visibility: hasDropdown ? "hidden" : null })
+          }, null),
+          createVNode("div", {
+            "class": classNames(`${pre}-ink-bar`, { [`${pre}-ink-bar-animated`]: animated.inkBar }),
+            "style": inkStyle.value
+          }, null)
+        ])] })])] }),
+        createVNode(OperationNode_default, _objectSpread2(_objectSpread2({}, props), {}, {
+          "removeAriaLabel": locale === null || locale === void 0 ? void 0 : locale.removeAriaLabel,
+          "ref": operationsRef,
+          "prefixCls": pre,
+          "tabs": hiddenTabs.value,
+          "class": !hasDropdown && operationsHiddenClassName.value
+        }), pick(slots, ["moreIcon"])),
+        createVNode(ExtraContent, {
+          "position": "right",
+          "prefixCls": pre,
+          "extra": slots.rightExtra
+        }, null),
+        createVNode(ExtraContent, {
+          "position": "right",
+          "prefixCls": pre,
+          "extra": slots.tabBarExtraContent
+        }, null)
+      ]);
+    };
+  }
+});
+var TabPanelList_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "TabPanelList",
+  inheritAttrs: false,
+  props: {
+    activeKey: { type: [String, Number] },
+    id: { type: String },
+    rtl: { type: Boolean },
+    animated: {
+      type: Object,
+      default: void 0
+    },
+    tabPosition: { type: String },
+    destroyInactiveTabPane: { type: Boolean }
+  },
+  setup(props) {
+    const { tabs, prefixCls } = useInjectTabs();
+    return () => {
+      const { id, activeKey, animated, tabPosition, rtl, destroyInactiveTabPane } = props;
+      const tabPaneAnimated = animated.tabPane;
+      const pre = prefixCls.value;
+      const activeIndex = tabs.value.findIndex((tab) => tab.key === activeKey);
+      return createVNode("div", { "class": `${pre}-content-holder` }, [createVNode("div", {
+        "class": [
+          `${pre}-content`,
+          `${pre}-content-${tabPosition}`,
+          { [`${pre}-content-animated`]: tabPaneAnimated }
+        ],
+        "style": activeIndex && tabPaneAnimated ? { [rtl ? "marginRight" : "marginLeft"]: `-${activeIndex}00%` } : null
+      }, [tabs.value.map((tab) => {
+        return cloneElement(tab.node, {
+          key: tab.key,
+          prefixCls: pre,
+          tabKey: tab.key,
+          id,
+          animated: tabPaneAnimated,
+          active: tab.key === activeKey,
+          destroyInactiveTabPane
+        });
+      })])]);
+    };
+  }
+});
+var genMotionStyle = (token) => {
+  const { componentCls, motionDurationSlow } = token;
+  return [{ [componentCls]: { [`${componentCls}-switch`]: {
+    "&-appear, &-enter": {
+      transition: "none",
+      "&-start": { opacity: 0 },
+      "&-active": {
+        opacity: 1,
+        transition: `opacity ${motionDurationSlow}`
+      }
+    },
+    "&-leave": {
+      position: "absolute",
+      transition: "none",
+      inset: 0,
+      "&-start": { opacity: 1 },
+      "&-active": {
+        opacity: 0,
+        transition: `opacity ${motionDurationSlow}`
+      }
+    }
+  } } }, [initSlideMotion(token, "slide-up"), initSlideMotion(token, "slide-down")]];
+};
+var genCardStyle = (token) => {
+  const { componentCls, tabsCardHorizontalPadding, tabsCardHeadBackground, tabsCardGutter, colorSplit } = token;
+  return { [`${componentCls}-card`]: {
+    [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+      [`${componentCls}-tab`]: {
+        margin: 0,
+        padding: tabsCardHorizontalPadding,
+        background: tabsCardHeadBackground,
+        border: `${token.lineWidth}px ${token.lineType} ${colorSplit}`,
+        transition: `all ${token.motionDurationSlow} ${token.motionEaseInOut}`
+      },
+      [`${componentCls}-tab-active`]: {
+        color: token.colorPrimary,
+        background: token.colorBgContainer
+      },
+      [`${componentCls}-ink-bar`]: { visibility: "hidden" }
+    },
+    [`&${componentCls}-top, &${componentCls}-bottom`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: { [`${componentCls}-tab + ${componentCls}-tab`]: { marginLeft: {
+      _skip_check_: true,
+      value: `${tabsCardGutter}px`
+    } } } },
+    [`&${componentCls}-top`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+      [`${componentCls}-tab`]: { borderRadius: `${token.borderRadiusLG}px ${token.borderRadiusLG}px 0 0` },
+      [`${componentCls}-tab-active`]: { borderBottomColor: token.colorBgContainer }
+    } },
+    [`&${componentCls}-bottom`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+      [`${componentCls}-tab`]: { borderRadius: `0 0 ${token.borderRadiusLG}px ${token.borderRadiusLG}px` },
+      [`${componentCls}-tab-active`]: { borderTopColor: token.colorBgContainer }
+    } },
+    [`&${componentCls}-left, &${componentCls}-right`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: { [`${componentCls}-tab + ${componentCls}-tab`]: { marginTop: `${tabsCardGutter}px` } } },
+    [`&${componentCls}-left`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+      [`${componentCls}-tab`]: { borderRadius: {
+        _skip_check_: true,
+        value: `${token.borderRadiusLG}px 0 0 ${token.borderRadiusLG}px`
+      } },
+      [`${componentCls}-tab-active`]: { borderRightColor: {
+        _skip_check_: true,
+        value: token.colorBgContainer
+      } }
+    } },
+    [`&${componentCls}-right`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+      [`${componentCls}-tab`]: { borderRadius: {
+        _skip_check_: true,
+        value: `0 ${token.borderRadiusLG}px ${token.borderRadiusLG}px 0`
+      } },
+      [`${componentCls}-tab-active`]: { borderLeftColor: {
+        _skip_check_: true,
+        value: token.colorBgContainer
+      } }
+    } }
+  } };
+};
+var genDropdownStyle = (token) => {
+  const { componentCls, tabsHoverColor, dropdownEdgeChildVerticalPadding } = token;
+  return { [`${componentCls}-dropdown`]: _extends(_extends({}, resetComponent(token)), {
+    position: "absolute",
+    top: -9999,
+    left: {
+      _skip_check_: true,
+      value: -9999
+    },
+    zIndex: token.zIndexPopup,
+    display: "block",
+    "&-hidden": { display: "none" },
+    [`${componentCls}-dropdown-menu`]: {
+      maxHeight: token.tabsDropdownHeight,
+      margin: 0,
+      padding: `${dropdownEdgeChildVerticalPadding}px 0`,
+      overflowX: "hidden",
+      overflowY: "auto",
+      textAlign: {
+        _skip_check_: true,
+        value: "left"
+      },
+      listStyleType: "none",
+      backgroundColor: token.colorBgContainer,
+      backgroundClip: "padding-box",
+      borderRadius: token.borderRadiusLG,
+      outline: "none",
+      boxShadow: token.boxShadowSecondary,
+      "&-item": _extends(_extends({}, textEllipsis), {
+        display: "flex",
+        alignItems: "center",
+        minWidth: token.tabsDropdownWidth,
+        margin: 0,
+        padding: `${token.paddingXXS}px ${token.paddingSM}px`,
+        color: token.colorText,
+        fontWeight: "normal",
+        fontSize: token.fontSize,
+        lineHeight: token.lineHeight,
+        cursor: "pointer",
+        transition: `all ${token.motionDurationSlow}`,
+        "> span": {
+          flex: 1,
+          whiteSpace: "nowrap"
+        },
+        "&-remove": {
+          flex: "none",
+          marginLeft: {
+            _skip_check_: true,
+            value: token.marginSM
+          },
+          color: token.colorTextDescription,
+          fontSize: token.fontSizeSM,
+          background: "transparent",
+          border: 0,
+          cursor: "pointer",
+          "&:hover": { color: tabsHoverColor }
+        },
+        "&:hover": { background: token.controlItemBgHover },
+        "&-disabled": { "&, &:hover": {
+          color: token.colorTextDisabled,
+          background: "transparent",
+          cursor: "not-allowed"
+        } }
+      })
+    }
+  }) };
+};
+var genPositionStyle = (token) => {
+  const { componentCls, margin, colorSplit } = token;
+  return {
+    [`${componentCls}-top, ${componentCls}-bottom`]: {
+      flexDirection: "column",
+      [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+        margin: `0 0 ${margin}px 0`,
+        "&::before": {
+          position: "absolute",
+          right: {
+            _skip_check_: true,
+            value: 0
+          },
+          left: {
+            _skip_check_: true,
+            value: 0
+          },
+          borderBottom: `${token.lineWidth}px ${token.lineType} ${colorSplit}`,
+          content: "''"
+        },
+        [`${componentCls}-ink-bar`]: {
+          height: token.lineWidthBold,
+          "&-animated": { transition: `width ${token.motionDurationSlow}, left ${token.motionDurationSlow},
+            right ${token.motionDurationSlow}` }
+        },
+        [`${componentCls}-nav-wrap`]: {
+          "&::before, &::after": {
+            top: 0,
+            bottom: 0,
+            width: token.controlHeight
+          },
+          "&::before": {
+            left: {
+              _skip_check_: true,
+              value: 0
+            },
+            boxShadow: token.boxShadowTabsOverflowLeft
+          },
+          "&::after": {
+            right: {
+              _skip_check_: true,
+              value: 0
+            },
+            boxShadow: token.boxShadowTabsOverflowRight
+          },
+          [`&${componentCls}-nav-wrap-ping-left::before`]: { opacity: 1 },
+          [`&${componentCls}-nav-wrap-ping-right::after`]: { opacity: 1 }
+        }
+      }
+    },
+    [`${componentCls}-top`]: { [`> ${componentCls}-nav,
+        > div > ${componentCls}-nav`]: {
+      "&::before": { bottom: 0 },
+      [`${componentCls}-ink-bar`]: { bottom: 0 }
+    } },
+    [`${componentCls}-bottom`]: {
+      [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+        order: 1,
+        marginTop: `${margin}px`,
+        marginBottom: 0,
+        "&::before": { top: 0 },
+        [`${componentCls}-ink-bar`]: { top: 0 }
+      },
+      [`> ${componentCls}-content-holder, > div > ${componentCls}-content-holder`]: { order: 0 }
+    },
+    [`${componentCls}-left, ${componentCls}-right`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+      flexDirection: "column",
+      minWidth: token.controlHeight * 1.25,
+      [`${componentCls}-tab`]: {
+        padding: `${token.paddingXS}px ${token.paddingLG}px`,
+        textAlign: "center"
+      },
+      [`${componentCls}-tab + ${componentCls}-tab`]: { margin: `${token.margin}px 0 0 0` },
+      [`${componentCls}-nav-wrap`]: {
+        flexDirection: "column",
+        "&::before, &::after": {
+          right: {
+            _skip_check_: true,
+            value: 0
+          },
+          left: {
+            _skip_check_: true,
+            value: 0
+          },
+          height: token.controlHeight
+        },
+        "&::before": {
+          top: 0,
+          boxShadow: token.boxShadowTabsOverflowTop
+        },
+        "&::after": {
+          bottom: 0,
+          boxShadow: token.boxShadowTabsOverflowBottom
+        },
+        [`&${componentCls}-nav-wrap-ping-top::before`]: { opacity: 1 },
+        [`&${componentCls}-nav-wrap-ping-bottom::after`]: { opacity: 1 }
+      },
+      [`${componentCls}-ink-bar`]: {
+        width: token.lineWidthBold,
+        "&-animated": { transition: `height ${token.motionDurationSlow}, top ${token.motionDurationSlow}` }
+      },
+      [`${componentCls}-nav-list, ${componentCls}-nav-operations`]: {
+        flex: "1 0 auto",
+        flexDirection: "column"
+      }
+    } },
+    [`${componentCls}-left`]: {
+      [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: { [`${componentCls}-ink-bar`]: { right: {
+        _skip_check_: true,
+        value: 0
+      } } },
+      [`> ${componentCls}-content-holder, > div > ${componentCls}-content-holder`]: {
+        marginLeft: {
+          _skip_check_: true,
+          value: `-${token.lineWidth}px`
+        },
+        borderLeft: {
+          _skip_check_: true,
+          value: `${token.lineWidth}px ${token.lineType} ${token.colorBorder}`
+        },
+        [`> ${componentCls}-content > ${componentCls}-tabpane`]: { paddingLeft: {
+          _skip_check_: true,
+          value: token.paddingLG
+        } }
+      }
+    },
+    [`${componentCls}-right`]: {
+      [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+        order: 1,
+        [`${componentCls}-ink-bar`]: { left: {
+          _skip_check_: true,
+          value: 0
+        } }
+      },
+      [`> ${componentCls}-content-holder, > div > ${componentCls}-content-holder`]: {
+        order: 0,
+        marginRight: {
+          _skip_check_: true,
+          value: -token.lineWidth
+        },
+        borderRight: {
+          _skip_check_: true,
+          value: `${token.lineWidth}px ${token.lineType} ${token.colorBorder}`
+        },
+        [`> ${componentCls}-content > ${componentCls}-tabpane`]: { paddingRight: {
+          _skip_check_: true,
+          value: token.paddingLG
+        } }
+      }
+    }
+  };
+};
+var genSizeStyle = (token) => {
+  const { componentCls, padding } = token;
+  return {
+    [componentCls]: {
+      "&-small": { [`> ${componentCls}-nav`]: { [`${componentCls}-tab`]: {
+        padding: `${token.paddingXS}px 0`,
+        fontSize: token.fontSize
+      } } },
+      "&-large": { [`> ${componentCls}-nav`]: { [`${componentCls}-tab`]: {
+        padding: `${padding}px 0`,
+        fontSize: token.fontSizeLG
+      } } }
+    },
+    [`${componentCls}-card`]: {
+      [`&${componentCls}-small`]: {
+        [`> ${componentCls}-nav`]: { [`${componentCls}-tab`]: { padding: `${token.paddingXXS * 1.5}px ${padding}px` } },
+        [`&${componentCls}-bottom`]: { [`> ${componentCls}-nav ${componentCls}-tab`]: { borderRadius: `0 0 ${token.borderRadius}px ${token.borderRadius}px` } },
+        [`&${componentCls}-top`]: { [`> ${componentCls}-nav ${componentCls}-tab`]: { borderRadius: `${token.borderRadius}px ${token.borderRadius}px 0 0` } },
+        [`&${componentCls}-right`]: { [`> ${componentCls}-nav ${componentCls}-tab`]: { borderRadius: {
+          _skip_check_: true,
+          value: `0 ${token.borderRadius}px ${token.borderRadius}px 0`
+        } } },
+        [`&${componentCls}-left`]: { [`> ${componentCls}-nav ${componentCls}-tab`]: { borderRadius: {
+          _skip_check_: true,
+          value: `${token.borderRadius}px 0 0 ${token.borderRadius}px`
+        } } }
+      },
+      [`&${componentCls}-large`]: { [`> ${componentCls}-nav`]: { [`${componentCls}-tab`]: { padding: `${token.paddingXS}px ${padding}px ${token.paddingXXS * 1.5}px` } } }
+    }
+  };
+};
+var genTabStyle = (token) => {
+  const { componentCls, tabsActiveColor, tabsHoverColor, iconCls, tabsHorizontalGutter } = token;
+  const tabCls = `${componentCls}-tab`;
+  return {
+    [tabCls]: {
+      position: "relative",
+      display: "inline-flex",
+      alignItems: "center",
+      padding: `${token.paddingSM}px 0`,
+      fontSize: `${token.fontSize}px`,
+      background: "transparent",
+      border: 0,
+      outline: "none",
+      cursor: "pointer",
+      "&-btn, &-remove": _extends({ "&:focus:not(:focus-visible), &:active": { color: tabsActiveColor } }, genFocusStyle(token)),
+      "&-btn": {
+        outline: "none",
+        transition: "all 0.3s"
+      },
+      "&-remove": {
+        flex: "none",
+        marginRight: {
+          _skip_check_: true,
+          value: -token.marginXXS
+        },
+        marginLeft: {
+          _skip_check_: true,
+          value: token.marginXS
+        },
+        color: token.colorTextDescription,
+        fontSize: token.fontSizeSM,
+        background: "transparent",
+        border: "none",
+        outline: "none",
+        cursor: "pointer",
+        transition: `all ${token.motionDurationSlow}`,
+        "&:hover": { color: token.colorTextHeading }
+      },
+      "&:hover": { color: tabsHoverColor },
+      [`&${tabCls}-active ${tabCls}-btn`]: {
+        color: token.colorPrimary,
+        textShadow: token.tabsActiveTextShadow
+      },
+      [`&${tabCls}-disabled`]: {
+        color: token.colorTextDisabled,
+        cursor: "not-allowed"
+      },
+      [`&${tabCls}-disabled ${tabCls}-btn, &${tabCls}-disabled ${componentCls}-remove`]: { "&:focus, &:active": { color: token.colorTextDisabled } },
+      [`& ${tabCls}-remove ${iconCls}`]: { margin: 0 },
+      [iconCls]: { marginRight: {
+        _skip_check_: true,
+        value: token.marginSM
+      } }
+    },
+    [`${tabCls} + ${tabCls}`]: { margin: {
+      _skip_check_: true,
+      value: `0 0 0 ${tabsHorizontalGutter}px`
+    } }
+  };
+};
+var genRtlStyle = (token) => {
+  const { componentCls, tabsHorizontalGutter, iconCls, tabsCardGutter } = token;
+  return {
+    [`${componentCls}-rtl`]: {
+      direction: "rtl",
+      [`${componentCls}-nav`]: { [`${componentCls}-tab`]: {
+        margin: {
+          _skip_check_: true,
+          value: `0 0 0 ${tabsHorizontalGutter}px`
+        },
+        [`${componentCls}-tab:last-of-type`]: { marginLeft: {
+          _skip_check_: true,
+          value: 0
+        } },
+        [iconCls]: {
+          marginRight: {
+            _skip_check_: true,
+            value: 0
+          },
+          marginLeft: {
+            _skip_check_: true,
+            value: `${token.marginSM}px`
+          }
+        },
+        [`${componentCls}-tab-remove`]: {
+          marginRight: {
+            _skip_check_: true,
+            value: `${token.marginXS}px`
+          },
+          marginLeft: {
+            _skip_check_: true,
+            value: `-${token.marginXXS}px`
+          },
+          [iconCls]: { margin: 0 }
+        }
+      } },
+      [`&${componentCls}-left`]: {
+        [`> ${componentCls}-nav`]: { order: 1 },
+        [`> ${componentCls}-content-holder`]: { order: 0 }
+      },
+      [`&${componentCls}-right`]: {
+        [`> ${componentCls}-nav`]: { order: 0 },
+        [`> ${componentCls}-content-holder`]: { order: 1 }
+      },
+      [`&${componentCls}-card${componentCls}-top, &${componentCls}-card${componentCls}-bottom`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: { [`${componentCls}-tab + ${componentCls}-tab`]: {
+        marginRight: {
+          _skip_check_: true,
+          value: `${tabsCardGutter}px`
+        },
+        marginLeft: {
+          _skip_check_: true,
+          value: 0
+        }
+      } } }
+    },
+    [`${componentCls}-dropdown-rtl`]: { direction: "rtl" },
+    [`${componentCls}-menu-item`]: { [`${componentCls}-dropdown-rtl`]: { textAlign: {
+      _skip_check_: true,
+      value: "right"
+    } } }
+  };
+};
+var genTabsStyle = (token) => {
+  const { componentCls, tabsCardHorizontalPadding, tabsCardHeight, tabsCardGutter, tabsHoverColor, tabsActiveColor, colorSplit } = token;
+  return {
+    [componentCls]: _extends(_extends(_extends(_extends({}, resetComponent(token)), {
+      display: "flex",
+      [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: {
+        position: "relative",
+        display: "flex",
+        flex: "none",
+        alignItems: "center",
+        [`${componentCls}-nav-wrap`]: {
+          position: "relative",
+          display: "flex",
+          flex: "auto",
+          alignSelf: "stretch",
+          overflow: "hidden",
+          whiteSpace: "nowrap",
+          transform: "translate(0)",
+          "&::before, &::after": {
+            position: "absolute",
+            zIndex: 1,
+            opacity: 0,
+            transition: `opacity ${token.motionDurationSlow}`,
+            content: "''",
+            pointerEvents: "none"
+          }
+        },
+        [`${componentCls}-nav-list`]: {
+          position: "relative",
+          display: "flex",
+          transition: `opacity ${token.motionDurationSlow}`
+        },
+        [`${componentCls}-nav-operations`]: {
+          display: "flex",
+          alignSelf: "stretch"
+        },
+        [`${componentCls}-nav-operations-hidden`]: {
+          position: "absolute",
+          visibility: "hidden",
+          pointerEvents: "none"
+        },
+        [`${componentCls}-nav-more`]: {
+          position: "relative",
+          padding: tabsCardHorizontalPadding,
+          background: "transparent",
+          border: 0,
+          "&::after": {
+            position: "absolute",
+            right: {
+              _skip_check_: true,
+              value: 0
+            },
+            bottom: 0,
+            left: {
+              _skip_check_: true,
+              value: 0
+            },
+            height: token.controlHeightLG / 8,
+            transform: "translateY(100%)",
+            content: "''"
+          }
+        },
+        [`${componentCls}-nav-add`]: _extends({
+          minWidth: `${tabsCardHeight}px`,
+          marginLeft: {
+            _skip_check_: true,
+            value: `${tabsCardGutter}px`
+          },
+          padding: `0 ${token.paddingXS}px`,
+          background: "transparent",
+          border: `${token.lineWidth}px ${token.lineType} ${colorSplit}`,
+          borderRadius: `${token.borderRadiusLG}px ${token.borderRadiusLG}px 0 0`,
+          outline: "none",
+          cursor: "pointer",
+          color: token.colorText,
+          transition: `all ${token.motionDurationSlow} ${token.motionEaseInOut}`,
+          "&:hover": { color: tabsHoverColor },
+          "&:active, &:focus:not(:focus-visible)": { color: tabsActiveColor }
+        }, genFocusStyle(token))
+      },
+      [`${componentCls}-extra-content`]: { flex: "none" },
+      [`${componentCls}-ink-bar`]: {
+        position: "absolute",
+        background: token.colorPrimary,
+        pointerEvents: "none"
+      }
+    }), genTabStyle(token)), {
+      [`${componentCls}-content`]: {
+        position: "relative",
+        display: "flex",
+        width: "100%",
+        ["&-animated"]: { transition: "margin 0.3s" }
+      },
+      [`${componentCls}-content-holder`]: {
+        flex: "auto",
+        minWidth: 0,
+        minHeight: 0
+      },
+      [`${componentCls}-tabpane`]: {
+        outline: "none",
+        flex: "none",
+        width: "100%"
+      }
+    }),
+    [`${componentCls}-centered`]: { [`> ${componentCls}-nav, > div > ${componentCls}-nav`]: { [`${componentCls}-nav-wrap`]: { [`&:not([class*='${componentCls}-nav-wrap-ping'])`]: { justifyContent: "center" } } } }
+  };
+};
+var style_default = genComponentStyleHook("Tabs", (token) => {
+  const tabsCardHeight = token.controlHeightLG;
+  const tabsToken = merge(token, {
+    tabsHoverColor: token.colorPrimaryHover,
+    tabsActiveColor: token.colorPrimaryActive,
+    tabsCardHorizontalPadding: `${(tabsCardHeight - Math.round(token.fontSize * token.lineHeight)) / 2 - token.lineWidth}px ${token.padding}px`,
+    tabsCardHeight,
+    tabsCardGutter: token.marginXXS / 2,
+    tabsHorizontalGutter: 32,
+    tabsCardHeadBackground: token.colorFillAlter,
+    dropdownEdgeChildVerticalPadding: token.paddingXXS,
+    tabsActiveTextShadow: "0 0 0.25px currentcolor",
+    tabsDropdownHeight: 200,
+    tabsDropdownWidth: 120
+  });
+  return [
+    genSizeStyle(tabsToken),
+    genRtlStyle(tabsToken),
+    genPositionStyle(tabsToken),
+    genDropdownStyle(tabsToken),
+    genCardStyle(tabsToken),
+    genTabsStyle(tabsToken),
+    genMotionStyle(tabsToken)
+  ];
+}, (token) => ({ zIndexPopup: token.zIndexPopupBase + 50 }));
+var tabsProps = () => {
+  return {
+    prefixCls: { type: String },
+    id: { type: String },
+    popupClassName: String,
+    getPopupContainer: functionType(),
+    activeKey: { type: [String, Number] },
+    defaultActiveKey: { type: [String, Number] },
+    direction: stringType(),
+    animated: someType([Boolean, Object]),
+    renderTabBar: functionType(),
+    tabBarGutter: { type: Number },
+    tabBarStyle: objectType(),
+    tabPosition: stringType(),
+    destroyInactiveTabPane: booleanType(),
+    hideAdd: Boolean,
+    type: stringType(),
+    size: stringType(),
+    centered: Boolean,
+    onEdit: functionType(),
+    onChange: functionType(),
+    onTabClick: functionType(),
+    onTabScroll: functionType(),
+    "onUpdate:activeKey": functionType(),
+    locale: objectType(),
+    onPrevClick: functionType(),
+    onNextClick: functionType(),
+    tabBarExtraContent: PropTypes.any
+  };
+};
+function parseTabList(children) {
+  return children.map((node) => {
+    if (isValidElement(node)) {
+      const props = _extends({}, node.props || {});
+      for (const [k, v] of Object.entries(props)) {
+        delete props[k];
+        props[camelize(k)] = v;
+      }
+      const slots = node.children || {};
+      const key = node.key !== void 0 ? node.key : void 0;
+      const { tab = slots.tab, disabled, forceRender, closable, animated, active, destroyInactiveTabPane } = props;
+      return _extends(_extends({ key }, props), {
+        node,
+        closeIcon: slots.closeIcon,
+        tab,
+        disabled: disabled === "" || disabled,
+        forceRender: forceRender === "" || forceRender,
+        closable: closable === "" || closable,
+        animated: animated === "" || animated,
+        active: active === "" || active,
+        destroyInactiveTabPane: destroyInactiveTabPane === "" || destroyInactiveTabPane
+      });
+    }
+    return null;
+  }).filter((tab) => tab);
+}
+var InternalTabs = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "InternalTabs",
+  inheritAttrs: false,
+  props: _extends(_extends({}, initDefaultProps(tabsProps(), {
+    tabPosition: "top",
+    animated: {
+      inkBar: true,
+      tabPane: false
+    }
+  })), { tabs: arrayType() }),
+  slots: Object,
+  setup(props, _ref) {
+    let { attrs, slots } = _ref;
+    devWarning_default(!(props.onPrevClick !== void 0) && !(props.onNextClick !== void 0), "Tabs", "`onPrevClick / @prevClick` and `onNextClick / @nextClick` has been removed. Please use `onTabScroll / @tabScroll` instead.");
+    devWarning_default(!(props.tabBarExtraContent !== void 0), "Tabs", "`tabBarExtraContent` prop has been removed. Please use `rightExtra` slot instead.");
+    devWarning_default(!(slots.tabBarExtraContent !== void 0), "Tabs", "`tabBarExtraContent` slot is deprecated. Please use `rightExtra` slot instead.");
+    const { prefixCls, direction, size, rootPrefixCls, getPopupContainer } = useConfigInject_default("tabs", props);
+    const [wrapSSR, hashId] = style_default(prefixCls);
+    const rtl = computed(() => direction.value === "rtl");
+    const mergedAnimated = computed(() => {
+      const { animated, tabPosition } = props;
+      if (animated === false || ["left", "right"].includes(tabPosition)) return {
+        inkBar: false,
+        tabPane: false
+      };
+      else if (animated === true) return {
+        inkBar: true,
+        tabPane: true
+      };
+      else return _extends({
+        inkBar: true,
+        tabPane: false
+      }, typeof animated === "object" ? animated : {});
+    });
+    const [mobile] = useState(false);
+    const [mergedActiveKey, setMergedActiveKey] = useMergedState(() => {
+      var _a;
+      return (_a = props.tabs[0]) === null || _a === void 0 ? void 0 : _a.key;
+    }, {
+      value: computed(() => props.activeKey),
+      defaultValue: props.defaultActiveKey
+    });
+    const [activeIndex, setActiveIndex] = useState(() => props.tabs.findIndex((tab) => tab.key === mergedActiveKey.value));
+    watchEffect(() => {
+      var _a;
+      let newActiveIndex = props.tabs.findIndex((tab) => tab.key === mergedActiveKey.value);
+      if (newActiveIndex === -1) {
+        newActiveIndex = Math.max(0, Math.min(activeIndex.value, props.tabs.length - 1));
+        setMergedActiveKey((_a = props.tabs[newActiveIndex]) === null || _a === void 0 ? void 0 : _a.key);
+      }
+      setActiveIndex(newActiveIndex);
+    });
+    const [mergedId] = useMergedState(null, { value: computed(() => props.id) });
+    const mergedTabPosition = computed(() => {
+      if (mobile.value && !["left", "right"].includes(props.tabPosition)) return "top";
+      else return props.tabPosition;
+    });
+    const onInternalTabClick = (key, e) => {
+      var _a, _b;
+      (_a = props.onTabClick) === null || _a === void 0 || _a.call(props, key, e);
+      const isActiveChanged = key !== mergedActiveKey.value;
+      setMergedActiveKey(key);
+      if (isActiveChanged) (_b = props.onChange) === null || _b === void 0 || _b.call(props, key);
+    };
+    useProvideTabs({
+      tabs: computed(() => props.tabs),
+      prefixCls
+    });
+    return () => {
+      const { id, type, tabBarGutter, tabBarStyle, locale, destroyInactiveTabPane, renderTabBar = slots.renderTabBar, onTabScroll, hideAdd, centered } = props;
+      const sharedProps = {
+        id: mergedId.value,
+        activeKey: mergedActiveKey.value,
+        animated: mergedAnimated.value,
+        tabPosition: mergedTabPosition.value,
+        rtl: rtl.value,
+        mobile: mobile.value
+      };
+      let editable;
+      if (type === "editable-card") editable = {
+        onEdit: (editType, _ref2) => {
+          let { key, event } = _ref2;
+          var _a;
+          (_a = props.onEdit) === null || _a === void 0 || _a.call(props, editType === "add" ? event : key, editType);
+        },
+        removeIcon: () => createVNode(CloseOutlined, null, null),
+        addIcon: slots.addIcon ? slots.addIcon : () => createVNode(PlusOutlined, null, null),
+        showAdd: hideAdd !== true
+      };
+      let tabNavBar;
+      const tabNavBarProps = _extends(_extends({}, sharedProps), {
+        moreTransitionName: `${rootPrefixCls.value}-slide-up`,
+        editable,
+        locale,
+        tabBarGutter,
+        onTabClick: onInternalTabClick,
+        onTabScroll,
+        style: tabBarStyle,
+        getPopupContainer: getPopupContainer.value,
+        popupClassName: classNames(props.popupClassName, hashId.value)
+      });
+      if (renderTabBar) tabNavBar = renderTabBar(_extends(_extends({}, tabNavBarProps), { DefaultTabBar: TabNavList_default }));
+      else tabNavBar = createVNode(TabNavList_default, tabNavBarProps, pick(slots, [
+        "moreIcon",
+        "leftExtra",
+        "rightExtra",
+        "tabBarExtraContent"
+      ]));
+      const pre = prefixCls.value;
+      return wrapSSR(createVNode("div", _objectSpread2(_objectSpread2({}, attrs), {}, {
+        "id": id,
+        "class": classNames(pre, `${pre}-${mergedTabPosition.value}`, {
+          [hashId.value]: true,
+          [`${pre}-${size.value}`]: size.value,
+          [`${pre}-card`]: ["card", "editable-card"].includes(type),
+          [`${pre}-editable-card`]: type === "editable-card",
+          [`${pre}-centered`]: centered,
+          [`${pre}-mobile`]: mobile.value,
+          [`${pre}-editable`]: type === "editable-card",
+          [`${pre}-rtl`]: rtl.value
+        }, attrs.class)
+      }), [tabNavBar, createVNode(TabPanelList_default, _objectSpread2(_objectSpread2({ "destroyInactiveTabPane": destroyInactiveTabPane }, sharedProps), {}, { "animated": mergedAnimated.value }), null)]));
+    };
+  }
+});
+var Tabs_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ATabs",
+  inheritAttrs: false,
+  props: initDefaultProps(tabsProps(), {
+    tabPosition: "top",
+    animated: {
+      inkBar: true,
+      tabPane: false
+    }
+  }),
+  slots: Object,
+  setup(props, _ref3) {
+    let { attrs, slots, emit } = _ref3;
+    const handleChange = (key) => {
+      emit("update:activeKey", key);
+      emit("change", key);
+    };
+    return () => {
+      var _a;
+      const tabs = parseTabList(flattenChildren((_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots)));
+      return createVNode(InternalTabs, _objectSpread2(_objectSpread2(_objectSpread2({}, omit(props, ["onUpdate:activeKey"])), attrs), {}, {
+        "onChange": handleChange,
+        "tabs": tabs
+      }), slots);
+    };
+  }
+});
+var tabPaneProps = () => ({
+  tab: PropTypes.any,
+  disabled: { type: Boolean },
+  forceRender: { type: Boolean },
+  closable: { type: Boolean },
+  animated: { type: Boolean },
+  active: { type: Boolean },
+  destroyInactiveTabPane: { type: Boolean },
+  prefixCls: { type: String },
+  tabKey: { type: [String, Number] },
+  id: { type: String }
+});
+var TabPane_default = defineComponent({
+  compatConfig: { MODE: 3 },
+  name: "ATabPane",
+  inheritAttrs: false,
+  __ANT_TAB_PANE: true,
+  props: tabPaneProps(),
+  slots: Object,
+  setup(props, _ref) {
+    let { attrs, slots } = _ref;
+    const visited = ref(props.forceRender);
+    watch([() => props.active, () => props.destroyInactiveTabPane], () => {
+      if (props.active) visited.value = true;
+      else if (props.destroyInactiveTabPane) visited.value = false;
+    }, { immediate: true });
+    const mergedStyle = computed(() => {
+      if (!props.active) {
+        if (props.animated) return {
+          visibility: "hidden",
+          height: 0,
+          overflowY: "hidden"
+        };
+        else return { display: "none" };
+      }
+      return {};
+    });
+    return () => {
+      var _a;
+      const { prefixCls, forceRender, id, active, tabKey } = props;
+      return createVNode("div", {
+        "id": id && `${id}-panel-${tabKey}`,
+        "role": "tabpanel",
+        "tabindex": active ? 0 : -1,
+        "aria-labelledby": id && `${id}-tab-${tabKey}`,
+        "aria-hidden": !active,
+        "style": [mergedStyle.value, attrs.style],
+        "class": [
+          `${prefixCls}-tabpane`,
+          active && `${prefixCls}-tabpane-active`,
+          attrs.class
+        ]
+      }, [(active || visited.value || forceRender) && ((_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots))]);
+    };
+  }
+});
+var src_default = Tabs_default;
+src_default.TabPane = TabPane_default;
+src_default.install = function(app) {
+  app.component(src_default.name, src_default);
+  app.component(TabPane_default.name, TabPane_default);
+  return app;
+};
+var tabs_default = src_default;
+
+export { TabPane_default as T, tabs_default as t, useRefs as u };
+//# sourceMappingURL=tabs-BCwBXjNt.mjs.map