` by default. You can change this
+ * behavior by providing a `component` prop.
+ * If you use React v16+ and would like to avoid a wrapping `
` element
+ * you can pass in `component={null}`. This is useful if the wrapping div
+ * borks your css styles.
+ */
+ component: h.any,
+ /**
+ * A set of `
` components, that are toggled `in` and out as they
+ * leave. the `` will inject specific transition props, so
+ * remember to spread them through if you are wrapping the `` as
+ * with our `` 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: h.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: h.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: h.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: h.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: h.func
+} : {};
+kC.defaultProps = xw;
+const bb = {};
+function oE(o, u) {
+ const s = V.useRef(bb);
+ return s.current === bb && (s.current = o(u)), s;
+}
+const Ow = [];
+function Rw(o) {
+ V.useEffect(o, Ow);
+}
+class Xp {
+ static create() {
+ return new Xp();
+ }
+ currentId = null;
+ /**
+ * Executes `fn` after `delay`, clearing any previously scheduled call.
+ */
+ start(u, s) {
+ this.clear(), this.currentId = setTimeout(() => {
+ this.currentId = null, s();
+ }, u);
+ }
+ clear = () => {
+ this.currentId !== null && (clearTimeout(this.currentId), this.currentId = null);
+ };
+ disposeEffect = () => this.clear;
+}
+function p5() {
+ const o = oE(Xp.create).current;
+ return Rw(o.disposeEffect), o;
+}
+function Aw(o) {
+ const {
+ prototype: u = {}
+ } = o;
+ return !!u.isReactComponent;
+}
+function Mw(o, u, s, d, m) {
+ const y = o[u], b = m || u;
+ if (y == 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 S;
+ return typeof y == "function" && !Aw(y) && (S = "Did you accidentally provide a plain function component instead?"), y === V.Fragment && (S = "Did you accidentally provide a React.Fragment instead?"), S !== void 0 ? new Error(`Invalid ${d} \`${b}\` supplied to \`${s}\`. Expected an element type that can hold a ref. ${S} For more information see https://v7.mui.com/r/caveat-with-refs-guide`) : null;
+}
+const YC = Vo(h.elementType, Mw), rE = (o) => o.scrollTop;
+function i8(o, u) {
+ return (s) => {
+ if (u) {
+ const d = o.current;
+ s === void 0 ? u(d) : u(d, s);
+ }
+ };
+}
+function iE(o, u, s, d, m, y) {
+ const b = o === "exited" && !u ? d : s[o] || s.exited;
+ return m || y ? {
+ ...b,
+ ...m,
+ ...y
+ } : b;
+}
+function vp(o, u) {
+ const {
+ timeout: s,
+ easing: d,
+ style: m = {}
+ } = o;
+ return {
+ duration: m.transitionDuration ?? (typeof s == "number" ? s : s[u.mode] || 0),
+ easing: m.transitionTimingFunction ?? (typeof d == "object" ? d[u.mode] : d),
+ delay: m.transitionDelay
+ };
+}
+function uE(o) {
+ return typeof o == "string";
+}
+function cE(o, u, s) {
+ return o === void 0 || uE(o) ? u : {
+ ...u,
+ ownerState: {
+ ...u.ownerState,
+ ...s
+ }
+ };
+}
+function sE(o, u, s) {
+ return typeof o == "function" ? o(u, s) : o;
+}
+function fE(o, u = []) {
+ if (o === void 0)
+ return {};
+ const s = {};
+ return Object.keys(o).filter((d) => d.match(/^on[A-Z]/) && typeof o[d] == "function" && !u.includes(d)).forEach((d) => {
+ s[d] = o[d];
+ }), s;
+}
+function Sb(o) {
+ if (o === void 0)
+ return {};
+ const u = {};
+ return Object.keys(o).filter((s) => !(s.match(/^on[A-Z]/) && typeof o[s] == "function")).forEach((s) => {
+ u[s] = o[s];
+ }), u;
+}
+function dE(o) {
+ const {
+ getSlotProps: u,
+ additionalProps: s,
+ externalSlotProps: d,
+ externalForwardedProps: m,
+ className: y
+ } = o;
+ if (!u) {
+ const _ = Ce(s?.className, y, m?.className, d?.className), B = {
+ ...s?.style,
+ ...m?.style,
+ ...d?.style
+ }, z = {
+ ...s,
+ ...m,
+ ...d
+ };
+ return _.length > 0 && (z.className = _), Object.keys(B).length > 0 && (z.style = B), {
+ props: z,
+ internalRef: void 0
+ };
+ }
+ const b = fE({
+ ...m,
+ ...d
+ }), S = Sb(d), T = Sb(m), x = u(b), M = Ce(x?.className, s?.className, y, m?.className, d?.className), A = {
+ ...x?.style,
+ ...s?.style,
+ ...m?.style,
+ ...d?.style
+ }, R = {
+ ...x,
+ ...s,
+ ...T,
+ ...S
+ };
+ return M.length > 0 && (R.className = M), Object.keys(A).length > 0 && (R.style = A), {
+ props: R,
+ internalRef: x.ref
+ };
+}
+function N0(o, u) {
+ const {
+ className: s,
+ elementType: d,
+ ownerState: m,
+ externalForwardedProps: y,
+ internalForwardedProps: b,
+ shouldForwardComponentProp: S = !1,
+ ...T
+ } = u, {
+ component: x,
+ slots: M = {
+ [o]: void 0
+ },
+ slotProps: A = {
+ [o]: void 0
+ },
+ ...R
+ } = y, _ = M[o] || d, B = sE(A[o], m), {
+ props: {
+ component: z,
+ ...q
+ },
+ internalRef: Z
+ } = dE({
+ className: s,
+ ...T,
+ externalForwardedProps: o === "root" ? R : void 0,
+ externalSlotProps: B
+ }), F = H4(Z, B?.ref, u.ref), G = o === "root" ? z || x : z, k = cE(_, {
+ ...o === "root" && !x && !M[o] && b,
+ ...o !== "root" && !M[o] && b,
+ ...q,
+ ...G && !S && {
+ as: G
+ },
+ ...G && S && {
+ component: G
+ },
+ ref: F
+ }, m);
+ return [_, k];
+}
+function ww(o) {
+ const u = typeof o;
+ switch (u) {
+ case "number":
+ return Number.isNaN(o) ? "NaN" : Number.isFinite(o) ? o !== Math.floor(o) ? "float" : "number" : "Infinity";
+ case "object":
+ return o === null ? "null" : o.constructor.name;
+ default:
+ return u;
+ }
+}
+function pE(o, u, s, d) {
+ const m = o[u];
+ if (m == null || !Number.isInteger(m)) {
+ const y = ww(m);
+ return new RangeError(`Invalid ${d} \`${u}\` of type \`${y}\` supplied to \`${s}\`, expected \`integer\`.`);
+ }
+ return null;
+}
+function hE(o, u, s, d) {
+ return o[u] === void 0 ? null : pE(o, u, s, d);
+}
+function iC() {
+ return null;
+}
+hE.isRequired = pE;
+iC.isRequired = iC;
+const mE = process.env.NODE_ENV === "production" ? iC : hE;
+function _w(o) {
+ return j0("MuiPaper", o);
+}
+Z0("MuiPaper", ["root", "rounded", "outlined", "elevation", "elevation0", "elevation1", "elevation2", "elevation3", "elevation4", "elevation5", "elevation6", "elevation7", "elevation8", "elevation9", "elevation10", "elevation11", "elevation12", "elevation13", "elevation14", "elevation15", "elevation16", "elevation17", "elevation18", "elevation19", "elevation20", "elevation21", "elevation22", "elevation23", "elevation24"]);
+const Dw = (o) => {
+ const {
+ square: u,
+ elevation: s,
+ variant: d,
+ classes: m
+ } = o, y = {
+ root: ["root", d, !u && "rounded", d === "elevation" && `elevation${s}`]
+ };
+ return I0(y, _w, m);
+}, zw = pe("div", {
+ name: "MuiPaper",
+ slot: "Root",
+ overridesResolver: (o, u) => {
+ const {
+ ownerState: s
+ } = o;
+ return [u.root, u[s.variant], !s.square && u.rounded, s.variant === "elevation" && u[`elevation${s.elevation}`]];
+ }
+})(st(({
+ theme: o
+}) => ({
+ backgroundColor: (o.vars || o).palette.background.paper,
+ color: (o.vars || o).palette.text.primary,
+ transition: o.transitions.create("box-shadow"),
+ variants: [{
+ props: ({
+ ownerState: u
+ }) => !u.square,
+ style: {
+ borderRadius: o.shape.borderRadius
+ }
+ }, {
+ props: {
+ variant: "outlined"
+ },
+ style: {
+ border: `1px solid ${(o.vars || o).palette.divider}`
+ }
+ }, {
+ props: {
+ variant: "elevation"
+ },
+ style: {
+ boxShadow: "var(--Paper-shadow)",
+ backgroundImage: "var(--Paper-overlay)"
+ }
+ }]
+}))), qC = /* @__PURE__ */ V.forwardRef(function(u, s) {
+ const d = U0({
+ props: u,
+ name: "MuiPaper"
+ }), m = w5(), {
+ className: y,
+ component: b = "div",
+ elevation: S = 1,
+ square: T = !1,
+ variant: x = "elevation",
+ ...M
+ } = d, A = {
+ ...d,
+ component: b,
+ elevation: S,
+ square: T,
+ variant: x
+ }, R = Dw(A);
+ return process.env.NODE_ENV !== "production" && m.shadows[S] === void 0 && console.error([`MUI: The elevation provided is not available in the theme.`, `Please make sure that \`theme.shadows[${S}]\` is defined.`].join(`
+`)), /* @__PURE__ */ Y.jsx(zw, {
+ as: b,
+ ownerState: A,
+ className: Ce(R.root, y),
+ ref: s,
+ ...M,
+ style: {
+ ...x === "elevation" && {
+ "--Paper-shadow": (m.vars || m).shadows[S],
+ ...m.vars && {
+ "--Paper-overlay": m.vars.overlays?.[S]
+ },
+ ...!m.vars && m.palette.mode === "dark" && {
+ "--Paper-overlay": `linear-gradient(${b5("#fff", tC(S))}, ${b5("#fff", tC(S))})`
+ }
+ },
+ ...M.style
+ }
+ });
+});
+process.env.NODE_ENV !== "production" && (qC.propTypes = {
+ // ┌────────────────────────────── Warning ──────────────────────────────┐
+ // │ These PropTypes are generated from the TypeScript type definitions. │
+ // │ To update them, edit the d.ts file and run `pnpm proptypes`. │
+ // └─────────────────────────────────────────────────────────────────────┘
+ /**
+ * The content of the component.
+ */
+ children: h.node,
+ /**
+ * Override or extend the styles applied to the component.
+ */
+ classes: h.object,
+ /**
+ * @ignore
+ */
+ className: h.string,
+ /**
+ * The component used for the root node.
+ * Either a string to use a HTML element or a component.
+ */
+ component: h.elementType,
+ /**
+ * Shadow depth, corresponds to `dp` in the spec.
+ * It accepts values between 0 and 24 inclusive.
+ * @default 1
+ */
+ elevation: Vo(mE, (o) => {
+ const {
+ elevation: u,
+ variant: s
+ } = o;
+ return u > 0 && s === "outlined" ? new Error(`MUI: Combining \`elevation={${u}}\` with \`variant="${s}"\` has no effect. Either use \`elevation={0}\` or use a different \`variant\`.`) : null;
+ }),
+ /**
+ * If `true`, rounded corners are disabled.
+ * @default false
+ */
+ square: h.bool,
+ /**
+ * @ignore
+ */
+ style: h.object,
+ /**
+ * The system prop that allows defining system overrides as well as additional CSS styles.
+ */
+ sx: h.oneOfType([h.arrayOf(h.oneOfType([h.func, h.object, h.bool])), h.func, h.object]),
+ /**
+ * The variant to use.
+ * @default 'elevation'
+ */
+ variant: h.oneOfType([h.oneOf(["elevation", "outlined"]), h.string])
+});
+const Pp = h.oneOfType([h.func, h.object]);
+function S5(o) {
+ try {
+ return o.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;
+}
+class bp {
+ /** 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 bp();
+ }
+ static use() {
+ const u = oE(bp.create).current, [s, d] = V.useState(!1);
+ return u.shouldMount = s, u.setShouldMount = d, V.useEffect(u.mountEffect, [s]), u;
+ }
+ constructor() {
+ this.ref = {
+ current: null
+ }, this.mounted = null, this.didMount = !1, this.shouldMount = !1, this.setShouldMount = null;
+ }
+ mount() {
+ return this.mounted || (this.mounted = Nw(), 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(...u) {
+ this.mount().then(() => this.ref.current?.start(...u));
+ }
+ stop(...u) {
+ this.mount().then(() => this.ref.current?.stop(...u));
+ }
+ pulsate(...u) {
+ this.mount().then(() => this.ref.current?.pulsate(...u));
+ }
+}
+function Lw() {
+ return bp.use();
+}
+function Nw() {
+ let o, u;
+ const s = new Promise((d, m) => {
+ o = d, u = m;
+ });
+ return s.resolve = o, s.reject = u, s;
+}
+function CE(o) {
+ const {
+ className: u,
+ classes: s,
+ pulsate: d = !1,
+ rippleX: m,
+ rippleY: y,
+ rippleSize: b,
+ in: S,
+ onExited: T,
+ timeout: x
+ } = o, [M, A] = V.useState(!1), R = Ce(u, s.ripple, s.rippleVisible, d && s.ripplePulsate), _ = {
+ width: b,
+ height: b,
+ top: -(b / 2) + y,
+ left: -(b / 2) + m
+ }, B = Ce(s.child, M && s.childLeaving, d && s.childPulsate);
+ return !S && !M && A(!0), V.useEffect(() => {
+ if (!S && T != null) {
+ const z = setTimeout(T, x);
+ return () => {
+ clearTimeout(z);
+ };
+ }
+ }, [T, S, x]), /* @__PURE__ */ Y.jsx("span", {
+ className: R,
+ style: _,
+ children: /* @__PURE__ */ Y.jsx("span", {
+ className: B
+ })
+ });
+}
+process.env.NODE_ENV !== "production" && (CE.propTypes = {
+ /**
+ * Override or extend the styles applied to the component.
+ */
+ classes: h.object.isRequired,
+ className: h.string,
+ /**
+ * @ignore - injected from TransitionGroup
+ */
+ in: h.bool,
+ /**
+ * @ignore - injected from TransitionGroup
+ */
+ onExited: h.func,
+ /**
+ * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+ */
+ pulsate: h.bool,
+ /**
+ * Diameter of the ripple.
+ */
+ rippleSize: h.number,
+ /**
+ * Horizontal position of the ripple center.
+ */
+ rippleX: h.number,
+ /**
+ * Vertical position of the ripple center.
+ */
+ rippleY: h.number,
+ /**
+ * exit delay
+ */
+ timeout: h.number.isRequired
+});
+const o8 = Z0("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), uC = 550, jw = 80, Uw = ka`
+ 0% {
+ transform: scale(0);
+ opacity: 0.1;
+ }
+
+ 100% {
+ transform: scale(1);
+ opacity: 0.3;
+ }
+`, Bw = ka`
+ 0% {
+ opacity: 1;
+ }
+
+ 100% {
+ opacity: 0;
+ }
+`, Hw = ka`
+ 0% {
+ transform: scale(1);
+ }
+
+ 50% {
+ transform: scale(0.92);
+ }
+
+ 100% {
+ transform: scale(1);
+ }
+`, $w = pe("span", {
+ name: "MuiTouchRipple",
+ slot: "Root"
+})({
+ overflow: "hidden",
+ pointerEvents: "none",
+ position: "absolute",
+ zIndex: 0,
+ top: 0,
+ right: 0,
+ bottom: 0,
+ left: 0,
+ borderRadius: "inherit"
+}), Vw = pe(CE, {
+ name: "MuiTouchRipple",
+ slot: "Ripple"
+})`
+ opacity: 0;
+ position: absolute;
+
+ &.${o8.rippleVisible} {
+ opacity: 0.3;
+ transform: scale(1);
+ animation-name: ${Uw};
+ animation-duration: ${uC}ms;
+ animation-timing-function: ${({
+ theme: o
+}) => o.transitions.easing.easeInOut};
+ }
+
+ &.${o8.ripplePulsate} {
+ animation-duration: ${({
+ theme: o
+}) => o.transitions.duration.shorter}ms;
+ }
+
+ & .${o8.child} {
+ opacity: 1;
+ display: block;
+ width: 100%;
+ height: 100%;
+ border-radius: 50%;
+ background-color: currentColor;
+ }
+
+ & .${o8.childLeaving} {
+ opacity: 0;
+ animation-name: ${Bw};
+ animation-duration: ${uC}ms;
+ animation-timing-function: ${({
+ theme: o
+}) => o.transitions.easing.easeInOut};
+ }
+
+ & .${o8.childPulsate} {
+ position: absolute;
+ /* @noflip */
+ left: 0px;
+ top: 0;
+ animation-name: ${Hw};
+ animation-duration: 2500ms;
+ animation-timing-function: ${({
+ theme: o
+}) => o.transitions.easing.easeInOut};
+ animation-iteration-count: infinite;
+ animation-delay: 200ms;
+ }
+`, yE = /* @__PURE__ */ V.forwardRef(function(u, s) {
+ const d = U0({
+ props: u,
+ name: "MuiTouchRipple"
+ }), {
+ center: m = !1,
+ classes: y = {},
+ className: b,
+ ...S
+ } = d, [T, x] = V.useState([]), M = V.useRef(0), A = V.useRef(null);
+ V.useEffect(() => {
+ A.current && (A.current(), A.current = null);
+ }, [T]);
+ const R = V.useRef(!1), _ = p5(), B = V.useRef(null), z = V.useRef(null), q = V.useCallback((k) => {
+ const {
+ pulsate: $,
+ rippleX: K,
+ rippleY: a2,
+ rippleSize: u2,
+ cb: d2
+ } = k;
+ x((r2) => [...r2, /* @__PURE__ */ Y.jsx(Vw, {
+ classes: {
+ ripple: Ce(y.ripple, o8.ripple),
+ rippleVisible: Ce(y.rippleVisible, o8.rippleVisible),
+ ripplePulsate: Ce(y.ripplePulsate, o8.ripplePulsate),
+ child: Ce(y.child, o8.child),
+ childLeaving: Ce(y.childLeaving, o8.childLeaving),
+ childPulsate: Ce(y.childPulsate, o8.childPulsate)
+ },
+ timeout: uC,
+ pulsate: $,
+ rippleX: K,
+ rippleY: a2,
+ rippleSize: u2
+ }, M.current)]), M.current += 1, A.current = d2;
+ }, [y]), Z = V.useCallback((k = {}, $ = {}, K = () => {
+ }) => {
+ const {
+ pulsate: a2 = !1,
+ center: u2 = m || $.pulsate,
+ fakeElement: d2 = !1
+ // For test purposes
+ } = $;
+ if (k?.type === "mousedown" && R.current) {
+ R.current = !1;
+ return;
+ }
+ k?.type === "touchstart" && (R.current = !0);
+ const r2 = d2 ? null : z.current, S2 = r2 ? r2.getBoundingClientRect() : {
+ width: 0,
+ height: 0,
+ left: 0,
+ top: 0
+ };
+ let N, o2, g2;
+ if (u2 || k === void 0 || k.clientX === 0 && k.clientY === 0 || !k.clientX && !k.touches)
+ N = Math.round(S2.width / 2), o2 = Math.round(S2.height / 2);
+ else {
+ const {
+ clientX: R2,
+ clientY: H
+ } = k.touches && k.touches.length > 0 ? k.touches[0] : k;
+ N = Math.round(R2 - S2.left), o2 = Math.round(H - S2.top);
+ }
+ if (u2)
+ g2 = Math.sqrt((2 * S2.width ** 2 + S2.height ** 2) / 3), g2 % 2 === 0 && (g2 += 1);
+ else {
+ const R2 = Math.max(Math.abs((r2 ? r2.clientWidth : 0) - N), N) * 2 + 2, H = Math.max(Math.abs((r2 ? r2.clientHeight : 0) - o2), o2) * 2 + 2;
+ g2 = Math.sqrt(R2 ** 2 + H ** 2);
+ }
+ k?.touches ? B.current === null && (B.current = () => {
+ q({
+ pulsate: a2,
+ rippleX: N,
+ rippleY: o2,
+ rippleSize: g2,
+ cb: K
+ });
+ }, _.start(jw, () => {
+ B.current && (B.current(), B.current = null);
+ })) : q({
+ pulsate: a2,
+ rippleX: N,
+ rippleY: o2,
+ rippleSize: g2,
+ cb: K
+ });
+ }, [m, q, _]), F = V.useCallback(() => {
+ Z({}, {
+ pulsate: !0
+ });
+ }, [Z]), G = V.useCallback((k, $) => {
+ if (_.clear(), k?.type === "touchend" && B.current) {
+ B.current(), B.current = null, _.start(0, () => {
+ G(k, $);
+ });
+ return;
+ }
+ B.current = null, x((K) => K.length > 0 ? K.slice(1) : K), A.current = $;
+ }, [_]);
+ return V.useImperativeHandle(s, () => ({
+ pulsate: F,
+ start: Z,
+ stop: G
+ }), [F, Z, G]), /* @__PURE__ */ Y.jsx($w, {
+ className: Ce(o8.root, y.root, b),
+ ref: z,
+ ...S,
+ children: /* @__PURE__ */ Y.jsx(kC, {
+ component: null,
+ exit: !0,
+ children: T
+ })
+ });
+});
+process.env.NODE_ENV !== "production" && (yE.propTypes = {
+ /**
+ * If `true`, the ripple starts at the center of the component
+ * rather than at the point of interaction.
+ */
+ center: h.bool,
+ /**
+ * Override or extend the styles applied to the component.
+ */
+ classes: h.object,
+ /**
+ * @ignore
+ */
+ className: h.string
+});
+function kw(o) {
+ return j0("MuiButtonBase", o);
+}
+const Yw = Z0("MuiButtonBase", ["root", "disabled", "focusVisible"]), qw = (o) => {
+ const {
+ disabled: u,
+ focusVisible: s,
+ focusVisibleClassName: d,
+ classes: m
+ } = o, b = I0({
+ root: ["root", u && "disabled", s && "focusVisible"]
+ }, kw, m);
+ return s && d && (b.root += ` ${d}`), b;
+}, Zw = pe("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 element.
+ color: "inherit",
+ "&::-moz-focus-inner": {
+ borderStyle: "none"
+ // Remove Firefox dotted outline.
+ },
+ [`&.${Yw.disabled}`]: {
+ pointerEvents: "none",
+ // Disable link interactions
+ cursor: "default"
+ },
+ "@media print": {
+ colorAdjust: "exact"
+ }
+}), Bo = /* @__PURE__ */ V.forwardRef(function(u, s) {
+ const d = U0({
+ props: u,
+ name: "MuiButtonBase"
+ }), {
+ action: m,
+ centerRipple: y = !1,
+ children: b,
+ className: S,
+ component: T = "button",
+ disabled: x = !1,
+ disableRipple: M = !1,
+ disableTouchRipple: A = !1,
+ focusRipple: R = !1,
+ focusVisibleClassName: _,
+ LinkComponent: B = "a",
+ onBlur: z,
+ onClick: q,
+ onContextMenu: Z,
+ onDragLeave: F,
+ onFocus: G,
+ onFocusVisible: k,
+ onKeyDown: $,
+ onKeyUp: K,
+ onMouseDown: a2,
+ onMouseLeave: u2,
+ onMouseUp: d2,
+ onTouchEnd: r2,
+ onTouchMove: S2,
+ onTouchStart: N,
+ tabIndex: o2 = 0,
+ TouchRippleProps: g2,
+ touchRippleRef: R2,
+ type: H,
+ ...e2
+ } = d, v2 = V.useRef(null), E2 = Lw(), i2 = H4(E2.ref, R2), [D, X] = V.useState(!1);
+ x && D && X(!1), V.useImperativeHandle(m, () => ({
+ focusVisible: () => {
+ X(!0), v2.current.focus();
+ }
+ }), []);
+ const p2 = E2.shouldMount && !M && !x;
+ V.useEffect(() => {
+ D && R && !M && E2.pulsate();
+ }, [M, R, D, E2]);
+ const s2 = F1(E2, "start", a2, A), L2 = F1(E2, "stop", Z, A), D2 = F1(E2, "stop", F, A), A2 = F1(E2, "stop", d2, A), B2 = F1(E2, "stop", (P2) => {
+ D && P2.preventDefault(), u2 && u2(P2);
+ }, A), k2 = F1(E2, "start", N, A), $2 = F1(E2, "stop", r2, A), M2 = F1(E2, "stop", S2, A), h2 = F1(E2, "stop", (P2) => {
+ S5(P2.target) || X(!1), z && z(P2);
+ }, !1), ge = No((P2) => {
+ v2.current || (v2.current = P2.currentTarget), S5(P2.target) && (X(!0), k && k(P2)), G && G(P2);
+ }), he = () => {
+ const P2 = v2.current;
+ return P2 ? P2.tagName === "BUTTON" ? !1 : !(P2.tagName === "A" && P2.href) : T && T !== "button";
+ }, je = No((P2) => {
+ R && !P2.repeat && D && P2.key === " " && E2.stop(P2, () => {
+ E2.start(P2);
+ }), P2.target === P2.currentTarget && he() && P2.key === " " && P2.preventDefault(), $ && $(P2), P2.target === P2.currentTarget && he() && P2.key === "Enter" && !x && (P2.preventDefault(), q && q(P2));
+ }), me = No((P2) => {
+ R && P2.key === " " && D && !P2.defaultPrevented && E2.stop(P2, () => {
+ E2.pulsate(P2);
+ }), K && K(P2), q && P2.target === P2.currentTarget && he() && P2.key === " " && !P2.defaultPrevented && !x && q(P2);
+ });
+ let Ue = T;
+ Ue === "button" && (e2.href || e2.to) && (Ue = B);
+ const y0 = {};
+ if (Ue === "button") {
+ const P2 = !!e2.formAction;
+ y0.type = H === void 0 && !P2 ? "button" : H, y0.disabled = x;
+ } else
+ !e2.href && !e2.to && (y0.role = "button"), x && (y0["aria-disabled"] = x);
+ const Qe = H4(s, v2), Y2 = {
+ ...d,
+ centerRipple: y,
+ component: T,
+ disabled: x,
+ disableRipple: M,
+ disableTouchRipple: A,
+ focusRipple: R,
+ tabIndex: o2,
+ focusVisible: D
+ }, Be = qw(Y2);
+ return /* @__PURE__ */ Y.jsxs(Zw, {
+ as: Ue,
+ className: Ce(Be.root, S),
+ ownerState: Y2,
+ onBlur: h2,
+ onClick: q,
+ onContextMenu: L2,
+ onFocus: ge,
+ onKeyDown: je,
+ onKeyUp: me,
+ onMouseDown: s2,
+ onMouseLeave: B2,
+ onMouseUp: A2,
+ onDragLeave: D2,
+ onTouchEnd: $2,
+ onTouchMove: M2,
+ onTouchStart: k2,
+ ref: Qe,
+ tabIndex: x ? -1 : o2,
+ type: H,
+ ...y0,
+ ...e2,
+ children: [b, p2 ? /* @__PURE__ */ Y.jsx(yE, {
+ ref: i2,
+ center: y,
+ ...g2
+ }) : null]
+ });
+});
+function F1(o, u, s, d = !1) {
+ return No((m) => (s && s(m), d || o[u](m), !0));
+}
+process.env.NODE_ENV !== "production" && (Bo.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: Pp,
+ /**
+ * If `true`, the ripples are centered.
+ * They won't start at the cursor interaction position.
+ * @default false
+ */
+ centerRipple: h.bool,
+ /**
+ * The content of the component.
+ */
+ children: h.node,
+ /**
+ * Override or extend the styles applied to the component.
+ */
+ classes: h.object,
+ /**
+ * @ignore
+ */
+ className: h.string,
+ /**
+ * The component used for the root node.
+ * Either a string to use a HTML element or a component.
+ */
+ component: YC,
+ /**
+ * If `true`, the component is disabled.
+ * @default false
+ */
+ disabled: h.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: h.bool,
+ /**
+ * If `true`, the touch ripple effect is disabled.
+ * @default false
+ */
+ disableTouchRipple: h.bool,
+ /**
+ * If `true`, the base button will have a keyboard focus ripple.
+ * @default false
+ */
+ focusRipple: h.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: h.string,
+ /**
+ * @ignore
+ */
+ formAction: h.oneOfType([h.func, h.string]),
+ /**
+ * @ignore
+ */
+ href: h.any,
+ /**
+ * The component used to render a link when the `href` prop is provided.
+ * @default 'a'
+ */
+ LinkComponent: h.elementType,
+ /**
+ * @ignore
+ */
+ onBlur: h.func,
+ /**
+ * @ignore
+ */
+ onClick: h.func,
+ /**
+ * @ignore
+ */
+ onContextMenu: h.func,
+ /**
+ * @ignore
+ */
+ onDragLeave: h.func,
+ /**
+ * @ignore
+ */
+ onFocus: h.func,
+ /**
+ * Callback fired when the component is focused with a keyboard.
+ * We trigger a `onFocus` callback too.
+ */
+ onFocusVisible: h.func,
+ /**
+ * @ignore
+ */
+ onKeyDown: h.func,
+ /**
+ * @ignore
+ */
+ onKeyUp: h.func,
+ /**
+ * @ignore
+ */
+ onMouseDown: h.func,
+ /**
+ * @ignore
+ */
+ onMouseLeave: h.func,
+ /**
+ * @ignore
+ */
+ onMouseUp: h.func,
+ /**
+ * @ignore
+ */
+ onTouchEnd: h.func,
+ /**
+ * @ignore
+ */
+ onTouchMove: h.func,
+ /**
+ * @ignore
+ */
+ onTouchStart: h.func,
+ /**
+ * The system prop that allows defining system overrides as well as additional CSS styles.
+ */
+ sx: h.oneOfType([h.arrayOf(h.oneOfType([h.func, h.object, h.bool])), h.func, h.object]),
+ /**
+ * @default 0
+ */
+ tabIndex: h.number,
+ /**
+ * Props applied to the `TouchRipple` element.
+ */
+ TouchRippleProps: h.object,
+ /**
+ * A ref that points to the `TouchRipple` element.
+ */
+ touchRippleRef: h.oneOfType([h.func, h.shape({
+ current: h.shape({
+ pulsate: h.func.isRequired,
+ start: h.func.isRequired,
+ stop: h.func.isRequired
+ })
+ })]),
+ /**
+ * @ignore
+ */
+ type: h.oneOfType([h.oneOf(["button", "reset", "submit"]), h.string])
+});
+function Gw(o) {
+ return typeof o.main == "string";
+}
+function Xw(o, u = []) {
+ if (!Gw(o))
+ return !1;
+ for (const s of u)
+ if (!o.hasOwnProperty(s) || typeof o[s] != "string")
+ return !1;
+ return !0;
+}
+function fn(o = []) {
+ return ([, u]) => u && Xw(u, o);
+}
+function Pw(o) {
+ return j0("MuiAlert", o);
+}
+const Eb = Z0("MuiAlert", ["root", "action", "icon", "message", "filled", "colorSuccess", "colorInfo", "colorWarning", "colorError", "filledSuccess", "filledInfo", "filledWarning", "filledError", "outlined", "outlinedSuccess", "outlinedInfo", "outlinedWarning", "outlinedError", "standard", "standardSuccess", "standardInfo", "standardWarning", "standardError"]);
+function Qw(o) {
+ return j0("MuiCircularProgress", o);
+}
+Z0("MuiCircularProgress", ["root", "determinate", "indeterminate", "colorPrimary", "colorSecondary", "svg", "track", "circle", "circleDeterminate", "circleIndeterminate", "circleDisableShrink"]);
+const Y8 = 44, cC = ka`
+ 0% {
+ transform: rotate(0deg);
+ }
+
+ 100% {
+ transform: rotate(360deg);
+ }
+`, sC = ka`
+ 0% {
+ stroke-dasharray: 1px, 200px;
+ stroke-dashoffset: 0;
+ }
+
+ 50% {
+ stroke-dasharray: 100px, 200px;
+ stroke-dashoffset: -15px;
+ }
+
+ 100% {
+ stroke-dasharray: 1px, 200px;
+ stroke-dashoffset: -126px;
+ }
+`, Iw = typeof cC != "string" ? RC`
+ animation: ${cC} 1.4s linear infinite;
+ ` : null, Kw = typeof sC != "string" ? RC`
+ animation: ${sC} 1.4s ease-in-out infinite;
+ ` : null, Jw = (o) => {
+ const {
+ classes: u,
+ variant: s,
+ color: d,
+ disableShrink: m
+ } = o, y = {
+ root: ["root", s, `color${I2(d)}`],
+ svg: ["svg"],
+ track: ["track"],
+ circle: ["circle", `circle${I2(s)}`, m && "circleDisableShrink"]
+ };
+ return I0(y, Qw, u);
+}, Fw = pe("span", {
+ name: "MuiCircularProgress",
+ slot: "Root",
+ overridesResolver: (o, u) => {
+ const {
+ ownerState: s
+ } = o;
+ return [u.root, u[s.variant], u[`color${I2(s.color)}`]];
+ }
+})(st(({
+ theme: o
+}) => ({
+ display: "inline-block",
+ variants: [{
+ props: {
+ variant: "determinate"
+ },
+ style: {
+ transition: o.transitions.create("transform")
+ }
+ }, {
+ props: {
+ variant: "indeterminate"
+ },
+ style: Iw || {
+ animation: `${cC} 1.4s linear infinite`
+ }
+ }, ...Object.entries(o.palette).filter(fn()).map(([u]) => ({
+ props: {
+ color: u
+ },
+ style: {
+ color: (o.vars || o).palette[u].main
+ }
+ }))]
+}))), Ww = pe("svg", {
+ name: "MuiCircularProgress",
+ slot: "Svg"
+})({
+ display: "block"
+ // Keeps the progress centered
+}), e_ = pe("circle", {
+ name: "MuiCircularProgress",
+ slot: "Circle",
+ overridesResolver: (o, u) => {
+ const {
+ ownerState: s
+ } = o;
+ return [u.circle, u[`circle${I2(s.variant)}`], s.disableShrink && u.circleDisableShrink];
+ }
+})(st(({
+ theme: o
+}) => ({
+ stroke: "currentColor",
+ variants: [{
+ props: {
+ variant: "determinate"
+ },
+ style: {
+ transition: o.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: u
+ }) => u.variant === "indeterminate" && !u.disableShrink,
+ style: Kw || {
+ // At runtime for Pigment CSS, `bufferAnimation` will be null and the generated keyframe will be used.
+ animation: `${sC} 1.4s ease-in-out infinite`
+ }
+ }]
+}))), t_ = pe("circle", {
+ name: "MuiCircularProgress",
+ slot: "Track"
+})(st(({
+ theme: o
+}) => ({
+ stroke: "currentColor",
+ opacity: (o.vars || o).palette.action.activatedOpacity
+}))), $i = /* @__PURE__ */ V.forwardRef(function(u, s) {
+ const d = U0({
+ props: u,
+ name: "MuiCircularProgress"
+ }), {
+ className: m,
+ color: y = "primary",
+ disableShrink: b = !1,
+ enableTrackSlot: S = !1,
+ size: T = 40,
+ style: x,
+ thickness: M = 3.6,
+ value: A = 0,
+ variant: R = "indeterminate",
+ ..._
+ } = d, B = {
+ ...d,
+ color: y,
+ disableShrink: b,
+ size: T,
+ thickness: M,
+ value: A,
+ variant: R,
+ enableTrackSlot: S
+ }, z = Jw(B), q = {}, Z = {}, F = {};
+ if (R === "determinate") {
+ const G = 2 * Math.PI * ((Y8 - M) / 2);
+ q.strokeDasharray = G.toFixed(3), F["aria-valuenow"] = Math.round(A), q.strokeDashoffset = `${((100 - A) / 100 * G).toFixed(3)}px`, Z.transform = "rotate(-90deg)";
+ }
+ return /* @__PURE__ */ Y.jsx(Fw, {
+ className: Ce(z.root, m),
+ style: {
+ width: T,
+ height: T,
+ ...Z,
+ ...x
+ },
+ ownerState: B,
+ ref: s,
+ role: "progressbar",
+ ...F,
+ ..._,
+ children: /* @__PURE__ */ Y.jsxs(Ww, {
+ className: z.svg,
+ ownerState: B,
+ viewBox: `${Y8 / 2} ${Y8 / 2} ${Y8} ${Y8}`,
+ children: [S ? /* @__PURE__ */ Y.jsx(t_, {
+ className: z.track,
+ ownerState: B,
+ cx: Y8,
+ cy: Y8,
+ r: (Y8 - M) / 2,
+ fill: "none",
+ strokeWidth: M,
+ "aria-hidden": "true"
+ }) : null, /* @__PURE__ */ Y.jsx(e_, {
+ className: z.circle,
+ style: q,
+ ownerState: B,
+ cx: Y8,
+ cy: Y8,
+ r: (Y8 - M) / 2,
+ fill: "none",
+ strokeWidth: M
+ })]
+ })
+ });
+});
+process.env.NODE_ENV !== "production" && ($i.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: h.object,
+ /**
+ * @ignore
+ */
+ className: h.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: h.oneOfType([h.oneOf(["inherit", "primary", "secondary", "error", "info", "success", "warning"]), h.string]),
+ /**
+ * If `true`, the shrink animation is disabled.
+ * This only works if variant is `indeterminate`.
+ * @default false
+ */
+ disableShrink: Vo(h.bool, (o) => o.disableShrink && o.variant && o.variant !== "indeterminate" ? new Error("MUI: You have provided the `disableShrink` prop with a variant other than `indeterminate`. This will have no effect.") : null),
+ /**
+ * If `true`, a track circle slot is mounted to show a subtle background for the progress.
+ * The `size` and `thickness` apply to the track slot to be consistent with the progress circle.
+ * @default false
+ */
+ enableTrackSlot: h.bool,
+ /**
+ * 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: h.oneOfType([h.number, h.string]),
+ /**
+ * @ignore
+ */
+ style: h.object,
+ /**
+ * The system prop that allows defining system overrides as well as additional CSS styles.
+ */
+ sx: h.oneOfType([h.arrayOf(h.oneOfType([h.func, h.object, h.bool])), h.func, h.object]),
+ /**
+ * The thickness of the circle.
+ * @default 3.6
+ */
+ thickness: h.number,
+ /**
+ * The value of the progress indicator for the determinate variant.
+ * Value between 0 and 100.
+ * @default 0
+ */
+ value: h.number,
+ /**
+ * The variant to use.
+ * Use indeterminate when there is no progress value.
+ * @default 'indeterminate'
+ */
+ variant: h.oneOf(["determinate", "indeterminate"])
+});
+function n_(o) {
+ return j0("MuiIconButton", o);
+}
+const Tb = Z0("MuiIconButton", ["root", "disabled", "colorInherit", "colorPrimary", "colorSecondary", "colorError", "colorInfo", "colorSuccess", "colorWarning", "edgeStart", "edgeEnd", "sizeSmall", "sizeMedium", "sizeLarge", "loading", "loadingIndicator", "loadingWrapper"]), a_ = (o) => {
+ const {
+ classes: u,
+ disabled: s,
+ color: d,
+ edge: m,
+ size: y,
+ loading: b
+ } = o, S = {
+ root: ["root", b && "loading", s && "disabled", d !== "default" && `color${I2(d)}`, m && `edge${I2(m)}`, `size${I2(y)}`],
+ loadingIndicator: ["loadingIndicator"],
+ loadingWrapper: ["loadingWrapper"]
+ };
+ return I0(S, n_, u);
+}, l_ = pe(Bo, {
+ name: "MuiIconButton",
+ slot: "Root",
+ overridesResolver: (o, u) => {
+ const {
+ ownerState: s
+ } = o;
+ return [u.root, s.loading && u.loading, s.color !== "default" && u[`color${I2(s.color)}`], s.edge && u[`edge${I2(s.edge)}`], u[`size${I2(s.size)}`]];
+ }
+})(st(({
+ theme: o
+}) => ({
+ textAlign: "center",
+ flex: "0 0 auto",
+ fontSize: o.typography.pxToRem(24),
+ padding: 8,
+ borderRadius: "50%",
+ color: (o.vars || o).palette.action.active,
+ transition: o.transitions.create("background-color", {
+ duration: o.transitions.duration.shortest
+ }),
+ variants: [{
+ props: (u) => !u.disableRipple,
+ style: {
+ "--IconButton-hoverBg": o.alpha((o.vars || o).palette.action.active, (o.vars || o).palette.action.hoverOpacity),
+ "&:hover": {
+ backgroundColor: "var(--IconButton-hoverBg)",
+ // Reset on touch devices, it doesn't add specificity
+ "@media (hover: none)": {
+ backgroundColor: "transparent"
+ }
+ }
+ }
+ }, {
+ props: {
+ edge: "start"
+ },
+ style: {
+ marginLeft: -12
+ }
+ }, {
+ props: {
+ edge: "start",
+ size: "small"
+ },
+ style: {
+ marginLeft: -3
+ }
+ }, {
+ props: {
+ edge: "end"
+ },
+ style: {
+ marginRight: -12
+ }
+ }, {
+ props: {
+ edge: "end",
+ size: "small"
+ },
+ style: {
+ marginRight: -3
+ }
+ }]
+})), st(({
+ theme: o
+}) => ({
+ variants: [{
+ props: {
+ color: "inherit"
+ },
+ style: {
+ color: "inherit"
+ }
+ }, ...Object.entries(o.palette).filter(fn()).map(([u]) => ({
+ props: {
+ color: u
+ },
+ style: {
+ color: (o.vars || o).palette[u].main
+ }
+ })), ...Object.entries(o.palette).filter(fn()).map(([u]) => ({
+ props: {
+ color: u
+ },
+ style: {
+ "--IconButton-hoverBg": o.alpha((o.vars || o).palette[u].main, (o.vars || o).palette.action.hoverOpacity)
+ }
+ })), {
+ props: {
+ size: "small"
+ },
+ style: {
+ padding: 5,
+ fontSize: o.typography.pxToRem(18)
+ }
+ }, {
+ props: {
+ size: "large"
+ },
+ style: {
+ padding: 12,
+ fontSize: o.typography.pxToRem(28)
+ }
+ }],
+ [`&.${Tb.disabled}`]: {
+ backgroundColor: "transparent",
+ color: (o.vars || o).palette.action.disabled
+ },
+ [`&.${Tb.loading}`]: {
+ color: "transparent"
+ }
+}))), o_ = pe("span", {
+ name: "MuiIconButton",
+ slot: "LoadingIndicator"
+})(({
+ theme: o
+}) => ({
+ display: "none",
+ position: "absolute",
+ visibility: "visible",
+ top: "50%",
+ left: "50%",
+ transform: "translate(-50%, -50%)",
+ color: (o.vars || o).palette.action.disabled,
+ variants: [{
+ props: {
+ loading: !0
+ },
+ style: {
+ display: "flex"
+ }
+ }]
+})), gE = /* @__PURE__ */ V.forwardRef(function(u, s) {
+ const d = U0({
+ props: u,
+ name: "MuiIconButton"
+ }), {
+ edge: m = !1,
+ children: y,
+ className: b,
+ color: S = "default",
+ disabled: T = !1,
+ disableFocusRipple: x = !1,
+ size: M = "medium",
+ id: A,
+ loading: R = null,
+ loadingIndicator: _,
+ ...B
+ } = d, z = qp(A), q = _ ?? /* @__PURE__ */ Y.jsx($i, {
+ "aria-labelledby": z,
+ color: "inherit",
+ size: 16
+ }), Z = {
+ ...d,
+ edge: m,
+ color: S,
+ disabled: T,
+ disableFocusRipple: x,
+ loading: R,
+ loadingIndicator: q,
+ size: M
+ }, F = a_(Z);
+ return /* @__PURE__ */ Y.jsxs(l_, {
+ id: R ? z : A,
+ className: Ce(F.root, b),
+ centerRipple: !0,
+ focusRipple: !x,
+ disabled: T || R,
+ ref: s,
+ ...B,
+ ownerState: Z,
+ children: [typeof R == "boolean" && // use plain HTML span to minimize the runtime overhead
+ /* @__PURE__ */ Y.jsx("span", {
+ className: F.loadingWrapper,
+ style: {
+ display: "contents"
+ },
+ children: /* @__PURE__ */ Y.jsx(o_, {
+ className: F.loadingIndicator,
+ ownerState: Z,
+ children: R && q
+ })
+ }), y]
+ });
+});
+process.env.NODE_ENV !== "production" && (gE.propTypes = {
+ // ┌────────────────────────────── Warning ──────────────────────────────┐
+ // │ These PropTypes are generated from the TypeScript type definitions. │
+ // │ To update them, edit the d.ts file and run `pnpm proptypes`. │
+ // └─────────────────────────────────────────────────────────────────────┘
+ /**
+ * The icon to display.
+ */
+ children: Vo(h.node, (o) => V.Children.toArray(o.children).some((s) => /* @__PURE__ */ V.isValidElement(s) && s.props.onClick) ? new Error(["MUI: You are providing an onClick event listener to a child of a button element.", "Prefer applying it to the IconButton directly.", "This guarantees that the whole