@genai-fi/base 3.0.2 → 4.0.0

package/dist/CircularProgress-C6sMwjDC.js

@@ -0,0 +1,1275 @@
+var Xe = Object.defineProperty;
+var qe = (e, t, n) => t in e ? Xe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var W = (e, t, n) => qe(e, typeof t != "symbol" ? t + "" : t, n);
+import * as c from "react";
+import H, { isValidElement as Q, cloneElement as ee, Children as We } from "react";
+import { P as r, g as Te, a as ne } from "./createTheme-a85zdZWm.js";
+import { c as E, g as ce, u as pe, s as z, a as Ce, m as Ee } from "./DefaultPropsProvider-D2IJ8Qbs.js";
+import { jsx as D, jsxs as He } from "react/jsx-runtime";
+import { keyframes as G, css as xe } from "@emotion/react";
+const Ge = typeof window < "u" ? c.useLayoutEffect : c.useEffect;
+let be = 0;
+function Ze(e) {
+  const [t, n] = c.useState(e), o = e || t;
+  return c.useEffect(() => {
+    t == null && (be += 1, n(`mui-${be}`));
+  }, [t]), o;
+}
+const Je = {
+  ...c
+}, ge = Je.useId;
+function Yt(e) {
+  if (ge !== void 0) {
+    const t = ge();
+    return e ?? t;
+  }
+  return Ze(e);
+}
+function te(e) {
+  const t = c.useRef(e);
+  return Ge(() => {
+    t.current = e;
+  }), c.useRef((...n) => (
+    // @ts-expect-error hide `this`
+    (0, t.current)(...n)
+  )).current;
+}
+function ye(...e) {
+  const t = c.useRef(void 0), n = c.useCallback((o) => {
+    const s = e.map((i) => {
+      if (i == null)
+        return null;
+      if (typeof i == "function") {
+        const a = i, l = a(o);
+        return typeof l == "function" ? l : () => {
+          a(null);
+        };
+      }
+      return i.current = o, () => {
+        i.current = null;
+      };
+    });
+    return () => {
+      s.forEach((i) => i == null ? void 0 : i());
+    };
+  }, e);
+  return c.useMemo(() => e.every((o) => o == null) ? null : (o) => {
+    t.current && (t.current(), t.current = void 0), o != null && (t.current = n(o));
+  }, e);
+}
+const Qe = r.oneOfType([r.func, r.object]);
+function Pe(e, t) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...o) {
+    return e(...o) || t(...o);
+  };
+}
+function et(e) {
+  const {
+    prototype: t = {}
+  } = e;
+  return !!t.isReactComponent;
+}
+function tt(e, t, n, o, s) {
+  const i = e[t], a = s || t;
+  if (i == null || // When server-side rendering React doesn't warn either.
+  // This is not an accurate check for SSR.
+  // This is only in place for emotion compat.
+  // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
+  typeof window > "u")
+    return null;
+  let l;
+  return typeof i == "function" && !et(i) && (l = "Did you accidentally provide a plain function component instead?"), l !== void 0 ? new Error(`Invalid ${o} \`${a}\` supplied to \`${n}\`. Expected an element type that can hold a ref. ${l} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const nt = Pe(r.elementType, tt);
+function Me(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;
+}
+const Re = {};
+function we(e, t) {
+  const n = c.useRef(Re);
+  return n.current === Re && (n.current = e(t)), n;
+}
+class re {
+  constructor() {
+    W(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 re();
+  }
+  static use() {
+    const t = we(re.create).current, [n, o] = c.useState(!1);
+    return t.shouldMount = n, t.setShouldMount = o, c.useEffect(t.mountEffect, [n]), t;
+  }
+  mount() {
+    return this.mounted || (this.mounted = ot(), 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 rt() {
+  return re.use();
+}
+function ot() {
+  let e, t;
+  const n = new Promise((o, s) => {
+    e = o, t = s;
+  });
+  return n.resolve = e, n.reject = t, n;
+}
+function ie() {
+  return ie = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var o in n) ({}).hasOwnProperty.call(n, o) && (e[o] = n[o]);
+    }
+    return e;
+  }, ie.apply(null, arguments);
+}
+function it(e, t) {
+  if (e == null) return {};
+  var n = {};
+  for (var o in e) if ({}.hasOwnProperty.call(e, o)) {
+    if (t.indexOf(o) !== -1) continue;
+    n[o] = e[o];
+  }
+  return n;
+}
+function se(e, t) {
+  return se = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, o) {
+    return n.__proto__ = o, n;
+  }, se(e, t);
+}
+function st(e, t) {
+  e.prototype = Object.create(t.prototype), e.prototype.constructor = e, se(e, t);
+}
+const ve = H.createContext(null);
+function at(e) {
+  if (e === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function fe(e, t) {
+  var n = function(i) {
+    return t && Q(i) ? t(i) : i;
+  }, o = /* @__PURE__ */ Object.create(null);
+  return e && We.map(e, function(s) {
+    return s;
+  }).forEach(function(s) {
+    o[s.key] = n(s);
+  }), o;
+}
+function ut(e, t) {
+  e = e || {}, t = t || {};
+  function n(h) {
+    return h in t ? t[h] : e[h];
+  }
+  var o = /* @__PURE__ */ Object.create(null), s = [];
+  for (var i in e)
+    i in t ? s.length && (o[i] = s, s = []) : s.push(i);
+  var a, l = {};
+  for (var p in t) {
+    if (o[p])
+      for (a = 0; a < o[p].length; a++) {
+        var f = o[p][a];
+        l[o[p][a]] = n(f);
+      }
+    l[p] = n(p);
+  }
+  for (a = 0; a < s.length; a++)
+    l[s[a]] = n(s[a]);
+  return l;
+}
+function F(e, t, n) {
+  return n[t] != null ? n[t] : e.props[t];
+}
+function lt(e, t) {
+  return fe(e.children, function(n) {
+    return ee(n, {
+      onExited: t.bind(null, n),
+      in: !0,
+      appear: F(n, "appear", e),
+      enter: F(n, "enter", e),
+      exit: F(n, "exit", e)
+    });
+  });
+}
+function ct(e, t, n) {
+  var o = fe(e.children), s = ut(t, o);
+  return Object.keys(s).forEach(function(i) {
+    var a = s[i];
+    if (Q(a)) {
+      var l = i in t, p = i in o, f = t[i], h = Q(f) && !f.props.in;
+      p && (!l || h) ? s[i] = ee(a, {
+        onExited: n.bind(null, a),
+        in: !0,
+        exit: F(a, "exit", e),
+        enter: F(a, "enter", e)
+      }) : !p && l && !h ? s[i] = ee(a, {
+        in: !1
+      }) : p && l && Q(f) && (s[i] = ee(a, {
+        onExited: n.bind(null, a),
+        in: f.props.in,
+        exit: F(a, "exit", e),
+        enter: F(a, "enter", e)
+      }));
+    }
+  }), s;
+}
+var pt = Object.values || function(e) {
+  return Object.keys(e).map(function(t) {
+    return e[t];
+  });
+}, ft = {
+  component: "div",
+  childFactory: function(t) {
+    return t;
+  }
+}, de = /* @__PURE__ */ function(e) {
+  st(t, e);
+  function t(o, s) {
+    var i;
+    i = e.call(this, o, s) || this;
+    var a = i.handleExited.bind(at(i));
+    return i.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: a,
+      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 a = i.children, l = i.handleExited, p = i.firstRender;
+    return {
+      children: p ? lt(s, l) : ct(s, a, l),
+      firstRender: !1
+    };
+  }, n.handleExited = function(s, i) {
+    var a = fe(this.props.children);
+    s.key in a || (s.props.onExited && s.props.onExited(i), this.mounted && this.setState(function(l) {
+      var p = ie({}, l.children);
+      return delete p[s.key], {
+        children: p
+      };
+    }));
+  }, n.render = function() {
+    var s = this.props, i = s.component, a = s.childFactory, l = it(s, ["component", "childFactory"]), p = this.state.contextValue, f = pt(this.state.children).map(a);
+    return delete l.appear, delete l.enter, delete l.exit, i === null ? /* @__PURE__ */ H.createElement(ve.Provider, {
+      value: p
+    }, f) : /* @__PURE__ */ H.createElement(ve.Provider, {
+      value: p
+    }, /* @__PURE__ */ H.createElement(i, l, f));
+  }, t;
+}(H.Component);
+de.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: r.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: r.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: r.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: r.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: r.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: r.func
+} : {};
+de.defaultProps = ft;
+const dt = [];
+function ht(e) {
+  c.useEffect(e, dt);
+}
+class he {
+  constructor() {
+    W(this, "currentId", null);
+    W(this, "clear", () => {
+      this.currentId !== null && (clearTimeout(this.currentId), this.currentId = null);
+    });
+    W(this, "disposeEffect", () => this.clear);
+  }
+  static create() {
+    return new he();
+  }
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  start(t, n) {
+    this.clear(), this.currentId = setTimeout(() => {
+      this.currentId = null, n();
+    }, t);
+  }
+}
+function mt() {
+  const e = we(he.create).current;
+  return ht(e.disposeEffect), e;
+}
+function Se(e) {
+  const {
+    className: t,
+    classes: n,
+    pulsate: o = !1,
+    rippleX: s,
+    rippleY: i,
+    rippleSize: a,
+    in: l,
+    onExited: p,
+    timeout: f
+  } = e, [h, m] = c.useState(!1), y = E(t, n.ripple, n.rippleVisible, o && n.ripplePulsate), M = {
+    width: a,
+    height: a,
+    top: -(a / 2) + i,
+    left: -(a / 2) + s
+  }, b = E(n.child, h && n.childLeaving, o && n.childPulsate);
+  return !l && !h && m(!0), c.useEffect(() => {
+    if (!l && p != null) {
+      const T = setTimeout(p, f);
+      return () => {
+        clearTimeout(T);
+      };
+    }
+  }, [p, l, f]), /* @__PURE__ */ D("span", {
+    className: y,
+    style: M,
+    children: /* @__PURE__ */ D("span", {
+      className: b
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (Se.propTypes = {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object.isRequired,
+  className: r.string,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  in: r.bool,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  onExited: r.func,
+  /**
+   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+   */
+  pulsate: r.bool,
+  /**
+   * Diameter of the ripple.
+   */
+  rippleSize: r.number,
+  /**
+   * Horizontal position of the ripple center.
+   */
+  rippleX: r.number,
+  /**
+   * Vertical position of the ripple center.
+   */
+  rippleY: r.number,
+  /**
+   * exit delay
+   */
+  timeout: r.number.isRequired
+});
+const v = ce("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), ae = 550, bt = 80, gt = G`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`, yt = G`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`, Mt = G`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`, Rt = z("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), vt = z(Se, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})`
+  opacity: 0;
+  position: absolute;
+
+  &.${v.rippleVisible} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${gt};
+    animation-duration: ${ae}ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+  }
+
+  &.${v.ripplePulsate} {
+    animation-duration: ${({
+  theme: e
+}) => e.transitions.duration.shorter}ms;
+  }
+
+  & .${v.child} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${v.childLeaving} {
+    opacity: 0;
+    animation-name: ${yt};
+    animation-duration: ${ae}ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+  }
+
+  & .${v.childPulsate} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${Mt};
+    animation-duration: 2500ms;
+    animation-timing-function: ${({
+  theme: e
+}) => e.transitions.easing.easeInOut};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`, ke = /* @__PURE__ */ c.forwardRef(function(t, n) {
+  const o = pe({
+    props: t,
+    name: "MuiTouchRipple"
+  }), {
+    center: s = !1,
+    classes: i = {},
+    className: a,
+    ...l
+  } = o, [p, f] = c.useState([]), h = c.useRef(0), m = c.useRef(null);
+  c.useEffect(() => {
+    m.current && (m.current(), m.current = null);
+  }, [p]);
+  const y = c.useRef(!1), M = mt(), b = c.useRef(null), T = c.useRef(null), R = c.useCallback((d) => {
+    const {
+      pulsate: x,
+      rippleX: C,
+      rippleY: _,
+      rippleSize: j,
+      cb: A
+    } = d;
+    f((P) => [...P, /* @__PURE__ */ D(vt, {
+      classes: {
+        ripple: E(i.ripple, v.ripple),
+        rippleVisible: E(i.rippleVisible, v.rippleVisible),
+        ripplePulsate: E(i.ripplePulsate, v.ripplePulsate),
+        child: E(i.child, v.child),
+        childLeaving: E(i.childLeaving, v.childLeaving),
+        childPulsate: E(i.childPulsate, v.childPulsate)
+      },
+      timeout: ae,
+      pulsate: x,
+      rippleX: C,
+      rippleY: _,
+      rippleSize: j
+    }, h.current)]), h.current += 1, m.current = A;
+  }, [i]), w = c.useCallback((d = {}, x = {}, C = () => {
+  }) => {
+    const {
+      pulsate: _ = !1,
+      center: j = s || x.pulsate,
+      fakeElement: A = !1
+      // For test purposes
+    } = x;
+    if ((d == null ? void 0 : d.type) === "mousedown" && y.current) {
+      y.current = !1;
+      return;
+    }
+    (d == null ? void 0 : d.type) === "touchstart" && (y.current = !0);
+    const P = A ? null : T.current, N = P ? P.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let O, S, I;
+    if (j || d === void 0 || d.clientX === 0 && d.clientY === 0 || !d.clientX && !d.touches)
+      O = Math.round(N.width / 2), S = Math.round(N.height / 2);
+    else {
+      const {
+        clientX: Y,
+        clientY: B
+      } = d.touches && d.touches.length > 0 ? d.touches[0] : d;
+      O = Math.round(Y - N.left), S = Math.round(B - N.top);
+    }
+    if (j)
+      I = Math.sqrt((2 * N.width ** 2 + N.height ** 2) / 3), I % 2 === 0 && (I += 1);
+    else {
+      const Y = Math.max(Math.abs((P ? P.clientWidth : 0) - O), O) * 2 + 2, B = Math.max(Math.abs((P ? P.clientHeight : 0) - S), S) * 2 + 2;
+      I = Math.sqrt(Y ** 2 + B ** 2);
+    }
+    d != null && d.touches ? b.current === null && (b.current = () => {
+      R({
+        pulsate: _,
+        rippleX: O,
+        rippleY: S,
+        rippleSize: I,
+        cb: C
+      });
+    }, M.start(bt, () => {
+      b.current && (b.current(), b.current = null);
+    })) : R({
+      pulsate: _,
+      rippleX: O,
+      rippleY: S,
+      rippleSize: I,
+      cb: C
+    });
+  }, [s, R, M]), V = c.useCallback(() => {
+    w({}, {
+      pulsate: !0
+    });
+  }, [w]), U = c.useCallback((d, x) => {
+    if (M.clear(), (d == null ? void 0 : d.type) === "touchend" && b.current) {
+      b.current(), b.current = null, M.start(0, () => {
+        U(d, x);
+      });
+      return;
+    }
+    b.current = null, f((C) => C.length > 0 ? C.slice(1) : C), m.current = x;
+  }, [M]);
+  return c.useImperativeHandle(n, () => ({
+    pulsate: V,
+    start: w,
+    stop: U
+  }), [V, w, U]), /* @__PURE__ */ D(Rt, {
+    className: E(v.root, i.root, a),
+    ref: T,
+    ...l,
+    children: /* @__PURE__ */ D(de, {
+      component: null,
+      exit: !0,
+      children: p
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ke.propTypes = {
+  /**
+   * If `true`, the ripple starts at the center of the component
+   * rather than at the point of interaction.
+   */
+  center: r.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * @ignore
+   */
+  className: r.string
+});
+function Tt(e) {
+  return Te("MuiButtonBase", e);
+}
+const Ct = ce("MuiButtonBase", ["root", "disabled", "focusVisible"]), Et = (e) => {
+  const {
+    disabled: t,
+    focusVisible: n,
+    focusVisibleClassName: o,
+    classes: s
+  } = e, a = Ce({
+    root: ["root", t && "disabled", n && "focusVisible"]
+  }, Tt, s);
+  return n && o && (a.root += ` ${o}`), a;
+}, xt = z("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"
+  }
+}), Pt = /* @__PURE__ */ c.forwardRef(function(t, n) {
+  const o = pe({
+    props: t,
+    name: "MuiButtonBase"
+  }), {
+    action: s,
+    centerRipple: i = !1,
+    children: a,
+    className: l,
+    component: p = "button",
+    disabled: f = !1,
+    disableRipple: h = !1,
+    disableTouchRipple: m = !1,
+    focusRipple: y = !1,
+    focusVisibleClassName: M,
+    LinkComponent: b = "a",
+    onBlur: T,
+    onClick: R,
+    onContextMenu: w,
+    onDragLeave: V,
+    onFocus: U,
+    onFocusVisible: d,
+    onKeyDown: x,
+    onKeyUp: C,
+    onMouseDown: _,
+    onMouseLeave: j,
+    onMouseUp: A,
+    onTouchEnd: P,
+    onTouchMove: N,
+    onTouchStart: O,
+    tabIndex: S = 0,
+    TouchRippleProps: I,
+    touchRippleRef: Y,
+    type: B,
+    ...K
+  } = o, X = c.useRef(null), g = rt(), De = ye(g.ref, Y), [L, Z] = c.useState(!1);
+  f && L && Z(!1), c.useImperativeHandle(s, () => ({
+    focusVisible: () => {
+      Z(!0), X.current.focus();
+    }
+  }), []);
+  const Ne = g.shouldMount && !h && !f;
+  c.useEffect(() => {
+    L && y && !h && g.pulsate();
+  }, [h, y, L, g]);
+  const Oe = k(g, "start", _, m), Ie = k(g, "stop", w, m), $e = k(g, "stop", V, m), Ve = k(g, "stop", A, m), je = k(g, "stop", (u) => {
+    L && u.preventDefault(), j && j(u);
+  }, m), Be = k(g, "start", O, m), Le = k(g, "stop", P, m), Fe = k(g, "stop", N, m), Ue = k(g, "stop", (u) => {
+    Me(u.target) || Z(!1), T && T(u);
+  }, !1), _e = te((u) => {
+    X.current || (X.current = u.currentTarget), Me(u.target) && (Z(!0), d && d(u)), U && U(u);
+  }), oe = () => {
+    const u = X.current;
+    return p && p !== "button" && !(u.tagName === "A" && u.href);
+  }, ze = te((u) => {
+    y && !u.repeat && L && u.key === " " && g.stop(u, () => {
+      g.start(u);
+    }), u.target === u.currentTarget && oe() && u.key === " " && u.preventDefault(), x && x(u), u.target === u.currentTarget && oe() && u.key === "Enter" && !f && (u.preventDefault(), R && R(u));
+  }), Ae = te((u) => {
+    y && u.key === " " && L && !u.defaultPrevented && g.stop(u, () => {
+      g.pulsate(u);
+    }), C && C(u), R && u.target === u.currentTarget && oe() && u.key === " " && !u.defaultPrevented && R(u);
+  });
+  let J = p;
+  J === "button" && (K.href || K.to) && (J = b);
+  const q = {};
+  J === "button" ? (q.type = B === void 0 ? "button" : B, q.disabled = f) : (!K.href && !K.to && (q.role = "button"), f && (q["aria-disabled"] = f));
+  const Ye = ye(n, X), me = {
+    ...o,
+    centerRipple: i,
+    component: p,
+    disabled: f,
+    disableRipple: h,
+    disableTouchRipple: m,
+    focusRipple: y,
+    tabIndex: S,
+    focusVisible: L
+  }, Ke = Et(me);
+  return /* @__PURE__ */ He(xt, {
+    as: J,
+    className: E(Ke.root, l),
+    ownerState: me,
+    onBlur: Ue,
+    onClick: R,
+    onContextMenu: Ie,
+    onFocus: _e,
+    onKeyDown: ze,
+    onKeyUp: Ae,
+    onMouseDown: Oe,
+    onMouseLeave: je,
+    onMouseUp: Ve,
+    onDragLeave: $e,
+    onTouchEnd: Le,
+    onTouchMove: Fe,
+    onTouchStart: Be,
+    ref: Ye,
+    tabIndex: f ? -1 : S,
+    type: B,
+    ...q,
+    ...K,
+    children: [a, Ne ? /* @__PURE__ */ D(ke, {
+      ref: De,
+      center: i,
+      ...I
+    }) : null]
+  });
+});
+function k(e, t, n, o = !1) {
+  return te((s) => (n && n(s), o || e[t](s), !0));
+}
+process.env.NODE_ENV !== "production" && (Pt.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: Qe,
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: r.bool,
+  /**
+   * The content of the component.
+   */
+  children: r.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * @ignore
+   */
+  className: r.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: nt,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: r.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: r.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: r.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: r.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: r.string,
+  /**
+   * @ignore
+   */
+  href: r.any,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: r.elementType,
+  /**
+   * @ignore
+   */
+  onBlur: r.func,
+  /**
+   * @ignore
+   */
+  onClick: r.func,
+  /**
+   * @ignore
+   */
+  onContextMenu: r.func,
+  /**
+   * @ignore
+   */
+  onDragLeave: r.func,
+  /**
+   * @ignore
+   */
+  onFocus: r.func,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: r.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: r.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: r.func,
+  /**
+   * @ignore
+   */
+  onMouseDown: r.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: r.func,
+  /**
+   * @ignore
+   */
+  onMouseUp: r.func,
+  /**
+   * @ignore
+   */
+  onTouchEnd: r.func,
+  /**
+   * @ignore
+   */
+  onTouchMove: r.func,
+  /**
+   * @ignore
+   */
+  onTouchStart: r.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  /**
+   * @default 0
+   */
+  tabIndex: r.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: r.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: r.oneOfType([r.func, r.shape({
+    current: r.shape({
+      pulsate: r.func.isRequired,
+      start: r.func.isRequired,
+      stop: r.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  type: r.oneOfType([r.oneOf(["button", "reset", "submit"]), r.string])
+});
+function wt(e) {
+  return typeof e.main == "string";
+}
+function St(e, t = []) {
+  if (!wt(e))
+    return !1;
+  for (const n of t)
+    if (!e.hasOwnProperty(n) || typeof e[n] != "string")
+      return !1;
+  return !0;
+}
+function kt(e = []) {
+  return ([, t]) => t && St(t, e);
+}
+function Dt(e) {
+  return Te("MuiCircularProgress", e);
+}
+ce("MuiCircularProgress", ["root", "determinate", "indeterminate", "colorPrimary", "colorSecondary", "svg", "circle", "circleDeterminate", "circleIndeterminate", "circleDisableShrink"]);
+const $ = 44, ue = G`
+  0% {
+    transform: rotate(0deg);
+  }
+
+  100% {
+    transform: rotate(360deg);
+  }
+`, le = G`
+  0% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: 0;
+  }
+
+  50% {
+    stroke-dasharray: 100px, 200px;
+    stroke-dashoffset: -15px;
+  }
+
+  100% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: -126px;
+  }
+`, Nt = typeof ue != "string" ? xe`
+        animation: ${ue} 1.4s linear infinite;
+      ` : null, Ot = typeof le != "string" ? xe`
+        animation: ${le} 1.4s ease-in-out infinite;
+      ` : null, It = (e) => {
+  const {
+    classes: t,
+    variant: n,
+    color: o,
+    disableShrink: s
+  } = e, i = {
+    root: ["root", n, `color${ne(o)}`],
+    svg: ["svg"],
+    circle: ["circle", `circle${ne(n)}`, s && "circleDisableShrink"]
+  };
+  return Ce(i, Dt, t);
+}, $t = z("span", {
+  name: "MuiCircularProgress",
+  slot: "Root",
+  overridesResolver: (e, t) => {
+    const {
+      ownerState: n
+    } = e;
+    return [t.root, t[n.variant], t[`color${ne(n.color)}`]];
+  }
+})(Ee(({
+  theme: e
+}) => ({
+  display: "inline-block",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: e.transitions.create("transform")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: Nt || {
+      animation: `${ue} 1.4s linear infinite`
+    }
+  }, ...Object.entries(e.palette).filter(kt()).map(([t]) => ({
+    props: {
+      color: t
+    },
+    style: {
+      color: (e.vars || e).palette[t].main
+    }
+  }))]
+}))), Vt = z("svg", {
+  name: "MuiCircularProgress",
+  slot: "Svg"
+})({
+  display: "block"
+  // Keeps the progress centered
+}), jt = z("circle", {
+  name: "MuiCircularProgress",
+  slot: "Circle",
+  overridesResolver: (e, t) => {
+    const {
+      ownerState: n
+    } = e;
+    return [t.circle, t[`circle${ne(n.variant)}`], n.disableShrink && t.circleDisableShrink];
+  }
+})(Ee(({
+  theme: e
+}) => ({
+  stroke: "currentColor",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: e.transitions.create("stroke-dashoffset")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: {
+      // Some default value that looks fine waiting for the animation to kicks in.
+      strokeDasharray: "80px, 200px",
+      strokeDashoffset: 0
+      // Add the unit to fix a Edge 16 and below bug.
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.variant === "indeterminate" && !t.disableShrink,
+    style: Ot || {
+      // At runtime for Pigment CSS, `bufferAnimation` will be null and the generated keyframe will be used.
+      animation: `${le} 1.4s ease-in-out infinite`
+    }
+  }]
+}))), Bt = /* @__PURE__ */ c.forwardRef(function(t, n) {
+  const o = pe({
+    props: t,
+    name: "MuiCircularProgress"
+  }), {
+    className: s,
+    color: i = "primary",
+    disableShrink: a = !1,
+    size: l = 40,
+    style: p,
+    thickness: f = 3.6,
+    value: h = 0,
+    variant: m = "indeterminate",
+    ...y
+  } = o, M = {
+    ...o,
+    color: i,
+    disableShrink: a,
+    size: l,
+    thickness: f,
+    value: h,
+    variant: m
+  }, b = It(M), T = {}, R = {}, w = {};
+  if (m === "determinate") {
+    const V = 2 * Math.PI * (($ - f) / 2);
+    T.strokeDasharray = V.toFixed(3), w["aria-valuenow"] = Math.round(h), T.strokeDashoffset = `${((100 - h) / 100 * V).toFixed(3)}px`, R.transform = "rotate(-90deg)";
+  }
+  return /* @__PURE__ */ D($t, {
+    className: E(b.root, s),
+    style: {
+      width: l,
+      height: l,
+      ...R,
+      ...p
+    },
+    ownerState: M,
+    ref: n,
+    role: "progressbar",
+    ...w,
+    ...y,
+    children: /* @__PURE__ */ D(Vt, {
+      className: b.svg,
+      ownerState: M,
+      viewBox: `${$ / 2} ${$ / 2} ${$} ${$}`,
+      children: /* @__PURE__ */ D(jt, {
+        className: b.circle,
+        style: T,
+        ownerState: M,
+        cx: $,
+        cy: $,
+        r: ($ - f) / 2,
+        fill: "none",
+        strokeWidth: f
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Bt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * @ignore
+   */
+  className: r.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: r.oneOfType([r.oneOf(["inherit", "primary", "secondary", "error", "info", "success", "warning"]), r.string]),
+  /**
+   * If `true`, the shrink animation is disabled.
+   * This only works if variant is `indeterminate`.
+   * @default false
+   */
+  disableShrink: Pe(r.bool, (e) => e.disableShrink && e.variant && e.variant !== "indeterminate" ? new Error("MUI: You have provided the `disableShrink` prop with a variant other than `indeterminate`. This will have no effect.") : null),
+  /**
+   * The size of the component.
+   * If using a number, the pixel unit is assumed.
+   * If using a string, you need to provide the CSS unit, for example '3rem'.
+   * @default 40
+   */
+  size: r.oneOfType([r.number, r.string]),
+  /**
+   * @ignore
+   */
+  style: r.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  /**
+   * The thickness of the circle.
+   * @default 3.6
+   */
+  thickness: r.number,
+  /**
+   * The value of the progress indicator for the determinate variant.
+   * Value between 0 and 100.
+   * @default 0
+   */
+  value: r.number,
+  /**
+   * The variant to use.
+   * Use indeterminate when there is no progress value.
+   * @default 'indeterminate'
+   */
+  variant: r.oneOf(["determinate", "indeterminate"])
+});
+export {
+  Pt as B,
+  Bt as C,
+  ve as T,
+  st as _,
+  Pe as a,
+  ye as b,
+  kt as c,
+  Ge as d,
+  it as e,
+  te as f,
+  nt as g,
+  mt as h,
+  ie as i,
+  we as j,
+  Qe as r,
+  Yt as u
+};