@solostylist/ui-kit 1.0.88 → 1.0.89

package/dist/ButtonBase-C0g54hXq.js

@@ -0,0 +1,910 @@
+var De = Object.defineProperty;
+var xe = (t, n, e) => n in t ? De(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var q = (t, n, e) => xe(t, typeof n != "symbol" ? n + "" : n, e);
+import { c as oe } from "./defaultTheme-CFAmbghg.js";
+import * as l from "react";
+import { P as o } from "./createTheme-DbdaZ0Ku.js";
+import { c as D, u as ue, s as Q, a as Ie } from "./createSvgIcon-DpVs_nKR.js";
+import { j as P } from "./jsx-runtime-DywqP_6a.js";
+import { g as Se } from "./generateUtilityClasses-BtVDwGrk.js";
+import { a as Ve } from "./TransitionGroup-SToIdl-5.js";
+import { keyframes as ee } from "@emotion/react";
+import { g as je, b as Le } from "./buttonBaseClasses-jCihfot4.js";
+import { u as Oe } from "./useEnhancedEffect-CJGo-L3B.js";
+function Z(t) {
+  const n = l.useRef(t);
+  return Oe(() => {
+    n.current = t;
+  }), l.useRef((...e) => (
+    // @ts-expect-error hide `this`
+    (0, n.current)(...e)
+  )).current;
+}
+function v(...t) {
+  const n = l.useRef(void 0), e = l.useCallback((s) => {
+    const i = t.map((u) => {
+      if (u == null)
+        return null;
+      if (typeof u == "function") {
+        const f = u, h = f(s);
+        return typeof h == "function" ? h : () => {
+          f(null);
+        };
+      }
+      return u.current = s, () => {
+        u.current = null;
+      };
+    });
+    return () => {
+      i.forEach((u) => u == null ? void 0 : u());
+    };
+  }, t);
+  return l.useMemo(() => t.every((s) => s == null) ? null : (s) => {
+    n.current && (n.current(), n.current = void 0), s != null && (n.current = e(s));
+  }, t);
+}
+function $e(t, n) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...s) {
+    return t(...s) || n(...s);
+  };
+}
+const se = {};
+function ce(t, n) {
+  const e = l.useRef(se);
+  return e.current === se && (e.current = t(n)), e;
+}
+const Be = [];
+function Pe(t) {
+  l.useEffect(t, Be);
+}
+class te {
+  constructor() {
+    q(this, "currentId", null);
+    q(this, "clear", () => {
+      this.currentId !== null && (clearTimeout(this.currentId), this.currentId = null);
+    });
+    q(this, "disposeEffect", () => this.clear);
+  }
+  static create() {
+    return new te();
+  }
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  start(n, e) {
+    this.clear(), this.currentId = setTimeout(() => {
+      this.currentId = null, e();
+    }, n);
+  }
+}
+function Ue() {
+  const t = ce(te.create).current;
+  return Pe(t.disposeEffect), t;
+}
+function Ae(t) {
+  const {
+    prototype: n = {}
+  } = t;
+  return !!n.isReactComponent;
+}
+function ze(t, n, e, s, i) {
+  const u = t[n], f = i || n;
+  if (u == null || // When server-side rendering React doesn't warn either.
+  // This is not an accurate check for SSR.
+  // This is only in place for emotion compat.
+  // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
+  typeof window > "u")
+    return null;
+  let h;
+  return typeof u == "function" && !Ae(u) && (h = "Did you accidentally provide a plain function component instead?"), h !== void 0 ? new Error(`Invalid ${s} \`${f}\` supplied to \`${e}\`. Expected an element type that can hold a ref. ${h} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const He = $e(o.elementType, ze);
+function Ke(t) {
+  return typeof t == "string";
+}
+function Ye(t, n, e) {
+  return t === void 0 || Ke(t) ? n : {
+    ...n,
+    ownerState: {
+      ...n.ownerState,
+      ...e
+    }
+  };
+}
+function Xe(t, n, e) {
+  return typeof t == "function" ? t(n, e) : t;
+}
+function qe(t, n = []) {
+  if (t === void 0)
+    return {};
+  const e = {};
+  return Object.keys(t).filter((s) => s.match(/^on[A-Z]/) && typeof t[s] == "function" && !n.includes(s)).forEach((s) => {
+    e[s] = t[s];
+  }), e;
+}
+function re(t) {
+  if (t === void 0)
+    return {};
+  const n = {};
+  return Object.keys(t).filter((e) => !(e.match(/^on[A-Z]/) && typeof t[e] == "function")).forEach((e) => {
+    n[e] = t[e];
+  }), n;
+}
+function Fe(t) {
+  const {
+    getSlotProps: n,
+    additionalProps: e,
+    externalSlotProps: s,
+    externalForwardedProps: i,
+    className: u
+  } = t;
+  if (!n) {
+    const R = oe(e == null ? void 0 : e.className, u, i == null ? void 0 : i.className, s == null ? void 0 : s.className), d = {
+      ...e == null ? void 0 : e.style,
+      ...i == null ? void 0 : i.style,
+      ...s == null ? void 0 : s.style
+    }, T = {
+      ...e,
+      ...i,
+      ...s
+    };
+    return R.length > 0 && (T.className = R), Object.keys(d).length > 0 && (T.style = d), {
+      props: T,
+      internalRef: void 0
+    };
+  }
+  const f = qe({
+    ...i,
+    ...s
+  }), h = re(s), g = re(i), a = n(f), m = oe(a == null ? void 0 : a.className, e == null ? void 0 : e.className, u, i == null ? void 0 : i.className, s == null ? void 0 : s.className), p = {
+    ...a == null ? void 0 : a.style,
+    ...e == null ? void 0 : e.style,
+    ...i == null ? void 0 : i.style,
+    ...s == null ? void 0 : s.style
+  }, y = {
+    ...a,
+    ...e,
+    ...g,
+    ...h
+  };
+  return m.length > 0 && (y.className = m), Object.keys(p).length > 0 && (y.style = p), {
+    props: y,
+    internalRef: a.ref
+  };
+}
+function mt(t, n) {
+  const {
+    className: e,
+    elementType: s,
+    ownerState: i,
+    externalForwardedProps: u,
+    internalForwardedProps: f,
+    shouldForwardComponentProp: h = !1,
+    ...g
+  } = n, {
+    component: a,
+    slots: m = {
+      [t]: void 0
+    },
+    slotProps: p = {
+      [t]: void 0
+    },
+    ...y
+  } = u, R = m[t] || s, d = Xe(p[t], i), {
+    props: {
+      component: T,
+      ...E
+    },
+    internalRef: S
+  } = Fe({
+    className: e,
+    ...g,
+    externalForwardedProps: t === "root" ? y : void 0,
+    externalSlotProps: d
+  }), U = v(S, d == null ? void 0 : d.ref, n.ref), C = t === "root" ? T || a : T, c = Ye(R, {
+    ...t === "root" && !a && !m[t] && f,
+    ...t !== "root" && !m[t] && f,
+    ...E,
+    ...C && !h && {
+      as: C
+    },
+    ...C && h && {
+      component: C
+    },
+    ref: U
+  }, i);
+  return [R, c];
+}
+const We = o.oneOfType([o.func, o.object]);
+function ie(t) {
+  try {
+    return t.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 _ {
+  constructor() {
+    q(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 _();
+  }
+  static use() {
+    const n = ce(_.create).current, [e, s] = l.useState(!1);
+    return n.shouldMount = e, n.setShouldMount = s, l.useEffect(n.mountEffect, [e]), n;
+  }
+  mount() {
+    return this.mounted || (this.mounted = _e(), this.shouldMount = !0, this.setShouldMount(this.shouldMount)), this.mounted;
+  }
+  /* Ripple API */
+  start(...n) {
+    this.mount().then(() => {
+      var e;
+      return (e = this.ref.current) == null ? void 0 : e.start(...n);
+    });
+  }
+  stop(...n) {
+    this.mount().then(() => {
+      var e;
+      return (e = this.ref.current) == null ? void 0 : e.stop(...n);
+    });
+  }
+  pulsate(...n) {
+    this.mount().then(() => {
+      var e;
+      return (e = this.ref.current) == null ? void 0 : e.pulsate(...n);
+    });
+  }
+}
+function Ze() {
+  return _.use();
+}
+function _e() {
+  let t, n;
+  const e = new Promise((s, i) => {
+    t = s, n = i;
+  });
+  return e.resolve = t, e.reject = n, e;
+}
+function le(t) {
+  const {
+    className: n,
+    classes: e,
+    pulsate: s = !1,
+    rippleX: i,
+    rippleY: u,
+    rippleSize: f,
+    in: h,
+    onExited: g,
+    timeout: a
+  } = t, [m, p] = l.useState(!1), y = D(n, e.ripple, e.rippleVisible, s && e.ripplePulsate), R = {
+    width: f,
+    height: f,
+    top: -(f / 2) + u,
+    left: -(f / 2) + i
+  }, d = D(e.child, m && e.childLeaving, s && e.childPulsate);
+  return !h && !m && p(!0), l.useEffect(() => {
+    if (!h && g != null) {
+      const T = setTimeout(g, a);
+      return () => {
+        clearTimeout(T);
+      };
+    }
+  }, [g, h, a]), /* @__PURE__ */ P.jsx("span", {
+    className: y,
+    style: R,
+    children: /* @__PURE__ */ P.jsx("span", {
+      className: d
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (le.propTypes = {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object.isRequired,
+  className: o.string,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  in: o.bool,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  onExited: o.func,
+  /**
+   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+   */
+  pulsate: o.bool,
+  /**
+   * Diameter of the ripple.
+   */
+  rippleSize: o.number,
+  /**
+   * Horizontal position of the ripple center.
+   */
+  rippleX: o.number,
+  /**
+   * Vertical position of the ripple center.
+   */
+  rippleY: o.number,
+  /**
+   * exit delay
+   */
+  timeout: o.number.isRequired
+});
+const M = Se("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), J = 550, Ge = 80, ve = ee`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`, Je = ee`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`, Qe = ee`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`, et = Q("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), tt = Q(le, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})`
+  opacity: 0;
+  position: absolute;
+
+  &.${M.rippleVisible} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${ve};
+    animation-duration: ${J}ms;
+    animation-timing-function: ${({
+  theme: t
+}) => t.transitions.easing.easeInOut};
+  }
+
+  &.${M.ripplePulsate} {
+    animation-duration: ${({
+  theme: t
+}) => t.transitions.duration.shorter}ms;
+  }
+
+  & .${M.child} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${M.childLeaving} {
+    opacity: 0;
+    animation-name: ${Je};
+    animation-duration: ${J}ms;
+    animation-timing-function: ${({
+  theme: t
+}) => t.transitions.easing.easeInOut};
+  }
+
+  & .${M.childPulsate} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${Qe};
+    animation-duration: 2500ms;
+    animation-timing-function: ${({
+  theme: t
+}) => t.transitions.easing.easeInOut};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`, ae = /* @__PURE__ */ l.forwardRef(function(n, e) {
+  const s = ue({
+    props: n,
+    name: "MuiTouchRipple"
+  }), {
+    center: i = !1,
+    classes: u = {},
+    className: f,
+    ...h
+  } = s, [g, a] = l.useState([]), m = l.useRef(0), p = l.useRef(null);
+  l.useEffect(() => {
+    p.current && (p.current(), p.current = null);
+  }, [g]);
+  const y = l.useRef(!1), R = Ue(), d = l.useRef(null), T = l.useRef(null), E = l.useCallback((c) => {
+    const {
+      pulsate: w,
+      rippleX: N,
+      rippleY: A,
+      rippleSize: O,
+      cb: z
+    } = c;
+    a((k) => [...k, /* @__PURE__ */ P.jsx(tt, {
+      classes: {
+        ripple: D(u.ripple, M.ripple),
+        rippleVisible: D(u.rippleVisible, M.rippleVisible),
+        ripplePulsate: D(u.ripplePulsate, M.ripplePulsate),
+        child: D(u.child, M.child),
+        childLeaving: D(u.childLeaving, M.childLeaving),
+        childPulsate: D(u.childPulsate, M.childPulsate)
+      },
+      timeout: J,
+      pulsate: w,
+      rippleX: N,
+      rippleY: A,
+      rippleSize: O
+    }, m.current)]), m.current += 1, p.current = z;
+  }, [u]), S = l.useCallback((c = {}, w = {}, N = () => {
+  }) => {
+    const {
+      pulsate: A = !1,
+      center: O = i || w.pulsate,
+      fakeElement: z = !1
+      // For test purposes
+    } = w;
+    if ((c == null ? void 0 : c.type) === "mousedown" && y.current) {
+      y.current = !1;
+      return;
+    }
+    (c == null ? void 0 : c.type) === "touchstart" && (y.current = !0);
+    const k = z ? null : T.current, V = k ? k.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let j, x, L;
+    if (O || c === void 0 || c.clientX === 0 && c.clientY === 0 || !c.clientX && !c.touches)
+      j = Math.round(V.width / 2), x = Math.round(V.height / 2);
+    else {
+      const {
+        clientX: H,
+        clientY: $
+      } = c.touches && c.touches.length > 0 ? c.touches[0] : c;
+      j = Math.round(H - V.left), x = Math.round($ - V.top);
+    }
+    if (O)
+      L = Math.sqrt((2 * V.width ** 2 + V.height ** 2) / 3), L % 2 === 0 && (L += 1);
+    else {
+      const H = Math.max(Math.abs((k ? k.clientWidth : 0) - j), j) * 2 + 2, $ = Math.max(Math.abs((k ? k.clientHeight : 0) - x), x) * 2 + 2;
+      L = Math.sqrt(H ** 2 + $ ** 2);
+    }
+    c != null && c.touches ? d.current === null && (d.current = () => {
+      E({
+        pulsate: A,
+        rippleX: j,
+        rippleY: x,
+        rippleSize: L,
+        cb: N
+      });
+    }, R.start(Ge, () => {
+      d.current && (d.current(), d.current = null);
+    })) : E({
+      pulsate: A,
+      rippleX: j,
+      rippleY: x,
+      rippleSize: L,
+      cb: N
+    });
+  }, [i, E, R]), U = l.useCallback(() => {
+    S({}, {
+      pulsate: !0
+    });
+  }, [S]), C = l.useCallback((c, w) => {
+    if (R.clear(), (c == null ? void 0 : c.type) === "touchend" && d.current) {
+      d.current(), d.current = null, R.start(0, () => {
+        C(c, w);
+      });
+      return;
+    }
+    d.current = null, a((N) => N.length > 0 ? N.slice(1) : N), p.current = w;
+  }, [R]);
+  return l.useImperativeHandle(e, () => ({
+    pulsate: U,
+    start: S,
+    stop: C
+  }), [U, S, C]), /* @__PURE__ */ P.jsx(et, {
+    className: D(M.root, u.root, f),
+    ref: T,
+    ...h,
+    children: /* @__PURE__ */ P.jsx(Ve, {
+      component: null,
+      exit: !0,
+      children: g
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ae.propTypes = {
+  /**
+   * If `true`, the ripple starts at the center of the component
+   * rather than at the point of interaction.
+   */
+  center: o.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string
+});
+const nt = (t) => {
+  const {
+    disabled: n,
+    focusVisible: e,
+    focusVisibleClassName: s,
+    classes: i
+  } = t, f = Ie({
+    root: ["root", n && "disabled", e && "focusVisible"]
+  }, je, i);
+  return e && s && (f.root += ` ${s}`), f;
+}, ot = Q("button", {
+  name: "MuiButtonBase",
+  slot: "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.
+  },
+  [`&.${Le.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), st = /* @__PURE__ */ l.forwardRef(function(n, e) {
+  const s = ue({
+    props: n,
+    name: "MuiButtonBase"
+  }), {
+    action: i,
+    centerRipple: u = !1,
+    children: f,
+    className: h,
+    component: g = "button",
+    disabled: a = !1,
+    disableRipple: m = !1,
+    disableTouchRipple: p = !1,
+    focusRipple: y = !1,
+    focusVisibleClassName: R,
+    LinkComponent: d = "a",
+    onBlur: T,
+    onClick: E,
+    onContextMenu: S,
+    onDragLeave: U,
+    onFocus: C,
+    onFocusVisible: c,
+    onKeyDown: w,
+    onKeyUp: N,
+    onMouseDown: A,
+    onMouseLeave: O,
+    onMouseUp: z,
+    onTouchEnd: k,
+    onTouchMove: V,
+    onTouchStart: j,
+    tabIndex: x = 0,
+    TouchRippleProps: L,
+    touchRippleRef: H,
+    type: $,
+    ...K
+  } = s, Y = l.useRef(null), b = Ze(), pe = v(b.ref, H), [B, F] = l.useState(!1);
+  a && B && F(!1), l.useImperativeHandle(i, () => ({
+    focusVisible: () => {
+      F(!0), Y.current.focus();
+    }
+  }), []);
+  const fe = b.shouldMount && !m && !a;
+  l.useEffect(() => {
+    B && y && !m && b.pulsate();
+  }, [m, y, B, b]);
+  const de = I(b, "start", A, p), he = I(b, "stop", S, p), me = I(b, "stop", U, p), ye = I(b, "stop", z, p), be = I(b, "stop", (r) => {
+    B && r.preventDefault(), O && O(r);
+  }, p), ge = I(b, "start", j, p), Re = I(b, "stop", k, p), Te = I(b, "stop", V, p), Me = I(b, "stop", (r) => {
+    ie(r.target) || F(!1), T && T(r);
+  }, !1), Ee = Z((r) => {
+    Y.current || (Y.current = r.currentTarget), ie(r.target) && (F(!0), c && c(r)), C && C(r);
+  }), G = () => {
+    const r = Y.current;
+    return g && g !== "button" && !(r.tagName === "A" && r.href);
+  }, Ce = Z((r) => {
+    y && !r.repeat && B && r.key === " " && b.stop(r, () => {
+      b.start(r);
+    }), r.target === r.currentTarget && G() && r.key === " " && r.preventDefault(), w && w(r), r.target === r.currentTarget && G() && r.key === "Enter" && !a && (r.preventDefault(), E && E(r));
+  }), Ne = Z((r) => {
+    y && r.key === " " && B && !r.defaultPrevented && b.stop(r, () => {
+      b.pulsate(r);
+    }), N && N(r), E && r.target === r.currentTarget && G() && r.key === " " && !r.defaultPrevented && E(r);
+  });
+  let W = g;
+  W === "button" && (K.href || K.to) && (W = d);
+  const X = {};
+  W === "button" ? (X.type = $ === void 0 ? "button" : $, X.disabled = a) : (!K.href && !K.to && (X.role = "button"), a && (X["aria-disabled"] = a));
+  const we = v(e, Y), ne = {
+    ...s,
+    centerRipple: u,
+    component: g,
+    disabled: a,
+    disableRipple: m,
+    disableTouchRipple: p,
+    focusRipple: y,
+    tabIndex: x,
+    focusVisible: B
+  }, ke = nt(ne);
+  return /* @__PURE__ */ P.jsxs(ot, {
+    as: W,
+    className: D(ke.root, h),
+    ownerState: ne,
+    onBlur: Me,
+    onClick: E,
+    onContextMenu: he,
+    onFocus: Ee,
+    onKeyDown: Ce,
+    onKeyUp: Ne,
+    onMouseDown: de,
+    onMouseLeave: be,
+    onMouseUp: ye,
+    onDragLeave: me,
+    onTouchEnd: Re,
+    onTouchMove: Te,
+    onTouchStart: ge,
+    ref: we,
+    tabIndex: a ? -1 : x,
+    type: $,
+    ...X,
+    ...K,
+    children: [f, fe ? /* @__PURE__ */ P.jsx(ae, {
+      ref: pe,
+      center: u,
+      ...L
+    }) : null]
+  });
+});
+function I(t, n, e, s = !1) {
+  return Z((i) => (e && e(i), s || t[n](i), !0));
+}
+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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A ref for imperative actions.
+   * It currently only supports `focusVisible()` action.
+   */
+  action: We,
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: o.bool,
+  /**
+   * The content of the component.
+   */
+  children: o.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: He,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: o.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: o.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: o.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: o.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: o.string,
+  /**
+   * @ignore
+   */
+  href: o.any,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: o.elementType,
+  /**
+   * @ignore
+   */
+  onBlur: o.func,
+  /**
+   * @ignore
+   */
+  onClick: o.func,
+  /**
+   * @ignore
+   */
+  onContextMenu: o.func,
+  /**
+   * @ignore
+   */
+  onDragLeave: o.func,
+  /**
+   * @ignore
+   */
+  onFocus: o.func,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: o.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: o.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: o.func,
+  /**
+   * @ignore
+   */
+  onMouseDown: o.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: o.func,
+  /**
+   * @ignore
+   */
+  onMouseUp: o.func,
+  /**
+   * @ignore
+   */
+  onTouchEnd: o.func,
+  /**
+   * @ignore
+   */
+  onTouchMove: o.func,
+  /**
+   * @ignore
+   */
+  onTouchStart: o.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object]),
+  /**
+   * @default 0
+   */
+  tabIndex: o.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: o.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: o.oneOfType([o.func, o.shape({
+    current: o.shape({
+      pulsate: o.func.isRequired,
+      start: o.func.isRequired,
+      stop: o.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  type: o.oneOfType([o.oneOf(["button", "reset", "submit"]), o.string])
+});
+export {
+  st as B,
+  Xe as a,
+  Ue as b,
+  $e as c,
+  mt as d,
+  He as e,
+  Z as f,
+  qe as g,
+  Ye as h,
+  Fe as m,
+  We as r,
+  v as u
+};