@loopr-ai/craft 0.1.0 → 0.3.0

package/dist/ButtonBase-750a4103.js

@@ -0,0 +1,832 @@
+import { _ as Y, a as ie, P as e, g as Xe } from "./createTheme-95c30431.js";
+import * as c from "react";
+import W, { Children as Ye, isValidElement as G, cloneElement as J } from "react";
+import { c as x, g as Te, s as re, a as ye, b as Ae } from "./styled-05df7dc6.js";
+import { jsx as I, jsxs as qe } from "react/jsx-runtime";
+import { k as se } from "./emotion-react.browser.esm-ff33c213.js";
+import { _ as We, T as de, u as he, a as He, b as H, r as Ge, e as Je } from "./TransitionGroupContext-e16207d6.js";
+function Qe(t) {
+  if (t === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return t;
+}
+function ae(t, s) {
+  var a = function(n) {
+    return s && G(n) ? s(n) : n;
+  }, l = /* @__PURE__ */ Object.create(null);
+  return t && Ye.map(t, function(o) {
+    return o;
+  }).forEach(function(o) {
+    l[o.key] = a(o);
+  }), l;
+}
+function Ze(t, s) {
+  t = t || {}, s = s || {};
+  function a(h) {
+    return h in s ? s[h] : t[h];
+  }
+  var l = /* @__PURE__ */ Object.create(null), o = [];
+  for (var n in t)
+    n in s ? o.length && (l[n] = o, o = []) : o.push(n);
+  var i, p = {};
+  for (var u in s) {
+    if (l[u])
+      for (i = 0; i < l[u].length; i++) {
+        var f = l[u][i];
+        p[l[u][i]] = a(f);
+      }
+    p[u] = a(u);
+  }
+  for (i = 0; i < o.length; i++)
+    p[o[i]] = a(o[i]);
+  return p;
+}
+function F(t, s, a) {
+  return a[s] != null ? a[s] : t.props[s];
+}
+function et(t, s) {
+  return ae(t.children, function(a) {
+    return J(a, {
+      onExited: s.bind(null, a),
+      in: !0,
+      appear: F(a, "appear", t),
+      enter: F(a, "enter", t),
+      exit: F(a, "exit", t)
+    });
+  });
+}
+function tt(t, s, a) {
+  var l = ae(t.children), o = Ze(s, l);
+  return Object.keys(o).forEach(function(n) {
+    var i = o[n];
+    if (G(i)) {
+      var p = n in s, u = n in l, f = s[n], h = G(f) && !f.props.in;
+      u && (!p || h) ? o[n] = J(i, {
+        onExited: a.bind(null, i),
+        in: !0,
+        exit: F(i, "exit", t),
+        enter: F(i, "enter", t)
+      }) : !u && p && !h ? o[n] = J(i, {
+        in: !1
+      }) : u && p && G(f) && (o[n] = J(i, {
+        onExited: a.bind(null, i),
+        in: f.props.in,
+        exit: F(i, "exit", t),
+        enter: F(i, "enter", t)
+      }));
+    }
+  }), o;
+}
+var nt = Object.values || function(t) {
+  return Object.keys(t).map(function(s) {
+    return t[s];
+  });
+}, ot = {
+  component: "div",
+  childFactory: function(s) {
+    return s;
+  }
+}, le = /* @__PURE__ */ function(t) {
+  We(s, t);
+  function s(l, o) {
+    var n;
+    n = t.call(this, l, o) || this;
+    var i = n.handleExited.bind(Qe(n));
+    return n.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: i,
+      firstRender: !0
+    }, n;
+  }
+  var a = s.prototype;
+  return a.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, a.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, s.getDerivedStateFromProps = function(o, n) {
+    var i = n.children, p = n.handleExited, u = n.firstRender;
+    return {
+      children: u ? et(o, p) : tt(o, i, p),
+      firstRender: !1
+    };
+  }, a.handleExited = function(o, n) {
+    var i = ae(this.props.children);
+    o.key in i || (o.props.onExited && o.props.onExited(n), this.mounted && this.setState(function(p) {
+      var u = Y({}, p.children);
+      return delete u[o.key], {
+        children: u
+      };
+    }));
+  }, a.render = function() {
+    var o = this.props, n = o.component, i = o.childFactory, p = ie(o, ["component", "childFactory"]), u = this.state.contextValue, f = nt(this.state.children).map(i);
+    return delete p.appear, delete p.enter, delete p.exit, n === null ? /* @__PURE__ */ W.createElement(de.Provider, {
+      value: u
+    }, f) : /* @__PURE__ */ W.createElement(de.Provider, {
+      value: u
+    }, /* @__PURE__ */ W.createElement(n, p, f));
+  }, s;
+}(W.Component);
+le.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: e.any,
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: e.node,
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: e.bool,
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: e.bool,
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: e.bool,
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: e.func
+} : {};
+le.defaultProps = ot;
+const it = le;
+function Me(t) {
+  const {
+    className: s,
+    classes: a,
+    pulsate: l = !1,
+    rippleX: o,
+    rippleY: n,
+    rippleSize: i,
+    in: p,
+    onExited: u,
+    timeout: f
+  } = t, [h, T] = c.useState(!1), g = x(s, a.ripple, a.rippleVisible, l && a.ripplePulsate), v = {
+    width: i,
+    height: i,
+    top: -(i / 2) + n,
+    left: -(i / 2) + o
+  }, m = x(a.child, h && a.childLeaving, l && a.childPulsate);
+  return !p && !h && T(!0), c.useEffect(() => {
+    if (!p && u != null) {
+      const y = setTimeout(u, f);
+      return () => {
+        clearTimeout(y);
+      };
+    }
+  }, [u, p, f]), /* @__PURE__ */ I("span", {
+    className: g,
+    style: v,
+    children: /* @__PURE__ */ I("span", {
+      className: m
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (Me.propTypes = {
+  /**
+   * Override or extend the styles applied to the component.
+   * See [CSS API](#css) below for more details.
+   */
+  classes: e.object.isRequired,
+  className: e.string,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  in: e.bool,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  onExited: e.func,
+  /**
+   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+   */
+  pulsate: e.bool,
+  /**
+   * Diameter of the ripple.
+   */
+  rippleSize: e.number,
+  /**
+   * Horizontal position of the ripple center.
+   */
+  rippleX: e.number,
+  /**
+   * Vertical position of the ripple center.
+   */
+  rippleY: e.number,
+  /**
+   * exit delay
+   */
+  timeout: e.number.isRequired
+});
+const rt = Te("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), b = rt, st = ["center", "classes", "className"];
+let Q = (t) => t, me, be, ge, Re;
+const oe = 550, at = 80, lt = se(me || (me = Q`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`)), ut = se(be || (be = Q`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`)), ct = se(ge || (ge = Q`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`)), pt = re("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), ft = re(Me, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})(Re || (Re = Q`
+  opacity: 0;
+  position: absolute;
+
+  &.${0} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${0};
+    animation-duration: ${0}ms;
+    animation-timing-function: ${0};
+  }
+
+  &.${0} {
+    animation-duration: ${0}ms;
+  }
+
+  & .${0} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${0} {
+    opacity: 0;
+    animation-name: ${0};
+    animation-duration: ${0}ms;
+    animation-timing-function: ${0};
+  }
+
+  & .${0} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${0};
+    animation-duration: 2500ms;
+    animation-timing-function: ${0};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`), b.rippleVisible, lt, oe, ({
+  theme: t
+}) => t.transitions.easing.easeInOut, b.ripplePulsate, ({
+  theme: t
+}) => t.transitions.duration.shorter, b.child, b.childLeaving, ut, oe, ({
+  theme: t
+}) => t.transitions.easing.easeInOut, b.childPulsate, ct, ({
+  theme: t
+}) => t.transitions.easing.easeInOut), Ce = /* @__PURE__ */ c.forwardRef(function(s, a) {
+  const l = ye({
+    props: s,
+    name: "MuiTouchRipple"
+  }), {
+    center: o = !1,
+    classes: n = {},
+    className: i
+  } = l, p = ie(l, st), [u, f] = c.useState([]), h = c.useRef(0), T = c.useRef(null);
+  c.useEffect(() => {
+    T.current && (T.current(), T.current = null);
+  }, [u]);
+  const g = c.useRef(!1), v = c.useRef(0), m = c.useRef(null), y = c.useRef(null);
+  c.useEffect(() => () => {
+    v.current && clearTimeout(v.current);
+  }, []);
+  const U = c.useCallback((d) => {
+    const {
+      pulsate: M,
+      rippleX: C,
+      rippleY: k,
+      rippleSize: O,
+      cb: z
+    } = d;
+    f((E) => [...E, /* @__PURE__ */ I(ft, {
+      classes: {
+        ripple: x(n.ripple, b.ripple),
+        rippleVisible: x(n.rippleVisible, b.rippleVisible),
+        ripplePulsate: x(n.ripplePulsate, b.ripplePulsate),
+        child: x(n.child, b.child),
+        childLeaving: x(n.childLeaving, b.childLeaving),
+        childPulsate: x(n.childPulsate, b.childPulsate)
+      },
+      timeout: oe,
+      pulsate: M,
+      rippleX: C,
+      rippleY: k,
+      rippleSize: O
+    }, h.current)]), h.current += 1, T.current = z;
+  }, [n]), $ = c.useCallback((d = {}, M = {}, C = () => {
+  }) => {
+    const {
+      pulsate: k = !1,
+      center: O = o || M.pulsate,
+      fakeElement: z = !1
+      // For test purposes
+    } = M;
+    if ((d == null ? void 0 : d.type) === "mousedown" && g.current) {
+      g.current = !1;
+      return;
+    }
+    (d == null ? void 0 : d.type) === "touchstart" && (g.current = !0);
+    const E = z ? null : y.current, P = E ? E.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let V, D, S;
+    if (O || d === void 0 || d.clientX === 0 && d.clientY === 0 || !d.clientX && !d.touches)
+      V = Math.round(P.width / 2), D = Math.round(P.height / 2);
+    else {
+      const {
+        clientX: w,
+        clientY: N
+      } = d.touches && d.touches.length > 0 ? d.touches[0] : d;
+      V = Math.round(w - P.left), D = Math.round(N - P.top);
+    }
+    if (O)
+      S = Math.sqrt((2 * P.width ** 2 + P.height ** 2) / 3), S % 2 === 0 && (S += 1);
+    else {
+      const w = Math.max(Math.abs((E ? E.clientWidth : 0) - V), V) * 2 + 2, N = Math.max(Math.abs((E ? E.clientHeight : 0) - D), D) * 2 + 2;
+      S = Math.sqrt(w ** 2 + N ** 2);
+    }
+    d != null && d.touches ? m.current === null && (m.current = () => {
+      U({
+        pulsate: k,
+        rippleX: V,
+        rippleY: D,
+        rippleSize: S,
+        cb: C
+      });
+    }, v.current = setTimeout(() => {
+      m.current && (m.current(), m.current = null);
+    }, at)) : U({
+      pulsate: k,
+      rippleX: V,
+      rippleY: D,
+      rippleSize: S,
+      cb: C
+    });
+  }, [o, U]), j = c.useCallback(() => {
+    $({}, {
+      pulsate: !0
+    });
+  }, [$]), _ = c.useCallback((d, M) => {
+    if (clearTimeout(v.current), (d == null ? void 0 : d.type) === "touchend" && m.current) {
+      m.current(), m.current = null, v.current = setTimeout(() => {
+        _(d, M);
+      });
+      return;
+    }
+    m.current = null, f((C) => C.length > 0 ? C.slice(1) : C), T.current = M;
+  }, []);
+  return c.useImperativeHandle(a, () => ({
+    pulsate: j,
+    start: $,
+    stop: _
+  }), [j, $, _]), /* @__PURE__ */ I(pt, Y({
+    className: x(b.root, n.root, i),
+    ref: y
+  }, p, {
+    children: /* @__PURE__ */ I(it, {
+      component: null,
+      exit: !0,
+      children: u
+    })
+  }));
+});
+process.env.NODE_ENV !== "production" && (Ce.propTypes = {
+  /**
+   * If `true`, the ripple starts at the center of the component
+   * rather than at the point of interaction.
+   */
+  center: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   * See [CSS API](#css) below for more details.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string
+});
+const dt = Ce;
+function ht(t) {
+  return Xe("MuiButtonBase", t);
+}
+const mt = Te("MuiButtonBase", ["root", "disabled", "focusVisible"]), bt = mt, gt = ["action", "centerRipple", "children", "className", "component", "disabled", "disableRipple", "disableTouchRipple", "focusRipple", "focusVisibleClassName", "LinkComponent", "onBlur", "onClick", "onContextMenu", "onDragLeave", "onFocus", "onFocusVisible", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseLeave", "onMouseUp", "onTouchEnd", "onTouchMove", "onTouchStart", "tabIndex", "TouchRippleProps", "touchRippleRef", "type"], Rt = (t) => {
+  const {
+    disabled: s,
+    focusVisible: a,
+    focusVisibleClassName: l,
+    classes: o
+  } = t, i = Ae({
+    root: ["root", s && "disabled", a && "focusVisible"]
+  }, ht, o);
+  return a && l && (i.root += ` ${l}`), i;
+}, Tt = re("button", {
+  name: "MuiButtonBase",
+  slot: "Root",
+  overridesResolver: (t, s) => s.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"
+  }
+}), Ee = /* @__PURE__ */ c.forwardRef(function(s, a) {
+  const l = ye({
+    props: s,
+    name: "MuiButtonBase"
+  }), {
+    action: o,
+    centerRipple: n = !1,
+    children: i,
+    className: p,
+    component: u = "button",
+    disabled: f = !1,
+    disableRipple: h = !1,
+    disableTouchRipple: T = !1,
+    focusRipple: g = !1,
+    LinkComponent: v = "a",
+    onBlur: m,
+    onClick: y,
+    onContextMenu: U,
+    onDragLeave: $,
+    onFocus: j,
+    onFocusVisible: _,
+    onKeyDown: d,
+    onKeyUp: M,
+    onMouseDown: C,
+    onMouseLeave: k,
+    onMouseUp: O,
+    onTouchEnd: z,
+    onTouchMove: E,
+    onTouchStart: P,
+    tabIndex: V = 0,
+    TouchRippleProps: D,
+    touchRippleRef: S,
+    type: w
+  } = l, N = ie(l, gt), K = c.useRef(null), R = c.useRef(null), xe = he(R, S), {
+    isFocusVisibleRef: ue,
+    onFocus: ve,
+    onBlur: Ve,
+    ref: Ne
+  } = He(), [L, A] = c.useState(!1);
+  f && L && A(!1), c.useImperativeHandle(o, () => ({
+    focusVisible: () => {
+      A(!0), K.current.focus();
+    }
+  }), []);
+  const [Z, Be] = c.useState(!1);
+  c.useEffect(() => {
+    Be(!0);
+  }, []);
+  const ee = Z && !h && !f;
+  c.useEffect(() => {
+    L && g && !h && Z && R.current.pulsate();
+  }, [h, g, L, Z]);
+  function B(r, pe, Ke = T) {
+    return H((fe) => (pe && pe(fe), !Ke && R.current && R.current[r](fe), !0));
+  }
+  const Pe = B("start", C), De = B("stop", U), Se = B("stop", $), ke = B("stop", O), we = B("stop", (r) => {
+    L && r.preventDefault(), k && k(r);
+  }), Le = B("start", P), Fe = B("stop", z), $e = B("stop", E), _e = B("stop", (r) => {
+    Ve(r), ue.current === !1 && A(!1), m && m(r);
+  }, !1), Oe = H((r) => {
+    K.current || (K.current = r.currentTarget), ve(r), ue.current === !0 && (A(!0), _ && _(r)), j && j(r);
+  }), te = () => {
+    const r = K.current;
+    return u && u !== "button" && !(r.tagName === "A" && r.href);
+  }, ne = c.useRef(!1), Ie = H((r) => {
+    g && !ne.current && L && R.current && r.key === " " && (ne.current = !0, R.current.stop(r, () => {
+      R.current.start(r);
+    })), r.target === r.currentTarget && te() && r.key === " " && r.preventDefault(), d && d(r), r.target === r.currentTarget && te() && r.key === "Enter" && !f && (r.preventDefault(), y && y(r));
+  }), Ue = H((r) => {
+    g && r.key === " " && R.current && L && !r.defaultPrevented && (ne.current = !1, R.current.stop(r, () => {
+      R.current.pulsate(r);
+    })), M && M(r), y && r.target === r.currentTarget && te() && r.key === " " && !r.defaultPrevented && y(r);
+  });
+  let q = u;
+  q === "button" && (N.href || N.to) && (q = v);
+  const X = {};
+  q === "button" ? (X.type = w === void 0 ? "button" : w, X.disabled = f) : (!N.href && !N.to && (X.role = "button"), f && (X["aria-disabled"] = f));
+  const je = he(a, Ne, K);
+  process.env.NODE_ENV !== "production" && c.useEffect(() => {
+    ee && !R.current && console.error(["MUI: The `component` prop provided to ButtonBase is invalid.", "Please make sure the children prop is rendered in this custom component."].join(`
+`));
+  }, [ee]);
+  const ce = Y({}, l, {
+    centerRipple: n,
+    component: u,
+    disabled: f,
+    disableRipple: h,
+    disableTouchRipple: T,
+    focusRipple: g,
+    tabIndex: V,
+    focusVisible: L
+  }), ze = Rt(ce);
+  return /* @__PURE__ */ qe(Tt, Y({
+    as: q,
+    className: x(ze.root, p),
+    ownerState: ce,
+    onBlur: _e,
+    onClick: y,
+    onContextMenu: De,
+    onFocus: Oe,
+    onKeyDown: Ie,
+    onKeyUp: Ue,
+    onMouseDown: Pe,
+    onMouseLeave: we,
+    onMouseUp: ke,
+    onDragLeave: Se,
+    onTouchEnd: Fe,
+    onTouchMove: $e,
+    onTouchStart: Le,
+    ref: je,
+    tabIndex: f ? -1 : V,
+    type: w
+  }, X, N, {
+    children: [i, ee ? (
+      /* TouchRipple is only needed client-side, x2 boost on the server. */
+      /* @__PURE__ */ I(dt, Y({
+        ref: xe,
+        center: n
+      }, D))
+    ) : null]
+  }));
+});
+process.env.NODE_ENV !== "production" && (Ee.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn proptypes"     |
+  // ----------------------------------------------------------------------
+  /**
+   * A ref for imperative actions.
+   * It currently only supports `focusVisible()` action.
+   */
+  action: Ge,
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: e.bool,
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: Je,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: e.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: e.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: e.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: e.string,
+  /**
+   * @ignore
+   */
+  href: e.any,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: e.elementType,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * @ignore
+   */
+  onClick: e.func,
+  /**
+   * @ignore
+   */
+  onContextMenu: e.func,
+  /**
+   * @ignore
+   */
+  onDragLeave: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: e.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: e.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: e.func,
+  /**
+   * @ignore
+   */
+  onMouseDown: e.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: e.func,
+  /**
+   * @ignore
+   */
+  onMouseUp: e.func,
+  /**
+   * @ignore
+   */
+  onTouchEnd: e.func,
+  /**
+   * @ignore
+   */
+  onTouchMove: e.func,
+  /**
+   * @ignore
+   */
+  onTouchStart: e.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * @default 0
+   */
+  tabIndex: e.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: e.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: e.oneOfType([e.func, e.shape({
+    current: e.shape({
+      pulsate: e.func.isRequired,
+      start: e.func.isRequired,
+      stop: e.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  type: e.oneOfType([e.oneOf(["button", "reset", "submit"]), e.string])
+});
+const Nt = Ee;
+export {
+  Nt as B
+};