@solostylist/ui-kit 1.0.0

package/dist/ButtonBase-p_uz8ITC.js

@@ -0,0 +1,989 @@
+var $e = Object.defineProperty;
+var Fe = (e, t, n) => t in e ? $e(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var X = (e, t, n) => Fe(e, typeof t != "symbol" ? t + "" : t, n);
+import * as f from "react";
+import K, { Children as Ue, isValidElement as Z, cloneElement as J } from "react";
+import { P as o } from "./createTheme-C97xvI-s.js";
+import { c as E } from "./clsx-C-FXfxyk.js";
+import { j as L } from "./jsx-runtime-B6kdoens.js";
+import { g as be, a as _e } from "./generateUtilityClasses-CuEy5gtx.js";
+import { s as re, c as ze } from "./memoTheme-B2qvAi64.js";
+import { u as ge } from "./DefaultPropsProvider-BV4t9fEW.js";
+import { keyframes as ie } from "@emotion/react";
+import { u as Ae } from "./useEnhancedEffect-CJGo-L3B.js";
+function Ye(e, t) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...r) {
+    return e(...r) || t(...r);
+  };
+}
+const Xe = o.oneOfType([o.func, o.object]);
+function Ke(e) {
+  const {
+    prototype: t = {}
+  } = e;
+  return !!t.isReactComponent;
+}
+function qe(e, t, n, r, s) {
+  const i = e[t], u = s || t;
+  if (i == 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 l;
+  return typeof i == "function" && !Ke(i) && (l = "Did you accidentally provide a plain function component instead?"), l !== void 0 ? new Error(`Invalid ${r} \`${u}\` supplied to \`${n}\`. Expected an element type that can hold a ref. ${l} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const He = Ye(o.elementType, qe);
+function fe(e) {
+  try {
+    return e.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;
+}
+function We(e, t) {
+  typeof e == "function" ? e(t) : e && (e.current = t);
+}
+function de(...e) {
+  return f.useMemo(() => e.every((t) => t == null) ? null : (t) => {
+    e.forEach((n) => {
+      We(n, t);
+    });
+  }, e);
+}
+function G(e) {
+  const t = f.useRef(e);
+  return Ae(() => {
+    t.current = e;
+  }), f.useRef((...n) => (
+    // @ts-expect-error hide `this`
+    (0, t.current)(...n)
+  )).current;
+}
+const he = {};
+function ye(e, t) {
+  const n = f.useRef(he);
+  return n.current === he && (n.current = e(t)), n;
+}
+class Q {
+  constructor() {
+    X(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 t = ye(Q.create).current, [n, r] = f.useState(!1);
+    return t.shouldMount = n, t.setShouldMount = r, f.useEffect(t.mountEffect, [n]), t;
+  }
+  mount() {
+    return this.mounted || (this.mounted = Ze(), this.shouldMount = !0, this.setShouldMount(this.shouldMount)), this.mounted;
+  }
+  /* Ripple API */
+  start(...t) {
+    this.mount().then(() => {
+      var n;
+      return (n = this.ref.current) == null ? void 0 : n.start(...t);
+    });
+  }
+  stop(...t) {
+    this.mount().then(() => {
+      var n;
+      return (n = this.ref.current) == null ? void 0 : n.stop(...t);
+    });
+  }
+  pulsate(...t) {
+    this.mount().then(() => {
+      var n;
+      return (n = this.ref.current) == null ? void 0 : n.pulsate(...t);
+    });
+  }
+}
+function Ge() {
+  return Q.use();
+}
+function Ze() {
+  let e, t;
+  const n = new Promise((r, s) => {
+    e = r, t = s;
+  });
+  return n.resolve = e, n.reject = t, n;
+}
+function te() {
+  return te = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var r in n) ({}).hasOwnProperty.call(n, r) && (e[r] = n[r]);
+    }
+    return e;
+  }, te.apply(null, arguments);
+}
+function Je(e, t) {
+  if (e == null) return {};
+  var n = {};
+  for (var r in e) if ({}.hasOwnProperty.call(e, r)) {
+    if (t.includes(r)) continue;
+    n[r] = e[r];
+  }
+  return n;
+}
+function ne(e, t) {
+  return ne = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, r) {
+    return n.__proto__ = r, n;
+  }, ne(e, t);
+}
+function Qe(e, t) {
+  e.prototype = Object.create(t.prototype), e.prototype.constructor = e, ne(e, t);
+}
+const me = K.createContext(null);
+function et(e) {
+  if (e === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function se(e, t) {
+  var n = function(i) {
+    return t && Z(i) ? t(i) : i;
+  }, r = /* @__PURE__ */ Object.create(null);
+  return e && Ue.map(e, function(s) {
+    return s;
+  }).forEach(function(s) {
+    r[s.key] = n(s);
+  }), r;
+}
+function tt(e, t) {
+  e = e || {}, t = t || {};
+  function n(h) {
+    return h in t ? t[h] : e[h];
+  }
+  var r = /* @__PURE__ */ Object.create(null), s = [];
+  for (var i in e)
+    i in t ? s.length && (r[i] = s, s = []) : s.push(i);
+  var u, l = {};
+  for (var c in t) {
+    if (r[c])
+      for (u = 0; u < r[c].length; u++) {
+        var d = r[c][u];
+        l[r[c][u]] = n(d);
+      }
+    l[c] = n(c);
+  }
+  for (u = 0; u < s.length; u++)
+    l[s[u]] = n(s[u]);
+  return l;
+}
+function B(e, t, n) {
+  return n[t] != null ? n[t] : e.props[t];
+}
+function nt(e, t) {
+  return se(e.children, function(n) {
+    return J(n, {
+      onExited: t.bind(null, n),
+      in: !0,
+      appear: B(n, "appear", e),
+      enter: B(n, "enter", e),
+      exit: B(n, "exit", e)
+    });
+  });
+}
+function ot(e, t, n) {
+  var r = se(e.children), s = tt(t, r);
+  return Object.keys(s).forEach(function(i) {
+    var u = s[i];
+    if (Z(u)) {
+      var l = i in t, c = i in r, d = t[i], h = Z(d) && !d.props.in;
+      c && (!l || h) ? s[i] = J(u, {
+        onExited: n.bind(null, u),
+        in: !0,
+        exit: B(u, "exit", e),
+        enter: B(u, "enter", e)
+      }) : !c && l && !h ? s[i] = J(u, {
+        in: !1
+      }) : c && l && Z(d) && (s[i] = J(u, {
+        onExited: n.bind(null, u),
+        in: d.props.in,
+        exit: B(u, "exit", e),
+        enter: B(u, "enter", e)
+      }));
+    }
+  }), s;
+}
+var rt = Object.values || function(e) {
+  return Object.keys(e).map(function(t) {
+    return e[t];
+  });
+}, it = {
+  component: "div",
+  childFactory: function(t) {
+    return t;
+  }
+}, ue = /* @__PURE__ */ function(e) {
+  Qe(t, e);
+  function t(r, s) {
+    var i;
+    i = e.call(this, r, s) || this;
+    var u = i.handleExited.bind(et(i));
+    return i.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: u,
+      firstRender: !0
+    }, i;
+  }
+  var n = t.prototype;
+  return n.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, n.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, t.getDerivedStateFromProps = function(s, i) {
+    var u = i.children, l = i.handleExited, c = i.firstRender;
+    return {
+      children: c ? nt(s, l) : ot(s, u, l),
+      firstRender: !1
+    };
+  }, n.handleExited = function(s, i) {
+    var u = se(this.props.children);
+    s.key in u || (s.props.onExited && s.props.onExited(i), this.mounted && this.setState(function(l) {
+      var c = te({}, l.children);
+      return delete c[s.key], {
+        children: c
+      };
+    }));
+  }, n.render = function() {
+    var s = this.props, i = s.component, u = s.childFactory, l = Je(s, ["component", "childFactory"]), c = this.state.contextValue, d = rt(this.state.children).map(u);
+    return delete l.appear, delete l.enter, delete l.exit, i === null ? /* @__PURE__ */ K.createElement(me.Provider, {
+      value: c
+    }, d) : /* @__PURE__ */ K.createElement(me.Provider, {
+      value: c
+    }, /* @__PURE__ */ K.createElement(i, l, d));
+  }, t;
+}(K.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: o.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: o.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: o.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: o.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: o.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: o.func
+} : {};
+ue.defaultProps = it;
+const st = [];
+function ut(e) {
+  f.useEffect(e, st);
+}
+class ae {
+  constructor() {
+    X(this, "currentId", null);
+    X(this, "clear", () => {
+      this.currentId !== null && (clearTimeout(this.currentId), this.currentId = null);
+    });
+    X(this, "disposeEffect", () => this.clear);
+  }
+  static create() {
+    return new ae();
+  }
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  start(t, n) {
+    this.clear(), this.currentId = setTimeout(() => {
+      this.currentId = null, n();
+    }, t);
+  }
+}
+function at() {
+  const e = ye(ae.create).current;
+  return ut(e.disposeEffect), e;
+}
+function Me(e) {
+  const {
+    className: t,
+    classes: n,
+    pulsate: r = !1,
+    rippleX: s,
+    rippleY: i,
+    rippleSize: u,
+    in: l,
+    onExited: c,
+    timeout: d
+  } = e, [h, M] = f.useState(!1), g = E(t, n.ripple, n.rippleVisible, r && n.ripplePulsate), w = {
+    width: u,
+    height: u,
+    top: -(u / 2) + i,
+    left: -(u / 2) + s
+  }, m = E(n.child, h && n.childLeaving, r && n.childPulsate);
+  return !l && !h && M(!0), f.useEffect(() => {
+    if (!l && c != null) {
+      const D = setTimeout(c, d);
+      return () => {
+        clearTimeout(D);
+      };
+    }
+  }, [c, l, d]), /* @__PURE__ */ L.jsx("span", {
+    className: g,
+    style: w,
+    children: /* @__PURE__ */ L.jsx("span", {
+      className: m
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (Me.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 b = be("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), oe = 550, lt = 80, ct = ie`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`, pt = ie`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`, ft = ie`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`, dt = re("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), ht = re(Me, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})`
+  opacity: 0;
+  position: absolute;
+
+  &.${b.rippleVisible} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${ct};
+    animation-duration: ${oe}ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+  }
+
+  &.${b.ripplePulsate} {
+    animation-duration: ${({
+  theme: e
+}) => e.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: ${pt};
+    animation-duration: ${oe}ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+  }
+
+  & .${b.childPulsate} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${ft};
+    animation-duration: 2500ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`, Re = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  const r = ge({
+    props: t,
+    name: "MuiTouchRipple"
+  }), {
+    center: s = !1,
+    classes: i = {},
+    className: u,
+    ...l
+  } = r, [c, d] = f.useState([]), h = f.useRef(0), M = f.useRef(null);
+  f.useEffect(() => {
+    M.current && (M.current(), M.current = null);
+  }, [c]);
+  const g = f.useRef(!1), w = at(), m = f.useRef(null), D = f.useRef(null), x = f.useCallback((p) => {
+    const {
+      pulsate: R,
+      rippleX: y,
+      rippleY: F,
+      rippleSize: V,
+      cb: U
+    } = p;
+    d((T) => [...T, /* @__PURE__ */ L.jsx(ht, {
+      classes: {
+        ripple: E(i.ripple, b.ripple),
+        rippleVisible: E(i.rippleVisible, b.rippleVisible),
+        ripplePulsate: E(i.ripplePulsate, b.ripplePulsate),
+        child: E(i.child, b.child),
+        childLeaving: E(i.childLeaving, b.childLeaving),
+        childPulsate: E(i.childPulsate, b.childPulsate)
+      },
+      timeout: oe,
+      pulsate: R,
+      rippleX: y,
+      rippleY: F,
+      rippleSize: V
+    }, h.current)]), h.current += 1, M.current = U;
+  }, [i]), k = f.useCallback((p = {}, R = {}, y = () => {
+  }) => {
+    const {
+      pulsate: F = !1,
+      center: V = s || R.pulsate,
+      fakeElement: U = !1
+      // For test purposes
+    } = R;
+    if ((p == null ? void 0 : p.type) === "mousedown" && g.current) {
+      g.current = !1;
+      return;
+    }
+    (p == null ? void 0 : p.type) === "touchstart" && (g.current = !0);
+    const T = U ? null : D.current, N = T ? T.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let O, C, j;
+    if (V || p === void 0 || p.clientX === 0 && p.clientY === 0 || !p.clientX && !p.touches)
+      O = Math.round(N.width / 2), C = Math.round(N.height / 2);
+    else {
+      const {
+        clientX: _,
+        clientY: S
+      } = p.touches && p.touches.length > 0 ? p.touches[0] : p;
+      O = Math.round(_ - N.left), C = Math.round(S - N.top);
+    }
+    if (V)
+      j = Math.sqrt((2 * N.width ** 2 + N.height ** 2) / 3), j % 2 === 0 && (j += 1);
+    else {
+      const _ = Math.max(Math.abs((T ? T.clientWidth : 0) - O), O) * 2 + 2, S = Math.max(Math.abs((T ? T.clientHeight : 0) - C), C) * 2 + 2;
+      j = Math.sqrt(_ ** 2 + S ** 2);
+    }
+    p != null && p.touches ? m.current === null && (m.current = () => {
+      x({
+        pulsate: F,
+        rippleX: O,
+        rippleY: C,
+        rippleSize: j,
+        cb: y
+      });
+    }, w.start(lt, () => {
+      m.current && (m.current(), m.current = null);
+    })) : x({
+      pulsate: F,
+      rippleX: O,
+      rippleY: C,
+      rippleSize: j,
+      cb: y
+    });
+  }, [s, x, w]), q = f.useCallback(() => {
+    k({}, {
+      pulsate: !0
+    });
+  }, [k]), $ = f.useCallback((p, R) => {
+    if (w.clear(), (p == null ? void 0 : p.type) === "touchend" && m.current) {
+      m.current(), m.current = null, w.start(0, () => {
+        $(p, R);
+      });
+      return;
+    }
+    m.current = null, d((y) => y.length > 0 ? y.slice(1) : y), M.current = R;
+  }, [w]);
+  return f.useImperativeHandle(n, () => ({
+    pulsate: q,
+    start: k,
+    stop: $
+  }), [q, k, $]), /* @__PURE__ */ L.jsx(dt, {
+    className: E(b.root, i.root, u),
+    ref: D,
+    ...l,
+    children: /* @__PURE__ */ L.jsx(ue, {
+      component: null,
+      exit: !0,
+      children: c
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Re.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
+});
+function mt(e) {
+  return _e("MuiButtonBase", e);
+}
+const bt = be("MuiButtonBase", ["root", "disabled", "focusVisible"]), gt = (e) => {
+  const {
+    disabled: t,
+    focusVisible: n,
+    focusVisibleClassName: r,
+    classes: s
+  } = e, u = ze({
+    root: ["root", t && "disabled", n && "focusVisible"]
+  }, mt, s);
+  return n && r && (u.root += ` ${r}`), u;
+}, yt = re("button", {
+  name: "MuiButtonBase",
+  slot: "Root",
+  overridesResolver: (e, t) => t.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.
+  },
+  [`&.${bt.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), Mt = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  const r = ge({
+    props: t,
+    name: "MuiButtonBase"
+  }), {
+    action: s,
+    centerRipple: i = !1,
+    children: u,
+    className: l,
+    component: c = "button",
+    disabled: d = !1,
+    disableRipple: h = !1,
+    disableTouchRipple: M = !1,
+    focusRipple: g = !1,
+    focusVisibleClassName: w,
+    LinkComponent: m = "a",
+    onBlur: D,
+    onClick: x,
+    onContextMenu: k,
+    onDragLeave: q,
+    onFocus: $,
+    onFocusVisible: p,
+    onKeyDown: R,
+    onKeyUp: y,
+    onMouseDown: F,
+    onMouseLeave: V,
+    onMouseUp: U,
+    onTouchEnd: T,
+    onTouchMove: N,
+    onTouchStart: O,
+    tabIndex: C = 0,
+    TouchRippleProps: j,
+    touchRippleRef: _,
+    type: S,
+    ...z
+  } = r, A = f.useRef(null), P = Ge(), Te = de(P.ref, _), [I, H] = f.useState(!1);
+  d && I && H(!1), f.useImperativeHandle(s, () => ({
+    focusVisible: () => {
+      H(!0), A.current.focus();
+    }
+  }), []);
+  const Ee = P.shouldMount && !h && !d;
+  f.useEffect(() => {
+    I && g && !h && P.pulsate();
+  }, [h, g, I, P]);
+  function v(a, ce, ke = M) {
+    return G((pe) => (ce && ce(pe), ke || P[a](pe), !0));
+  }
+  const xe = v("start", F), Ce = v("stop", k), Pe = v("stop", q), ve = v("stop", U), we = v("stop", (a) => {
+    I && a.preventDefault(), V && V(a);
+  }), Ne = v("start", O), Oe = v("stop", T), je = v("stop", N), De = v("stop", (a) => {
+    fe(a.target) || H(!1), D && D(a);
+  }, !1), Ve = G((a) => {
+    A.current || (A.current = a.currentTarget), fe(a.target) && (H(!0), p && p(a)), $ && $(a);
+  }), ee = () => {
+    const a = A.current;
+    return c && c !== "button" && !(a.tagName === "A" && a.href);
+  }, Se = G((a) => {
+    g && !a.repeat && I && a.key === " " && P.stop(a, () => {
+      P.start(a);
+    }), a.target === a.currentTarget && ee() && a.key === " " && a.preventDefault(), R && R(a), a.target === a.currentTarget && ee() && a.key === "Enter" && !d && (a.preventDefault(), x && x(a));
+  }), Ie = G((a) => {
+    g && a.key === " " && I && !a.defaultPrevented && P.stop(a, () => {
+      P.pulsate(a);
+    }), y && y(a), x && a.target === a.currentTarget && ee() && a.key === " " && !a.defaultPrevented && x(a);
+  });
+  let W = c;
+  W === "button" && (z.href || z.to) && (W = m);
+  const Y = {};
+  W === "button" ? (Y.type = S === void 0 ? "button" : S, Y.disabled = d) : (!z.href && !z.to && (Y.role = "button"), d && (Y["aria-disabled"] = d));
+  const Be = de(n, A), le = {
+    ...r,
+    centerRipple: i,
+    component: c,
+    disabled: d,
+    disableRipple: h,
+    disableTouchRipple: M,
+    focusRipple: g,
+    tabIndex: C,
+    focusVisible: I
+  }, Le = gt(le);
+  return /* @__PURE__ */ L.jsxs(yt, {
+    as: W,
+    className: E(Le.root, l),
+    ownerState: le,
+    onBlur: De,
+    onClick: x,
+    onContextMenu: Ce,
+    onFocus: Ve,
+    onKeyDown: Se,
+    onKeyUp: Ie,
+    onMouseDown: xe,
+    onMouseLeave: we,
+    onMouseUp: ve,
+    onDragLeave: Pe,
+    onTouchEnd: Oe,
+    onTouchMove: je,
+    onTouchStart: Ne,
+    ref: Be,
+    tabIndex: d ? -1 : C,
+    type: S,
+    ...Y,
+    ...z,
+    children: [u, Ee ? /* @__PURE__ */ L.jsx(Re, {
+      ref: Te,
+      center: i,
+      ...j
+    }) : null]
+  });
+});
+process.env.NODE_ENV !== "production" && (Mt.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: 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 {
+  Mt as B,
+  me as T,
+  Qe as _,
+  Je as a,
+  at as b,
+  Ye as c,
+  He as e,
+  Xe as r,
+  de as u
+};