@max-ts/components 0.3.3 → 0.3.5

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

@@ -0,0 +1,696 @@
+import * as i from "react";
+import { r as Ve } from "../../../../../../../_virtual/index3.mjs";
+import r from "../../../../../../../_virtual/index.mjs";
+import { clsx as N } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.mjs";
+import { useRtl as Fe } from "../../../../../@mui_system@6.4.3_@emotion_react@11.14.0_@types_react@19.0.10_react@19.0.0__@emotion_st_5f10f346196051285cfc2e46c43ad4ff/node_modules/@mui/system/esm/RtlProvider/index.mjs";
+import Ye from "../styles/useTheme.mjs";
+import { j as T } from "../../../../../../../_virtual/jsx-runtime.mjs";
+import R from "../styles/styled.mjs";
+import Be from "../utils/memoTheme.mjs";
+import He from "../internal/animate.mjs";
+import Ue from "./ScrollbarSize.mjs";
+import J, { getTabsUtilityClass as $e } from "./tabsClasses.mjs";
+import { useDefaultProps as _e } from "../DefaultPropsProvider/DefaultPropsProvider.mjs";
+import Ke from "../TabScrollButton/TabScrollButton.mjs";
+import Se from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.mjs";
+import Q from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.mjs";
+import qe from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/debounce/debounce.mjs";
+import Ge from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/ownerWindow/ownerWindow.mjs";
+import Je from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/composeClasses/composeClasses.mjs";
+import Qe from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/ownerDocument/ownerDocument.mjs";
+import Ze from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/refType/refType.mjs";
+const ve = (o, l) => o === l ? o.firstChild : l && l.nextElementSibling ? l.nextElementSibling : o.firstChild, ye = (o, l) => o === l ? o.lastChild : l && l.previousElementSibling ? l.previousElementSibling : o.lastChild, W = (o, l, c) => {
+  let m = !1, d = c(o, l);
+  for (; d; ) {
+    if (d === o.firstChild) {
+      if (m)
+        return;
+      m = !0;
+    }
+    const u = d.disabled || d.getAttribute("aria-disabled") === "true";
+    if (!d.hasAttribute("tabindex") || u)
+      d = c(o, d);
+    else {
+      d.focus();
+      return;
+    }
+  }
+}, et = (o) => {
+  const {
+    vertical: l,
+    fixed: c,
+    hideScrollbar: m,
+    scrollableX: d,
+    scrollableY: u,
+    centered: X,
+    scrollButtonsHideMobile: V,
+    classes: F
+  } = o;
+  return Je({
+    root: ["root", l && "vertical"],
+    scroller: ["scroller", c && "fixed", m && "hideScrollbar", d && "scrollableX", u && "scrollableY"],
+    flexContainer: ["flexContainer", l && "flexContainerVertical", X && "centered"],
+    indicator: ["indicator"],
+    scrollButtons: ["scrollButtons", V && "scrollButtonsHideMobile"],
+    scrollableX: [d && "scrollableX"],
+    hideScrollbar: [m && "hideScrollbar"]
+  }, $e, F);
+}, tt = R("div", {
+  name: "MuiTabs",
+  slot: "Root",
+  overridesResolver: (o, l) => {
+    const {
+      ownerState: c
+    } = o;
+    return [{
+      [`& .${J.scrollButtons}`]: l.scrollButtons
+    }, {
+      [`& .${J.scrollButtons}`]: c.scrollButtonsHideMobile && l.scrollButtonsHideMobile
+    }, l.root, c.vertical && l.vertical];
+  }
+})(Be(({
+  theme: o
+}) => ({
+  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: {
+      [`& .${J.scrollButtons}`]: {
+        [o.breakpoints.down("sm")]: {
+          display: "none"
+        }
+      }
+    }
+  }]
+}))), ot = R("div", {
+  name: "MuiTabs",
+  slot: "Scroller",
+  overridesResolver: (o, l) => {
+    const {
+      ownerState: c
+    } = o;
+    return [l.scroller, c.fixed && l.fixed, c.hideScrollbar && l.hideScrollbar, c.scrollableX && l.scrollableX, c.scrollableY && l.scrollableY];
+  }
+})({
+  position: "relative",
+  display: "inline-block",
+  flex: "1 1 auto",
+  whiteSpace: "nowrap",
+  variants: [{
+    props: ({
+      ownerState: o
+    }) => o.fixed,
+    style: {
+      overflowX: "hidden",
+      width: "100%"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.hideScrollbar,
+    style: {
+      // Hide dimensionless scrollbar on macOS
+      scrollbarWidth: "none",
+      // Firefox
+      "&::-webkit-scrollbar": {
+        display: "none"
+        // Safari + Chrome
+      }
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.scrollableX,
+    style: {
+      overflowX: "auto",
+      overflowY: "hidden"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.scrollableY,
+    style: {
+      overflowY: "auto",
+      overflowX: "hidden"
+    }
+  }]
+}), rt = R("div", {
+  name: "MuiTabs",
+  slot: "FlexContainer",
+  overridesResolver: (o, l) => {
+    const {
+      ownerState: c
+    } = o;
+    return [l.flexContainer, c.vertical && l.flexContainerVertical, c.centered && l.centered];
+  }
+})({
+  display: "flex",
+  variants: [{
+    props: ({
+      ownerState: o
+    }) => o.vertical,
+    style: {
+      flexDirection: "column"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.centered,
+    style: {
+      justifyContent: "center"
+    }
+  }]
+}), lt = R("span", {
+  name: "MuiTabs",
+  slot: "Indicator",
+  overridesResolver: (o, l) => l.indicator
+})(Be(({
+  theme: o
+}) => ({
+  position: "absolute",
+  height: 2,
+  bottom: 0,
+  width: "100%",
+  transition: o.transitions.create(),
+  variants: [{
+    props: {
+      indicatorColor: "primary"
+    },
+    style: {
+      backgroundColor: (o.vars || o).palette.primary.main
+    }
+  }, {
+    props: {
+      indicatorColor: "secondary"
+    },
+    style: {
+      backgroundColor: (o.vars || o).palette.secondary.main
+    }
+  }, {
+    props: ({
+      ownerState: l
+    }) => l.vertical,
+    style: {
+      height: "100%",
+      width: 2,
+      right: 0
+    }
+  }]
+}))), nt = R(Ue)({
+  overflowX: "auto",
+  overflowY: "hidden",
+  // Hide dimensionless scrollbar on macOS
+  scrollbarWidth: "none",
+  // Firefox
+  "&::-webkit-scrollbar": {
+    display: "none"
+    // Safari + Chrome
+  }
+}), we = {};
+let ge = !1;
+const st = /* @__PURE__ */ i.forwardRef(function(l, c) {
+  const m = _e({
+    props: l,
+    name: "MuiTabs"
+  }), d = Ye(), u = Fe(), {
+    "aria-label": X,
+    "aria-labelledby": V,
+    action: F,
+    centered: Y = !1,
+    children: Z,
+    className: Te,
+    component: ee = "div",
+    allowScrollButtonsMobile: te = !1,
+    indicatorColor: xe = "primary",
+    onChange: Ee,
+    orientation: S = "horizontal",
+    ScrollButtonComponent: oe = Ke,
+    scrollButtons: x = "auto",
+    selectionFollowsFocus: Ie,
+    slots: k = {},
+    slotProps: re = {},
+    TabIndicatorProps: H = {},
+    TabScrollButtonProps: z = {},
+    textColor: le = "primary",
+    value: E,
+    variant: U = "standard",
+    visibleScrollbar: $ = !1,
+    ...Ce
+  } = m, f = U === "scrollable", p = S === "vertical", I = p ? "scrollTop" : "scrollLeft", j = p ? "top" : "left", D = p ? "bottom" : "right", _ = p ? "clientHeight" : "clientWidth", C = p ? "height" : "width", y = {
+    ...m,
+    component: ee,
+    allowScrollButtonsMobile: te,
+    indicatorColor: xe,
+    orientation: S,
+    vertical: p,
+    scrollButtons: x,
+    textColor: le,
+    variant: U,
+    visibleScrollbar: $,
+    fixed: !f,
+    hideScrollbar: f && !$,
+    scrollableX: f && !p,
+    scrollableY: f && p,
+    centered: Y && !f,
+    scrollButtonsHideMobile: !te
+  }, v = et(y), Oe = Se({
+    elementType: k.StartScrollButtonIcon,
+    externalSlotProps: re.startScrollButtonIcon,
+    ownerState: y
+  }), Me = Se({
+    elementType: k.EndScrollButtonIcon,
+    externalSlotProps: re.endScrollButtonIcon,
+    ownerState: y
+  });
+  process.env.NODE_ENV !== "production" && Y && f && console.error('MUI: You can not use the `centered={true}` and `variant="scrollable"` properties at the same time on a `Tabs` component.');
+  const [ne, Ne] = i.useState(!1), [w, se] = i.useState(we), [ae, Re] = i.useState(!1), [ie, ke] = i.useState(!1), [ce, ze] = i.useState(!1), [de, je] = i.useState({
+    overflow: "hidden",
+    scrollbarWidth: 0
+  }), P = /* @__PURE__ */ new Map(), h = i.useRef(null), g = i.useRef(null), ue = () => {
+    const e = h.current;
+    let t;
+    if (e) {
+      const s = e.getBoundingClientRect();
+      t = {
+        clientWidth: e.clientWidth,
+        scrollLeft: e.scrollLeft,
+        scrollTop: e.scrollTop,
+        scrollWidth: e.scrollWidth,
+        top: s.top,
+        bottom: s.bottom,
+        left: s.left,
+        right: s.right
+      };
+    }
+    let n;
+    if (e && E !== !1) {
+      const s = g.current.children;
+      if (s.length > 0) {
+        const a = s[P.get(E)];
+        process.env.NODE_ENV !== "production" && (a || console.error(["MUI: The `value` provided to the Tabs component is invalid.", `None of the Tabs' children match with "${E}".`, P.keys ? `You can provide one of the following values: ${Array.from(P.keys()).join(", ")}.` : null].join(`
+`))), n = a ? a.getBoundingClientRect() : null, process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test" && !ge && n && n.width === 0 && n.height === 0 && // if the whole Tabs component is hidden, don't warn
+        t.clientWidth !== 0 && (t = 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(`
+`)), ge = !0);
+      }
+    }
+    return {
+      tabsMeta: t,
+      tabMeta: n
+    };
+  }, O = Q(() => {
+    const {
+      tabsMeta: e,
+      tabMeta: t
+    } = ue();
+    let n = 0, s;
+    p ? (s = "top", t && e && (n = t.top - e.top + e.scrollTop)) : (s = u ? "right" : "left", t && e && (n = (u ? -1 : 1) * (t[s] - e[s] + e.scrollLeft)));
+    const a = {
+      [s]: n,
+      // May be wrong until the font is loaded.
+      [C]: t ? t[C] : 0
+    };
+    if (typeof w[s] != "number" || typeof w[C] != "number")
+      se(a);
+    else {
+      const b = Math.abs(w[s] - a[s]), B = Math.abs(w[C] - a[C]);
+      (b >= 1 || B >= 1) && se(a);
+    }
+  }), K = (e, {
+    animation: t = !0
+  } = {}) => {
+    t ? He(I, h.current, e, {
+      duration: d.transitions.duration.standard
+    }) : h.current[I] = e;
+  }, fe = (e) => {
+    let t = h.current[I];
+    p ? t += e : t += e * (u ? -1 : 1), K(t);
+  }, pe = () => {
+    const e = h.current[_];
+    let t = 0;
+    const n = Array.from(g.current.children);
+    for (let s = 0; s < n.length; s += 1) {
+      const a = n[s];
+      if (t + a[_] > e) {
+        s === 0 && (t = e);
+        break;
+      }
+      t += a[_];
+    }
+    return t;
+  }, De = () => {
+    fe(-1 * pe());
+  }, Pe = () => {
+    fe(pe());
+  }, Le = i.useCallback((e) => {
+    je({
+      overflow: null,
+      scrollbarWidth: e
+    });
+  }, []), Ae = () => {
+    const e = {};
+    e.scrollbarSizeListener = f ? /* @__PURE__ */ T.jsx(nt, {
+      onChange: Le,
+      className: N(v.scrollableX, v.hideScrollbar)
+    }) : null;
+    const n = f && (x === "auto" && (ae || ie) || x === !0);
+    return e.scrollButtonStart = n ? /* @__PURE__ */ T.jsx(oe, {
+      slots: {
+        StartScrollButtonIcon: k.StartScrollButtonIcon
+      },
+      slotProps: {
+        startScrollButtonIcon: Oe
+      },
+      orientation: S,
+      direction: u ? "right" : "left",
+      onClick: De,
+      disabled: !ae,
+      ...z,
+      className: N(v.scrollButtons, z.className)
+    }) : null, e.scrollButtonEnd = n ? /* @__PURE__ */ T.jsx(oe, {
+      slots: {
+        EndScrollButtonIcon: k.EndScrollButtonIcon
+      },
+      slotProps: {
+        endScrollButtonIcon: Me
+      },
+      orientation: S,
+      direction: u ? "left" : "right",
+      onClick: Pe,
+      disabled: !ie,
+      ...z,
+      className: N(v.scrollButtons, z.className)
+    }) : null, e;
+  }, be = Q((e) => {
+    const {
+      tabsMeta: t,
+      tabMeta: n
+    } = ue();
+    if (!(!n || !t)) {
+      if (n[j] < t[j]) {
+        const s = t[I] + (n[j] - t[j]);
+        K(s, {
+          animation: e
+        });
+      } else if (n[D] > t[D]) {
+        const s = t[I] + (n[D] - t[D]);
+        K(s, {
+          animation: e
+        });
+      }
+    }
+  }), L = Q(() => {
+    f && x !== !1 && ze(!ce);
+  });
+  i.useEffect(() => {
+    const e = qe(() => {
+      h.current && O();
+    });
+    let t;
+    const n = (b) => {
+      b.forEach((B) => {
+        B.removedNodes.forEach((M) => {
+          t?.unobserve(M);
+        }), B.addedNodes.forEach((M) => {
+          t?.observe(M);
+        });
+      }), e(), L();
+    }, s = Ge(h.current);
+    s.addEventListener("resize", e);
+    let a;
+    return typeof ResizeObserver < "u" && (t = new ResizeObserver(e), Array.from(g.current.children).forEach((b) => {
+      t.observe(b);
+    })), typeof MutationObserver < "u" && (a = new MutationObserver(n), a.observe(g.current, {
+      childList: !0
+    })), () => {
+      e.clear(), s.removeEventListener("resize", e), a?.disconnect(), t?.disconnect();
+    };
+  }, [O, L]), i.useEffect(() => {
+    const e = Array.from(g.current.children), t = e.length;
+    if (typeof IntersectionObserver < "u" && t > 0 && f && x !== !1) {
+      const n = e[0], s = e[t - 1], a = {
+        root: h.current,
+        threshold: 0.99
+      }, b = (G) => {
+        Re(!G[0].isIntersecting);
+      }, B = new IntersectionObserver(b, a);
+      B.observe(n);
+      const M = (G) => {
+        ke(!G[0].isIntersecting);
+      }, me = new IntersectionObserver(M, a);
+      return me.observe(s), () => {
+        B.disconnect(), me.disconnect();
+      };
+    }
+  }, [f, x, ce, Z?.length]), i.useEffect(() => {
+    Ne(!0);
+  }, []), i.useEffect(() => {
+    O();
+  }), i.useEffect(() => {
+    be(we !== w);
+  }, [be, w]), i.useImperativeHandle(F, () => ({
+    updateIndicator: O,
+    updateScrollButtons: L
+  }), [O, L]);
+  const he = /* @__PURE__ */ T.jsx(lt, {
+    ...H,
+    className: N(v.indicator, H.className),
+    ownerState: y,
+    style: {
+      ...w,
+      ...H.style
+    }
+  });
+  let A = 0;
+  const We = i.Children.map(Z, (e) => {
+    if (!/* @__PURE__ */ i.isValidElement(e))
+      return null;
+    process.env.NODE_ENV !== "production" && Ve.isFragment(e) && console.error(["MUI: The Tabs component doesn't accept a Fragment as a child.", "Consider providing an array instead."].join(`
+`));
+    const t = e.props.value === void 0 ? A : e.props.value;
+    P.set(t, A);
+    const n = t === E;
+    return A += 1, /* @__PURE__ */ i.cloneElement(e, {
+      fullWidth: U === "fullWidth",
+      indicator: n && !ne && he,
+      selected: n,
+      selectionFollowsFocus: Ie,
+      onChange: Ee,
+      textColor: le,
+      value: t,
+      ...A === 1 && E === !1 && !e.props.tabIndex ? {
+        tabIndex: 0
+      } : {}
+    });
+  }), Xe = (e) => {
+    const t = g.current, n = Qe(t).activeElement;
+    if (n.getAttribute("role") !== "tab")
+      return;
+    let a = S === "horizontal" ? "ArrowLeft" : "ArrowUp", b = S === "horizontal" ? "ArrowRight" : "ArrowDown";
+    switch (S === "horizontal" && u && (a = "ArrowRight", b = "ArrowLeft"), e.key) {
+      case a:
+        e.preventDefault(), W(t, n, ye);
+        break;
+      case b:
+        e.preventDefault(), W(t, n, ve);
+        break;
+      case "Home":
+        e.preventDefault(), W(t, null, ve);
+        break;
+      case "End":
+        e.preventDefault(), W(t, null, ye);
+        break;
+    }
+  }, q = Ae();
+  return /* @__PURE__ */ T.jsxs(tt, {
+    className: N(v.root, Te),
+    ownerState: y,
+    ref: c,
+    as: ee,
+    ...Ce,
+    children: [q.scrollButtonStart, q.scrollbarSizeListener, /* @__PURE__ */ T.jsxs(ot, {
+      className: v.scroller,
+      ownerState: y,
+      style: {
+        overflow: de.overflow,
+        [p ? `margin${u ? "Left" : "Right"}` : "marginBottom"]: $ ? void 0 : -de.scrollbarWidth
+      },
+      ref: h,
+      children: [/* @__PURE__ */ T.jsx(rt, {
+        "aria-label": X,
+        "aria-labelledby": V,
+        "aria-orientation": S === "vertical" ? "vertical" : null,
+        className: v.flexContainer,
+        ownerState: y,
+        onKeyDown: Xe,
+        ref: g,
+        role: "tablist",
+        children: We
+      }), ne && he]
+    }), q.scrollButtonEnd]
+  });
+});
+process.env.NODE_ENV !== "production" && (st.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: Ze,
+  /**
+   * 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: r.bool,
+  /**
+   * The label for the Tabs as a string.
+   */
+  "aria-label": r.string,
+  /**
+   * An id or list of ids separated by a space that label the Tabs.
+   */
+  "aria-labelledby": r.string,
+  /**
+   * If `true`, the tabs are centered.
+   * This prop is intended for large views.
+   * @default false
+   */
+  centered: r.bool,
+  /**
+   * The content of the component.
+   */
+  children: r.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * @ignore
+   */
+  className: r.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: r.elementType,
+  /**
+   * Determines the color of the indicator.
+   * @default 'primary'
+   */
+  indicatorColor: r.oneOfType([r.oneOf(["primary", "secondary"]), r.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: r.func,
+  /**
+   * The component orientation (layout flow direction).
+   * @default 'horizontal'
+   */
+  orientation: r.oneOf(["horizontal", "vertical"]),
+  /**
+   * The component used to render the scroll buttons.
+   * @default TabScrollButton
+   */
+  ScrollButtonComponent: r.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: r.oneOf(["auto", !1, !0]),
+  /**
+   * If `true` the selected tab changes on focus. Otherwise it only
+   * changes on activation.
+   */
+  selectionFollowsFocus: r.bool,
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   * @default {}
+   */
+  slotProps: r.shape({
+    endScrollButtonIcon: r.oneOfType([r.func, r.object]),
+    startScrollButtonIcon: r.oneOfType([r.func, r.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: r.shape({
+    EndScrollButtonIcon: r.elementType,
+    StartScrollButtonIcon: r.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  /**
+   * Props applied to the tab indicator element.
+   * @default  {}
+   */
+  TabIndicatorProps: r.object,
+  /**
+   * Props applied to the [`TabScrollButton`](https://mui.com/material-ui/api/tab-scroll-button/) element.
+   * @default {}
+   */
+  TabScrollButtonProps: r.object,
+  /**
+   * Determines the color of the `Tab`.
+   * @default 'primary'
+   */
+  textColor: r.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: r.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: r.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: r.bool
+});
+export {
+  st as default
+};

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

@@ -0,0 +1,10 @@
+import t from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.mjs";
+import l from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.mjs";
+function i(e) {
+  return l("MuiTabs", e);
+}
+const o = t("MuiTabs", ["root", "vertical", "flexContainer", "flexContainerVertical", "centered", "scroller", "fixed", "scrollableX", "scrollableY", "hideScrollbar", "scrollButtons", "scrollButtonsHideMobile", "indicator"]);
+export {
+  o as default,
+  i as getTabsUtilityClass
+};