@notificationapi/react 0.0.37 → 1.0.1

package/dist/assets/ButtonBase.js

@@ -0,0 +1,1224 @@
+var ze = Object.defineProperty;
+var ke = (e, t, n) => t in e ? ze(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var Z = (e, t, n) => ke(e, typeof t != "symbol" ? t + "" : t, n);
+import { r as Ue, m as Xe, u as ye, a as qe } from "./resolveComponentProps.js";
+import * as b from "react";
+import Q, { Children as Ke, isValidElement as re, cloneElement as oe } from "react";
+import { G as We, H as He, I as Ge, J as Je, P as o, _ as Ze, c as F, g as Oe, s as Re, u as Ne, a as Qe, f as et } from "./DefaultPropsProvider.js";
+import { jsx as H, jsxs as tt } from "react/jsx-runtime";
+var be = { exports: {} }, h = {};
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Pe;
+function nt() {
+  if (Pe) return h;
+  Pe = 1;
+  var e = typeof Symbol == "function" && Symbol.for, t = e ? Symbol.for("react.element") : 60103, n = e ? Symbol.for("react.portal") : 60106, a = e ? Symbol.for("react.fragment") : 60107, s = e ? Symbol.for("react.strict_mode") : 60108, i = e ? Symbol.for("react.profiler") : 60114, u = e ? Symbol.for("react.provider") : 60109, f = e ? Symbol.for("react.context") : 60110, p = e ? Symbol.for("react.async_mode") : 60111, m = e ? Symbol.for("react.concurrent_mode") : 60111, E = e ? Symbol.for("react.forward_ref") : 60112, T = e ? Symbol.for("react.suspense") : 60113, M = e ? Symbol.for("react.suspense_list") : 60120, S = e ? Symbol.for("react.memo") : 60115, R = e ? Symbol.for("react.lazy") : 60116, x = e ? Symbol.for("react.block") : 60121, P = e ? Symbol.for("react.fundamental") : 60117, _ = e ? Symbol.for("react.responder") : 60118, A = e ? Symbol.for("react.scope") : 60119;
+  function g(r) {
+    if (typeof r == "object" && r !== null) {
+      var C = r.$$typeof;
+      switch (C) {
+        case t:
+          switch (r = r.type, r) {
+            case p:
+            case m:
+            case a:
+            case i:
+            case s:
+            case T:
+              return r;
+            default:
+              switch (r = r && r.$$typeof, r) {
+                case f:
+                case E:
+                case R:
+                case S:
+                case u:
+                  return r;
+                default:
+                  return C;
+              }
+          }
+        case n:
+          return C;
+      }
+    }
+  }
+  function l(r) {
+    return g(r) === m;
+  }
+  return h.AsyncMode = p, h.ConcurrentMode = m, h.ContextConsumer = f, h.ContextProvider = u, h.Element = t, h.ForwardRef = E, h.Fragment = a, h.Lazy = R, h.Memo = S, h.Portal = n, h.Profiler = i, h.StrictMode = s, h.Suspense = T, h.isAsyncMode = function(r) {
+    return l(r) || g(r) === p;
+  }, h.isConcurrentMode = l, h.isContextConsumer = function(r) {
+    return g(r) === f;
+  }, h.isContextProvider = function(r) {
+    return g(r) === u;
+  }, h.isElement = function(r) {
+    return typeof r == "object" && r !== null && r.$$typeof === t;
+  }, h.isForwardRef = function(r) {
+    return g(r) === E;
+  }, h.isFragment = function(r) {
+    return g(r) === a;
+  }, h.isLazy = function(r) {
+    return g(r) === R;
+  }, h.isMemo = function(r) {
+    return g(r) === S;
+  }, h.isPortal = function(r) {
+    return g(r) === n;
+  }, h.isProfiler = function(r) {
+    return g(r) === i;
+  }, h.isStrictMode = function(r) {
+    return g(r) === s;
+  }, h.isSuspense = function(r) {
+    return g(r) === T;
+  }, h.isValidElementType = function(r) {
+    return typeof r == "string" || typeof r == "function" || r === a || r === m || r === i || r === s || r === T || r === M || typeof r == "object" && r !== null && (r.$$typeof === R || r.$$typeof === S || r.$$typeof === u || r.$$typeof === f || r.$$typeof === E || r.$$typeof === P || r.$$typeof === _ || r.$$typeof === A || r.$$typeof === x);
+  }, h.typeOf = g, h;
+}
+var y = {};
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var xe;
+function rt() {
+  return xe || (xe = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = typeof Symbol == "function" && Symbol.for, t = e ? Symbol.for("react.element") : 60103, n = e ? Symbol.for("react.portal") : 60106, a = e ? Symbol.for("react.fragment") : 60107, s = e ? Symbol.for("react.strict_mode") : 60108, i = e ? Symbol.for("react.profiler") : 60114, u = e ? Symbol.for("react.provider") : 60109, f = e ? Symbol.for("react.context") : 60110, p = e ? Symbol.for("react.async_mode") : 60111, m = e ? Symbol.for("react.concurrent_mode") : 60111, E = e ? Symbol.for("react.forward_ref") : 60112, T = e ? Symbol.for("react.suspense") : 60113, M = e ? Symbol.for("react.suspense_list") : 60120, S = e ? Symbol.for("react.memo") : 60115, R = e ? Symbol.for("react.lazy") : 60116, x = e ? Symbol.for("react.block") : 60121, P = e ? Symbol.for("react.fundamental") : 60117, _ = e ? Symbol.for("react.responder") : 60118, A = e ? Symbol.for("react.scope") : 60119;
+    function g(c) {
+      return typeof c == "string" || typeof c == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      c === a || c === m || c === i || c === s || c === T || c === M || typeof c == "object" && c !== null && (c.$$typeof === R || c.$$typeof === S || c.$$typeof === u || c.$$typeof === f || c.$$typeof === E || c.$$typeof === P || c.$$typeof === _ || c.$$typeof === A || c.$$typeof === x);
+    }
+    function l(c) {
+      if (typeof c == "object" && c !== null) {
+        var G = c.$$typeof;
+        switch (G) {
+          case t:
+            var k = c.type;
+            switch (k) {
+              case p:
+              case m:
+              case a:
+              case i:
+              case s:
+              case T:
+                return k;
+              default:
+                var te = k && k.$$typeof;
+                switch (te) {
+                  case f:
+                  case E:
+                  case R:
+                  case S:
+                  case u:
+                    return te;
+                  default:
+                    return G;
+                }
+            }
+          case n:
+            return G;
+        }
+      }
+    }
+    var r = p, C = m, B = f, L = u, U = t, $ = E, N = a, I = R, O = S, D = n, X = i, V = s, q = T, z = !1;
+    function v(c) {
+      return z || (z = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), ee(c) || l(c) === p;
+    }
+    function ee(c) {
+      return l(c) === m;
+    }
+    function Y(c) {
+      return l(c) === f;
+    }
+    function W(c) {
+      return l(c) === u;
+    }
+    function ae(c) {
+      return typeof c == "object" && c !== null && c.$$typeof === t;
+    }
+    function ue(c) {
+      return l(c) === E;
+    }
+    function ce(c) {
+      return l(c) === a;
+    }
+    function le(c) {
+      return l(c) === R;
+    }
+    function fe(c) {
+      return l(c) === S;
+    }
+    function pe(c) {
+      return l(c) === n;
+    }
+    function de(c) {
+      return l(c) === i;
+    }
+    function me(c) {
+      return l(c) === s;
+    }
+    function he(c) {
+      return l(c) === T;
+    }
+    y.AsyncMode = r, y.ConcurrentMode = C, y.ContextConsumer = B, y.ContextProvider = L, y.Element = U, y.ForwardRef = $, y.Fragment = N, y.Lazy = I, y.Memo = O, y.Portal = D, y.Profiler = X, y.StrictMode = V, y.Suspense = q, y.isAsyncMode = v, y.isConcurrentMode = ee, y.isContextConsumer = Y, y.isContextProvider = W, y.isElement = ae, y.isForwardRef = ue, y.isFragment = ce, y.isLazy = le, y.isMemo = fe, y.isPortal = pe, y.isProfiler = de, y.isStrictMode = me, y.isSuspense = he, y.isValidElementType = g, y.typeOf = l;
+  }()), y;
+}
+process.env.NODE_ENV === "production" ? be.exports = nt() : be.exports = rt();
+var ot = be.exports, Ie = ot, st = {
+  $$typeof: !0,
+  render: !0,
+  defaultProps: !0,
+  displayName: !0,
+  propTypes: !0
+}, it = {
+  $$typeof: !0,
+  compare: !0,
+  defaultProps: !0,
+  displayName: !0,
+  propTypes: !0,
+  type: !0
+}, De = {};
+De[Ie.ForwardRef] = st;
+De[Ie.Memo] = it;
+var _e = function(t, n) {
+  var a = arguments;
+  if (n == null || !We.call(n, "css"))
+    return b.createElement.apply(void 0, a);
+  var s = a.length, i = new Array(s);
+  i[0] = He, i[1] = Ge(t, n);
+  for (var u = 2; u < s; u++)
+    i[u] = a[u];
+  return b.createElement.apply(null, i);
+};
+(function(e) {
+  var t;
+  t || (t = e.JSX || (e.JSX = {}));
+})(_e || (_e = {}));
+function at() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return Je(t);
+}
+function ge() {
+  var e = at.apply(void 0, arguments), t = "animation-" + e.name;
+  return {
+    name: t,
+    styles: "@keyframes " + t + "{" + e.styles + "}",
+    anim: 1,
+    toString: function() {
+      return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
+    }
+  };
+}
+const ut = typeof window < "u" ? b.useLayoutEffect : b.useEffect;
+function ct(e, t) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...a) {
+    return e(...a) || t(...a);
+  };
+}
+function lt(e) {
+  const {
+    prototype: t = {}
+  } = e;
+  return !!t.isReactComponent;
+}
+function ft(e, t, n, a, 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 f;
+  return typeof i == "function" && !lt(i) && (f = "Did you accidentally provide a plain function component instead?"), f !== void 0 ? new Error(`Invalid ${a} \`${u}\` supplied to \`${n}\`. Expected an element type that can hold a ref. ${f} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const pt = ct(o.elementType, ft), dt = o.oneOfType([o.func, o.object]);
+function se(e) {
+  const t = b.useRef(e);
+  return ut(() => {
+    t.current = e;
+  }), b.useRef((...n) => (
+    // @ts-expect-error hide `this`
+    (0, t.current)(...n)
+  )).current;
+}
+const $e = {};
+function Fe(e, t) {
+  const n = b.useRef($e);
+  return n.current === $e && (n.current = e(t)), n;
+}
+const mt = [];
+function ht(e) {
+  b.useEffect(e, mt);
+}
+class Se {
+  constructor() {
+    Z(this, "currentId", null);
+    Z(this, "clear", () => {
+      this.currentId !== null && (clearTimeout(this.currentId), this.currentId = null);
+    });
+    Z(this, "disposeEffect", () => this.clear);
+  }
+  static create() {
+    return new Se();
+  }
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  start(t, n) {
+    this.clear(), this.currentId = setTimeout(() => {
+      this.currentId = null, n();
+    }, t);
+  }
+}
+function yt() {
+  const e = Fe(Se.create).current;
+  return ht(e.disposeEffect), e;
+}
+function we(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 bt(e, t) {
+  if (e == null) return {};
+  var n = {};
+  for (var a in e) if ({}.hasOwnProperty.call(e, a)) {
+    if (t.includes(a)) continue;
+    n[a] = e[a];
+  }
+  return n;
+}
+function Ee(e, t) {
+  return Ee = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, a) {
+    return n.__proto__ = a, n;
+  }, Ee(e, t);
+}
+function Et(e, t) {
+  e.prototype = Object.create(t.prototype), e.prototype.constructor = e, Ee(e, t);
+}
+const Ae = Q.createContext(null);
+function Tt(e) {
+  if (e === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function ve(e, t) {
+  var n = function(i) {
+    return t && re(i) ? t(i) : i;
+  }, a = /* @__PURE__ */ Object.create(null);
+  return e && Ke.map(e, function(s) {
+    return s;
+  }).forEach(function(s) {
+    a[s.key] = n(s);
+  }), a;
+}
+function Rt(e, t) {
+  e = e || {}, t = t || {};
+  function n(E) {
+    return E in t ? t[E] : e[E];
+  }
+  var a = /* @__PURE__ */ Object.create(null), s = [];
+  for (var i in e)
+    i in t ? s.length && (a[i] = s, s = []) : s.push(i);
+  var u, f = {};
+  for (var p in t) {
+    if (a[p])
+      for (u = 0; u < a[p].length; u++) {
+        var m = a[p][u];
+        f[a[p][u]] = n(m);
+      }
+    f[p] = n(p);
+  }
+  for (u = 0; u < s.length; u++)
+    f[s[u]] = n(s[u]);
+  return f;
+}
+function K(e, t, n) {
+  return n[t] != null ? n[t] : e.props[t];
+}
+function gt(e, t) {
+  return ve(e.children, function(n) {
+    return oe(n, {
+      onExited: t.bind(null, n),
+      in: !0,
+      appear: K(n, "appear", e),
+      enter: K(n, "enter", e),
+      exit: K(n, "exit", e)
+    });
+  });
+}
+function St(e, t, n) {
+  var a = ve(e.children), s = Rt(t, a);
+  return Object.keys(s).forEach(function(i) {
+    var u = s[i];
+    if (re(u)) {
+      var f = i in t, p = i in a, m = t[i], E = re(m) && !m.props.in;
+      p && (!f || E) ? s[i] = oe(u, {
+        onExited: n.bind(null, u),
+        in: !0,
+        exit: K(u, "exit", e),
+        enter: K(u, "enter", e)
+      }) : !p && f && !E ? s[i] = oe(u, {
+        in: !1
+      }) : p && f && re(m) && (s[i] = oe(u, {
+        onExited: n.bind(null, u),
+        in: m.props.in,
+        exit: K(u, "exit", e),
+        enter: K(u, "enter", e)
+      }));
+    }
+  }), s;
+}
+var vt = Object.values || function(e) {
+  return Object.keys(e).map(function(t) {
+    return e[t];
+  });
+}, Mt = {
+  component: "div",
+  childFactory: function(t) {
+    return t;
+  }
+}, Me = /* @__PURE__ */ function(e) {
+  Et(t, e);
+  function t(a, s) {
+    var i;
+    i = e.call(this, a, s) || this;
+    var u = i.handleExited.bind(Tt(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, f = i.handleExited, p = i.firstRender;
+    return {
+      children: p ? gt(s, f) : St(s, u, f),
+      firstRender: !1
+    };
+  }, n.handleExited = function(s, i) {
+    var u = ve(this.props.children);
+    s.key in u || (s.props.onExited && s.props.onExited(i), this.mounted && this.setState(function(f) {
+      var p = Ze({}, f.children);
+      return delete p[s.key], {
+        children: p
+      };
+    }));
+  }, n.render = function() {
+    var s = this.props, i = s.component, u = s.childFactory, f = bt(s, ["component", "childFactory"]), p = this.state.contextValue, m = vt(this.state.children).map(u);
+    return delete f.appear, delete f.enter, delete f.exit, i === null ? /* @__PURE__ */ Q.createElement(Ae.Provider, {
+      value: p
+    }, m) : /* @__PURE__ */ Q.createElement(Ae.Provider, {
+      value: p
+    }, /* @__PURE__ */ Q.createElement(i, f, m));
+  }, t;
+}(Q.Component);
+Me.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
+} : {};
+Me.defaultProps = Mt;
+function kt(e, t) {
+  const {
+    className: n,
+    elementType: a,
+    ownerState: s,
+    externalForwardedProps: i,
+    internalForwardedProps: u,
+    ...f
+  } = t, {
+    component: p,
+    slots: m = {
+      [e]: void 0
+    },
+    slotProps: E = {
+      [e]: void 0
+    },
+    ...T
+  } = i, M = m[e] || a, S = Ue(E[e], s), {
+    props: {
+      component: R,
+      ...x
+    },
+    internalRef: P
+  } = Xe({
+    className: n,
+    ...f,
+    externalForwardedProps: e === "root" ? T : void 0,
+    externalSlotProps: S
+  }), _ = ye(P, S == null ? void 0 : S.ref, t.ref), A = e === "root" ? R || p : R, g = qe(M, {
+    ...e === "root" && !p && !m[e] && u,
+    ...e !== "root" && !m[e] && u,
+    ...x,
+    ...A && {
+      as: A
+    },
+    ref: _
+  }, s);
+  return [M, g];
+}
+class ie {
+  constructor() {
+    Z(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 ie();
+  }
+  static use() {
+    const t = Fe(ie.create).current, [n, a] = b.useState(!1);
+    return t.shouldMount = n, t.setShouldMount = a, b.useEffect(t.mountEffect, [n]), t;
+  }
+  mount() {
+    return this.mounted || (this.mounted = Pt(), 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 Ct() {
+  return ie.use();
+}
+function Pt() {
+  let e, t;
+  const n = new Promise((a, s) => {
+    e = a, t = s;
+  });
+  return n.resolve = e, n.reject = t, n;
+}
+function Le(e) {
+  const {
+    className: t,
+    classes: n,
+    pulsate: a = !1,
+    rippleX: s,
+    rippleY: i,
+    rippleSize: u,
+    in: f,
+    onExited: p,
+    timeout: m
+  } = e, [E, T] = b.useState(!1), M = F(t, n.ripple, n.rippleVisible, a && n.ripplePulsate), S = {
+    width: u,
+    height: u,
+    top: -(u / 2) + i,
+    left: -(u / 2) + s
+  }, R = F(n.child, E && n.childLeaving, a && n.childPulsate);
+  return !f && !E && T(!0), b.useEffect(() => {
+    if (!f && p != null) {
+      const x = setTimeout(p, m);
+      return () => {
+        clearTimeout(x);
+      };
+    }
+  }, [p, f, m]), /* @__PURE__ */ H("span", {
+    className: M,
+    style: S,
+    children: /* @__PURE__ */ H("span", {
+      className: R
+    })
+  });
+}
+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 w = Oe("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), Te = 550, xt = 80, _t = ge`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`, $t = ge`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`, wt = ge`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`, At = Re("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), Ot = Re(Le, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})`
+  opacity: 0;
+  position: absolute;
+
+  &.${w.rippleVisible} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${_t};
+    animation-duration: ${Te}ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+  }
+
+  &.${w.ripplePulsate} {
+    animation-duration: ${({
+  theme: e
+}) => e.transitions.duration.shorter}ms;
+  }
+
+  & .${w.child} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${w.childLeaving} {
+    opacity: 0;
+    animation-name: ${$t};
+    animation-duration: ${Te}ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+  }
+
+  & .${w.childPulsate} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${wt};
+    animation-duration: 2500ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`, Ve = /* @__PURE__ */ b.forwardRef(function(t, n) {
+  const a = Ne({
+    props: t,
+    name: "MuiTouchRipple"
+  }), {
+    center: s = !1,
+    classes: i = {},
+    className: u,
+    ...f
+  } = a, [p, m] = b.useState([]), E = b.useRef(0), T = b.useRef(null);
+  b.useEffect(() => {
+    T.current && (T.current(), T.current = null);
+  }, [p]);
+  const M = b.useRef(!1), S = yt(), R = b.useRef(null), x = b.useRef(null), P = b.useCallback((l) => {
+    const {
+      pulsate: r,
+      rippleX: C,
+      rippleY: B,
+      rippleSize: L,
+      cb: U
+    } = l;
+    m(($) => [...$, /* @__PURE__ */ H(Ot, {
+      classes: {
+        ripple: F(i.ripple, w.ripple),
+        rippleVisible: F(i.rippleVisible, w.rippleVisible),
+        ripplePulsate: F(i.ripplePulsate, w.ripplePulsate),
+        child: F(i.child, w.child),
+        childLeaving: F(i.childLeaving, w.childLeaving),
+        childPulsate: F(i.childPulsate, w.childPulsate)
+      },
+      timeout: Te,
+      pulsate: r,
+      rippleX: C,
+      rippleY: B,
+      rippleSize: L
+    }, E.current)]), E.current += 1, T.current = U;
+  }, [i]), _ = b.useCallback((l = {}, r = {}, C = () => {
+  }) => {
+    const {
+      pulsate: B = !1,
+      center: L = s || r.pulsate,
+      fakeElement: U = !1
+      // For test purposes
+    } = r;
+    if ((l == null ? void 0 : l.type) === "mousedown" && M.current) {
+      M.current = !1;
+      return;
+    }
+    (l == null ? void 0 : l.type) === "touchstart" && (M.current = !0);
+    const $ = U ? null : x.current, N = $ ? $.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let I, O, D;
+    if (L || l === void 0 || l.clientX === 0 && l.clientY === 0 || !l.clientX && !l.touches)
+      I = Math.round(N.width / 2), O = Math.round(N.height / 2);
+    else {
+      const {
+        clientX: X,
+        clientY: V
+      } = l.touches && l.touches.length > 0 ? l.touches[0] : l;
+      I = Math.round(X - N.left), O = Math.round(V - N.top);
+    }
+    if (L)
+      D = Math.sqrt((2 * N.width ** 2 + N.height ** 2) / 3), D % 2 === 0 && (D += 1);
+    else {
+      const X = Math.max(Math.abs(($ ? $.clientWidth : 0) - I), I) * 2 + 2, V = Math.max(Math.abs(($ ? $.clientHeight : 0) - O), O) * 2 + 2;
+      D = Math.sqrt(X ** 2 + V ** 2);
+    }
+    l != null && l.touches ? R.current === null && (R.current = () => {
+      P({
+        pulsate: B,
+        rippleX: I,
+        rippleY: O,
+        rippleSize: D,
+        cb: C
+      });
+    }, S.start(xt, () => {
+      R.current && (R.current(), R.current = null);
+    })) : P({
+      pulsate: B,
+      rippleX: I,
+      rippleY: O,
+      rippleSize: D,
+      cb: C
+    });
+  }, [s, P, S]), A = b.useCallback(() => {
+    _({}, {
+      pulsate: !0
+    });
+  }, [_]), g = b.useCallback((l, r) => {
+    if (S.clear(), (l == null ? void 0 : l.type) === "touchend" && R.current) {
+      R.current(), R.current = null, S.start(0, () => {
+        g(l, r);
+      });
+      return;
+    }
+    R.current = null, m((C) => C.length > 0 ? C.slice(1) : C), T.current = r;
+  }, [S]);
+  return b.useImperativeHandle(n, () => ({
+    pulsate: A,
+    start: _,
+    stop: g
+  }), [A, _, g]), /* @__PURE__ */ H(At, {
+    className: F(w.root, i.root, u),
+    ref: x,
+    ...f,
+    children: /* @__PURE__ */ H(Me, {
+      component: null,
+      exit: !0,
+      children: p
+    })
+  });
+});
+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: o.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string
+});
+function Nt(e) {
+  return Qe("MuiButtonBase", e);
+}
+const It = Oe("MuiButtonBase", ["root", "disabled", "focusVisible"]), Dt = (e) => {
+  const {
+    disabled: t,
+    focusVisible: n,
+    focusVisibleClassName: a,
+    classes: s
+  } = e, u = et({
+    root: ["root", t && "disabled", n && "focusVisible"]
+  }, Nt, s);
+  return n && a && (u.root += ` ${a}`), u;
+}, Ft = 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.
+  },
+  [`&.${It.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), Lt = /* @__PURE__ */ b.forwardRef(function(t, n) {
+  const a = Ne({
+    props: t,
+    name: "MuiButtonBase"
+  }), {
+    action: s,
+    centerRipple: i = !1,
+    children: u,
+    className: f,
+    component: p = "button",
+    disabled: m = !1,
+    disableRipple: E = !1,
+    disableTouchRipple: T = !1,
+    focusRipple: M = !1,
+    focusVisibleClassName: S,
+    LinkComponent: R = "a",
+    onBlur: x,
+    onClick: P,
+    onContextMenu: _,
+    onDragLeave: A,
+    onFocus: g,
+    onFocusVisible: l,
+    onKeyDown: r,
+    onKeyUp: C,
+    onMouseDown: B,
+    onMouseLeave: L,
+    onMouseUp: U,
+    onTouchEnd: $,
+    onTouchMove: N,
+    onTouchStart: I,
+    tabIndex: O = 0,
+    TouchRippleProps: D,
+    touchRippleRef: X,
+    type: V,
+    ...q
+  } = a, z = b.useRef(null), v = Ct(), ee = ye(v.ref, X), [Y, W] = b.useState(!1);
+  m && Y && W(!1), b.useImperativeHandle(s, () => ({
+    focusVisible: () => {
+      W(!0), z.current.focus();
+    }
+  }), []);
+  const ae = v.shouldMount && !E && !m;
+  b.useEffect(() => {
+    Y && M && !E && v.pulsate();
+  }, [E, M, Y, v]);
+  const ue = j(v, "start", B, T), ce = j(v, "stop", _, T), le = j(v, "stop", A, T), fe = j(v, "stop", U, T), pe = j(v, "stop", (d) => {
+    Y && d.preventDefault(), L && L(d);
+  }, T), de = j(v, "start", I, T), me = j(v, "stop", $, T), he = j(v, "stop", N, T), c = j(v, "stop", (d) => {
+    we(d.target) || W(!1), x && x(d);
+  }, !1), G = se((d) => {
+    z.current || (z.current = d.currentTarget), we(d.target) && (W(!0), l && l(d)), g && g(d);
+  }), k = () => {
+    const d = z.current;
+    return p && p !== "button" && !(d.tagName === "A" && d.href);
+  }, te = se((d) => {
+    M && !d.repeat && Y && d.key === " " && v.stop(d, () => {
+      v.start(d);
+    }), d.target === d.currentTarget && k() && d.key === " " && d.preventDefault(), r && r(d), d.target === d.currentTarget && k() && d.key === "Enter" && !m && (d.preventDefault(), P && P(d));
+  }), Ye = se((d) => {
+    M && d.key === " " && Y && !d.defaultPrevented && v.stop(d, () => {
+      v.pulsate(d);
+    }), C && C(d), P && d.target === d.currentTarget && k() && d.key === " " && !d.defaultPrevented && P(d);
+  });
+  let ne = p;
+  ne === "button" && (q.href || q.to) && (ne = R);
+  const J = {};
+  ne === "button" ? (J.type = V === void 0 ? "button" : V, J.disabled = m) : (!q.href && !q.to && (J.role = "button"), m && (J["aria-disabled"] = m));
+  const je = ye(n, z), Ce = {
+    ...a,
+    centerRipple: i,
+    component: p,
+    disabled: m,
+    disableRipple: E,
+    disableTouchRipple: T,
+    focusRipple: M,
+    tabIndex: O,
+    focusVisible: Y
+  }, Be = Dt(Ce);
+  return /* @__PURE__ */ tt(Ft, {
+    as: ne,
+    className: F(Be.root, f),
+    ownerState: Ce,
+    onBlur: c,
+    onClick: P,
+    onContextMenu: ce,
+    onFocus: G,
+    onKeyDown: te,
+    onKeyUp: Ye,
+    onMouseDown: ue,
+    onMouseLeave: pe,
+    onMouseUp: fe,
+    onDragLeave: le,
+    onTouchEnd: me,
+    onTouchMove: he,
+    onTouchStart: de,
+    ref: je,
+    tabIndex: m ? -1 : O,
+    type: V,
+    ...J,
+    ...q,
+    children: [u, ae ? /* @__PURE__ */ H(Ve, {
+      ref: ee,
+      center: i,
+      ...D
+    }) : null]
+  });
+});
+function j(e, t, n, a = !1) {
+  return se((s) => (n && n(s), a || e[t](s), !0));
+}
+process.env.NODE_ENV !== "production" && (Lt.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: dt,
+  /**
+   * 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: pt,
+  /**
+   * 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 {
+  Lt as B,
+  Ae as T,
+  Et as _,
+  ut as a,
+  bt as b,
+  ct as c,
+  yt as d,
+  pt as e,
+  se as f,
+  Se as g,
+  Ee as h,
+  we as i,
+  Tt as j,
+  dt as r,
+  kt as u
+};