@sisense/sdk-shared-ui 1.27.1 → 1.28.0

package/dist/createSvgIcon-CXJWSg3i.js

@@ -0,0 +1,902 @@
+var Be = Object.defineProperty;
+var Le = (o, e, t) => e in o ? Be(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var se = (o, e, t) => Le(o, typeof e != "symbol" ? e + "" : e, t);
+import * as f from "react";
+import H, { Children as $e, isValidElement as W, cloneElement as G } from "react";
+import { P as n } from "./index-D0lMis-I.js";
+import { f as E, b as pe, o as te, s as ne, e as fe, g as Fe, h as Oe } from "./ThemeProvider-aq1EWT1u.js";
+import { jsx as O, jsxs as ke } from "react/jsx-runtime";
+import { c as Ie, a as je, _ as Ue, T as ae, b as _e, d as ue, e as J, i as le, r as ze } from "./TransitionGroupContext-Ci_clMyv.js";
+import { _ as Ae } from "./setPrototypeOf-CEtRTXk2.js";
+import { _ as Xe } from "./extends-DX42hfxm.js";
+import { _ as Ye } from "./assertThisInitialized-lz6cHcRv.js";
+import { S as ce } from "./SvgIcon-LwOuESoH.js";
+function Ke(o) {
+  const {
+    prototype: e = {}
+  } = o;
+  return !!e.isReactComponent;
+}
+function qe(o, e, t, a, i) {
+  const r = o[e], s = i || e;
+  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" && !Ke(r) && (l = "Did you accidentally provide a plain function component instead?"), l !== void 0 ? new Error(`Invalid ${a} \`${s}\` supplied to \`${t}\`. 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 = Ie(n.elementType, qe), de = /* @__PURE__ */ f.createContext(void 0);
+process.env.NODE_ENV !== "production" && (de.displayName = "FormControlContext");
+function Et() {
+  return f.useContext(de);
+}
+class Q {
+  constructor() {
+    se(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 e = je(Q.create).current, [t, a] = f.useState(!1);
+    return e.shouldMount = t, e.setShouldMount = a, f.useEffect(e.mountEffect, [t]), e;
+  }
+  mount() {
+    return this.mounted || (this.mounted = Ge(), this.shouldMount = !0, this.setShouldMount(this.shouldMount)), this.mounted;
+  }
+  /* Ripple API */
+  start(...e) {
+    this.mount().then(() => {
+      var t;
+      return (t = this.ref.current) == null ? void 0 : t.start(...e);
+    });
+  }
+  stop(...e) {
+    this.mount().then(() => {
+      var t;
+      return (t = this.ref.current) == null ? void 0 : t.stop(...e);
+    });
+  }
+  pulsate(...e) {
+    this.mount().then(() => {
+      var t;
+      return (t = this.ref.current) == null ? void 0 : t.pulsate(...e);
+    });
+  }
+}
+function We() {
+  return Q.use();
+}
+function Ge() {
+  let o, e;
+  const t = new Promise((a, i) => {
+    o = a, e = i;
+  });
+  return t.resolve = o, t.reject = e, t;
+}
+function oe(o, e) {
+  var t = function(r) {
+    return e && W(r) ? e(r) : r;
+  }, a = /* @__PURE__ */ Object.create(null);
+  return o && $e.map(o, function(i) {
+    return i;
+  }).forEach(function(i) {
+    a[i.key] = t(i);
+  }), a;
+}
+function Je(o, e) {
+  o = o || {}, e = e || {};
+  function t(h) {
+    return h in e ? e[h] : o[h];
+  }
+  var a = /* @__PURE__ */ Object.create(null), i = [];
+  for (var r in o)
+    r in e ? i.length && (a[r] = i, i = []) : i.push(r);
+  var s, l = {};
+  for (var c in e) {
+    if (a[c])
+      for (s = 0; s < a[c].length; s++) {
+        var d = a[c][s];
+        l[a[c][s]] = t(d);
+      }
+    l[c] = t(c);
+  }
+  for (s = 0; s < i.length; s++)
+    l[i[s]] = t(i[s]);
+  return l;
+}
+function F(o, e, t) {
+  return t[e] != null ? t[e] : o.props[e];
+}
+function Qe(o, e) {
+  return oe(o.children, function(t) {
+    return G(t, {
+      onExited: e.bind(null, t),
+      in: !0,
+      appear: F(t, "appear", o),
+      enter: F(t, "enter", o),
+      exit: F(t, "exit", o)
+    });
+  });
+}
+function Ze(o, e, t) {
+  var a = oe(o.children), i = Je(e, a);
+  return Object.keys(i).forEach(function(r) {
+    var s = i[r];
+    if (W(s)) {
+      var l = r in e, c = r in a, d = e[r], h = W(d) && !d.props.in;
+      c && (!l || h) ? i[r] = G(s, {
+        onExited: t.bind(null, s),
+        in: !0,
+        exit: F(s, "exit", o),
+        enter: F(s, "enter", o)
+      }) : !c && l && !h ? i[r] = G(s, {
+        in: !1
+      }) : c && l && W(d) && (i[r] = G(s, {
+        onExited: t.bind(null, s),
+        in: d.props.in,
+        exit: F(s, "exit", o),
+        enter: F(s, "enter", o)
+      }));
+    }
+  }), i;
+}
+var et = Object.values || function(o) {
+  return Object.keys(o).map(function(e) {
+    return o[e];
+  });
+}, tt = {
+  component: "div",
+  childFactory: function(e) {
+    return e;
+  }
+}, ie = /* @__PURE__ */ function(o) {
+  Ue(e, o);
+  function e(a, i) {
+    var r;
+    r = o.call(this, a, i) || this;
+    var s = r.handleExited.bind(Ye(r));
+    return r.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: s,
+      firstRender: !0
+    }, r;
+  }
+  var t = e.prototype;
+  return t.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, t.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, e.getDerivedStateFromProps = function(i, r) {
+    var s = r.children, l = r.handleExited, c = r.firstRender;
+    return {
+      children: c ? Qe(i, l) : Ze(i, s, l),
+      firstRender: !1
+    };
+  }, t.handleExited = function(i, r) {
+    var s = oe(this.props.children);
+    i.key in s || (i.props.onExited && i.props.onExited(r), this.mounted && this.setState(function(l) {
+      var c = Xe({}, l.children);
+      return delete c[i.key], {
+        children: c
+      };
+    }));
+  }, t.render = function() {
+    var i = this.props, r = i.component, s = i.childFactory, l = Ae(i, ["component", "childFactory"]), c = this.state.contextValue, d = et(this.state.children).map(s);
+    return delete l.appear, delete l.enter, delete l.exit, r === null ? /* @__PURE__ */ H.createElement(ae.Provider, {
+      value: c
+    }, d) : /* @__PURE__ */ H.createElement(ae.Provider, {
+      value: c
+    }, /* @__PURE__ */ H.createElement(r, l, d));
+  }, e;
+}(H.Component);
+ie.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
+} : {};
+ie.defaultProps = tt;
+function he(o) {
+  const {
+    className: e,
+    classes: t,
+    pulsate: a = !1,
+    rippleX: i,
+    rippleY: r,
+    rippleSize: s,
+    in: l,
+    onExited: c,
+    timeout: d
+  } = o, [h, m] = f.useState(!1), R = E(e, t.ripple, t.rippleVisible, a && t.ripplePulsate), D = {
+    width: s,
+    height: s,
+    top: -(s / 2) + r,
+    left: -(s / 2) + i
+  }, g = E(t.child, h && t.childLeaving, a && t.childPulsate);
+  return !l && !h && m(!0), f.useEffect(() => {
+    if (!l && c != null) {
+      const w = setTimeout(c, d);
+      return () => {
+        clearTimeout(w);
+      };
+    }
+  }, [c, l, d]), /* @__PURE__ */ O("span", {
+    className: R,
+    style: D,
+    children: /* @__PURE__ */ O("span", {
+      className: g
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (he.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 = pe("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), ee = 550, nt = 80, ot = te`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`, it = te`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`, rt = te`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`, st = ne("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), at = ne(he, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})`
+  opacity: 0;
+  position: absolute;
+
+  &.${y.rippleVisible} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${ot};
+    animation-duration: ${ee}ms;
+    animation-timing-function: ${({
+  theme: o
+}) => o.transitions.easing.easeInOut};
+  }
+
+  &.${y.ripplePulsate} {
+    animation-duration: ${({
+  theme: o
+}) => o.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: ${ee}ms;
+    animation-timing-function: ${({
+  theme: o
+}) => o.transitions.easing.easeInOut};
+  }
+
+  & .${y.childPulsate} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${rt};
+    animation-duration: 2500ms;
+    animation-timing-function: ${({
+  theme: o
+}) => o.transitions.easing.easeInOut};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`, me = /* @__PURE__ */ f.forwardRef(function(e, t) {
+  const a = fe({
+    props: e,
+    name: "MuiTouchRipple"
+  }), {
+    center: i = !1,
+    classes: r = {},
+    className: s,
+    ...l
+  } = a, [c, d] = f.useState([]), h = f.useRef(0), m = f.useRef(null);
+  f.useEffect(() => {
+    m.current && (m.current(), m.current = null);
+  }, [c]);
+  const R = f.useRef(!1), D = _e(), g = f.useRef(null), w = f.useRef(null), x = f.useCallback((p) => {
+    const {
+      pulsate: C,
+      rippleX: M,
+      rippleY: j,
+      rippleSize: B,
+      cb: U
+    } = p;
+    d((T) => [...T, /* @__PURE__ */ O(at, {
+      classes: {
+        ripple: E(r.ripple, y.ripple),
+        rippleVisible: E(r.rippleVisible, y.rippleVisible),
+        ripplePulsate: E(r.ripplePulsate, y.ripplePulsate),
+        child: E(r.child, y.child),
+        childLeaving: E(r.childLeaving, y.childLeaving),
+        childPulsate: E(r.childPulsate, y.childPulsate)
+      },
+      timeout: ee,
+      pulsate: C,
+      rippleX: M,
+      rippleY: j,
+      rippleSize: B
+    }, h.current)]), h.current += 1, m.current = U;
+  }, [r]), k = f.useCallback((p = {}, C = {}, M = () => {
+  }) => {
+    const {
+      pulsate: j = !1,
+      center: B = i || C.pulsate,
+      fakeElement: U = !1
+      // For test purposes
+    } = C;
+    if ((p == null ? void 0 : p.type) === "mousedown" && R.current) {
+      R.current = !1;
+      return;
+    }
+    (p == null ? void 0 : p.type) === "touchstart" && (R.current = !0);
+    const T = U ? null : w.current, V = T ? T.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let v, N, S;
+    if (B || p === void 0 || p.clientX === 0 && p.clientY === 0 || !p.clientX && !p.touches)
+      v = Math.round(V.width / 2), N = Math.round(V.height / 2);
+    else {
+      const {
+        clientX: _,
+        clientY: L
+      } = p.touches && p.touches.length > 0 ? p.touches[0] : p;
+      v = Math.round(_ - V.left), N = Math.round(L - V.top);
+    }
+    if (B)
+      S = Math.sqrt((2 * V.width ** 2 + V.height ** 2) / 3), S % 2 === 0 && (S += 1);
+    else {
+      const _ = Math.max(Math.abs((T ? T.clientWidth : 0) - v), v) * 2 + 2, L = Math.max(Math.abs((T ? T.clientHeight : 0) - N), N) * 2 + 2;
+      S = Math.sqrt(_ ** 2 + L ** 2);
+    }
+    p != null && p.touches ? g.current === null && (g.current = () => {
+      x({
+        pulsate: j,
+        rippleX: v,
+        rippleY: N,
+        rippleSize: S,
+        cb: M
+      });
+    }, D.start(nt, () => {
+      g.current && (g.current(), g.current = null);
+    })) : x({
+      pulsate: j,
+      rippleX: v,
+      rippleY: N,
+      rippleSize: S,
+      cb: M
+    });
+  }, [i, x, D]), Y = f.useCallback(() => {
+    k({}, {
+      pulsate: !0
+    });
+  }, [k]), I = f.useCallback((p, C) => {
+    if (D.clear(), (p == null ? void 0 : p.type) === "touchend" && g.current) {
+      g.current(), g.current = null, D.start(0, () => {
+        I(p, C);
+      });
+      return;
+    }
+    g.current = null, d((M) => M.length > 0 ? M.slice(1) : M), m.current = C;
+  }, [D]);
+  return f.useImperativeHandle(t, () => ({
+    pulsate: Y,
+    start: k,
+    stop: I
+  }), [Y, k, I]), /* @__PURE__ */ O(st, {
+    className: E(y.root, r.root, s),
+    ref: w,
+    ...l,
+    children: /* @__PURE__ */ O(ie, {
+      component: null,
+      exit: !0,
+      children: c
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (me.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 ut(o) {
+  return Fe("MuiButtonBase", o);
+}
+const lt = pe("MuiButtonBase", ["root", "disabled", "focusVisible"]), ct = (o) => {
+  const {
+    disabled: e,
+    focusVisible: t,
+    focusVisibleClassName: a,
+    classes: i
+  } = o, s = Oe({
+    root: ["root", e && "disabled", t && "focusVisible"]
+  }, ut, i);
+  return t && a && (s.root += ` ${a}`), s;
+}, pt = ne("button", {
+  name: "MuiButtonBase",
+  slot: "Root",
+  overridesResolver: (o, e) => e.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.
+  },
+  [`&.${lt.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), ft = /* @__PURE__ */ f.forwardRef(function(e, t) {
+  const a = fe({
+    props: e,
+    name: "MuiButtonBase"
+  }), {
+    action: i,
+    centerRipple: r = !1,
+    children: s,
+    className: l,
+    component: c = "button",
+    disabled: d = !1,
+    disableRipple: h = !1,
+    disableTouchRipple: m = !1,
+    focusRipple: R = !1,
+    focusVisibleClassName: D,
+    LinkComponent: g = "a",
+    onBlur: w,
+    onClick: x,
+    onContextMenu: k,
+    onDragLeave: Y,
+    onFocus: I,
+    onFocusVisible: p,
+    onKeyDown: C,
+    onKeyUp: M,
+    onMouseDown: j,
+    onMouseLeave: B,
+    onMouseUp: U,
+    onTouchEnd: T,
+    onTouchMove: V,
+    onTouchStart: v,
+    tabIndex: N = 0,
+    TouchRippleProps: S,
+    touchRippleRef: _,
+    type: L,
+    ...z
+  } = a, A = f.useRef(null), b = We(), be = ue(b.ref, _), [$, K] = f.useState(!1);
+  d && $ && K(!1), f.useImperativeHandle(i, () => ({
+    focusVisible: () => {
+      K(!0), A.current.focus();
+    }
+  }), []);
+  const ge = b.shouldMount && !h && !d;
+  f.useEffect(() => {
+    $ && R && !h && b.pulsate();
+  }, [h, R, $, b]);
+  const ye = P(b, "start", j, m), Re = P(b, "stop", k, m), Me = P(b, "stop", Y, m), Ce = P(b, "stop", U, m), Te = P(b, "stop", (u) => {
+    $ && u.preventDefault(), B && B(u);
+  }, m), Ee = P(b, "start", v, m), xe = P(b, "stop", T, m), Ne = P(b, "stop", V, m), Pe = P(b, "stop", (u) => {
+    le(u.target) || K(!1), w && w(u);
+  }, !1), De = J((u) => {
+    A.current || (A.current = u.currentTarget), le(u.target) && (K(!0), p && p(u)), I && I(u);
+  }), Z = () => {
+    const u = A.current;
+    return c && c !== "button" && !(u.tagName === "A" && u.href);
+  }, Ve = J((u) => {
+    R && !u.repeat && $ && u.key === " " && b.stop(u, () => {
+      b.start(u);
+    }), u.target === u.currentTarget && Z() && u.key === " " && u.preventDefault(), C && C(u), u.target === u.currentTarget && Z() && u.key === "Enter" && !d && (u.preventDefault(), x && x(u));
+  }), ve = J((u) => {
+    R && u.key === " " && $ && !u.defaultPrevented && b.stop(u, () => {
+      b.pulsate(u);
+    }), M && M(u), x && u.target === u.currentTarget && Z() && u.key === " " && !u.defaultPrevented && x(u);
+  });
+  let q = c;
+  q === "button" && (z.href || z.to) && (q = g);
+  const X = {};
+  q === "button" ? (X.type = L === void 0 ? "button" : L, X.disabled = d) : (!z.href && !z.to && (X.role = "button"), d && (X["aria-disabled"] = d));
+  const Se = ue(t, A), re = {
+    ...a,
+    centerRipple: r,
+    component: c,
+    disabled: d,
+    disableRipple: h,
+    disableTouchRipple: m,
+    focusRipple: R,
+    tabIndex: N,
+    focusVisible: $
+  }, we = ct(re);
+  return /* @__PURE__ */ ke(pt, {
+    as: q,
+    className: E(we.root, l),
+    ownerState: re,
+    onBlur: Pe,
+    onClick: x,
+    onContextMenu: Re,
+    onFocus: De,
+    onKeyDown: Ve,
+    onKeyUp: ve,
+    onMouseDown: ye,
+    onMouseLeave: Te,
+    onMouseUp: Ce,
+    onDragLeave: Me,
+    onTouchEnd: xe,
+    onTouchMove: Ne,
+    onTouchStart: Ee,
+    ref: Se,
+    tabIndex: d ? -1 : N,
+    type: L,
+    ...X,
+    ...z,
+    children: [s, ge ? /* @__PURE__ */ O(me, {
+      ref: be,
+      center: r,
+      ...S
+    }) : null]
+  });
+});
+function P(o, e, t, a = !1) {
+  return J((i) => (t && t(i), a || o[e](i), !0));
+}
+process.env.NODE_ENV !== "production" && (ft.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: ze,
+  /**
+   * 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: He,
+  /**
+   * 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
+   */
+  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])
+});
+function xt(o, e) {
+  function t(a, i) {
+    return /* @__PURE__ */ O(ce, {
+      "data-testid": `${e}Icon`,
+      ref: i,
+      ...a,
+      children: o
+    });
+  }
+  return process.env.NODE_ENV !== "production" && (t.displayName = `${e}Icon`), t.muiName = ce.muiName, /* @__PURE__ */ f.memo(/* @__PURE__ */ f.forwardRef(t));
+}
+export {
+  ft as B,
+  de as F,
+  xt as c,
+  He as e,
+  Et as u
+};