@cgi-learning-hub/ui 1.2.0-dev.1725543340 → 1.2.0-dev.1725543764

package/dist/ButtonBase-D0vqeM8I.js

@@ -0,0 +1,890 @@
+var Oe = Object.defineProperty;
+var je = (n, e, o) => e in n ? Oe(n, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : n[e] = o;
+var le = (n, e, o) => je(n, typeof e != "symbol" ? e + "" : e, o);
+import * as d from "react";
+import W, { Children as ke, isValidElement as G, cloneElement as J } from "react";
+import { P as t, L as E, J as de, I as Fe } from "./identifier-Bsv46xiT.js";
+import { jsx as U, jsxs as Ie } from "react/jsx-runtime";
+import { s as ne, u as he, c as Ue } from "./DefaultPropsProvider-QV6PDjPd.js";
+import { u as $e, _ as ze, a as _e, T as ce, b as Ae } from "./TransitionGroupContext-B5aSBz0G.js";
+import { keyframes as oe } from "@emotion/react";
+import { a as pe } from "./useForkRef-DwN_Iz9R.js";
+import { u as H } from "./useEventCallback-BgMlqKLP.js";
+import { r as Xe, e as Ye } from "./refType-BnS1d2D8.js";
+function fe(n) {
+  try {
+    return n.matches(":focus-visible");
+  } catch {
+    process.env.NODE_ENV !== "production" && !/jsdom/.test(window.navigator.userAgent) && console.warn(["MUI: The `:focus-visible` pseudo class is not supported in this browser.", "Some components rely on this feature to work properly."].join(`
+`));
+  }
+  return !1;
+}
+class Q {
+  constructor() {
+    le(this, "mountEffect", () => {
+      this.shouldMount && !this.didMount && this.ref.current !== null && (this.didMount = !0, this.mounted.resolve());
+    });
+    this.ref = {
+      current: null
+    }, this.mounted = null, this.didMount = !1, this.shouldMount = !1, this.setShouldMount = null;
+  }
+  /** React ref to the ripple instance */
+  /** If the ripple component should be mounted */
+  /** Promise that resolves when the ripple component is mounted */
+  /** If the ripple component has been mounted */
+  /** React state hook setter */
+  static create() {
+    return new Q();
+  }
+  static use() {
+    const e = $e(Q.create).current, [o, u] = d.useState(!1);
+    return e.shouldMount = o, e.setShouldMount = u, d.useEffect(e.mountEffect, [o]), e;
+  }
+  mount() {
+    return this.mounted || (this.mounted = qe(), this.shouldMount = !0, this.setShouldMount(this.shouldMount)), this.mounted;
+  }
+  /* Ripple API */
+  start(...e) {
+    this.mount().then(() => {
+      var o;
+      return (o = this.ref.current) == null ? void 0 : o.start(...e);
+    });
+  }
+  stop(...e) {
+    this.mount().then(() => {
+      var o;
+      return (o = this.ref.current) == null ? void 0 : o.stop(...e);
+    });
+  }
+  pulsate(...e) {
+    this.mount().then(() => {
+      var o;
+      return (o = this.ref.current) == null ? void 0 : o.pulsate(...e);
+    });
+  }
+}
+function Ke() {
+  return Q.use();
+}
+function qe() {
+  let n, e;
+  const o = new Promise((u, i) => {
+    n = u, e = i;
+  });
+  return o.resolve = n, o.reject = e, o;
+}
+function ee() {
+  return ee = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var o = arguments[e];
+      for (var u in o) ({}).hasOwnProperty.call(o, u) && (n[u] = o[u]);
+    }
+    return n;
+  }, ee.apply(null, arguments);
+}
+function We(n) {
+  if (n === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return n;
+}
+function ie(n, e) {
+  var o = function(s) {
+    return e && G(s) ? e(s) : s;
+  }, u = /* @__PURE__ */ Object.create(null);
+  return n && ke.map(n, function(i) {
+    return i;
+  }).forEach(function(i) {
+    u[i.key] = o(i);
+  }), u;
+}
+function He(n, e) {
+  n = n || {}, e = e || {};
+  function o(h) {
+    return h in e ? e[h] : n[h];
+  }
+  var u = /* @__PURE__ */ Object.create(null), i = [];
+  for (var s in n)
+    s in e ? i.length && (u[s] = i, i = []) : i.push(s);
+  var r, p = {};
+  for (var l in e) {
+    if (u[l])
+      for (r = 0; r < u[l].length; r++) {
+        var f = u[l][r];
+        p[u[l][r]] = o(f);
+      }
+    p[l] = o(l);
+  }
+  for (r = 0; r < i.length; r++)
+    p[i[r]] = o(i[r]);
+  return p;
+}
+function j(n, e, o) {
+  return o[e] != null ? o[e] : n.props[e];
+}
+function Ge(n, e) {
+  return ie(n.children, function(o) {
+    return J(o, {
+      onExited: e.bind(null, o),
+      in: !0,
+      appear: j(o, "appear", n),
+      enter: j(o, "enter", n),
+      exit: j(o, "exit", n)
+    });
+  });
+}
+function Je(n, e, o) {
+  var u = ie(n.children), i = He(e, u);
+  return Object.keys(i).forEach(function(s) {
+    var r = i[s];
+    if (G(r)) {
+      var p = s in e, l = s in u, f = e[s], h = G(f) && !f.props.in;
+      l && (!p || h) ? i[s] = J(r, {
+        onExited: o.bind(null, r),
+        in: !0,
+        exit: j(r, "exit", n),
+        enter: j(r, "enter", n)
+      }) : !l && p && !h ? i[s] = J(r, {
+        in: !1
+      }) : l && p && G(f) && (i[s] = J(r, {
+        onExited: o.bind(null, r),
+        in: f.props.in,
+        exit: j(r, "exit", n),
+        enter: j(r, "enter", n)
+      }));
+    }
+  }), i;
+}
+var Qe = Object.values || function(n) {
+  return Object.keys(n).map(function(e) {
+    return n[e];
+  });
+}, Ze = {
+  component: "div",
+  childFactory: function(e) {
+    return e;
+  }
+}, se = /* @__PURE__ */ function(n) {
+  ze(e, n);
+  function e(u, i) {
+    var s;
+    s = n.call(this, u, i) || this;
+    var r = s.handleExited.bind(We(s));
+    return s.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: r,
+      firstRender: !0
+    }, s;
+  }
+  var o = e.prototype;
+  return o.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, o.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, e.getDerivedStateFromProps = function(i, s) {
+    var r = s.children, p = s.handleExited, l = s.firstRender;
+    return {
+      children: l ? Ge(i, p) : Je(i, r, p),
+      firstRender: !1
+    };
+  }, o.handleExited = function(i, s) {
+    var r = ie(this.props.children);
+    i.key in r || (i.props.onExited && i.props.onExited(s), this.mounted && this.setState(function(p) {
+      var l = ee({}, p.children);
+      return delete l[i.key], {
+        children: l
+      };
+    }));
+  }, o.render = function() {
+    var i = this.props, s = i.component, r = i.childFactory, p = _e(i, ["component", "childFactory"]), l = this.state.contextValue, f = Qe(this.state.children).map(r);
+    return delete p.appear, delete p.enter, delete p.exit, s === null ? /* @__PURE__ */ W.createElement(ce.Provider, {
+      value: l
+    }, f) : /* @__PURE__ */ W.createElement(ce.Provider, {
+      value: l
+    }, /* @__PURE__ */ W.createElement(s, p, f));
+  }, e;
+}(W.Component);
+se.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: t.any,
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: t.node,
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: t.bool,
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: t.bool,
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: t.bool,
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: t.func
+} : {};
+se.defaultProps = Ze;
+function me(n) {
+  const {
+    className: e,
+    classes: o,
+    pulsate: u = !1,
+    rippleX: i,
+    rippleY: s,
+    rippleSize: r,
+    in: p,
+    onExited: l,
+    timeout: f
+  } = n, [h, M] = d.useState(!1), g = E(e, o.ripple, o.rippleVisible, u && o.ripplePulsate), N = {
+    width: r,
+    height: r,
+    top: -(r / 2) + s,
+    left: -(r / 2) + i
+  }, m = E(o.child, h && o.childLeaving, u && o.childPulsate);
+  return !p && !h && M(!0), d.useEffect(() => {
+    if (!p && l != null) {
+      const S = setTimeout(l, f);
+      return () => {
+        clearTimeout(S);
+      };
+    }
+  }, [l, p, f]), /* @__PURE__ */ U("span", {
+    className: g,
+    style: N,
+    children: /* @__PURE__ */ U("span", {
+      className: m
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (me.propTypes = {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object.isRequired,
+  className: t.string,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  in: t.bool,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  onExited: t.func,
+  /**
+   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+   */
+  pulsate: t.bool,
+  /**
+   * Diameter of the ripple.
+   */
+  rippleSize: t.number,
+  /**
+   * Horizontal position of the ripple center.
+   */
+  rippleX: t.number,
+  /**
+   * Vertical position of the ripple center.
+   */
+  rippleY: t.number,
+  /**
+   * exit delay
+   */
+  timeout: t.number.isRequired
+});
+const b = de("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), te = 550, et = 80, tt = oe`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`, nt = oe`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`, ot = oe`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`, it = ne("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), st = ne(me, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})`
+  opacity: 0;
+  position: absolute;
+
+  &.${b.rippleVisible} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${tt};
+    animation-duration: ${te}ms;
+    animation-timing-function: ${({
+  theme: n
+}) => n.transitions.easing.easeInOut};
+  }
+
+  &.${b.ripplePulsate} {
+    animation-duration: ${({
+  theme: n
+}) => n.transitions.duration.shorter}ms;
+  }
+
+  & .${b.child} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${b.childLeaving} {
+    opacity: 0;
+    animation-name: ${nt};
+    animation-duration: ${te}ms;
+    animation-timing-function: ${({
+  theme: n
+}) => n.transitions.easing.easeInOut};
+  }
+
+  & .${b.childPulsate} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${ot};
+    animation-duration: 2500ms;
+    animation-timing-function: ${({
+  theme: n
+}) => n.transitions.easing.easeInOut};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`, be = /* @__PURE__ */ d.forwardRef(function(e, o) {
+  const u = he({
+    props: e,
+    name: "MuiTouchRipple"
+  }), {
+    center: i = !1,
+    classes: s = {},
+    className: r,
+    ...p
+  } = u, [l, f] = d.useState([]), h = d.useRef(0), M = d.useRef(null);
+  d.useEffect(() => {
+    M.current && (M.current(), M.current = null);
+  }, [l]);
+  const g = d.useRef(!1), N = Ae(), m = d.useRef(null), S = d.useRef(null), C = d.useCallback((c) => {
+    const {
+      pulsate: R,
+      rippleX: y,
+      rippleY: I,
+      rippleSize: B,
+      cb: $
+    } = c;
+    f((T) => [...T, /* @__PURE__ */ U(st, {
+      classes: {
+        ripple: E(s.ripple, b.ripple),
+        rippleVisible: E(s.rippleVisible, b.rippleVisible),
+        ripplePulsate: E(s.ripplePulsate, b.ripplePulsate),
+        child: E(s.child, b.child),
+        childLeaving: E(s.childLeaving, b.childLeaving),
+        childPulsate: E(s.childPulsate, b.childPulsate)
+      },
+      timeout: te,
+      pulsate: R,
+      rippleX: y,
+      rippleY: I,
+      rippleSize: B
+    }, h.current)]), h.current += 1, M.current = $;
+  }, [s]), k = d.useCallback((c = {}, R = {}, y = () => {
+  }) => {
+    const {
+      pulsate: I = !1,
+      center: B = i || R.pulsate,
+      fakeElement: $ = !1
+      // For test purposes
+    } = R;
+    if ((c == null ? void 0 : c.type) === "mousedown" && g.current) {
+      g.current = !1;
+      return;
+    }
+    (c == null ? void 0 : c.type) === "touchstart" && (g.current = !0);
+    const T = $ ? null : S.current, w = T ? T.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let D, x, V;
+    if (B || c === void 0 || c.clientX === 0 && c.clientY === 0 || !c.clientX && !c.touches)
+      D = Math.round(w.width / 2), x = Math.round(w.height / 2);
+    else {
+      const {
+        clientX: z,
+        clientY: L
+      } = c.touches && c.touches.length > 0 ? c.touches[0] : c;
+      D = Math.round(z - w.left), x = Math.round(L - w.top);
+    }
+    if (B)
+      V = Math.sqrt((2 * w.width ** 2 + w.height ** 2) / 3), V % 2 === 0 && (V += 1);
+    else {
+      const z = Math.max(Math.abs((T ? T.clientWidth : 0) - D), D) * 2 + 2, L = Math.max(Math.abs((T ? T.clientHeight : 0) - x), x) * 2 + 2;
+      V = Math.sqrt(z ** 2 + L ** 2);
+    }
+    c != null && c.touches ? m.current === null && (m.current = () => {
+      C({
+        pulsate: I,
+        rippleX: D,
+        rippleY: x,
+        rippleSize: V,
+        cb: y
+      });
+    }, N.start(et, () => {
+      m.current && (m.current(), m.current = null);
+    })) : C({
+      pulsate: I,
+      rippleX: D,
+      rippleY: x,
+      rippleSize: V,
+      cb: y
+    });
+  }, [i, C, N]), Y = d.useCallback(() => {
+    k({}, {
+      pulsate: !0
+    });
+  }, [k]), F = d.useCallback((c, R) => {
+    if (N.clear(), (c == null ? void 0 : c.type) === "touchend" && m.current) {
+      m.current(), m.current = null, N.start(0, () => {
+        F(c, R);
+      });
+      return;
+    }
+    m.current = null, f((y) => y.length > 0 ? y.slice(1) : y), M.current = R;
+  }, [N]);
+  return d.useImperativeHandle(o, () => ({
+    pulsate: Y,
+    start: k,
+    stop: F
+  }), [Y, k, F]), /* @__PURE__ */ U(it, {
+    className: E(b.root, s.root, r),
+    ref: S,
+    ...p,
+    children: /* @__PURE__ */ U(se, {
+      component: null,
+      exit: !0,
+      children: l
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (be.propTypes = {
+  /**
+   * If `true`, the ripple starts at the center of the component
+   * rather than at the point of interaction.
+   */
+  center: t.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string
+});
+function rt(n) {
+  return Fe("MuiButtonBase", n);
+}
+const at = de("MuiButtonBase", ["root", "disabled", "focusVisible"]), ut = (n) => {
+  const {
+    disabled: e,
+    focusVisible: o,
+    focusVisibleClassName: u,
+    classes: i
+  } = n, r = Ue({
+    root: ["root", e && "disabled", o && "focusVisible"]
+  }, rt, i);
+  return o && u && (r.root += ` ${u}`), r;
+}, lt = ne("button", {
+  name: "MuiButtonBase",
+  slot: "Root",
+  overridesResolver: (n, e) => e.root
+})({
+  display: "inline-flex",
+  alignItems: "center",
+  justifyContent: "center",
+  position: "relative",
+  boxSizing: "border-box",
+  WebkitTapHighlightColor: "transparent",
+  backgroundColor: "transparent",
+  // Reset default value
+  // We disable the focus ring for mouse, touch and keyboard users.
+  outline: 0,
+  border: 0,
+  margin: 0,
+  // Remove the margin in Safari
+  borderRadius: 0,
+  padding: 0,
+  // Remove the padding in Firefox
+  cursor: "pointer",
+  userSelect: "none",
+  verticalAlign: "middle",
+  MozAppearance: "none",
+  // Reset
+  WebkitAppearance: "none",
+  // Reset
+  textDecoration: "none",
+  // So we take precedent over the style of a native <a /> element.
+  color: "inherit",
+  "&::-moz-focus-inner": {
+    borderStyle: "none"
+    // Remove Firefox dotted outline.
+  },
+  [`&.${at.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), ct = /* @__PURE__ */ d.forwardRef(function(e, o) {
+  const u = he({
+    props: e,
+    name: "MuiButtonBase"
+  }), {
+    action: i,
+    centerRipple: s = !1,
+    children: r,
+    className: p,
+    component: l = "button",
+    disabled: f = !1,
+    disableRipple: h = !1,
+    disableTouchRipple: M = !1,
+    focusRipple: g = !1,
+    focusVisibleClassName: N,
+    LinkComponent: m = "a",
+    onBlur: S,
+    onClick: C,
+    onContextMenu: k,
+    onDragLeave: Y,
+    onFocus: F,
+    onFocusVisible: c,
+    onKeyDown: R,
+    onKeyUp: y,
+    onMouseDown: I,
+    onMouseLeave: B,
+    onMouseUp: $,
+    onTouchEnd: T,
+    onTouchMove: w,
+    onTouchStart: D,
+    tabIndex: x = 0,
+    TouchRippleProps: V,
+    touchRippleRef: z,
+    type: L,
+    ..._
+  } = u, A = d.useRef(null), P = Ke(), ge = pe(P.ref, z), [O, K] = d.useState(!1);
+  f && O && K(!1), d.useImperativeHandle(i, () => ({
+    focusVisible: () => {
+      K(!0), A.current.focus();
+    }
+  }), []);
+  const ye = P.shouldMount && !h && !f;
+  d.useEffect(() => {
+    O && g && !h && P.pulsate();
+  }, [h, g, O, P]);
+  function v(a, ae, Le = M) {
+    return H((ue) => (ae && ae(ue), Le || P[a](ue), !0));
+  }
+  const Me = v("start", I), Re = v("stop", k), Te = v("stop", Y), Ee = v("stop", $), Ce = v("stop", (a) => {
+    O && a.preventDefault(), B && B(a);
+  }), xe = v("start", D), Pe = v("stop", T), ve = v("stop", w), Ne = v("stop", (a) => {
+    fe(a.target) || K(!1), S && S(a);
+  }, !1), we = H((a) => {
+    A.current || (A.current = a.currentTarget), fe(a.target) && (K(!0), c && c(a)), F && F(a);
+  }), Z = () => {
+    const a = A.current;
+    return l && l !== "button" && !(a.tagName === "A" && a.href);
+  }, De = H((a) => {
+    g && !a.repeat && O && a.key === " " && P.stop(a, () => {
+      P.start(a);
+    }), a.target === a.currentTarget && Z() && a.key === " " && a.preventDefault(), R && R(a), a.target === a.currentTarget && Z() && a.key === "Enter" && !f && (a.preventDefault(), C && C(a));
+  }), Ve = H((a) => {
+    g && a.key === " " && O && !a.defaultPrevented && P.stop(a, () => {
+      P.pulsate(a);
+    }), y && y(a), C && a.target === a.currentTarget && Z() && a.key === " " && !a.defaultPrevented && C(a);
+  });
+  let q = l;
+  q === "button" && (_.href || _.to) && (q = m);
+  const X = {};
+  q === "button" ? (X.type = L === void 0 ? "button" : L, X.disabled = f) : (!_.href && !_.to && (X.role = "button"), f && (X["aria-disabled"] = f));
+  const Se = pe(o, A), re = {
+    ...u,
+    centerRipple: s,
+    component: l,
+    disabled: f,
+    disableRipple: h,
+    disableTouchRipple: M,
+    focusRipple: g,
+    tabIndex: x,
+    focusVisible: O
+  }, Be = ut(re);
+  return /* @__PURE__ */ Ie(lt, {
+    as: q,
+    className: E(Be.root, p),
+    ownerState: re,
+    onBlur: Ne,
+    onClick: C,
+    onContextMenu: Re,
+    onFocus: we,
+    onKeyDown: De,
+    onKeyUp: Ve,
+    onMouseDown: Me,
+    onMouseLeave: Ce,
+    onMouseUp: Ee,
+    onDragLeave: Te,
+    onTouchEnd: Pe,
+    onTouchMove: ve,
+    onTouchStart: xe,
+    ref: Se,
+    tabIndex: f ? -1 : x,
+    type: L,
+    ...X,
+    ..._,
+    children: [r, ye ? /* @__PURE__ */ U(be, {
+      ref: ge,
+      center: s,
+      ...V
+    }) : null]
+  });
+});
+process.env.NODE_ENV !== "production" && (ct.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A ref for imperative actions.
+   * It currently only supports `focusVisible()` action.
+   */
+  action: Xe,
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: 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: Ye,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: 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,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: t.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: t.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: t.string,
+  /**
+   * @ignore
+   */
+  href: t.any,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: t.elementType,
+  /**
+   * @ignore
+   */
+  onBlur: t.func,
+  /**
+   * @ignore
+   */
+  onClick: t.func,
+  /**
+   * @ignore
+   */
+  onContextMenu: t.func,
+  /**
+   * @ignore
+   */
+  onDragLeave: t.func,
+  /**
+   * @ignore
+   */
+  onFocus: t.func,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: t.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: t.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: t.func,
+  /**
+   * @ignore
+   */
+  onMouseDown: t.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: t.func,
+  /**
+   * @ignore
+   */
+  onMouseUp: t.func,
+  /**
+   * @ignore
+   */
+  onTouchEnd: t.func,
+  /**
+   * @ignore
+   */
+  onTouchMove: t.func,
+  /**
+   * @ignore
+   */
+  onTouchStart: 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]),
+  /**
+   * @default 0
+   */
+  tabIndex: t.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: t.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: t.oneOfType([t.func, t.shape({
+    current: t.shape({
+      pulsate: t.func.isRequired,
+      start: t.func.isRequired,
+      stop: t.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  type: t.oneOfType([t.oneOf(["button", "reset", "submit"]), t.string])
+});
+export {
+  ct as B,
+  se as T,
+  ee as _,
+  fe as i
+};