@jigowatts/jigowatts-ui 0.0.1-12

package/dist/ButtonBase-pxtIu13Q.js

@@ -0,0 +1,866 @@
+import { a as Y, _ as re, b as Te, s as se, u as Me, g as Xe, c as Ye } from "./styled-CWju4EfZ.js";
+import * as p from "react";
+import X, { Children as qe, isValidElement as G, cloneElement as J } from "react";
+import { P as e, c as C } from "./index-Bs3JCwgu.js";
+import { jsx as j, jsxs as He } from "react/jsx-runtime";
+import { d as We, u as he, c as Ge, b as W } from "./useIsFocusVisible-BxB-Hdhb.js";
+import { keyframes as ae } from "@emotion/react";
+function Je(t, n) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...l) {
+    return t(...l) || n(...l);
+  };
+}
+function Qe(t) {
+  const {
+    prototype: n = {}
+  } = t;
+  return !!n.isReactComponent;
+}
+function Ze(t, n, s, l, i) {
+  const o = t[n], r = i || n;
+  if (o == 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 u;
+  return typeof o == "function" && !Qe(o) && (u = "Did you accidentally provide a plain function component instead?"), u !== void 0 ? new Error(`Invalid ${l} \`${r}\` supplied to \`${s}\`. Expected an element type that can hold a ref. ${u} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const et = Je(e.elementType, Ze), tt = e.oneOfType([e.func, e.object]), nt = tt;
+function oe(t, n) {
+  return oe = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(l, i) {
+    return l.__proto__ = i, l;
+  }, oe(t, n);
+}
+function ot(t, n) {
+  t.prototype = Object.create(n.prototype), t.prototype.constructor = t, oe(t, n);
+}
+const me = X.createContext(null);
+function it(t) {
+  if (t === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return t;
+}
+function le(t, n) {
+  var s = function(o) {
+    return n && G(o) ? n(o) : o;
+  }, l = /* @__PURE__ */ Object.create(null);
+  return t && qe.map(t, function(i) {
+    return i;
+  }).forEach(function(i) {
+    l[i.key] = s(i);
+  }), l;
+}
+function rt(t, n) {
+  t = t || {}, n = n || {};
+  function s(h) {
+    return h in n ? n[h] : t[h];
+  }
+  var l = /* @__PURE__ */ Object.create(null), i = [];
+  for (var o in t)
+    o in n ? i.length && (l[o] = i, i = []) : i.push(o);
+  var r, u = {};
+  for (var c in n) {
+    if (l[c])
+      for (r = 0; r < l[c].length; r++) {
+        var f = l[c][r];
+        u[l[c][r]] = s(f);
+      }
+    u[c] = s(c);
+  }
+  for (r = 0; r < i.length; r++)
+    u[i[r]] = s(i[r]);
+  return u;
+}
+function $(t, n, s) {
+  return s[n] != null ? s[n] : t.props[n];
+}
+function st(t, n) {
+  return le(t.children, function(s) {
+    return J(s, {
+      onExited: n.bind(null, s),
+      in: !0,
+      appear: $(s, "appear", t),
+      enter: $(s, "enter", t),
+      exit: $(s, "exit", t)
+    });
+  });
+}
+function at(t, n, s) {
+  var l = le(t.children), i = rt(n, l);
+  return Object.keys(i).forEach(function(o) {
+    var r = i[o];
+    if (G(r)) {
+      var u = o in n, c = o in l, f = n[o], h = G(f) && !f.props.in;
+      c && (!u || h) ? i[o] = J(r, {
+        onExited: s.bind(null, r),
+        in: !0,
+        exit: $(r, "exit", t),
+        enter: $(r, "enter", t)
+      }) : !c && u && !h ? i[o] = J(r, {
+        in: !1
+      }) : c && u && G(f) && (i[o] = J(r, {
+        onExited: s.bind(null, r),
+        in: f.props.in,
+        exit: $(r, "exit", t),
+        enter: $(r, "enter", t)
+      }));
+    }
+  }), i;
+}
+var lt = Object.values || function(t) {
+  return Object.keys(t).map(function(n) {
+    return t[n];
+  });
+}, ut = {
+  component: "div",
+  childFactory: function(n) {
+    return n;
+  }
+}, ue = /* @__PURE__ */ function(t) {
+  ot(n, t);
+  function n(l, i) {
+    var o;
+    o = t.call(this, l, i) || this;
+    var r = o.handleExited.bind(it(o));
+    return o.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: r,
+      firstRender: !0
+    }, o;
+  }
+  var s = n.prototype;
+  return s.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, s.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, n.getDerivedStateFromProps = function(i, o) {
+    var r = o.children, u = o.handleExited, c = o.firstRender;
+    return {
+      children: c ? st(i, u) : at(i, r, u),
+      firstRender: !1
+    };
+  }, s.handleExited = function(i, o) {
+    var r = le(this.props.children);
+    i.key in r || (i.props.onExited && i.props.onExited(o), this.mounted && this.setState(function(u) {
+      var c = Y({}, u.children);
+      return delete c[i.key], {
+        children: c
+      };
+    }));
+  }, s.render = function() {
+    var i = this.props, o = i.component, r = i.childFactory, u = re(i, ["component", "childFactory"]), c = this.state.contextValue, f = lt(this.state.children).map(r);
+    return delete u.appear, delete u.enter, delete u.exit, o === null ? /* @__PURE__ */ X.createElement(me.Provider, {
+      value: c
+    }, f) : /* @__PURE__ */ X.createElement(me.Provider, {
+      value: c
+    }, /* @__PURE__ */ X.createElement(o, u, f));
+  }, n;
+}(X.Component);
+ue.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: e.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: e.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: e.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: e.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: e.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: e.func
+} : {};
+ue.defaultProps = ut;
+const ct = ue;
+function Ee(t) {
+  const {
+    className: n,
+    classes: s,
+    pulsate: l = !1,
+    rippleX: i,
+    rippleY: o,
+    rippleSize: r,
+    in: u,
+    onExited: c,
+    timeout: f
+  } = t, [h, R] = p.useState(!1), g = C(n, s.ripple, s.rippleVisible, l && s.ripplePulsate), x = {
+    width: r,
+    height: r,
+    top: -(r / 2) + o,
+    left: -(r / 2) + i
+  }, m = C(s.child, h && s.childLeaving, l && s.childPulsate);
+  return !u && !h && R(!0), p.useEffect(() => {
+    if (!u && c != null) {
+      const T = setTimeout(c, f);
+      return () => {
+        clearTimeout(T);
+      };
+    }
+  }, [c, u, f]), /* @__PURE__ */ j("span", {
+    className: g,
+    style: x,
+    children: /* @__PURE__ */ j("span", {
+      className: m
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (Ee.propTypes = {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object.isRequired,
+  className: e.string,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  in: e.bool,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  onExited: e.func,
+  /**
+   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+   */
+  pulsate: e.bool,
+  /**
+   * Diameter of the ripple.
+   */
+  rippleSize: e.number,
+  /**
+   * Horizontal position of the ripple center.
+   */
+  rippleX: e.number,
+  /**
+   * Vertical position of the ripple center.
+   */
+  rippleY: e.number,
+  /**
+   * exit delay
+   */
+  timeout: e.number.isRequired
+});
+const b = Te("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), pt = ["center", "classes", "className"];
+let Q = (t) => t, be, ge, ye, Re;
+const ie = 550, ft = 80, dt = ae(be || (be = Q`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`)), ht = ae(ge || (ge = Q`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`)), mt = ae(ye || (ye = Q`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`)), bt = se("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), gt = se(Ee, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})(Re || (Re = Q`
+  opacity: 0;
+  position: absolute;
+
+  &.${0} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${0};
+    animation-duration: ${0}ms;
+    animation-timing-function: ${0};
+  }
+
+  &.${0} {
+    animation-duration: ${0}ms;
+  }
+
+  & .${0} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${0} {
+    opacity: 0;
+    animation-name: ${0};
+    animation-duration: ${0}ms;
+    animation-timing-function: ${0};
+  }
+
+  & .${0} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${0};
+    animation-duration: 2500ms;
+    animation-timing-function: ${0};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`), b.rippleVisible, dt, ie, ({
+  theme: t
+}) => t.transitions.easing.easeInOut, b.ripplePulsate, ({
+  theme: t
+}) => t.transitions.duration.shorter, b.child, b.childLeaving, ht, ie, ({
+  theme: t
+}) => t.transitions.easing.easeInOut, b.childPulsate, mt, ({
+  theme: t
+}) => t.transitions.easing.easeInOut), ve = /* @__PURE__ */ p.forwardRef(function(n, s) {
+  const l = Me({
+    props: n,
+    name: "MuiTouchRipple"
+  }), {
+    center: i = !1,
+    classes: o = {},
+    className: r
+  } = l, u = re(l, pt), [c, f] = p.useState([]), h = p.useRef(0), R = p.useRef(null);
+  p.useEffect(() => {
+    R.current && (R.current(), R.current = null);
+  }, [c]);
+  const g = p.useRef(!1), x = We(), m = p.useRef(null), T = p.useRef(null), I = p.useCallback((d) => {
+    const {
+      pulsate: M,
+      rippleX: E,
+      rippleY: O,
+      rippleSize: F,
+      cb: z
+    } = d;
+    f((v) => [...v, /* @__PURE__ */ j(gt, {
+      classes: {
+        ripple: C(o.ripple, b.ripple),
+        rippleVisible: C(o.rippleVisible, b.rippleVisible),
+        ripplePulsate: C(o.ripplePulsate, b.ripplePulsate),
+        child: C(o.child, b.child),
+        childLeaving: C(o.childLeaving, b.childLeaving),
+        childPulsate: C(o.childPulsate, b.childPulsate)
+      },
+      timeout: ie,
+      pulsate: M,
+      rippleX: E,
+      rippleY: O,
+      rippleSize: F
+    }, h.current)]), h.current += 1, R.current = z;
+  }, [o]), L = p.useCallback((d = {}, M = {}, E = () => {
+  }) => {
+    const {
+      pulsate: O = !1,
+      center: F = i || M.pulsate,
+      fakeElement: z = !1
+      // For test purposes
+    } = M;
+    if ((d == null ? void 0 : d.type) === "mousedown" && g.current) {
+      g.current = !1;
+      return;
+    }
+    (d == null ? void 0 : d.type) === "touchstart" && (g.current = !0);
+    const v = z ? null : T.current, D = v ? v.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let P, B, w;
+    if (F || d === void 0 || d.clientX === 0 && d.clientY === 0 || !d.clientX && !d.touches)
+      P = Math.round(D.width / 2), B = Math.round(D.height / 2);
+    else {
+      const {
+        clientX: _,
+        clientY: V
+      } = d.touches && d.touches.length > 0 ? d.touches[0] : d;
+      P = Math.round(_ - D.left), B = Math.round(V - D.top);
+    }
+    if (F)
+      w = Math.sqrt((2 * D.width ** 2 + D.height ** 2) / 3), w % 2 === 0 && (w += 1);
+    else {
+      const _ = Math.max(Math.abs((v ? v.clientWidth : 0) - P), P) * 2 + 2, V = Math.max(Math.abs((v ? v.clientHeight : 0) - B), B) * 2 + 2;
+      w = Math.sqrt(_ ** 2 + V ** 2);
+    }
+    d != null && d.touches ? m.current === null && (m.current = () => {
+      I({
+        pulsate: O,
+        rippleX: P,
+        rippleY: B,
+        rippleSize: w,
+        cb: E
+      });
+    }, x.start(ft, () => {
+      m.current && (m.current(), m.current = null);
+    })) : I({
+      pulsate: O,
+      rippleX: P,
+      rippleY: B,
+      rippleSize: w,
+      cb: E
+    });
+  }, [i, I, x]), U = p.useCallback(() => {
+    L({}, {
+      pulsate: !0
+    });
+  }, [L]), k = p.useCallback((d, M) => {
+    if (x.clear(), (d == null ? void 0 : d.type) === "touchend" && m.current) {
+      m.current(), m.current = null, x.start(0, () => {
+        k(d, M);
+      });
+      return;
+    }
+    m.current = null, f((E) => E.length > 0 ? E.slice(1) : E), R.current = M;
+  }, [x]);
+  return p.useImperativeHandle(s, () => ({
+    pulsate: U,
+    start: L,
+    stop: k
+  }), [U, L, k]), /* @__PURE__ */ j(bt, Y({
+    className: C(b.root, o.root, r),
+    ref: T
+  }, u, {
+    children: /* @__PURE__ */ j(ct, {
+      component: null,
+      exit: !0,
+      children: c
+    })
+  }));
+});
+process.env.NODE_ENV !== "production" && (ve.propTypes = {
+  /**
+   * If `true`, the ripple starts at the center of the component
+   * rather than at the point of interaction.
+   */
+  center: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string
+});
+const yt = ve;
+function Rt(t) {
+  return Xe("MuiButtonBase", t);
+}
+const Tt = Te("MuiButtonBase", ["root", "disabled", "focusVisible"]), Mt = ["action", "centerRipple", "children", "className", "component", "disabled", "disableRipple", "disableTouchRipple", "focusRipple", "focusVisibleClassName", "LinkComponent", "onBlur", "onClick", "onContextMenu", "onDragLeave", "onFocus", "onFocusVisible", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseLeave", "onMouseUp", "onTouchEnd", "onTouchMove", "onTouchStart", "tabIndex", "TouchRippleProps", "touchRippleRef", "type"], Et = (t) => {
+  const {
+    disabled: n,
+    focusVisible: s,
+    focusVisibleClassName: l,
+    classes: i
+  } = t, r = Ye({
+    root: ["root", n && "disabled", s && "focusVisible"]
+  }, Rt, i);
+  return s && l && (r.root += ` ${l}`), r;
+}, vt = se("button", {
+  name: "MuiButtonBase",
+  slot: "Root",
+  overridesResolver: (t, n) => n.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.
+  },
+  [`&.${Tt.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), Ce = /* @__PURE__ */ p.forwardRef(function(n, s) {
+  const l = Me({
+    props: n,
+    name: "MuiButtonBase"
+  }), {
+    action: i,
+    centerRipple: o = !1,
+    children: r,
+    className: u,
+    component: c = "button",
+    disabled: f = !1,
+    disableRipple: h = !1,
+    disableTouchRipple: R = !1,
+    focusRipple: g = !1,
+    LinkComponent: x = "a",
+    onBlur: m,
+    onClick: T,
+    onContextMenu: I,
+    onDragLeave: L,
+    onFocus: U,
+    onFocusVisible: k,
+    onKeyDown: d,
+    onKeyUp: M,
+    onMouseDown: E,
+    onMouseLeave: O,
+    onMouseUp: F,
+    onTouchEnd: z,
+    onTouchMove: v,
+    onTouchStart: D,
+    tabIndex: P = 0,
+    TouchRippleProps: B,
+    touchRippleRef: w,
+    type: _
+  } = l, V = re(l, Mt), K = p.useRef(null), y = p.useRef(null), xe = he(y, w), {
+    isFocusVisibleRef: ce,
+    onFocus: Pe,
+    onBlur: Ve,
+    ref: Ne
+  } = Ge(), [S, q] = p.useState(!1);
+  f && S && q(!1), p.useImperativeHandle(i, () => ({
+    focusVisible: () => {
+      q(!0), K.current.focus();
+    }
+  }), []);
+  const [Z, De] = p.useState(!1);
+  p.useEffect(() => {
+    De(!0);
+  }, []);
+  const ee = Z && !h && !f;
+  p.useEffect(() => {
+    S && g && !h && Z && y.current.pulsate();
+  }, [h, g, S, Z]);
+  function N(a, fe, Ae = R) {
+    return W((de) => (fe && fe(de), !Ae && y.current && y.current[a](de), !0));
+  }
+  const Be = N("start", E), we = N("stop", I), Oe = N("stop", L), _e = N("stop", F), Se = N("stop", (a) => {
+    S && a.preventDefault(), O && O(a);
+  }), $e = N("start", D), Le = N("stop", z), ke = N("stop", v), Fe = N("stop", (a) => {
+    Ve(a), ce.current === !1 && q(!1), m && m(a);
+  }, !1), je = W((a) => {
+    K.current || (K.current = a.currentTarget), Pe(a), ce.current === !0 && (q(!0), k && k(a)), U && U(a);
+  }), te = () => {
+    const a = K.current;
+    return c && c !== "button" && !(a.tagName === "A" && a.href);
+  }, ne = p.useRef(!1), Ie = W((a) => {
+    g && !ne.current && S && y.current && a.key === " " && (ne.current = !0, y.current.stop(a, () => {
+      y.current.start(a);
+    })), a.target === a.currentTarget && te() && a.key === " " && a.preventDefault(), d && d(a), a.target === a.currentTarget && te() && a.key === "Enter" && !f && (a.preventDefault(), T && T(a));
+  }), Ue = W((a) => {
+    g && a.key === " " && y.current && S && !a.defaultPrevented && (ne.current = !1, y.current.stop(a, () => {
+      y.current.pulsate(a);
+    })), M && M(a), T && a.target === a.currentTarget && te() && a.key === " " && !a.defaultPrevented && T(a);
+  });
+  let H = c;
+  H === "button" && (V.href || V.to) && (H = x);
+  const A = {};
+  H === "button" ? (A.type = _ === void 0 ? "button" : _, A.disabled = f) : (!V.href && !V.to && (A.role = "button"), f && (A["aria-disabled"] = f));
+  const ze = he(s, Ne, K);
+  process.env.NODE_ENV !== "production" && p.useEffect(() => {
+    ee && !y.current && console.error(["MUI: The `component` prop provided to ButtonBase is invalid.", "Please make sure the children prop is rendered in this custom component."].join(`
+`));
+  }, [ee]);
+  const pe = Y({}, l, {
+    centerRipple: o,
+    component: c,
+    disabled: f,
+    disableRipple: h,
+    disableTouchRipple: R,
+    focusRipple: g,
+    tabIndex: P,
+    focusVisible: S
+  }), Ke = Et(pe);
+  return /* @__PURE__ */ He(vt, Y({
+    as: H,
+    className: C(Ke.root, u),
+    ownerState: pe,
+    onBlur: Fe,
+    onClick: T,
+    onContextMenu: we,
+    onFocus: je,
+    onKeyDown: Ie,
+    onKeyUp: Ue,
+    onMouseDown: Be,
+    onMouseLeave: Se,
+    onMouseUp: _e,
+    onDragLeave: Oe,
+    onTouchEnd: Le,
+    onTouchMove: ke,
+    onTouchStart: $e,
+    ref: ze,
+    tabIndex: f ? -1 : P,
+    type: _
+  }, A, V, {
+    children: [r, ee ? (
+      /* TouchRipple is only needed client-side, x2 boost on the server. */
+      /* @__PURE__ */ j(yt, Y({
+        ref: xe,
+        center: o
+      }, B))
+    ) : null]
+  }));
+});
+process.env.NODE_ENV !== "production" && (Ce.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: nt,
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: e.bool,
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: et,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: e.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: e.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: e.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: e.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: e.string,
+  /**
+   * @ignore
+   */
+  href: e.any,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: e.elementType,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * @ignore
+   */
+  onClick: e.func,
+  /**
+   * @ignore
+   */
+  onContextMenu: e.func,
+  /**
+   * @ignore
+   */
+  onDragLeave: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: e.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: e.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: e.func,
+  /**
+   * @ignore
+   */
+  onMouseDown: e.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: e.func,
+  /**
+   * @ignore
+   */
+  onMouseUp: e.func,
+  /**
+   * @ignore
+   */
+  onTouchEnd: e.func,
+  /**
+   * @ignore
+   */
+  onTouchMove: e.func,
+  /**
+   * @ignore
+   */
+  onTouchStart: e.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * @default 0
+   */
+  tabIndex: e.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: e.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: e.oneOfType([e.func, e.shape({
+    current: e.shape({
+      pulsate: e.func.isRequired,
+      start: e.func.isRequired,
+      stop: e.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  type: e.oneOfType([e.oneOf(["button", "reset", "submit"]), e.string])
+});
+const wt = Ce;
+export {
+  wt as B,
+  me as T,
+  ot as _,
+  ct as a,
+  oe as b,
+  Je as c,
+  it as d,
+  et as e,
+  nt as r
+};