@amateescu/portal-ui-components 0.0.35-beta0 → 0.0.37

package/dist/ButtonBase-D6nf3ymf.js

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