@max-ts/components 0.3.6 → 0.3.8

package/lib/node_modules/.pnpm/@mui_material@6.4.6_@emotion_react@11.14.0_@types_react@19.0.10_react@19.0.0__@emotion__136ab401d202919bd655185ec974b9a4/node_modules/@mui/material/Tabs/Tabs.mjs

@@ -0,0 +1,755 @@
+import * as a from "react";
+import { r as tt } from "../../../../../../../_virtual/index3.mjs";
+import e from "../../../../../../../_virtual/index2.mjs";
+import { clsx as R } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.mjs";
+import { useRtl as ot } from "../../../../../@mui_system@6.4.6_@emotion_react@11.14.0_@types_react@19.0.10_react@19.0.0__@emotion_st_c5f7f174f9b5adeef9715dbb91d6998a/node_modules/@mui/system/esm/RtlProvider/index.mjs";
+import rt from "../styles/useTheme.mjs";
+import { j as I } from "../../../../../../../_virtual/jsx-runtime.mjs";
+import k from "../styles/styled.mjs";
+import Ee from "../utils/memoTheme.mjs";
+import lt from "../internal/animate.mjs";
+import nt from "./ScrollbarSize.mjs";
+import Q, { getTabsUtilityClass as st } from "./tabsClasses.mjs";
+import O from "../utils/useSlot.mjs";
+import { useDefaultProps as ct } from "../DefaultPropsProvider/DefaultPropsProvider.mjs";
+import we from "../../../../../@mui_utils@6.4.6_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.mjs";
+import Z from "../../../../../@mui_utils@6.4.6_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.mjs";
+import at from "../TabScrollButton/TabScrollButton.mjs";
+import it from "../../../../../@mui_utils@6.4.6_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/debounce/debounce.mjs";
+import dt from "../../../../../@mui_utils@6.4.6_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/ownerWindow/ownerWindow.mjs";
+import ut from "../../../../../@mui_utils@6.4.6_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/composeClasses/composeClasses.mjs";
+import pt from "../../../../../@mui_utils@6.4.6_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/ownerDocument/ownerDocument.mjs";
+import ft from "../../../../../@mui_utils@6.4.6_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/refType/refType.mjs";
+const Be = (r, l) => r === l ? r.firstChild : l && l.nextElementSibling ? l.nextElementSibling : r.firstChild, ge = (r, l) => r === l ? r.lastChild : l && l.previousElementSibling ? l.previousElementSibling : r.lastChild, X = (r, l, i) => {
+  let S = !1, d = i(r, l);
+  for (; d; ) {
+    if (d === r.firstChild) {
+      if (S)
+        return;
+      S = !0;
+    }
+    const u = d.disabled || d.getAttribute("aria-disabled") === "true";
+    if (!d.hasAttribute("tabindex") || u)
+      d = i(r, d);
+    else {
+      d.focus();
+      return;
+    }
+  }
+}, bt = (r) => {
+  const {
+    vertical: l,
+    fixed: i,
+    hideScrollbar: S,
+    scrollableX: d,
+    scrollableY: u,
+    centered: F,
+    scrollButtonsHideMobile: V,
+    classes: Y
+  } = r;
+  return ut({
+    root: ["root", l && "vertical"],
+    scroller: ["scroller", i && "fixed", S && "hideScrollbar", d && "scrollableX", u && "scrollableY"],
+    list: ["list", "flexContainer", l && "flexContainerVertical", l && "vertical", F && "centered"],
+    indicator: ["indicator"],
+    scrollButtons: ["scrollButtons", V && "scrollButtonsHideMobile"],
+    scrollableX: [d && "scrollableX"],
+    hideScrollbar: [S && "hideScrollbar"]
+  }, st, Y);
+}, mt = k("div", {
+  name: "MuiTabs",
+  slot: "Root",
+  overridesResolver: (r, l) => {
+    const {
+      ownerState: i
+    } = r;
+    return [{
+      [`& .${Q.scrollButtons}`]: l.scrollButtons
+    }, {
+      [`& .${Q.scrollButtons}`]: i.scrollButtonsHideMobile && l.scrollButtonsHideMobile
+    }, l.root, i.vertical && l.vertical];
+  }
+})(Ee(({
+  theme: r
+}) => ({
+  overflow: "hidden",
+  minHeight: 48,
+  // Add iOS momentum scrolling for iOS < 13.0
+  WebkitOverflowScrolling: "touch",
+  display: "flex",
+  variants: [{
+    props: ({
+      ownerState: l
+    }) => l.vertical,
+    style: {
+      flexDirection: "column"
+    }
+  }, {
+    props: ({
+      ownerState: l
+    }) => l.scrollButtonsHideMobile,
+    style: {
+      [`& .${Q.scrollButtons}`]: {
+        [r.breakpoints.down("sm")]: {
+          display: "none"
+        }
+      }
+    }
+  }]
+}))), ht = k("div", {
+  name: "MuiTabs",
+  slot: "Scroller",
+  overridesResolver: (r, l) => {
+    const {
+      ownerState: i
+    } = r;
+    return [l.scroller, i.fixed && l.fixed, i.hideScrollbar && l.hideScrollbar, i.scrollableX && l.scrollableX, i.scrollableY && l.scrollableY];
+  }
+})({
+  position: "relative",
+  display: "inline-block",
+  flex: "1 1 auto",
+  whiteSpace: "nowrap",
+  variants: [{
+    props: ({
+      ownerState: r
+    }) => r.fixed,
+    style: {
+      overflowX: "hidden",
+      width: "100%"
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.hideScrollbar,
+    style: {
+      // Hide dimensionless scrollbar on macOS
+      scrollbarWidth: "none",
+      // Firefox
+      "&::-webkit-scrollbar": {
+        display: "none"
+        // Safari + Chrome
+      }
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.scrollableX,
+    style: {
+      overflowX: "auto",
+      overflowY: "hidden"
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.scrollableY,
+    style: {
+      overflowY: "auto",
+      overflowX: "hidden"
+    }
+  }]
+}), St = k("div", {
+  name: "MuiTabs",
+  slot: "List",
+  overridesResolver: (r, l) => {
+    const {
+      ownerState: i
+    } = r;
+    return [l.list, l.flexContainer, i.vertical && l.flexContainerVertical, i.centered && l.centered];
+  }
+})({
+  display: "flex",
+  variants: [{
+    props: ({
+      ownerState: r
+    }) => r.vertical,
+    style: {
+      flexDirection: "column"
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.centered,
+    style: {
+      justifyContent: "center"
+    }
+  }]
+}), vt = k("span", {
+  name: "MuiTabs",
+  slot: "Indicator",
+  overridesResolver: (r, l) => l.indicator
+})(Ee(({
+  theme: r
+}) => ({
+  position: "absolute",
+  height: 2,
+  bottom: 0,
+  width: "100%",
+  transition: r.transitions.create(),
+  variants: [{
+    props: {
+      indicatorColor: "primary"
+    },
+    style: {
+      backgroundColor: (r.vars || r).palette.primary.main
+    }
+  }, {
+    props: {
+      indicatorColor: "secondary"
+    },
+    style: {
+      backgroundColor: (r.vars || r).palette.secondary.main
+    }
+  }, {
+    props: ({
+      ownerState: l
+    }) => l.vertical,
+    style: {
+      height: "100%",
+      width: 2,
+      right: 0
+    }
+  }]
+}))), yt = k(nt)({
+  overflowX: "auto",
+  overflowY: "hidden",
+  // Hide dimensionless scrollbar on macOS
+  scrollbarWidth: "none",
+  // Firefox
+  "&::-webkit-scrollbar": {
+    display: "none"
+    // Safari + Chrome
+  }
+}), Ie = {};
+let xe = !1;
+const Tt = /* @__PURE__ */ a.forwardRef(function(l, i) {
+  const S = ct({
+    props: l,
+    name: "MuiTabs"
+  }), d = rt(), u = ot(), {
+    "aria-label": F,
+    "aria-labelledby": V,
+    action: Y,
+    centered: H = !1,
+    children: ee,
+    className: Ce,
+    component: te = "div",
+    allowScrollButtonsMobile: oe = !1,
+    indicatorColor: Oe = "primary",
+    onChange: Me,
+    orientation: y = "horizontal",
+    ScrollButtonComponent: wt,
+    // TODO: remove in v7 (deprecated in v6)
+    scrollButtons: x = "auto",
+    selectionFollowsFocus: Pe,
+    slots: T = {},
+    slotProps: U = {},
+    TabIndicatorProps: re = {},
+    // TODO: remove in v7 (deprecated in v6)
+    TabScrollButtonProps: le = {},
+    // TODO: remove in v7 (deprecated in v6)
+    textColor: ne = "primary",
+    value: E,
+    variant: $ = "standard",
+    visibleScrollbar: _ = !1,
+    ...je
+  } = S, p = $ === "scrollable", f = y === "vertical", M = f ? "scrollTop" : "scrollLeft", z = f ? "top" : "left", D = f ? "bottom" : "right", K = f ? "clientHeight" : "clientWidth", P = f ? "height" : "width", m = {
+    ...S,
+    component: te,
+    allowScrollButtonsMobile: oe,
+    indicatorColor: Oe,
+    orientation: y,
+    vertical: f,
+    scrollButtons: x,
+    textColor: ne,
+    variant: $,
+    visibleScrollbar: _,
+    fixed: !p,
+    hideScrollbar: p && !_,
+    scrollableX: p && !f,
+    scrollableY: p && f,
+    centered: H && !p,
+    scrollButtonsHideMobile: !oe
+  }, v = bt(m), Ne = we({
+    elementType: T.StartScrollButtonIcon,
+    externalSlotProps: U.startScrollButtonIcon,
+    ownerState: m
+  }), Re = we({
+    elementType: T.EndScrollButtonIcon,
+    externalSlotProps: U.endScrollButtonIcon,
+    ownerState: m
+  });
+  process.env.NODE_ENV !== "production" && H && p && console.error('MUI: You can not use the `centered={true}` and `variant="scrollable"` properties at the same time on a `Tabs` component.');
+  const [se, ke] = a.useState(!1), [w, ce] = a.useState(Ie), [ae, ze] = a.useState(!1), [ie, De] = a.useState(!1), [de, Le] = a.useState(!1), [ue, Ae] = a.useState({
+    overflow: "hidden",
+    scrollbarWidth: 0
+  }), L = /* @__PURE__ */ new Map(), h = a.useRef(null), B = a.useRef(null), C = {
+    slots: T,
+    slotProps: {
+      indicator: re,
+      scrollButton: le,
+      ...U
+    }
+  }, pe = () => {
+    const t = h.current;
+    let o;
+    if (t) {
+      const s = t.getBoundingClientRect();
+      o = {
+        clientWidth: t.clientWidth,
+        scrollLeft: t.scrollLeft,
+        scrollTop: t.scrollTop,
+        scrollWidth: t.scrollWidth,
+        top: s.top,
+        bottom: s.bottom,
+        left: s.left,
+        right: s.right
+      };
+    }
+    let n;
+    if (t && E !== !1) {
+      const s = B.current.children;
+      if (s.length > 0) {
+        const c = s[L.get(E)];
+        process.env.NODE_ENV !== "production" && (c || console.error(["MUI: The `value` provided to the Tabs component is invalid.", `None of the Tabs' children match with "${E}".`, L.keys ? `You can provide one of the following values: ${Array.from(L.keys()).join(", ")}.` : null].join(`
+`))), n = c ? c.getBoundingClientRect() : null, process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test" && !xe && n && n.width === 0 && n.height === 0 && // if the whole Tabs component is hidden, don't warn
+        o.clientWidth !== 0 && (o = null, console.error(["MUI: The `value` provided to the Tabs component is invalid.", `The Tab with this \`value\` ("${E}") is not part of the document layout.`, "Make sure the tab item is present in the document or that it's not `display: none`."].join(`
+`)), xe = !0);
+      }
+    }
+    return {
+      tabsMeta: o,
+      tabMeta: n
+    };
+  }, j = Z(() => {
+    const {
+      tabsMeta: t,
+      tabMeta: o
+    } = pe();
+    let n = 0, s;
+    f ? (s = "top", o && t && (n = o.top - t.top + t.scrollTop)) : (s = u ? "right" : "left", o && t && (n = (u ? -1 : 1) * (o[s] - t[s] + t.scrollLeft)));
+    const c = {
+      [s]: n,
+      // May be wrong until the font is loaded.
+      [P]: o ? o[P] : 0
+    };
+    if (typeof w[s] != "number" || typeof w[P] != "number")
+      ce(c);
+    else {
+      const b = Math.abs(w[s] - c[s]), g = Math.abs(w[P] - c[P]);
+      (b >= 1 || g >= 1) && ce(c);
+    }
+  }), q = (t, {
+    animation: o = !0
+  } = {}) => {
+    o ? lt(M, h.current, t, {
+      duration: d.transitions.duration.standard
+    }) : h.current[M] = t;
+  }, fe = (t) => {
+    let o = h.current[M];
+    f ? o += t : o += t * (u ? -1 : 1), q(o);
+  }, be = () => {
+    const t = h.current[K];
+    let o = 0;
+    const n = Array.from(B.current.children);
+    for (let s = 0; s < n.length; s += 1) {
+      const c = n[s];
+      if (o + c[K] > t) {
+        s === 0 && (o = t);
+        break;
+      }
+      o += c[K];
+    }
+    return o;
+  }, We = () => {
+    fe(-1 * be());
+  }, Xe = () => {
+    fe(be());
+  }, [Fe, {
+    onChange: me,
+    ...Ve
+  }] = O("scrollbar", {
+    className: R(v.scrollableX, v.hideScrollbar),
+    elementType: yt,
+    shouldForwardComponentProp: !0,
+    externalForwardedProps: C,
+    ownerState: m
+  }), Ye = a.useCallback((t) => {
+    me?.(t), Ae({
+      overflow: null,
+      scrollbarWidth: t
+    });
+  }, [me]), [he, Se] = O("scrollButtons", {
+    className: R(v.scrollButtons, le.className),
+    elementType: at,
+    externalForwardedProps: C,
+    ownerState: m,
+    additionalProps: {
+      orientation: y,
+      slots: {
+        StartScrollButtonIcon: T.startScrollButtonIcon || T.StartScrollButtonIcon,
+        EndScrollButtonIcon: T.endScrollButtonIcon || T.EndScrollButtonIcon
+      },
+      slotProps: {
+        startScrollButtonIcon: Ne,
+        endScrollButtonIcon: Re
+      }
+    }
+  }), He = () => {
+    const t = {};
+    t.scrollbarSizeListener = p ? /* @__PURE__ */ I.jsx(Fe, {
+      ...Ve,
+      onChange: Ye
+    }) : null;
+    const n = p && (x === "auto" && (ae || ie) || x === !0);
+    return t.scrollButtonStart = n ? /* @__PURE__ */ I.jsx(he, {
+      direction: u ? "right" : "left",
+      onClick: We,
+      disabled: !ae,
+      ...Se
+    }) : null, t.scrollButtonEnd = n ? /* @__PURE__ */ I.jsx(he, {
+      direction: u ? "left" : "right",
+      onClick: Xe,
+      disabled: !ie,
+      ...Se
+    }) : null, t;
+  }, ve = Z((t) => {
+    const {
+      tabsMeta: o,
+      tabMeta: n
+    } = pe();
+    if (!(!n || !o)) {
+      if (n[z] < o[z]) {
+        const s = o[M] + (n[z] - o[z]);
+        q(s, {
+          animation: t
+        });
+      } else if (n[D] > o[D]) {
+        const s = o[M] + (n[D] - o[D]);
+        q(s, {
+          animation: t
+        });
+      }
+    }
+  }), A = Z(() => {
+    p && x !== !1 && Le(!de);
+  });
+  a.useEffect(() => {
+    const t = it(() => {
+      h.current && j();
+    });
+    let o;
+    const n = (b) => {
+      b.forEach((g) => {
+        g.removedNodes.forEach((N) => {
+          o?.unobserve(N);
+        }), g.addedNodes.forEach((N) => {
+          o?.observe(N);
+        });
+      }), t(), A();
+    }, s = dt(h.current);
+    s.addEventListener("resize", t);
+    let c;
+    return typeof ResizeObserver < "u" && (o = new ResizeObserver(t), Array.from(B.current.children).forEach((b) => {
+      o.observe(b);
+    })), typeof MutationObserver < "u" && (c = new MutationObserver(n), c.observe(B.current, {
+      childList: !0
+    })), () => {
+      t.clear(), s.removeEventListener("resize", t), c?.disconnect(), o?.disconnect();
+    };
+  }, [j, A]), a.useEffect(() => {
+    const t = Array.from(B.current.children), o = t.length;
+    if (typeof IntersectionObserver < "u" && o > 0 && p && x !== !1) {
+      const n = t[0], s = t[o - 1], c = {
+        root: h.current,
+        threshold: 0.99
+      }, b = (J) => {
+        ze(!J[0].isIntersecting);
+      }, g = new IntersectionObserver(b, c);
+      g.observe(n);
+      const N = (J) => {
+        De(!J[0].isIntersecting);
+      }, Te = new IntersectionObserver(N, c);
+      return Te.observe(s), () => {
+        g.disconnect(), Te.disconnect();
+      };
+    }
+  }, [p, x, de, ee?.length]), a.useEffect(() => {
+    ke(!0);
+  }, []), a.useEffect(() => {
+    j();
+  }), a.useEffect(() => {
+    ve(Ie !== w);
+  }, [ve, w]), a.useImperativeHandle(Y, () => ({
+    updateIndicator: j,
+    updateScrollButtons: A
+  }), [j, A]);
+  const [Ue, $e] = O("indicator", {
+    className: R(v.indicator, re.className),
+    elementType: vt,
+    externalForwardedProps: C,
+    ownerState: m,
+    additionalProps: {
+      style: w
+    }
+  }), ye = /* @__PURE__ */ I.jsx(Ue, {
+    ...$e
+  });
+  let W = 0;
+  const _e = a.Children.map(ee, (t) => {
+    if (!/* @__PURE__ */ a.isValidElement(t))
+      return null;
+    process.env.NODE_ENV !== "production" && tt.isFragment(t) && console.error(["MUI: The Tabs component doesn't accept a Fragment as a child.", "Consider providing an array instead."].join(`
+`));
+    const o = t.props.value === void 0 ? W : t.props.value;
+    L.set(o, W);
+    const n = o === E;
+    return W += 1, /* @__PURE__ */ a.cloneElement(t, {
+      fullWidth: $ === "fullWidth",
+      indicator: n && !se && ye,
+      selected: n,
+      selectionFollowsFocus: Pe,
+      onChange: Me,
+      textColor: ne,
+      value: o,
+      ...W === 1 && E === !1 && !t.props.tabIndex ? {
+        tabIndex: 0
+      } : {}
+    });
+  }), Ke = (t) => {
+    const o = B.current, n = pt(o).activeElement;
+    if (n.getAttribute("role") !== "tab")
+      return;
+    let c = y === "horizontal" ? "ArrowLeft" : "ArrowUp", b = y === "horizontal" ? "ArrowRight" : "ArrowDown";
+    switch (y === "horizontal" && u && (c = "ArrowRight", b = "ArrowLeft"), t.key) {
+      case c:
+        t.preventDefault(), X(o, n, ge);
+        break;
+      case b:
+        t.preventDefault(), X(o, n, Be);
+        break;
+      case "Home":
+        t.preventDefault(), X(o, null, Be);
+        break;
+      case "End":
+        t.preventDefault(), X(o, null, ge);
+        break;
+    }
+  }, G = He(), [qe, Ge] = O("root", {
+    ref: i,
+    className: R(v.root, Ce),
+    elementType: mt,
+    externalForwardedProps: {
+      ...C,
+      ...je,
+      component: te
+    },
+    ownerState: m
+  }), [Je, Qe] = O("scroller", {
+    ref: h,
+    className: v.scroller,
+    elementType: ht,
+    externalForwardedProps: C,
+    ownerState: m,
+    additionalProps: {
+      style: {
+        overflow: ue.overflow,
+        [f ? `margin${u ? "Left" : "Right"}` : "marginBottom"]: _ ? void 0 : -ue.scrollbarWidth
+      }
+    }
+  }), [Ze, et] = O("list", {
+    ref: B,
+    className: R(v.list, v.flexContainer),
+    elementType: St,
+    externalForwardedProps: C,
+    ownerState: m,
+    getSlotProps: (t) => ({
+      ...t,
+      onKeyDown: (o) => {
+        Ke(o), t.onKeyDown?.(o);
+      }
+    })
+  });
+  return /* @__PURE__ */ I.jsxs(qe, {
+    ...Ge,
+    children: [G.scrollButtonStart, G.scrollbarSizeListener, /* @__PURE__ */ I.jsxs(Je, {
+      ...Qe,
+      children: [/* @__PURE__ */ I.jsx(Ze, {
+        "aria-label": F,
+        "aria-labelledby": V,
+        "aria-orientation": y === "vertical" ? "vertical" : null,
+        role: "tablist",
+        ...et,
+        children: _e
+      }), se && ye]
+    }), G.scrollButtonEnd]
+  });
+});
+process.env.NODE_ENV !== "production" && (Tt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Callback fired when the component mounts.
+   * This is useful when you want to trigger an action programmatically.
+   * It supports two actions: `updateIndicator()` and `updateScrollButtons()`
+   *
+   * @param {object} actions This object contains all possible actions
+   * that can be triggered programmatically.
+   */
+  action: ft,
+  /**
+   * If `true`, the scroll buttons aren't forced hidden on mobile.
+   * By default the scroll buttons are hidden on mobile and takes precedence over `scrollButtons`.
+   * @default false
+   */
+  allowScrollButtonsMobile: e.bool,
+  /**
+   * The label for the Tabs as a string.
+   */
+  "aria-label": e.string,
+  /**
+   * An id or list of ids separated by a space that label the Tabs.
+   */
+  "aria-labelledby": e.string,
+  /**
+   * If `true`, the tabs are centered.
+   * This prop is intended for large views.
+   * @default false
+   */
+  centered: e.bool,
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * Determines the color of the indicator.
+   * @default 'primary'
+   */
+  indicatorColor: e.oneOfType([e.oneOf(["primary", "secondary"]), e.string]),
+  /**
+   * Callback fired when the value changes.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback. **Warning**: This is a generic event not a change event.
+   * @param {any} value We default to the index of the child (number)
+   */
+  onChange: e.func,
+  /**
+   * The component orientation (layout flow direction).
+   * @default 'horizontal'
+   */
+  orientation: e.oneOf(["horizontal", "vertical"]),
+  /**
+   * The component used to render the scroll buttons.
+   * @deprecated use the `slots.scrollButtons` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   * @default TabScrollButton
+   */
+  ScrollButtonComponent: e.elementType,
+  /**
+   * Determine behavior of scroll buttons when tabs are set to scroll:
+   *
+   * - `auto` will only present them when not all the items are visible.
+   * - `true` will always present them.
+   * - `false` will never present them.
+   *
+   * By default the scroll buttons are hidden on mobile.
+   * This behavior can be disabled with `allowScrollButtonsMobile`.
+   * @default 'auto'
+   */
+  scrollButtons: e.oneOf(["auto", !1, !0]),
+  /**
+   * If `true` the selected tab changes on focus. Otherwise it only
+   * changes on activation.
+   */
+  selectionFollowsFocus: e.bool,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    endScrollButtonIcon: e.oneOfType([e.func, e.object]),
+    indicator: e.oneOfType([e.func, e.object]),
+    list: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object]),
+    scrollbar: e.oneOfType([e.func, e.object]),
+    scrollButtons: e.oneOfType([e.func, e.object]),
+    scroller: e.oneOfType([e.func, e.object]),
+    startScrollButtonIcon: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    endScrollButtonIcon: e.elementType,
+    EndScrollButtonIcon: e.elementType,
+    indicator: e.elementType,
+    list: e.elementType,
+    root: e.elementType,
+    scrollbar: e.elementType,
+    scrollButtons: e.elementType,
+    scroller: e.elementType,
+    startScrollButtonIcon: e.elementType,
+    StartScrollButtonIcon: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * Props applied to the tab indicator element.
+   * @deprecated use the `slotProps.indicator` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   * @default  {}
+   */
+  TabIndicatorProps: e.object,
+  /**
+   * Props applied to the [`TabScrollButton`](https://mui.com/material-ui/api/tab-scroll-button/) element.
+   * @deprecated use the `slotProps.scrollButtons` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   * @default {}
+   */
+  TabScrollButtonProps: e.object,
+  /**
+   * Determines the color of the `Tab`.
+   * @default 'primary'
+   */
+  textColor: e.oneOf(["inherit", "primary", "secondary"]),
+  /**
+   * The value of the currently selected `Tab`.
+   * If you don't want any selected `Tab`, you can set this prop to `false`.
+   */
+  value: e.any,
+  /**
+   * Determines additional display behavior of the tabs:
+   *
+   *  - `scrollable` will invoke scrolling properties and allow for horizontally
+   *  scrolling (or swiping) of the tab bar.
+   *  - `fullWidth` will make the tabs grow to use all the available space,
+   *  which should be used for small views, like on mobile.
+   *  - `standard` will render the default state.
+   * @default 'standard'
+   */
+  variant: e.oneOf(["fullWidth", "scrollable", "standard"]),
+  /**
+   * If `true`, the scrollbar is visible. It can be useful when displaying
+   * a long vertical list of tabs.
+   * @default false
+   */
+  visibleScrollbar: e.bool
+});
+export {
+  Tt as default
+};