@hybridcore/ui 1.3.7 → 1.4.0

package/dist/Tabs-BzelDJKy.js

@@ -0,0 +1,787 @@
+import { a as se, _ as b } from "./objectWithoutPropertiesLoose-BK36oJDi.js";
+import * as d from "react";
+import { P as l, r as Ke } from "./createStyled-BzvgQjjR.js";
+import { g as Be, u as Ee, c as L, a as Me } from "./useThemeProps-uYx_RkOH.js";
+import { g as Ne, s as O } from "./styled-LNCprp4n.js";
+import { u as Re } from "./useTheme-DBiahn6p.js";
+import { jsx as y, jsxs as ve } from "react/jsx-runtime";
+import { o as ze } from "./ownerWindow-niciwP7I.js";
+import { d as ne } from "./debounce-46wSf_lW.js";
+import { B as qe, b as re, r as Ge } from "./ButtonBase-D0qccOVb.js";
+import { c as Ie } from "./createSvgIcon-DEXLbMwp.js";
+import { o as Je } from "./ownerDocument-CUrv0DIK.js";
+let I;
+function Le() {
+  if (I)
+    return I;
+  const e = document.createElement("div"), t = document.createElement("div");
+  return t.style.width = "10px", t.style.height = "1px", e.appendChild(t), e.dir = "rtl", e.style.fontSize = "14px", e.style.width = "4px", e.style.height = "1px", e.style.position = "absolute", e.style.top = "-1000px", e.style.overflow = "scroll", document.body.appendChild(e), I = "reverse", e.scrollLeft > 0 ? I = "default" : (e.scrollLeft = 1, e.scrollLeft === 0 && (I = "negative")), document.body.removeChild(e), I;
+}
+function Se(e, t) {
+  const s = e.scrollLeft;
+  if (t !== "rtl")
+    return s;
+  switch (Le()) {
+    case "negative":
+      return e.scrollWidth - e.clientWidth + s;
+    case "reverse":
+      return e.scrollWidth - e.clientWidth - s;
+    default:
+      return s;
+  }
+}
+function Qe(e) {
+  return (1 + Math.sin(Math.PI * e - Math.PI / 2)) / 2;
+}
+function Ze(e, t, s, c = {}, a = () => {
+}) {
+  const {
+    ease: u = Qe,
+    duration: p = 300
+    // standard
+  } = c;
+  let m = null;
+  const v = t[e];
+  let w = !1;
+  const M = () => {
+    w = !0;
+  }, _ = (W) => {
+    if (w) {
+      a(new Error("Animation cancelled"));
+      return;
+    }
+    m === null && (m = W);
+    const k = Math.min(1, (W - m) / p);
+    if (t[e] = u(k) * (s - v) + v, k >= 1) {
+      requestAnimationFrame(() => {
+        a(null);
+      });
+      return;
+    }
+    requestAnimationFrame(_);
+  };
+  return v === s ? (a(new Error("Element already at target position")), M) : (requestAnimationFrame(_), M);
+}
+const et = ["onChange"], tt = {
+  width: 99,
+  height: 99,
+  position: "absolute",
+  top: -9999,
+  overflow: "scroll"
+};
+function Oe(e) {
+  const {
+    onChange: t
+  } = e, s = se(e, et), c = d.useRef(), a = d.useRef(null), u = () => {
+    c.current = a.current.offsetHeight - a.current.clientHeight;
+  };
+  return d.useEffect(() => {
+    const p = ne(() => {
+      const v = c.current;
+      u(), v !== c.current && t(c.current);
+    }), m = ze(a.current);
+    return m.addEventListener("resize", p), () => {
+      p.clear(), m.removeEventListener("resize", p);
+    };
+  }, [t]), d.useEffect(() => {
+    u(), t(c.current);
+  }, [t]), /* @__PURE__ */ y("div", b({
+    style: tt,
+    ref: a
+  }, s));
+}
+process.env.NODE_ENV !== "production" && (Oe.propTypes = {
+  onChange: l.func.isRequired
+});
+const ot = Ie(/* @__PURE__ */ y("path", {
+  d: "M15.41 16.09l-4.58-4.59 4.58-4.59L14 5.5l-6 6 6 6z"
+}), "KeyboardArrowLeft"), rt = Ie(/* @__PURE__ */ y("path", {
+  d: "M8.59 16.34l4.58-4.59-4.58-4.59L10 5.75l6 6-6 6z"
+}), "KeyboardArrowRight");
+function lt(e) {
+  return Ne("MuiTabScrollButton", e);
+}
+const nt = Be("MuiTabScrollButton", ["root", "vertical", "horizontal", "disabled"]);
+var ye, ge;
+const st = ["className", "direction", "orientation", "disabled"], it = (e) => {
+  const {
+    classes: t,
+    orientation: s,
+    disabled: c
+  } = e;
+  return Me({
+    root: ["root", s, c && "disabled"]
+  }, lt, t);
+}, at = O(qe, {
+  name: "MuiTabScrollButton",
+  slot: "Root",
+  overridesResolver: (e, t) => {
+    const {
+      ownerState: s
+    } = e;
+    return [t.root, s.orientation && t[s.orientation]];
+  }
+})(({
+  ownerState: e
+}) => b({
+  width: 40,
+  flexShrink: 0,
+  opacity: 0.8,
+  [`&.${nt.disabled}`]: {
+    opacity: 0
+  }
+}, e.orientation === "vertical" && {
+  width: "100%",
+  height: 40,
+  "& svg": {
+    transform: `rotate(${e.isRtl ? -90 : 90}deg)`
+  }
+})), We = /* @__PURE__ */ d.forwardRef(function(t, s) {
+  const c = Ee({
+    props: t,
+    name: "MuiTabScrollButton"
+  }), {
+    className: a,
+    direction: u
+  } = c, p = se(c, st), v = Re().direction === "rtl", w = b({
+    isRtl: v
+  }, c), M = it(w);
+  return /* @__PURE__ */ y(at, b({
+    component: "div",
+    className: L(M.root, a),
+    ref: s,
+    role: null,
+    ownerState: w,
+    tabIndex: null
+  }, p, {
+    children: u === "left" ? ye || (ye = /* @__PURE__ */ y(ot, {
+      fontSize: "small"
+    })) : ge || (ge = /* @__PURE__ */ y(rt, {
+      fontSize: "small"
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (We.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn proptypes"     |
+  // ----------------------------------------------------------------------
+  /**
+   * The content of the component.
+   */
+  children: l.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: l.object,
+  /**
+   * @ignore
+   */
+  className: l.string,
+  /**
+   * The direction the button should indicate.
+   */
+  direction: l.oneOf(["left", "right"]).isRequired,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: l.bool,
+  /**
+   * The component orientation (layout flow direction).
+   */
+  orientation: l.oneOf(["horizontal", "vertical"]).isRequired,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: l.oneOfType([l.arrayOf(l.oneOfType([l.func, l.object, l.bool])), l.func, l.object])
+});
+function ct(e) {
+  return Ne("MuiTabs", e);
+}
+const le = Be("MuiTabs", ["root", "vertical", "flexContainer", "flexContainerVertical", "centered", "scroller", "fixed", "scrollableX", "scrollableY", "hideScrollbar", "scrollButtons", "scrollButtonsHideMobile", "indicator"]), dt = ["aria-label", "aria-labelledby", "action", "centered", "children", "className", "component", "allowScrollButtonsMobile", "indicatorColor", "onChange", "orientation", "ScrollButtonComponent", "scrollButtons", "selectionFollowsFocus", "TabIndicatorProps", "TabScrollButtonProps", "textColor", "value", "variant", "visibleScrollbar"], we = (e, t) => e === t ? e.firstChild : t && t.nextElementSibling ? t.nextElementSibling : e.firstChild, Te = (e, t) => e === t ? e.lastChild : t && t.previousElementSibling ? t.previousElementSibling : e.lastChild, q = (e, t, s) => {
+  let c = !1, a = s(e, t);
+  for (; a; ) {
+    if (a === e.firstChild) {
+      if (c)
+        return;
+      c = !0;
+    }
+    const u = a.disabled || a.getAttribute("aria-disabled") === "true";
+    if (!a.hasAttribute("tabindex") || u)
+      a = s(e, a);
+    else {
+      a.focus();
+      return;
+    }
+  }
+}, ut = (e) => {
+  const {
+    vertical: t,
+    fixed: s,
+    hideScrollbar: c,
+    scrollableX: a,
+    scrollableY: u,
+    centered: p,
+    scrollButtonsHideMobile: m,
+    classes: v
+  } = e;
+  return Me({
+    root: ["root", t && "vertical"],
+    scroller: ["scroller", s && "fixed", c && "hideScrollbar", a && "scrollableX", u && "scrollableY"],
+    flexContainer: ["flexContainer", t && "flexContainerVertical", p && "centered"],
+    indicator: ["indicator"],
+    scrollButtons: ["scrollButtons", m && "scrollButtonsHideMobile"],
+    scrollableX: [a && "scrollableX"],
+    hideScrollbar: [c && "hideScrollbar"]
+  }, ct, v);
+}, ft = O("div", {
+  name: "MuiTabs",
+  slot: "Root",
+  overridesResolver: (e, t) => {
+    const {
+      ownerState: s
+    } = e;
+    return [{
+      [`& .${le.scrollButtons}`]: t.scrollButtons
+    }, {
+      [`& .${le.scrollButtons}`]: s.scrollButtonsHideMobile && t.scrollButtonsHideMobile
+    }, t.root, s.vertical && t.vertical];
+  }
+})(({
+  ownerState: e,
+  theme: t
+}) => b({
+  overflow: "hidden",
+  minHeight: 48,
+  // Add iOS momentum scrolling for iOS < 13.0
+  WebkitOverflowScrolling: "touch",
+  display: "flex"
+}, e.vertical && {
+  flexDirection: "column"
+}, e.scrollButtonsHideMobile && {
+  [`& .${le.scrollButtons}`]: {
+    [t.breakpoints.down("sm")]: {
+      display: "none"
+    }
+  }
+})), bt = O("div", {
+  name: "MuiTabs",
+  slot: "Scroller",
+  overridesResolver: (e, t) => {
+    const {
+      ownerState: s
+    } = e;
+    return [t.scroller, s.fixed && t.fixed, s.hideScrollbar && t.hideScrollbar, s.scrollableX && t.scrollableX, s.scrollableY && t.scrollableY];
+  }
+})(({
+  ownerState: e
+}) => b({
+  position: "relative",
+  display: "inline-block",
+  flex: "1 1 auto",
+  whiteSpace: "nowrap"
+}, e.fixed && {
+  overflowX: "hidden",
+  width: "100%"
+}, e.hideScrollbar && {
+  // Hide dimensionless scrollbar on macOS
+  scrollbarWidth: "none",
+  // Firefox
+  "&::-webkit-scrollbar": {
+    display: "none"
+    // Safari + Chrome
+  }
+}, e.scrollableX && {
+  overflowX: "auto",
+  overflowY: "hidden"
+}, e.scrollableY && {
+  overflowY: "auto",
+  overflowX: "hidden"
+})), ht = O("div", {
+  name: "MuiTabs",
+  slot: "FlexContainer",
+  overridesResolver: (e, t) => {
+    const {
+      ownerState: s
+    } = e;
+    return [t.flexContainer, s.vertical && t.flexContainerVertical, s.centered && t.centered];
+  }
+})(({
+  ownerState: e
+}) => b({
+  display: "flex"
+}, e.vertical && {
+  flexDirection: "column"
+}, e.centered && {
+  justifyContent: "center"
+})), pt = O("span", {
+  name: "MuiTabs",
+  slot: "Indicator",
+  overridesResolver: (e, t) => t.indicator
+})(({
+  ownerState: e,
+  theme: t
+}) => b({
+  position: "absolute",
+  height: 2,
+  bottom: 0,
+  width: "100%",
+  transition: t.transitions.create()
+}, e.indicatorColor === "primary" && {
+  backgroundColor: (t.vars || t).palette.primary.main
+}, e.indicatorColor === "secondary" && {
+  backgroundColor: (t.vars || t).palette.secondary.main
+}, e.vertical && {
+  height: "100%",
+  width: 2,
+  right: 0
+})), mt = O(Oe, {
+  name: "MuiTabs",
+  slot: "ScrollbarSize"
+})({
+  overflowX: "auto",
+  overflowY: "hidden",
+  // Hide dimensionless scrollbar on macOS
+  scrollbarWidth: "none",
+  // Firefox
+  "&::-webkit-scrollbar": {
+    display: "none"
+    // Safari + Chrome
+  }
+}), Ce = {};
+let xe = !1;
+const vt = /* @__PURE__ */ d.forwardRef(function(t, s) {
+  const c = Ee({
+    props: t,
+    name: "MuiTabs"
+  }), a = Re(), u = a.direction === "rtl", {
+    "aria-label": p,
+    "aria-labelledby": m,
+    action: v,
+    centered: w = !1,
+    children: M,
+    className: _,
+    component: W = "div",
+    allowScrollButtonsMobile: k = !1,
+    indicatorColor: ke = "primary",
+    onChange: Ae,
+    orientation: C = "horizontal",
+    ScrollButtonComponent: ie = We,
+    scrollButtons: V = "auto",
+    selectionFollowsFocus: De,
+    TabIndicatorProps: G = {},
+    TabScrollButtonProps: P = {},
+    textColor: ae = "primary",
+    value: N,
+    variant: J = "standard",
+    visibleScrollbar: Q = !1
+  } = c, He = se(c, dt), T = J === "scrollable", h = C === "vertical", A = h ? "scrollTop" : "scrollLeft", X = h ? "top" : "left", Y = h ? "bottom" : "right", Z = h ? "clientHeight" : "clientWidth", D = h ? "height" : "width", H = b({}, c, {
+    component: W,
+    allowScrollButtonsMobile: k,
+    indicatorColor: ke,
+    orientation: C,
+    vertical: h,
+    scrollButtons: V,
+    textColor: ae,
+    variant: J,
+    visibleScrollbar: Q,
+    fixed: !T,
+    hideScrollbar: T && !Q,
+    scrollableX: T && !h,
+    scrollableY: T && h,
+    centered: w && !T,
+    scrollButtonsHideMobile: !k
+  }), x = ut(H);
+  process.env.NODE_ENV !== "production" && w && T && console.error('MUI: You can not use the `centered={true}` and `variant="scrollable"` properties at the same time on a `Tabs` component.');
+  const [ce, je] = d.useState(!1), [B, de] = d.useState(Ce), [R, Fe] = d.useState({
+    start: !1,
+    end: !1
+  }), [ue, _e] = d.useState({
+    overflow: "hidden",
+    scrollbarWidth: 0
+  }), $ = /* @__PURE__ */ new Map(), g = d.useRef(null), j = d.useRef(null), fe = () => {
+    const o = g.current;
+    let r;
+    if (o) {
+      const i = o.getBoundingClientRect();
+      r = {
+        clientWidth: o.clientWidth,
+        scrollLeft: o.scrollLeft,
+        scrollTop: o.scrollTop,
+        scrollLeftNormalized: Se(o, a.direction),
+        scrollWidth: o.scrollWidth,
+        top: i.top,
+        bottom: i.bottom,
+        left: i.left,
+        right: i.right
+      };
+    }
+    let n;
+    if (o && N !== !1) {
+      const i = j.current.children;
+      if (i.length > 0) {
+        const f = i[$.get(N)];
+        process.env.NODE_ENV !== "production" && (f || console.error(["MUI: The `value` provided to the Tabs component is invalid.", `None of the Tabs' children match with "${N}".`, $.keys ? `You can provide one of the following values: ${Array.from($.keys()).join(", ")}.` : null].join(`
+`))), n = f ? f.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
+        r.clientWidth !== 0 && (r = null, console.error(["MUI: The `value` provided to the Tabs component is invalid.", `The Tab with this \`value\` ("${N}") 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: r,
+      tabMeta: n
+    };
+  }, F = re(() => {
+    const {
+      tabsMeta: o,
+      tabMeta: r
+    } = fe();
+    let n = 0, i;
+    if (h)
+      i = "top", r && o && (n = r.top - o.top + o.scrollTop);
+    else if (i = u ? "right" : "left", r && o) {
+      const S = u ? o.scrollLeftNormalized + o.clientWidth - o.scrollWidth : o.scrollLeft;
+      n = (u ? -1 : 1) * (r[i] - o[i] + S);
+    }
+    const f = {
+      [i]: n,
+      // May be wrong until the font is loaded.
+      [D]: r ? r[D] : 0
+    };
+    if (isNaN(B[i]) || isNaN(B[D]))
+      de(f);
+    else {
+      const S = Math.abs(B[i] - f[i]), z = Math.abs(B[D] - f[D]);
+      (S >= 1 || z >= 1) && de(f);
+    }
+  }), ee = (o, {
+    animation: r = !0
+  } = {}) => {
+    r ? Ze(A, g.current, o, {
+      duration: a.transitions.duration.standard
+    }) : g.current[A] = o;
+  }, be = (o) => {
+    let r = g.current[A];
+    h ? r += o : (r += o * (u ? -1 : 1), r *= u && Le() === "reverse" ? -1 : 1), ee(r);
+  }, he = () => {
+    const o = g.current[Z];
+    let r = 0;
+    const n = Array.from(j.current.children);
+    for (let i = 0; i < n.length; i += 1) {
+      const f = n[i];
+      if (r + f[Z] > o) {
+        i === 0 && (r = o);
+        break;
+      }
+      r += f[Z];
+    }
+    return r;
+  }, Ve = () => {
+    be(-1 * he());
+  }, Pe = () => {
+    be(he());
+  }, Xe = d.useCallback((o) => {
+    _e({
+      overflow: null,
+      scrollbarWidth: o
+    });
+  }, []), Ye = () => {
+    const o = {};
+    o.scrollbarSizeListener = T ? /* @__PURE__ */ y(mt, {
+      onChange: Xe,
+      className: L(x.scrollableX, x.hideScrollbar)
+    }) : null;
+    const r = R.start || R.end, n = T && (V === "auto" && r || V === !0);
+    return o.scrollButtonStart = n ? /* @__PURE__ */ y(ie, b({
+      orientation: C,
+      direction: u ? "right" : "left",
+      onClick: Ve,
+      disabled: !R.start
+    }, P, {
+      className: L(x.scrollButtons, P.className)
+    })) : null, o.scrollButtonEnd = n ? /* @__PURE__ */ y(ie, b({
+      orientation: C,
+      direction: u ? "left" : "right",
+      onClick: Pe,
+      disabled: !R.end
+    }, P, {
+      className: L(x.scrollButtons, P.className)
+    })) : null, o;
+  }, pe = re((o) => {
+    const {
+      tabsMeta: r,
+      tabMeta: n
+    } = fe();
+    if (!(!n || !r)) {
+      if (n[X] < r[X]) {
+        const i = r[A] + (n[X] - r[X]);
+        ee(i, {
+          animation: o
+        });
+      } else if (n[Y] > r[Y]) {
+        const i = r[A] + (n[Y] - r[Y]);
+        ee(i, {
+          animation: o
+        });
+      }
+    }
+  }), E = re(() => {
+    if (T && V !== !1) {
+      const {
+        scrollTop: o,
+        scrollHeight: r,
+        clientHeight: n,
+        scrollWidth: i,
+        clientWidth: f
+      } = g.current;
+      let S, z;
+      if (h)
+        S = o > 1, z = o < r - n - 1;
+      else {
+        const K = Se(g.current, a.direction);
+        S = u ? K < i - f - 1 : K > 1, z = u ? K > 1 : K < i - f - 1;
+      }
+      (S !== R.start || z !== R.end) && Fe({
+        start: S,
+        end: z
+      });
+    }
+  });
+  d.useEffect(() => {
+    const o = ne(() => {
+      g.current && (F(), E());
+    }), r = ze(g.current);
+    r.addEventListener("resize", o);
+    let n;
+    return typeof ResizeObserver < "u" && (n = new ResizeObserver(o), Array.from(j.current.children).forEach((i) => {
+      n.observe(i);
+    })), () => {
+      o.clear(), r.removeEventListener("resize", o), n && n.disconnect();
+    };
+  }, [F, E]);
+  const te = d.useMemo(() => ne(() => {
+    E();
+  }), [E]);
+  d.useEffect(() => () => {
+    te.clear();
+  }, [te]), d.useEffect(() => {
+    je(!0);
+  }, []), d.useEffect(() => {
+    F(), E();
+  }), d.useEffect(() => {
+    pe(Ce !== B);
+  }, [pe, B]), d.useImperativeHandle(v, () => ({
+    updateIndicator: F,
+    updateScrollButtons: E
+  }), [F, E]);
+  const me = /* @__PURE__ */ y(pt, b({}, G, {
+    className: L(x.indicator, G.className),
+    ownerState: H,
+    style: b({}, B, G.style)
+  }));
+  let U = 0;
+  const $e = d.Children.map(M, (o) => {
+    if (!/* @__PURE__ */ d.isValidElement(o))
+      return null;
+    process.env.NODE_ENV !== "production" && Ke.isFragment(o) && console.error(["MUI: The Tabs component doesn't accept a Fragment as a child.", "Consider providing an array instead."].join(`
+`));
+    const r = o.props.value === void 0 ? U : o.props.value;
+    $.set(r, U);
+    const n = r === N;
+    return U += 1, /* @__PURE__ */ d.cloneElement(o, b({
+      fullWidth: J === "fullWidth",
+      indicator: n && !ce && me,
+      selected: n,
+      selectionFollowsFocus: De,
+      onChange: Ae,
+      textColor: ae,
+      value: r
+    }, U === 1 && N === !1 && !o.props.tabIndex ? {
+      tabIndex: 0
+    } : {}));
+  }), Ue = (o) => {
+    const r = j.current, n = Je(r).activeElement;
+    if (n.getAttribute("role") !== "tab")
+      return;
+    let f = C === "horizontal" ? "ArrowLeft" : "ArrowUp", S = C === "horizontal" ? "ArrowRight" : "ArrowDown";
+    switch (C === "horizontal" && u && (f = "ArrowRight", S = "ArrowLeft"), o.key) {
+      case f:
+        o.preventDefault(), q(r, n, Te);
+        break;
+      case S:
+        o.preventDefault(), q(r, n, we);
+        break;
+      case "Home":
+        o.preventDefault(), q(r, null, we);
+        break;
+      case "End":
+        o.preventDefault(), q(r, null, Te);
+        break;
+    }
+  }, oe = Ye();
+  return /* @__PURE__ */ ve(ft, b({
+    className: L(x.root, _),
+    ownerState: H,
+    ref: s,
+    as: W
+  }, He, {
+    children: [oe.scrollButtonStart, oe.scrollbarSizeListener, /* @__PURE__ */ ve(bt, {
+      className: x.scroller,
+      ownerState: H,
+      style: {
+        overflow: ue.overflow,
+        [h ? `margin${u ? "Left" : "Right"}` : "marginBottom"]: Q ? void 0 : -ue.scrollbarWidth
+      },
+      ref: g,
+      onScroll: te,
+      children: [/* @__PURE__ */ y(ht, {
+        "aria-label": p,
+        "aria-labelledby": m,
+        "aria-orientation": C === "vertical" ? "vertical" : null,
+        className: x.flexContainer,
+        ownerState: H,
+        onKeyDown: Ue,
+        ref: j,
+        role: "tablist",
+        children: $e
+      }), ce && me]
+    }), oe.scrollButtonEnd]
+  }));
+});
+process.env.NODE_ENV !== "production" && (vt.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn 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: Ge,
+  /**
+   * 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: l.bool,
+  /**
+   * The label for the Tabs as a string.
+   */
+  "aria-label": l.string,
+  /**
+   * An id or list of ids separated by a space that label the Tabs.
+   */
+  "aria-labelledby": l.string,
+  /**
+   * If `true`, the tabs are centered.
+   * This prop is intended for large views.
+   * @default false
+   */
+  centered: l.bool,
+  /**
+   * The content of the component.
+   */
+  children: l.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: l.object,
+  /**
+   * @ignore
+   */
+  className: l.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: l.elementType,
+  /**
+   * Determines the color of the indicator.
+   * @default 'primary'
+   */
+  indicatorColor: l.oneOfType([l.oneOf(["primary", "secondary"]), l.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: l.func,
+  /**
+   * The component orientation (layout flow direction).
+   * @default 'horizontal'
+   */
+  orientation: l.oneOf(["horizontal", "vertical"]),
+  /**
+   * The component used to render the scroll buttons.
+   * @default TabScrollButton
+   */
+  ScrollButtonComponent: l.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: l.oneOf(["auto", !1, !0]),
+  /**
+   * If `true` the selected tab changes on focus. Otherwise it only
+   * changes on activation.
+   */
+  selectionFollowsFocus: l.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: l.oneOfType([l.arrayOf(l.oneOfType([l.func, l.object, l.bool])), l.func, l.object]),
+  /**
+   * Props applied to the tab indicator element.
+   * @default  {}
+   */
+  TabIndicatorProps: l.object,
+  /**
+   * Props applied to the [`TabScrollButton`](/material-ui/api/tab-scroll-button/) element.
+   * @default {}
+   */
+  TabScrollButtonProps: l.object,
+  /**
+   * Determines the color of the `Tab`.
+   * @default 'primary'
+   */
+  textColor: l.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: l.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: l.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: l.bool
+});
+export {
+  vt as T,
+  le as t
+};