@cgi-learning-hub/ui 1.2.0 → 1.3.0

package/dist/Tabs-CKic46Op.js

@@ -0,0 +1,1222 @@
+import * as c from "react";
+import { I as pe, J as fe, K as We, L as W, P as t } from "./identifier-Bu3vgTzE.js";
+import { m as be } from "./memoTheme-C4_nd-x4.js";
+import { jsxs as q, jsx as x } from "react/jsx-runtime";
+import { s as L, u as he, c as me, e as tt } from "./DefaultPropsProvider-7QnSWHxy.js";
+import { B as ke } from "./ButtonBase-Y5TK5SRu.js";
+import { a as ot } from "./useThemeProps-DftpgVZ0.js";
+import { u as ze, a as re } from "./index-D4YvqRSh.js";
+import { u as rt } from "./useTheme-B_3HWqyi.js";
+import { u as nt, r as lt } from "./refType-DvOnKTmB.js";
+import { o as De, d as $e, a as st } from "./ownerWindow-BoRkeomM.js";
+import { u as de } from "./useTimeout-Bx22KOcH.js";
+import { c as Ae } from "./createSvgIcon-Ae1vF9Lv.js";
+function at(o) {
+  return pe("MuiTab", o);
+}
+const T = fe("MuiTab", ["root", "labelIcon", "textColorInherit", "textColorPrimary", "textColorSecondary", "selected", "disabled", "fullWidth", "wrapped", "iconWrapper", "icon"]), it = (o) => {
+  const {
+    classes: e,
+    textColor: l,
+    fullWidth: d,
+    wrapped: i,
+    icon: u,
+    label: b,
+    selected: h,
+    disabled: f
+  } = o, S = {
+    root: ["root", u && b && "labelIcon", `textColor${We(l)}`, d && "fullWidth", i && "wrapped", h && "selected", f && "disabled"],
+    icon: ["iconWrapper", "icon"]
+  };
+  return me(S, at, e);
+}, ct = L(ke, {
+  name: "MuiTab",
+  slot: "Root",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: l
+    } = o;
+    return [e.root, l.label && l.icon && e.labelIcon, e[`textColor${We(l.textColor)}`], l.fullWidth && e.fullWidth, l.wrapped && e.wrapped, {
+      [`& .${T.iconWrapper}`]: e.iconWrapper
+    }, {
+      [`& .${T.icon}`]: e.icon
+    }];
+  }
+})(be(({
+  theme: o
+}) => ({
+  ...o.typography.button,
+  maxWidth: 360,
+  minWidth: 90,
+  position: "relative",
+  minHeight: 48,
+  flexShrink: 0,
+  padding: "12px 16px",
+  overflow: "hidden",
+  whiteSpace: "normal",
+  textAlign: "center",
+  lineHeight: 1.25,
+  variants: [{
+    props: ({
+      ownerState: e
+    }) => e.label && (e.iconPosition === "top" || e.iconPosition === "bottom"),
+    style: {
+      flexDirection: "column"
+    }
+  }, {
+    props: ({
+      ownerState: e
+    }) => e.label && e.iconPosition !== "top" && e.iconPosition !== "bottom",
+    style: {
+      flexDirection: "row"
+    }
+  }, {
+    props: ({
+      ownerState: e
+    }) => e.icon && e.label,
+    style: {
+      minHeight: 72,
+      paddingTop: 9,
+      paddingBottom: 9
+    }
+  }, {
+    props: ({
+      ownerState: e,
+      iconPosition: l
+    }) => e.icon && e.label && l === "top",
+    style: {
+      [`& > .${T.icon}`]: {
+        marginBottom: 6
+      }
+    }
+  }, {
+    props: ({
+      ownerState: e,
+      iconPosition: l
+    }) => e.icon && e.label && l === "bottom",
+    style: {
+      [`& > .${T.icon}`]: {
+        marginTop: 6
+      }
+    }
+  }, {
+    props: ({
+      ownerState: e,
+      iconPosition: l
+    }) => e.icon && e.label && l === "start",
+    style: {
+      [`& > .${T.icon}`]: {
+        marginRight: o.spacing(1)
+      }
+    }
+  }, {
+    props: ({
+      ownerState: e,
+      iconPosition: l
+    }) => e.icon && e.label && l === "end",
+    style: {
+      [`& > .${T.icon}`]: {
+        marginLeft: o.spacing(1)
+      }
+    }
+  }, {
+    props: {
+      textColor: "inherit"
+    },
+    style: {
+      color: "inherit",
+      opacity: 0.6,
+      // same opacity as theme.palette.text.secondary
+      [`&.${T.selected}`]: {
+        opacity: 1
+      },
+      [`&.${T.disabled}`]: {
+        opacity: (o.vars || o).palette.action.disabledOpacity
+      }
+    }
+  }, {
+    props: {
+      textColor: "primary"
+    },
+    style: {
+      color: (o.vars || o).palette.text.secondary,
+      [`&.${T.selected}`]: {
+        color: (o.vars || o).palette.primary.main
+      },
+      [`&.${T.disabled}`]: {
+        color: (o.vars || o).palette.text.disabled
+      }
+    }
+  }, {
+    props: {
+      textColor: "secondary"
+    },
+    style: {
+      color: (o.vars || o).palette.text.secondary,
+      [`&.${T.selected}`]: {
+        color: (o.vars || o).palette.secondary.main
+      },
+      [`&.${T.disabled}`]: {
+        color: (o.vars || o).palette.text.disabled
+      }
+    }
+  }, {
+    props: ({
+      ownerState: e
+    }) => e.fullWidth,
+    style: {
+      flexShrink: 1,
+      flexGrow: 1,
+      flexBasis: 0,
+      maxWidth: "none"
+    }
+  }, {
+    props: ({
+      ownerState: e
+    }) => e.wrapped,
+    style: {
+      fontSize: o.typography.pxToRem(12)
+    }
+  }]
+}))), dt = /* @__PURE__ */ c.forwardRef(function(e, l) {
+  const d = he({
+    props: e,
+    name: "MuiTab"
+  }), {
+    className: i,
+    disabled: u = !1,
+    disableFocusRipple: b = !1,
+    // eslint-disable-next-line react/prop-types
+    fullWidth: h,
+    icon: f,
+    iconPosition: S = "top",
+    // eslint-disable-next-line react/prop-types
+    indicator: v,
+    label: y,
+    onChange: m,
+    onClick: C,
+    onFocus: k,
+    // eslint-disable-next-line react/prop-types
+    selected: I,
+    // eslint-disable-next-line react/prop-types
+    selectionFollowsFocus: g,
+    // eslint-disable-next-line react/prop-types
+    textColor: j = "inherit",
+    value: M,
+    wrapped: ne = !1,
+    ...H
+  } = d, U = {
+    ...d,
+    disabled: u,
+    disableFocusRipple: b,
+    selected: I,
+    icon: !!f,
+    iconPosition: S,
+    label: !!y,
+    fullWidth: h,
+    textColor: j,
+    wrapped: ne
+  }, V = it(U), z = f && y && /* @__PURE__ */ c.isValidElement(f) ? /* @__PURE__ */ c.cloneElement(f, {
+    className: W(V.icon, f.props.className)
+  }) : f, G = (R) => {
+    !I && m && m(R, M), C && C(R);
+  }, N = (R) => {
+    g && !I && m && m(R, M), k && k(R);
+  };
+  return /* @__PURE__ */ q(ct, {
+    focusRipple: !b,
+    className: W(V.root, i),
+    ref: l,
+    role: "tab",
+    "aria-selected": I,
+    disabled: u,
+    onClick: G,
+    onFocus: N,
+    ownerState: U,
+    tabIndex: I ? 0 : -1,
+    ...H,
+    children: [S === "top" || S === "start" ? /* @__PURE__ */ q(c.Fragment, {
+      children: [z, y]
+    }) : /* @__PURE__ */ q(c.Fragment, {
+      children: [y, z]
+    }), v]
+  });
+});
+process.env.NODE_ENV !== "production" && (dt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * This prop isn't supported.
+   * Use the `component` prop if you need to change the children structure.
+   */
+  children: ot,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: t.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: t.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: t.bool,
+  /**
+   * The icon to display.
+   */
+  icon: t.oneOfType([t.element, t.string]),
+  /**
+   * The position of the icon relative to the label.
+   * @default 'top'
+   */
+  iconPosition: t.oneOf(["bottom", "end", "start", "top"]),
+  /**
+   * The label element.
+   */
+  label: t.node,
+  /**
+   * @ignore
+   */
+  onChange: t.func,
+  /**
+   * @ignore
+   */
+  onClick: t.func,
+  /**
+   * @ignore
+   */
+  onFocus: t.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * You can provide your own value. Otherwise, we fallback to the child position index.
+   */
+  value: t.any,
+  /**
+   * Tab labels appear in a single row.
+   * They can use a second line if needed.
+   * @default false
+   */
+  wrapped: t.bool
+});
+const ut = Ae(/* @__PURE__ */ x("path", {
+  d: "M15.41 16.09l-4.58-4.59 4.58-4.59L14 5.5l-6 6 6 6z"
+}), "KeyboardArrowLeft"), pt = Ae(/* @__PURE__ */ x("path", {
+  d: "M8.59 16.34l4.58-4.59-4.58-4.59L10 5.75l6 6-6 6z"
+}), "KeyboardArrowRight");
+function ft(o) {
+  return (1 + Math.sin(Math.PI * o - Math.PI / 2)) / 2;
+}
+function bt(o, e, l, d = {}, i = () => {
+}) {
+  const {
+    ease: u = ft,
+    duration: b = 300
+    // standard
+  } = d;
+  let h = null;
+  const f = e[o];
+  let S = !1;
+  const v = () => {
+    S = !0;
+  }, y = (m) => {
+    if (S) {
+      i(new Error("Animation cancelled"));
+      return;
+    }
+    h === null && (h = m);
+    const C = Math.min(1, (m - h) / b);
+    if (e[o] = u(C) * (l - f) + f, C >= 1) {
+      requestAnimationFrame(() => {
+        i(null);
+      });
+      return;
+    }
+    requestAnimationFrame(y);
+  };
+  return f === l ? (i(new Error("Element already at target position")), v) : (requestAnimationFrame(y), v);
+}
+const ht = {
+  width: 99,
+  height: 99,
+  position: "absolute",
+  top: -9999,
+  overflow: "scroll"
+};
+function Fe(o) {
+  const {
+    onChange: e,
+    ...l
+  } = o, d = c.useRef(), i = c.useRef(null), u = () => {
+    d.current = i.current.offsetHeight - i.current.clientHeight;
+  };
+  return nt(() => {
+    const b = $e(() => {
+      const f = d.current;
+      u(), f !== d.current && e(d.current);
+    }), h = De(i.current);
+    return h.addEventListener("resize", b), () => {
+      b.clear(), h.removeEventListener("resize", b);
+    };
+  }, [e]), c.useEffect(() => {
+    u(), e(d.current);
+  }, [e]), /* @__PURE__ */ x("div", {
+    style: ht,
+    ref: i,
+    ...l
+  });
+}
+process.env.NODE_ENV !== "production" && (Fe.propTypes = {
+  onChange: t.func.isRequired
+});
+function mt(o) {
+  return pe("MuiTabScrollButton", o);
+}
+const St = fe("MuiTabScrollButton", ["root", "vertical", "horizontal", "disabled"]), vt = (o) => {
+  const {
+    classes: e,
+    orientation: l,
+    disabled: d
+  } = o;
+  return me({
+    root: ["root", l, d && "disabled"]
+  }, mt, e);
+}, yt = L(ke, {
+  name: "MuiTabScrollButton",
+  slot: "Root",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: l
+    } = o;
+    return [e.root, l.orientation && e[l.orientation]];
+  }
+})({
+  width: 40,
+  flexShrink: 0,
+  opacity: 0.8,
+  [`&.${St.disabled}`]: {
+    opacity: 0
+  },
+  variants: [{
+    props: {
+      orientation: "vertical"
+    },
+    style: {
+      width: "100%",
+      height: 40,
+      "& svg": {
+        transform: "var(--TabScrollButton-svgRotate)"
+      }
+    }
+  }]
+}), Le = /* @__PURE__ */ c.forwardRef(function(e, l) {
+  const d = he({
+    props: e,
+    name: "MuiTabScrollButton"
+  }), {
+    className: i,
+    slots: u = {},
+    slotProps: b = {},
+    direction: h,
+    orientation: f,
+    disabled: S,
+    ...v
+  } = d, y = ze(), m = {
+    isRtl: y,
+    ...d
+  }, C = vt(m), k = u.StartScrollButtonIcon ?? ut, I = u.EndScrollButtonIcon ?? pt, g = re({
+    elementType: k,
+    externalSlotProps: b.startScrollButtonIcon,
+    additionalProps: {
+      fontSize: "small"
+    },
+    ownerState: m
+  }), j = re({
+    elementType: I,
+    externalSlotProps: b.endScrollButtonIcon,
+    additionalProps: {
+      fontSize: "small"
+    },
+    ownerState: m
+  });
+  return /* @__PURE__ */ x(yt, {
+    component: "div",
+    className: W(C.root, i),
+    ref: l,
+    role: null,
+    ownerState: m,
+    tabIndex: null,
+    ...v,
+    style: {
+      ...v.style,
+      ...f === "vertical" && {
+        "--TabScrollButton-svgRotate": `rotate(${y ? -90 : 90}deg)`
+      }
+    },
+    children: h === "left" ? /* @__PURE__ */ x(k, {
+      ...g
+    }) : /* @__PURE__ */ x(I, {
+      ...j
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Le.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The direction the button should indicate.
+   */
+  direction: t.oneOf(["left", "right"]).isRequired,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: t.bool,
+  /**
+   * The component orientation (layout flow direction).
+   */
+  orientation: t.oneOf(["horizontal", "vertical"]).isRequired,
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   * @default {}
+   */
+  slotProps: t.shape({
+    endScrollButtonIcon: t.oneOfType([t.func, t.object]),
+    startScrollButtonIcon: t.oneOfType([t.func, t.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: t.shape({
+    EndScrollButtonIcon: t.elementType,
+    StartScrollButtonIcon: t.elementType
+  }),
+  /**
+   * @ignore
+   */
+  style: t.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object])
+});
+function gt(o) {
+  return pe("MuiTabs", o);
+}
+const ue = fe("MuiTabs", ["root", "vertical", "flexContainer", "flexContainerVertical", "centered", "scroller", "fixed", "scrollableX", "scrollableY", "hideScrollbar", "scrollButtons", "scrollButtonsHideMobile", "indicator"]), Re = (o, e) => o === e ? o.firstChild : e && e.nextElementSibling ? e.nextElementSibling : o.firstChild, Oe = (o, e) => o === e ? o.lastChild : e && e.previousElementSibling ? e.previousElementSibling : o.lastChild, oe = (o, e, l) => {
+  let d = !1, i = l(o, e);
+  for (; i; ) {
+    if (i === o.firstChild) {
+      if (d)
+        return;
+      d = !0;
+    }
+    const u = i.disabled || i.getAttribute("aria-disabled") === "true";
+    if (!i.hasAttribute("tabindex") || u)
+      i = l(o, i);
+    else {
+      i.focus();
+      return;
+    }
+  }
+}, Tt = (o) => {
+  const {
+    vertical: e,
+    fixed: l,
+    hideScrollbar: d,
+    scrollableX: i,
+    scrollableY: u,
+    centered: b,
+    scrollButtonsHideMobile: h,
+    classes: f
+  } = o;
+  return me({
+    root: ["root", e && "vertical"],
+    scroller: ["scroller", l && "fixed", d && "hideScrollbar", i && "scrollableX", u && "scrollableY"],
+    flexContainer: ["flexContainer", e && "flexContainerVertical", b && "centered"],
+    indicator: ["indicator"],
+    scrollButtons: ["scrollButtons", h && "scrollButtonsHideMobile"],
+    scrollableX: [i && "scrollableX"],
+    hideScrollbar: [d && "hideScrollbar"]
+  }, gt, f);
+}, wt = L("div", {
+  name: "MuiTabs",
+  slot: "Root",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: l
+    } = o;
+    return [{
+      [`& .${ue.scrollButtons}`]: e.scrollButtons
+    }, {
+      [`& .${ue.scrollButtons}`]: l.scrollButtonsHideMobile && e.scrollButtonsHideMobile
+    }, e.root, l.vertical && e.vertical];
+  }
+})(be(({
+  theme: o
+}) => ({
+  overflow: "hidden",
+  minHeight: 48,
+  // Add iOS momentum scrolling for iOS < 13.0
+  WebkitOverflowScrolling: "touch",
+  display: "flex",
+  variants: [{
+    props: ({
+      ownerState: e
+    }) => e.vertical,
+    style: {
+      flexDirection: "column"
+    }
+  }, {
+    props: ({
+      ownerState: e
+    }) => e.scrollButtonsHideMobile,
+    style: {
+      [`& .${ue.scrollButtons}`]: {
+        [o.breakpoints.down("sm")]: {
+          display: "none"
+        }
+      }
+    }
+  }]
+}))), Bt = L("div", {
+  name: "MuiTabs",
+  slot: "Scroller",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: l
+    } = o;
+    return [e.scroller, l.fixed && e.fixed, l.hideScrollbar && e.hideScrollbar, l.scrollableX && e.scrollableX, l.scrollableY && e.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"
+    }
+  }]
+}), xt = L("div", {
+  name: "MuiTabs",
+  slot: "FlexContainer",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: l
+    } = o;
+    return [e.flexContainer, l.vertical && e.flexContainerVertical, l.centered && e.centered];
+  }
+})({
+  display: "flex",
+  variants: [{
+    props: ({
+      ownerState: o
+    }) => o.vertical,
+    style: {
+      flexDirection: "column"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.centered,
+    style: {
+      justifyContent: "center"
+    }
+  }]
+}), Ct = L("span", {
+  name: "MuiTabs",
+  slot: "Indicator",
+  overridesResolver: (o, e) => e.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: e
+    }) => e.vertical,
+    style: {
+      height: "100%",
+      width: 2,
+      right: 0
+    }
+  }]
+}))), It = L(Fe)({
+  overflowX: "auto",
+  overflowY: "hidden",
+  // Hide dimensionless scrollbar on macOS
+  scrollbarWidth: "none",
+  // Firefox
+  "&::-webkit-scrollbar": {
+    display: "none"
+    // Safari + Chrome
+  }
+}), Ne = {};
+let Pe = !1;
+const Et = /* @__PURE__ */ c.forwardRef(function(e, l) {
+  const d = he({
+    props: e,
+    name: "MuiTabs"
+  }), i = rt(), u = ze(), {
+    "aria-label": b,
+    "aria-labelledby": h,
+    action: f,
+    centered: S = !1,
+    children: v,
+    className: y,
+    component: m = "div",
+    allowScrollButtonsMobile: C = !1,
+    indicatorColor: k = "primary",
+    onChange: I,
+    orientation: g = "horizontal",
+    ScrollButtonComponent: j = Le,
+    scrollButtons: M = "auto",
+    selectionFollowsFocus: ne,
+    slots: H = {},
+    slotProps: U = {},
+    TabIndicatorProps: V = {},
+    TabScrollButtonProps: z = {},
+    textColor: G = "primary",
+    value: N,
+    variant: R = "standard",
+    visibleScrollbar: le = !1,
+    ...je
+  } = d, w = R === "scrollable", B = g === "vertical", X = B ? "scrollTop" : "scrollLeft", J = B ? "top" : "left", Q = B ? "bottom" : "right", se = B ? "clientHeight" : "clientWidth", Y = B ? "height" : "width", D = {
+    ...d,
+    component: m,
+    allowScrollButtonsMobile: C,
+    indicatorColor: k,
+    orientation: g,
+    vertical: B,
+    scrollButtons: M,
+    textColor: G,
+    variant: R,
+    visibleScrollbar: le,
+    fixed: !w,
+    hideScrollbar: w && !le,
+    scrollableX: w && !B,
+    scrollableY: w && B,
+    centered: S && !w,
+    scrollButtonsHideMobile: !C
+  }, P = Tt(D), He = re({
+    elementType: H.StartScrollButtonIcon,
+    externalSlotProps: U.startScrollButtonIcon,
+    ownerState: D
+  }), Ve = re({
+    elementType: H.EndScrollButtonIcon,
+    externalSlotProps: U.endScrollButtonIcon,
+    ownerState: D
+  });
+  process.env.NODE_ENV !== "production" && S && w && console.error('MUI: You can not use the `centered={true}` and `variant="scrollable"` properties at the same time on a `Tabs` component.');
+  const [Se, Ue] = c.useState(!1), [$, ve] = c.useState(Ne), [ye, Xe] = c.useState(!1), [ge, Ye] = c.useState(!1), [Te, Ke] = c.useState(!1), [we, _e] = c.useState({
+    overflow: "hidden",
+    scrollbarWidth: 0
+  }), Z = /* @__PURE__ */ new Map(), O = c.useRef(null), A = c.useRef(null), Be = () => {
+    const r = O.current;
+    let n;
+    if (r) {
+      const a = r.getBoundingClientRect();
+      n = {
+        clientWidth: r.clientWidth,
+        scrollLeft: r.scrollLeft,
+        scrollTop: r.scrollTop,
+        scrollWidth: r.scrollWidth,
+        top: a.top,
+        bottom: a.bottom,
+        left: a.left,
+        right: a.right
+      };
+    }
+    let s;
+    if (r && N !== !1) {
+      const a = A.current.children;
+      if (a.length > 0) {
+        const p = a[Z.get(N)];
+        process.env.NODE_ENV !== "production" && (p || console.error(["MUI: The `value` provided to the Tabs component is invalid.", `None of the Tabs' children match with "${N}".`, Z.keys ? `You can provide one of the following values: ${Array.from(Z.keys()).join(", ")}.` : null].join(`
+`))), s = p ? p.getBoundingClientRect() : null, process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test" && !Pe && s && s.width === 0 && s.height === 0 && // if the whole Tabs component is hidden, don't warn
+        n.clientWidth !== 0 && (n = 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(`
+`)), Pe = !0);
+      }
+    }
+    return {
+      tabsMeta: n,
+      tabMeta: s
+    };
+  }, K = de(() => {
+    const {
+      tabsMeta: r,
+      tabMeta: n
+    } = Be();
+    let s = 0, a;
+    B ? (a = "top", n && r && (s = n.top - r.top + r.scrollTop)) : (a = u ? "right" : "left", n && r && (s = (u ? -1 : 1) * (n[a] - r[a] + r.scrollLeft)));
+    const p = {
+      [a]: s,
+      // May be wrong until the font is loaded.
+      [Y]: n ? n[Y] : 0
+    };
+    if (typeof $[a] != "number" || typeof $[Y] != "number")
+      ve(p);
+    else {
+      const E = Math.abs($[a] - p[a]), F = Math.abs($[Y] - p[Y]);
+      (E >= 1 || F >= 1) && ve(p);
+    }
+  }), ae = (r, {
+    animation: n = !0
+  } = {}) => {
+    n ? bt(X, O.current, r, {
+      duration: i.transitions.duration.standard
+    }) : O.current[X] = r;
+  }, xe = (r) => {
+    let n = O.current[X];
+    B ? n += r : n += r * (u ? -1 : 1), ae(n);
+  }, Ce = () => {
+    const r = O.current[se];
+    let n = 0;
+    const s = Array.from(A.current.children);
+    for (let a = 0; a < s.length; a += 1) {
+      const p = s[a];
+      if (n + p[se] > r) {
+        a === 0 && (n = r);
+        break;
+      }
+      n += p[se];
+    }
+    return n;
+  }, qe = () => {
+    xe(-1 * Ce());
+  }, Ge = () => {
+    xe(Ce());
+  }, Je = c.useCallback((r) => {
+    _e({
+      overflow: null,
+      scrollbarWidth: r
+    });
+  }, []), Qe = () => {
+    const r = {};
+    r.scrollbarSizeListener = w ? /* @__PURE__ */ x(It, {
+      onChange: Je,
+      className: W(P.scrollableX, P.hideScrollbar)
+    }) : null;
+    const s = w && (M === "auto" && (ye || ge) || M === !0);
+    return r.scrollButtonStart = s ? /* @__PURE__ */ x(j, {
+      slots: {
+        StartScrollButtonIcon: H.StartScrollButtonIcon
+      },
+      slotProps: {
+        startScrollButtonIcon: He
+      },
+      orientation: g,
+      direction: u ? "right" : "left",
+      onClick: qe,
+      disabled: !ye,
+      ...z,
+      className: W(P.scrollButtons, z.className)
+    }) : null, r.scrollButtonEnd = s ? /* @__PURE__ */ x(j, {
+      slots: {
+        EndScrollButtonIcon: H.EndScrollButtonIcon
+      },
+      slotProps: {
+        endScrollButtonIcon: Ve
+      },
+      orientation: g,
+      direction: u ? "left" : "right",
+      onClick: Ge,
+      disabled: !ge,
+      ...z,
+      className: W(P.scrollButtons, z.className)
+    }) : null, r;
+  }, Ie = de((r) => {
+    const {
+      tabsMeta: n,
+      tabMeta: s
+    } = Be();
+    if (!(!s || !n)) {
+      if (s[J] < n[J]) {
+        const a = n[X] + (s[J] - n[J]);
+        ae(a, {
+          animation: r
+        });
+      } else if (s[Q] > n[Q]) {
+        const a = n[X] + (s[Q] - n[Q]);
+        ae(a, {
+          animation: r
+        });
+      }
+    }
+  }), ee = de(() => {
+    w && M !== !1 && Ke(!Te);
+  });
+  c.useEffect(() => {
+    const r = $e(() => {
+      O.current && K();
+    });
+    let n;
+    const s = (E) => {
+      E.forEach((F) => {
+        F.removedNodes.forEach((_) => {
+          n == null || n.unobserve(_);
+        }), F.addedNodes.forEach((_) => {
+          n == null || n.observe(_);
+        });
+      }), r(), ee();
+    }, a = De(O.current);
+    a.addEventListener("resize", r);
+    let p;
+    return typeof ResizeObserver < "u" && (n = new ResizeObserver(r), Array.from(A.current.children).forEach((E) => {
+      n.observe(E);
+    })), typeof MutationObserver < "u" && (p = new MutationObserver(s), p.observe(A.current, {
+      childList: !0
+    })), () => {
+      r.clear(), a.removeEventListener("resize", r), p == null || p.disconnect(), n == null || n.disconnect();
+    };
+  }, [K, ee]), c.useEffect(() => {
+    const r = Array.from(A.current.children), n = r.length;
+    if (typeof IntersectionObserver < "u" && n > 0 && w && M !== !1) {
+      const s = r[0], a = r[n - 1], p = {
+        root: O.current,
+        threshold: 0.99
+      }, E = (ce) => {
+        Xe(!ce[0].isIntersecting);
+      }, F = new IntersectionObserver(E, p);
+      F.observe(s);
+      const _ = (ce) => {
+        Ye(!ce[0].isIntersecting);
+      }, Me = new IntersectionObserver(_, p);
+      return Me.observe(a), () => {
+        F.disconnect(), Me.disconnect();
+      };
+    }
+  }, [w, M, Te, v == null ? void 0 : v.length]), c.useEffect(() => {
+    Ue(!0);
+  }, []), c.useEffect(() => {
+    K();
+  }), c.useEffect(() => {
+    Ie(Ne !== $);
+  }, [Ie, $]), c.useImperativeHandle(f, () => ({
+    updateIndicator: K,
+    updateScrollButtons: ee
+  }), [K, ee]);
+  const Ee = /* @__PURE__ */ x(Ct, {
+    ...V,
+    className: W(P.indicator, V.className),
+    ownerState: D,
+    style: {
+      ...$,
+      ...V.style
+    }
+  });
+  let te = 0;
+  const Ze = c.Children.map(v, (r) => {
+    if (!/* @__PURE__ */ c.isValidElement(r))
+      return null;
+    process.env.NODE_ENV !== "production" && tt.isFragment(r) && console.error(["MUI: The Tabs component doesn't accept a Fragment as a child.", "Consider providing an array instead."].join(`
+`));
+    const n = r.props.value === void 0 ? te : r.props.value;
+    Z.set(n, te);
+    const s = n === N;
+    return te += 1, /* @__PURE__ */ c.cloneElement(r, {
+      fullWidth: R === "fullWidth",
+      indicator: s && !Se && Ee,
+      selected: s,
+      selectionFollowsFocus: ne,
+      onChange: I,
+      textColor: G,
+      value: n,
+      ...te === 1 && N === !1 && !r.props.tabIndex ? {
+        tabIndex: 0
+      } : {}
+    });
+  }), et = (r) => {
+    const n = A.current, s = st(n).activeElement;
+    if (s.getAttribute("role") !== "tab")
+      return;
+    let p = g === "horizontal" ? "ArrowLeft" : "ArrowUp", E = g === "horizontal" ? "ArrowRight" : "ArrowDown";
+    switch (g === "horizontal" && u && (p = "ArrowRight", E = "ArrowLeft"), r.key) {
+      case p:
+        r.preventDefault(), oe(n, s, Oe);
+        break;
+      case E:
+        r.preventDefault(), oe(n, s, Re);
+        break;
+      case "Home":
+        r.preventDefault(), oe(n, null, Re);
+        break;
+      case "End":
+        r.preventDefault(), oe(n, null, Oe);
+        break;
+    }
+  }, ie = Qe();
+  return /* @__PURE__ */ q(wt, {
+    className: W(P.root, y),
+    ownerState: D,
+    ref: l,
+    as: m,
+    ...je,
+    children: [ie.scrollButtonStart, ie.scrollbarSizeListener, /* @__PURE__ */ q(Bt, {
+      className: P.scroller,
+      ownerState: D,
+      style: {
+        overflow: we.overflow,
+        [B ? `margin${u ? "Left" : "Right"}` : "marginBottom"]: le ? void 0 : -we.scrollbarWidth
+      },
+      ref: O,
+      children: [/* @__PURE__ */ x(xt, {
+        "aria-label": b,
+        "aria-labelledby": h,
+        "aria-orientation": g === "vertical" ? "vertical" : null,
+        className: P.flexContainer,
+        ownerState: D,
+        onKeyDown: et,
+        ref: A,
+        role: "tablist",
+        children: Ze
+      }), Se && Ee]
+    }), ie.scrollButtonEnd]
+  });
+});
+process.env.NODE_ENV !== "production" && (Et.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: lt,
+  /**
+   * 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: t.bool,
+  /**
+   * The label for the Tabs as a string.
+   */
+  "aria-label": t.string,
+  /**
+   * An id or list of ids separated by a space that label the Tabs.
+   */
+  "aria-labelledby": t.string,
+  /**
+   * If `true`, the tabs are centered.
+   * This prop is intended for large views.
+   * @default false
+   */
+  centered: t.bool,
+  /**
+   * The content of the component.
+   */
+  children: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: t.elementType,
+  /**
+   * Determines the color of the indicator.
+   * @default 'primary'
+   */
+  indicatorColor: t.oneOfType([t.oneOf(["primary", "secondary"]), t.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: t.func,
+  /**
+   * The component orientation (layout flow direction).
+   * @default 'horizontal'
+   */
+  orientation: t.oneOf(["horizontal", "vertical"]),
+  /**
+   * The component used to render the scroll buttons.
+   * @default TabScrollButton
+   */
+  ScrollButtonComponent: t.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: t.oneOf(["auto", !1, !0]),
+  /**
+   * If `true` the selected tab changes on focus. Otherwise it only
+   * changes on activation.
+   */
+  selectionFollowsFocus: t.bool,
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   * @default {}
+   */
+  slotProps: t.shape({
+    endScrollButtonIcon: t.oneOfType([t.func, t.object]),
+    startScrollButtonIcon: t.oneOfType([t.func, t.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: t.shape({
+    EndScrollButtonIcon: t.elementType,
+    StartScrollButtonIcon: t.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * Props applied to the tab indicator element.
+   * @default  {}
+   */
+  TabIndicatorProps: t.object,
+  /**
+   * Props applied to the [`TabScrollButton`](https://mui.com/material-ui/api/tab-scroll-button/) element.
+   * @default {}
+   */
+  TabScrollButtonProps: t.object,
+  /**
+   * Determines the color of the `Tab`.
+   * @default 'primary'
+   */
+  textColor: t.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: t.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: t.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: t.bool
+});
+export {
+  pt as K,
+  dt as T,
+  Et as a,
+  ue as b,
+  gt as c,
+  ut as d,
+  at as g,
+  T as t
+};