@evolver-fi/evolver-basics-admin-components 0.0.8

package/dist/TriggerablesRoute-i4z1o99f.js

@@ -0,0 +1,3536 @@
+import { j as p } from "./jsx-runtime-B6kdoens.js";
+import * as m from "react";
+import Z, { Children as an, isValidElement as Se, cloneElement as Re, useState as Ne } from "react";
+import { Card as ln, CardHeader as cn, CircularProgress as un, CardContent as ct, Typography as ce, CardActions as dn, Tooltip as ut, IconButton as dt, Collapse as pn, Box as fn, TextField as gn, Button as hn } from "@mui/material";
+import { P as t, _ as f, B as w, g as we, c as Me, a as Nt, r as mn, i as vn, C as bn, D as A, E as Oe, F as xn, G as yn, H as X, I as J, J as P, K as $e, L as Y, M as Q, N as Ot, O as En, Q as Ee, U as K, d as ve, V as pt, W as ft, X as $t, Y as Tn, Z as ke, $ as Ye, a0 as Cn, a1 as Sn, a2 as Rn } from "./createSvgIcon-DHqCx8A0.js";
+import { ThemeContext as Nn, keyframes as Ze } from "@emotion/react";
+import { d as jt } from "./ExpandMore-CCOUGfS4.js";
+import Te from "react-dom";
+import { useNavigate as On, useRevalidator as $n, useLoaderData as jn } from "react-router-dom";
+function Pe(e, n) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...r) {
+    return e(...r) || n(...r);
+  };
+}
+function wn(e) {
+  const {
+    prototype: n = {}
+  } = e;
+  return !!n.isReactComponent;
+}
+function Mn(e, n, o, r, i) {
+  const s = e[n], a = i || n;
+  if (s == 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 s == "function" && !wn(s) && (l = "Did you accidentally provide a plain function component instead?"), l !== void 0 ? new Error(`Invalid ${r} \`${a}\` supplied to \`${o}\`. Expected an element type that can hold a ref. ${l} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const wt = Pe(t.elementType, Mn), kn = t.oneOfType([t.func, t.object]);
+function Pn(e) {
+  const n = typeof e;
+  switch (n) {
+    case "number":
+      return Number.isNaN(e) ? "NaN" : Number.isFinite(e) ? e !== Math.floor(e) ? "float" : "number" : "Infinity";
+    case "object":
+      return e === null ? "null" : e.constructor.name;
+    default:
+      return n;
+  }
+}
+function In(e) {
+  return typeof e == "number" && isFinite(e) && Math.floor(e) === e;
+}
+const Vn = Number.isInteger || In;
+function Mt(e, n, o, r) {
+  const i = e[n];
+  if (i == null || !Vn(i)) {
+    const s = Pn(i);
+    return new RangeError(`Invalid ${r} \`${n}\` of type \`${s}\` supplied to \`${o}\`, expected \`integer\`.`);
+  }
+  return null;
+}
+function kt(e, n, ...o) {
+  return e[n] === void 0 ? null : Mt(e, n, ...o);
+}
+function Ue() {
+  return null;
+}
+kt.isRequired = Mt;
+Ue.isRequired = Ue;
+const An = process.env.NODE_ENV === "production" ? Ue : kt;
+function Dn(e) {
+  return typeof e == "string";
+}
+function Bn(e, n, o) {
+  return e === void 0 || Dn(e) ? n : f({}, n, {
+    ownerState: f({}, n.ownerState, o)
+  });
+}
+function zn(e, n = []) {
+  if (e === void 0)
+    return {};
+  const o = {};
+  return Object.keys(e).filter((r) => r.match(/^on[A-Z]/) && typeof e[r] == "function" && !n.includes(r)).forEach((r) => {
+    o[r] = e[r];
+  }), o;
+}
+function gt(e) {
+  if (e === void 0)
+    return {};
+  const n = {};
+  return Object.keys(e).filter((o) => !(o.match(/^on[A-Z]/) && typeof e[o] == "function")).forEach((o) => {
+    n[o] = e[o];
+  }), n;
+}
+function Ln(e) {
+  const {
+    getSlotProps: n,
+    additionalProps: o,
+    externalSlotProps: r,
+    externalForwardedProps: i,
+    className: s
+  } = e;
+  if (!n) {
+    const x = w(o == null ? void 0 : o.className, s, i == null ? void 0 : i.className, r == null ? void 0 : r.className), y = f({}, o == null ? void 0 : o.style, i == null ? void 0 : i.style, r == null ? void 0 : r.style), E = f({}, o, i, r);
+    return x.length > 0 && (E.className = x), Object.keys(y).length > 0 && (E.style = y), {
+      props: E,
+      internalRef: void 0
+    };
+  }
+  const a = zn(f({}, i, r)), l = gt(r), d = gt(i), c = n(a), u = w(c == null ? void 0 : c.className, o == null ? void 0 : o.className, s, i == null ? void 0 : i.className, r == null ? void 0 : r.className), g = f({}, c == null ? void 0 : c.style, o == null ? void 0 : o.style, i == null ? void 0 : i.style, r == null ? void 0 : r.style), h = f({}, c, o, d, l);
+  return u.length > 0 && (h.className = u), Object.keys(g).length > 0 && (h.style = g), {
+    props: h,
+    internalRef: c.ref
+  };
+}
+function _n(e, n, o) {
+  return typeof e == "function" ? e(n, o) : e;
+}
+const Pt = (e) => (e || we()).get("task/list/active"), Wn = (e, n) => we().get(`task/${e}`), _e = Me("task/fetchActiveTasks", async (e, n) => {
+  const o = await Pt();
+  return o.status !== 200 ? n.rejectWithValue({
+    message: "Failed to fetch task statuses"
+  }) : o.data;
+}), Fn = Me("task/fetchTaskStatus", async (e, n) => {
+  const o = await Wn(e);
+  return o.status !== 200 ? n.rejectWithValue({
+    message: `Failed to fetch task status for ${e}`
+  }) : o.data;
+}), Un = {
+  fetchStatus: "loading"
+};
+Nt({
+  name: "taskStatus",
+  initialState: Un,
+  reducers: {},
+  extraReducers: (e) => {
+    e.addCase(_e.pending, (n) => {
+      n.fetchStatus = "loading", n.fetchError = "undefined";
+    }), e.addCase(_e.fulfilled, (n, { payload: o }) => {
+      let r = {};
+      n.triggeredTaskStatuses && (r = { ...n.triggeredTaskStatuses }), o.forEach((i) => {
+        r[i.id] = i;
+      }), n.activeTaskStatuses = r, n.fetchStatus = "succeeded";
+    }), e.addCase(_e.rejected, (n, { payload: o }) => {
+      o && (n.fetchError = o.message), n.fetchStatus = "failed", n.activeTaskStatuses = void 0;
+    }), e.addCase(Fn.fulfilled, (n, { payload: o }) => {
+      n.triggeredTaskStatuses ? n.triggeredTaskStatuses[o.id] = o : n.triggeredTaskStatuses = { [o.id]: o }, n.activeTaskStatuses ? n.activeTaskStatuses[o.id] = o : n.activeTaskStatuses = { [o.id]: o };
+    });
+  }
+});
+var Je = {}, Gn = vn;
+Object.defineProperty(Je, "__esModule", {
+  value: !0
+});
+var It = Je.default = void 0, qn = Gn(mn()), Hn = p;
+It = Je.default = (0, qn.default)(/* @__PURE__ */ (0, Hn.jsx)("path", {
+  d: "M17 10H7v2h10zm2-7h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2m0 16H5V8h14zm-5-5H7v2h7z"
+}), "EventNote");
+const Kn = ({ taskStatus: e, openMessageChain: n }) => {
+  const [o, r] = Z.useState(!1), i = () => {
+    r(!o);
+  };
+  return p.jsxs(ln, { children: [p.jsx(cn, { title: `#${e.id} ${e.group}`, subheader: e.description, avatar: e.state === "RUNNING" || e.state === "CANCELLING" ? p.jsx(un, {}) : void 0 }), p.jsxs(ct, { children: [p.jsx(ce, { variant: "body2", color: "textSecondary", component: "p", children: `Task state is ${e.state}. ${e.durationMs ? `Run took ${e.durationMs / 1e3} seconds.` : ""}` }), p.jsx(ce, { variant: "body2", color: "textSecondary", component: "p", children: e.message })] }), p.jsxs(dn, { disableSpacing: !0, children: [p.jsx(ut, { title: "Show message chain", children: p.jsx(dt, { "aria-label": "show message chain", onClick: () => {
+    const s = e.metadata.find((a) => a.key === "MessageChainId");
+    s && n(Number(s.value));
+  }, children: p.jsx(It, {}) }) }), p.jsx(ut, { title: o ? "Hide metadata" : "Show metadata", children: p.jsx(dt, { sx: {
+    transform: o ? "rotate(180deg)" : "rotate(0deg)",
+    marginLeft: "auto",
+    transition: "transform duration.shortest",
+    // TODO: create a story and test this
+    display: e.metadata.length ? "flex" : "none"
+  }, onClick: i, "aria-expanded": o, "aria-label": "show metadata", children: p.jsx(jt, {}) }) })] }), p.jsx(pn, { in: o, timeout: "auto", unmountOnExit: !0, children: p.jsxs(ct, { children: [p.jsx(ce, { paragraph: !0, children: "Metadata:" }), e.metadata.map((s) => p.jsxs(ce, { children: [s.key, ": ", s.value] }, `task-status-md-${e.id}-${s.key}`))] }) })] });
+}, Vt = (e) => (e || we()).get("trigger"), Xn = (e) => new URLSearchParams(e), At = (e, n, o) => {
+  const r = we(), i = Xn(n), s = i.toString() ? `?${i.toString()}` : "";
+  return r.post(`trigger/${e}/async${s}`);
+}, We = Me("triggerables/fetchTriggerables", async (e, n) => {
+  const o = await Vt();
+  return o.status !== 200 ? n.rejectWithValue({
+    message: "Failed to fetch triggerables"
+  }) : o.data;
+}), Fe = Me("triggerables/trigger", async ({ triggerName: e, triggerParams: n }, o) => {
+  const r = await At(e, n);
+  return r.status !== 200 ? o.rejectWithValue({
+    message: "Failed to fetch triggerables"
+  }) : r.data;
+}), Yn = {
+  triggerables: {},
+  fetchStatus: "loading"
+};
+Nt({
+  name: "triggerable",
+  initialState: Yn,
+  reducers: {},
+  extraReducers: (e) => {
+    e.addCase(We.pending, (n) => {
+      n.fetchStatus = "loading", n.fetchError = "undefined";
+    }), e.addCase(We.fulfilled, (n, { payload: o }) => {
+      n.triggerables = o, n.fetchStatus = "succeeded";
+    }), e.addCase(We.rejected, (n, { payload: o }) => {
+      o && (n.fetchError = o.message), n.fetchStatus = "failed";
+    }), e.addCase(Fe.pending, (n) => {
+      n.triggerStatus = "loading";
+    }), e.addCase(Fe.fulfilled, (n, { payload: o }) => {
+      n.triggerResponse = o, n.triggerStatus = "succeeded";
+    }), e.addCase(Fe.rejected, (n, { payload: o }) => {
+      o && (n.triggerError = o.message), n.triggerStatus = "failed";
+    });
+  }
+});
+function Zn(e) {
+  return Object.keys(e).length === 0;
+}
+function Jn(e = null) {
+  const n = m.useContext(Nn);
+  return !n || Zn(n) ? e : n;
+}
+const Qn = bn();
+function eo(e = Qn) {
+  return Jn(e);
+}
+const to = ["className", "elementType", "ownerState", "externalForwardedProps", "getSlotOwnerState", "internalForwardedProps"], no = ["component", "slots", "slotProps"], oo = ["component"];
+function Ge(e, n) {
+  const {
+    className: o,
+    elementType: r,
+    ownerState: i,
+    externalForwardedProps: s,
+    getSlotOwnerState: a,
+    internalForwardedProps: l
+  } = n, d = A(n, to), {
+    component: c,
+    slots: u = {
+      [e]: void 0
+    },
+    slotProps: g = {
+      [e]: void 0
+    }
+  } = s, h = A(s, no), x = u[e] || r, y = _n(g[e], i), E = Ln(f({
+    className: o
+  }, d, {
+    externalForwardedProps: e === "root" ? h : void 0,
+    externalSlotProps: y
+  })), {
+    props: {
+      component: $
+    },
+    internalRef: C
+  } = E, M = A(E.props, oo), j = Oe(C, y == null ? void 0 : y.ref, n.ref), v = a ? a(M) : {}, N = f({}, i, v), R = e === "root" ? $ || c : $, O = Bn(x, f({}, e === "root" && !c && !u[e] && l, e !== "root" && !u[e] && l, M, R && {
+    as: R
+  }, {
+    ref: j
+  }), N);
+  return Object.keys(v).forEach((k) => {
+    delete O[k];
+  }), [x, O];
+}
+const ht = (e) => {
+  let n;
+  return e < 1 ? n = 5.11916 * e ** 2 : n = 4.5 * Math.log(e + 1) + 2, (n / 100).toFixed(2);
+};
+function Qe() {
+  const e = eo(yn);
+  return process.env.NODE_ENV !== "production" && m.useDebugValue(e), e[xn] || e;
+}
+function ro(e) {
+  return J("MuiPaper", e);
+}
+X("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 so = ["className", "component", "elevation", "square", "variant"], io = (e) => {
+  const {
+    square: n,
+    elevation: o,
+    variant: r,
+    classes: i
+  } = e, s = {
+    root: ["root", r, !n && "rounded", r === "elevation" && `elevation${o}`]
+  };
+  return Q(s, ro, i);
+}, ao = P("div", {
+  name: "MuiPaper",
+  slot: "Root",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: o
+    } = e;
+    return [n.root, n[o.variant], !o.square && n.rounded, o.variant === "elevation" && n[`elevation${o.elevation}`]];
+  }
+})(({
+  theme: e,
+  ownerState: n
+}) => {
+  var o;
+  return f({
+    backgroundColor: (e.vars || e).palette.background.paper,
+    color: (e.vars || e).palette.text.primary,
+    transition: e.transitions.create("box-shadow")
+  }, !n.square && {
+    borderRadius: e.shape.borderRadius
+  }, n.variant === "outlined" && {
+    border: `1px solid ${(e.vars || e).palette.divider}`
+  }, n.variant === "elevation" && f({
+    boxShadow: (e.vars || e).shadows[n.elevation]
+  }, !e.vars && e.palette.mode === "dark" && {
+    backgroundImage: `linear-gradient(${$e("#fff", ht(n.elevation))}, ${$e("#fff", ht(n.elevation))})`
+  }, e.vars && {
+    backgroundImage: (o = e.vars.overlays) == null ? void 0 : o[n.elevation]
+  }));
+}), et = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiPaper"
+  }), {
+    className: i,
+    component: s = "div",
+    elevation: a = 1,
+    square: l = !1,
+    variant: d = "elevation"
+  } = r, c = A(r, so), u = f({}, r, {
+    component: s,
+    elevation: a,
+    square: l,
+    variant: d
+  }), g = io(u);
+  return process.env.NODE_ENV !== "production" && Qe().shadows[a] === void 0 && console.error([`MUI: The elevation provided <Paper elevation={${a}}> is not available in the theme.`, `Please make sure that \`theme.shadows[${a}]\` is defined.`].join(`
+`)), /* @__PURE__ */ p.jsx(ao, f({
+    as: s,
+    ownerState: u,
+    className: w(g.root, i),
+    ref: o
+  }, c));
+});
+process.env.NODE_ENV !== "production" && (et.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: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: t.elementType,
+  /**
+   * Shadow depth, corresponds to `dp` in the spec.
+   * It accepts values between 0 and 24 inclusive.
+   * @default 1
+   */
+  elevation: Pe(An, (e) => {
+    const {
+      elevation: n,
+      variant: o
+    } = e;
+    return n > 0 && o === "outlined" ? new Error(`MUI: Combining \`elevation={${n}}\` with \`variant="${o}"\` has no effect. Either use \`elevation={0}\` or use a different \`variant\`.`) : null;
+  }),
+  /**
+   * If `true`, rounded corners are disabled.
+   * @default false
+   */
+  square: t.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * The variant to use.
+   * @default 'elevation'
+   */
+  variant: t.oneOfType([t.oneOf(["elevation", "outlined"]), t.string])
+});
+function lo(e) {
+  return J("MuiAlert", e);
+}
+const mt = X("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 qe(e, n) {
+  return qe = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, r) {
+    return o.__proto__ = r, o;
+  }, qe(e, n);
+}
+function Dt(e, n) {
+  e.prototype = Object.create(n.prototype), e.prototype.constructor = e, qe(e, n);
+}
+const vt = {
+  disabled: !1
+};
+var co = process.env.NODE_ENV !== "production" ? t.oneOfType([t.number, t.shape({
+  enter: t.number,
+  exit: t.number,
+  appear: t.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && t.oneOfType([t.string, t.shape({
+  enter: t.string,
+  exit: t.string,
+  active: t.string
+}), t.shape({
+  enter: t.string,
+  enterDone: t.string,
+  enterActive: t.string,
+  exit: t.string,
+  exitDone: t.string,
+  exitActive: t.string
+})]);
+const je = Z.createContext(null);
+var uo = function(n) {
+  return n.scrollTop;
+}, he = "unmounted", ne = "exited", oe = "entering", le = "entered", He = "exiting", te = /* @__PURE__ */ function(e) {
+  Dt(n, e);
+  function n(r, i) {
+    var s;
+    s = e.call(this, r, i) || this;
+    var a = i, l = a && !a.isMounting ? r.enter : r.appear, d;
+    return s.appearStatus = null, r.in ? l ? (d = ne, s.appearStatus = oe) : d = le : r.unmountOnExit || r.mountOnEnter ? d = he : d = ne, s.state = {
+      status: d
+    }, s.nextCallback = null, s;
+  }
+  n.getDerivedStateFromProps = function(i, s) {
+    var a = i.in;
+    return a && s.status === he ? {
+      status: ne
+    } : null;
+  };
+  var o = n.prototype;
+  return o.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, o.componentDidUpdate = function(i) {
+    var s = null;
+    if (i !== this.props) {
+      var a = this.state.status;
+      this.props.in ? a !== oe && a !== le && (s = oe) : (a === oe || a === le) && (s = He);
+    }
+    this.updateStatus(!1, s);
+  }, o.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, o.getTimeouts = function() {
+    var i = this.props.timeout, s, a, l;
+    return s = a = l = i, i != null && typeof i != "number" && (s = i.exit, a = i.enter, l = i.appear !== void 0 ? i.appear : a), {
+      exit: s,
+      enter: a,
+      appear: l
+    };
+  }, o.updateStatus = function(i, s) {
+    if (i === void 0 && (i = !1), s !== null)
+      if (this.cancelNextCallback(), s === oe) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var a = this.props.nodeRef ? this.props.nodeRef.current : Te.findDOMNode(this);
+          a && uo(a);
+        }
+        this.performEnter(i);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === ne && this.setState({
+      status: he
+    });
+  }, o.performEnter = function(i) {
+    var s = this, a = this.props.enter, l = this.context ? this.context.isMounting : i, d = this.props.nodeRef ? [l] : [Te.findDOMNode(this), l], c = d[0], u = d[1], g = this.getTimeouts(), h = l ? g.appear : g.enter;
+    if (!i && !a || vt.disabled) {
+      this.safeSetState({
+        status: le
+      }, function() {
+        s.props.onEntered(c);
+      });
+      return;
+    }
+    this.props.onEnter(c, u), this.safeSetState({
+      status: oe
+    }, function() {
+      s.props.onEntering(c, u), s.onTransitionEnd(h, function() {
+        s.safeSetState({
+          status: le
+        }, function() {
+          s.props.onEntered(c, u);
+        });
+      });
+    });
+  }, o.performExit = function() {
+    var i = this, s = this.props.exit, a = this.getTimeouts(), l = this.props.nodeRef ? void 0 : Te.findDOMNode(this);
+    if (!s || vt.disabled) {
+      this.safeSetState({
+        status: ne
+      }, function() {
+        i.props.onExited(l);
+      });
+      return;
+    }
+    this.props.onExit(l), this.safeSetState({
+      status: He
+    }, function() {
+      i.props.onExiting(l), i.onTransitionEnd(a.exit, function() {
+        i.safeSetState({
+          status: ne
+        }, function() {
+          i.props.onExited(l);
+        });
+      });
+    });
+  }, o.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, o.safeSetState = function(i, s) {
+    s = this.setNextCallback(s), this.setState(i, s);
+  }, o.setNextCallback = function(i) {
+    var s = this, a = !0;
+    return this.nextCallback = function(l) {
+      a && (a = !1, s.nextCallback = null, i(l));
+    }, this.nextCallback.cancel = function() {
+      a = !1;
+    }, this.nextCallback;
+  }, o.onTransitionEnd = function(i, s) {
+    this.setNextCallback(s);
+    var a = this.props.nodeRef ? this.props.nodeRef.current : Te.findDOMNode(this), l = i == null && !this.props.addEndListener;
+    if (!a || l) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var d = this.props.nodeRef ? [this.nextCallback] : [a, this.nextCallback], c = d[0], u = d[1];
+      this.props.addEndListener(c, u);
+    }
+    i != null && setTimeout(this.nextCallback, i);
+  }, o.render = function() {
+    var i = this.state.status;
+    if (i === he)
+      return null;
+    var s = this.props, a = s.children;
+    s.in, s.mountOnEnter, s.unmountOnExit, s.appear, s.enter, s.exit, s.timeout, s.addEndListener, s.onEnter, s.onEntering, s.onEntered, s.onExit, s.onExiting, s.onExited, s.nodeRef;
+    var l = A(s, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ Z.createElement(je.Provider, {
+        value: null
+      }, typeof a == "function" ? a(i, l) : Z.cloneElement(Z.Children.only(a), l))
+    );
+  }, n;
+}(Z.Component);
+te.contextType = je;
+te.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: t.shape({
+    current: typeof Element > "u" ? t.any : function(e, n, o, r, i, s) {
+      var a = e[n];
+      return t.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(e, n, o, r, i, s);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: t.oneOfType([t.func.isRequired, t.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: t.bool,
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: t.bool,
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: t.bool,
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: t.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: t.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: t.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function(n) {
+    var o = co;
+    n.addEndListener || (o = o.isRequired);
+    for (var r = arguments.length, i = new Array(r > 1 ? r - 1 : 0), s = 1; s < r; s++)
+      i[s - 1] = arguments[s];
+    return o.apply(void 0, [n].concat(i));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: t.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: t.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: t.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: t.func,
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: t.func,
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: t.func,
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: t.func
+} : {};
+function ae() {
+}
+te.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: ae,
+  onEntering: ae,
+  onEntered: ae,
+  onExit: ae,
+  onExiting: ae,
+  onExited: ae
+};
+te.UNMOUNTED = he;
+te.EXITED = ne;
+te.ENTERING = oe;
+te.ENTERED = le;
+te.EXITING = He;
+function po(e) {
+  if (e === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function tt(e, n) {
+  var o = function(s) {
+    return n && Se(s) ? n(s) : s;
+  }, r = /* @__PURE__ */ Object.create(null);
+  return e && an.map(e, function(i) {
+    return i;
+  }).forEach(function(i) {
+    r[i.key] = o(i);
+  }), r;
+}
+function fo(e, n) {
+  e = e || {}, n = n || {};
+  function o(u) {
+    return u in n ? n[u] : e[u];
+  }
+  var r = /* @__PURE__ */ Object.create(null), i = [];
+  for (var s in e)
+    s in n ? i.length && (r[s] = i, i = []) : i.push(s);
+  var a, l = {};
+  for (var d in n) {
+    if (r[d])
+      for (a = 0; a < r[d].length; a++) {
+        var c = r[d][a];
+        l[r[d][a]] = o(c);
+      }
+    l[d] = o(d);
+  }
+  for (a = 0; a < i.length; a++)
+    l[i[a]] = o(i[a]);
+  return l;
+}
+function re(e, n, o) {
+  return o[n] != null ? o[n] : e.props[n];
+}
+function go(e, n) {
+  return tt(e.children, function(o) {
+    return Re(o, {
+      onExited: n.bind(null, o),
+      in: !0,
+      appear: re(o, "appear", e),
+      enter: re(o, "enter", e),
+      exit: re(o, "exit", e)
+    });
+  });
+}
+function ho(e, n, o) {
+  var r = tt(e.children), i = fo(n, r);
+  return Object.keys(i).forEach(function(s) {
+    var a = i[s];
+    if (Se(a)) {
+      var l = s in n, d = s in r, c = n[s], u = Se(c) && !c.props.in;
+      d && (!l || u) ? i[s] = Re(a, {
+        onExited: o.bind(null, a),
+        in: !0,
+        exit: re(a, "exit", e),
+        enter: re(a, "enter", e)
+      }) : !d && l && !u ? i[s] = Re(a, {
+        in: !1
+      }) : d && l && Se(c) && (i[s] = Re(a, {
+        onExited: o.bind(null, a),
+        in: c.props.in,
+        exit: re(a, "exit", e),
+        enter: re(a, "enter", e)
+      }));
+    }
+  }), i;
+}
+var mo = Object.values || function(e) {
+  return Object.keys(e).map(function(n) {
+    return e[n];
+  });
+}, vo = {
+  component: "div",
+  childFactory: function(n) {
+    return n;
+  }
+}, nt = /* @__PURE__ */ function(e) {
+  Dt(n, e);
+  function n(r, i) {
+    var s;
+    s = e.call(this, r, i) || this;
+    var a = s.handleExited.bind(po(s));
+    return s.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: a,
+      firstRender: !0
+    }, s;
+  }
+  var o = n.prototype;
+  return o.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, o.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, n.getDerivedStateFromProps = function(i, s) {
+    var a = s.children, l = s.handleExited, d = s.firstRender;
+    return {
+      children: d ? go(i, l) : ho(i, a, l),
+      firstRender: !1
+    };
+  }, o.handleExited = function(i, s) {
+    var a = tt(this.props.children);
+    i.key in a || (i.props.onExited && i.props.onExited(s), this.mounted && this.setState(function(l) {
+      var d = f({}, l.children);
+      return delete d[i.key], {
+        children: d
+      };
+    }));
+  }, o.render = function() {
+    var i = this.props, s = i.component, a = i.childFactory, l = A(i, ["component", "childFactory"]), d = this.state.contextValue, c = mo(this.state.children).map(a);
+    return delete l.appear, delete l.enter, delete l.exit, s === null ? /* @__PURE__ */ Z.createElement(je.Provider, {
+      value: d
+    }, c) : /* @__PURE__ */ Z.createElement(je.Provider, {
+      value: d
+    }, /* @__PURE__ */ Z.createElement(s, l, c));
+  }, n;
+}(Z.Component);
+nt.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: t.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: t.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: t.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: t.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: t.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: t.func
+} : {};
+nt.defaultProps = vo;
+function Bt(e) {
+  const {
+    className: n,
+    classes: o,
+    pulsate: r = !1,
+    rippleX: i,
+    rippleY: s,
+    rippleSize: a,
+    in: l,
+    onExited: d,
+    timeout: c
+  } = e, [u, g] = m.useState(!1), h = w(n, o.ripple, o.rippleVisible, r && o.ripplePulsate), x = {
+    width: a,
+    height: a,
+    top: -(a / 2) + s,
+    left: -(a / 2) + i
+  }, y = w(o.child, u && o.childLeaving, r && o.childPulsate);
+  return !l && !u && g(!0), m.useEffect(() => {
+    if (!l && d != null) {
+      const E = setTimeout(d, c);
+      return () => {
+        clearTimeout(E);
+      };
+    }
+  }, [d, l, c]), /* @__PURE__ */ p.jsx("span", {
+    className: h,
+    style: x,
+    children: /* @__PURE__ */ p.jsx("span", {
+      className: y
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (Bt.propTypes = {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object.isRequired,
+  className: t.string,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  in: t.bool,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  onExited: t.func,
+  /**
+   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+   */
+  pulsate: t.bool,
+  /**
+   * Diameter of the ripple.
+   */
+  rippleSize: t.number,
+  /**
+   * Horizontal position of the ripple center.
+   */
+  rippleX: t.number,
+  /**
+   * Vertical position of the ripple center.
+   */
+  rippleY: t.number,
+  /**
+   * exit delay
+   */
+  timeout: t.number.isRequired
+});
+const q = X("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), bo = ["center", "classes", "className"];
+let Ie = (e) => e, bt, xt, yt, Et;
+const Ke = 550, xo = 80, yo = Ze(bt || (bt = Ie`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`)), Eo = Ze(xt || (xt = Ie`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`)), To = Ze(yt || (yt = Ie`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`)), Co = P("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), So = P(Bt, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})(Et || (Et = Ie`
+  opacity: 0;
+  position: absolute;
+
+  &.${0} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${0};
+    animation-duration: ${0}ms;
+    animation-timing-function: ${0};
+  }
+
+  &.${0} {
+    animation-duration: ${0}ms;
+  }
+
+  & .${0} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${0} {
+    opacity: 0;
+    animation-name: ${0};
+    animation-duration: ${0}ms;
+    animation-timing-function: ${0};
+  }
+
+  & .${0} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${0};
+    animation-duration: 2500ms;
+    animation-timing-function: ${0};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`), q.rippleVisible, yo, Ke, ({
+  theme: e
+}) => e.transitions.easing.easeInOut, q.ripplePulsate, ({
+  theme: e
+}) => e.transitions.duration.shorter, q.child, q.childLeaving, Eo, Ke, ({
+  theme: e
+}) => e.transitions.easing.easeInOut, q.childPulsate, To, ({
+  theme: e
+}) => e.transitions.easing.easeInOut), zt = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiTouchRipple"
+  }), {
+    center: i = !1,
+    classes: s = {},
+    className: a
+  } = r, l = A(r, bo), [d, c] = m.useState([]), u = m.useRef(0), g = m.useRef(null);
+  m.useEffect(() => {
+    g.current && (g.current(), g.current = null);
+  }, [d]);
+  const h = m.useRef(!1), x = Ot(), y = m.useRef(null), E = m.useRef(null), $ = m.useCallback((v) => {
+    const {
+      pulsate: N,
+      rippleX: R,
+      rippleY: O,
+      rippleSize: k,
+      cb: W
+    } = v;
+    c((S) => [...S, /* @__PURE__ */ p.jsx(So, {
+      classes: {
+        ripple: w(s.ripple, q.ripple),
+        rippleVisible: w(s.rippleVisible, q.rippleVisible),
+        ripplePulsate: w(s.ripplePulsate, q.ripplePulsate),
+        child: w(s.child, q.child),
+        childLeaving: w(s.childLeaving, q.childLeaving),
+        childPulsate: w(s.childPulsate, q.childPulsate)
+      },
+      timeout: Ke,
+      pulsate: N,
+      rippleX: R,
+      rippleY: O,
+      rippleSize: k
+    }, u.current)]), u.current += 1, g.current = W;
+  }, [s]), C = m.useCallback((v = {}, N = {}, R = () => {
+  }) => {
+    const {
+      pulsate: O = !1,
+      center: k = i || N.pulsate,
+      fakeElement: W = !1
+      // For test purposes
+    } = N;
+    if ((v == null ? void 0 : v.type) === "mousedown" && h.current) {
+      h.current = !1;
+      return;
+    }
+    (v == null ? void 0 : v.type) === "touchstart" && (h.current = !0);
+    const S = W ? null : E.current, z = S ? S.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let I, V, L;
+    if (k || v === void 0 || v.clientX === 0 && v.clientY === 0 || !v.clientX && !v.touches)
+      I = Math.round(z.width / 2), V = Math.round(z.height / 2);
+    else {
+      const {
+        clientX: U,
+        clientY: H
+      } = v.touches && v.touches.length > 0 ? v.touches[0] : v;
+      I = Math.round(U - z.left), V = Math.round(H - z.top);
+    }
+    if (k)
+      L = Math.sqrt((2 * z.width ** 2 + z.height ** 2) / 3), L % 2 === 0 && (L += 1);
+    else {
+      const U = Math.max(Math.abs((S ? S.clientWidth : 0) - I), I) * 2 + 2, H = Math.max(Math.abs((S ? S.clientHeight : 0) - V), V) * 2 + 2;
+      L = Math.sqrt(U ** 2 + H ** 2);
+    }
+    v != null && v.touches ? y.current === null && (y.current = () => {
+      $({
+        pulsate: O,
+        rippleX: I,
+        rippleY: V,
+        rippleSize: L,
+        cb: R
+      });
+    }, x.start(xo, () => {
+      y.current && (y.current(), y.current = null);
+    })) : $({
+      pulsate: O,
+      rippleX: I,
+      rippleY: V,
+      rippleSize: L,
+      cb: R
+    });
+  }, [i, $, x]), M = m.useCallback(() => {
+    C({}, {
+      pulsate: !0
+    });
+  }, [C]), j = m.useCallback((v, N) => {
+    if (x.clear(), (v == null ? void 0 : v.type) === "touchend" && y.current) {
+      y.current(), y.current = null, x.start(0, () => {
+        j(v, N);
+      });
+      return;
+    }
+    y.current = null, c((R) => R.length > 0 ? R.slice(1) : R), g.current = N;
+  }, [x]);
+  return m.useImperativeHandle(o, () => ({
+    pulsate: M,
+    start: C,
+    stop: j
+  }), [M, C, j]), /* @__PURE__ */ p.jsx(Co, f({
+    className: w(q.root, s.root, a),
+    ref: E
+  }, l, {
+    children: /* @__PURE__ */ p.jsx(nt, {
+      component: null,
+      exit: !0,
+      children: d
+    })
+  }));
+});
+process.env.NODE_ENV !== "production" && (zt.propTypes = {
+  /**
+   * If `true`, the ripple starts at the center of the component
+   * rather than at the point of interaction.
+   */
+  center: t.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string
+});
+function Ro(e) {
+  return J("MuiButtonBase", e);
+}
+const No = X("MuiButtonBase", ["root", "disabled", "focusVisible"]), Oo = ["action", "centerRipple", "children", "className", "component", "disabled", "disableRipple", "disableTouchRipple", "focusRipple", "focusVisibleClassName", "LinkComponent", "onBlur", "onClick", "onContextMenu", "onDragLeave", "onFocus", "onFocusVisible", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseLeave", "onMouseUp", "onTouchEnd", "onTouchMove", "onTouchStart", "tabIndex", "TouchRippleProps", "touchRippleRef", "type"], $o = (e) => {
+  const {
+    disabled: n,
+    focusVisible: o,
+    focusVisibleClassName: r,
+    classes: i
+  } = e, a = Q({
+    root: ["root", n && "disabled", o && "focusVisible"]
+  }, Ro, i);
+  return o && r && (a.root += ` ${r}`), a;
+}, jo = P("button", {
+  name: "MuiButtonBase",
+  slot: "Root",
+  overridesResolver: (e, n) => n.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.
+  },
+  [`&.${No.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), ot = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiButtonBase"
+  }), {
+    action: i,
+    centerRipple: s = !1,
+    children: a,
+    className: l,
+    component: d = "button",
+    disabled: c = !1,
+    disableRipple: u = !1,
+    disableTouchRipple: g = !1,
+    focusRipple: h = !1,
+    LinkComponent: x = "a",
+    onBlur: y,
+    onClick: E,
+    onContextMenu: $,
+    onDragLeave: C,
+    onFocus: M,
+    onFocusVisible: j,
+    onKeyDown: v,
+    onKeyUp: N,
+    onMouseDown: R,
+    onMouseLeave: O,
+    onMouseUp: k,
+    onTouchEnd: W,
+    onTouchMove: S,
+    onTouchStart: z,
+    tabIndex: I = 0,
+    TouchRippleProps: V,
+    touchRippleRef: L,
+    type: U
+  } = r, H = A(r, Oo), G = m.useRef(null), D = m.useRef(null), Ve = Oe(D, L), {
+    isFocusVisibleRef: be,
+    onFocus: Ae,
+    onBlur: De,
+    ref: Be
+  } = En(), [ee, se] = m.useState(!1);
+  c && ee && se(!1), m.useImperativeHandle(i, () => ({
+    focusVisible: () => {
+      se(!0), G.current.focus();
+    }
+  }), []);
+  const [T, _] = m.useState(!1);
+  m.useEffect(() => {
+    _(!0);
+  }, []);
+  const F = T && !u && !c;
+  m.useEffect(() => {
+    ee && h && !u && T && D.current.pulsate();
+  }, [u, h, ee, T]);
+  function B(b, at, sn = g) {
+    return Ee((lt) => (at && at(lt), !sn && D.current && D.current[b](lt), !0));
+  }
+  const ie = B("start", R), xe = B("stop", $), Ht = B("stop", C), Kt = B("stop", k), Xt = B("stop", (b) => {
+    ee && b.preventDefault(), O && O(b);
+  }), Yt = B("start", z), Zt = B("stop", W), Jt = B("stop", S), Qt = B("stop", (b) => {
+    De(b), be.current === !1 && se(!1), y && y(b);
+  }, !1), en = Ee((b) => {
+    G.current || (G.current = b.currentTarget), Ae(b), be.current === !0 && (se(!0), j && j(b)), M && M(b);
+  }), ze = () => {
+    const b = G.current;
+    return d && d !== "button" && !(b.tagName === "A" && b.href);
+  }, Le = m.useRef(!1), tn = Ee((b) => {
+    h && !Le.current && ee && D.current && b.key === " " && (Le.current = !0, D.current.stop(b, () => {
+      D.current.start(b);
+    })), b.target === b.currentTarget && ze() && b.key === " " && b.preventDefault(), v && v(b), b.target === b.currentTarget && ze() && b.key === "Enter" && !c && (b.preventDefault(), E && E(b));
+  }), nn = Ee((b) => {
+    h && b.key === " " && D.current && ee && !b.defaultPrevented && (Le.current = !1, D.current.stop(b, () => {
+      D.current.pulsate(b);
+    })), N && N(b), E && b.target === b.currentTarget && ze() && b.key === " " && !b.defaultPrevented && E(b);
+  });
+  let ye = d;
+  ye === "button" && (H.href || H.to) && (ye = x);
+  const fe = {};
+  ye === "button" ? (fe.type = U === void 0 ? "button" : U, fe.disabled = c) : (!H.href && !H.to && (fe.role = "button"), c && (fe["aria-disabled"] = c));
+  const on = Oe(o, Be, G);
+  process.env.NODE_ENV !== "production" && m.useEffect(() => {
+    F && !D.current && console.error(["MUI: The `component` prop provided to ButtonBase is invalid.", "Please make sure the children prop is rendered in this custom component."].join(`
+`));
+  }, [F]);
+  const it = f({}, r, {
+    centerRipple: s,
+    component: d,
+    disabled: c,
+    disableRipple: u,
+    disableTouchRipple: g,
+    focusRipple: h,
+    tabIndex: I,
+    focusVisible: ee
+  }), rn = $o(it);
+  return /* @__PURE__ */ p.jsxs(jo, f({
+    as: ye,
+    className: w(rn.root, l),
+    ownerState: it,
+    onBlur: Qt,
+    onClick: E,
+    onContextMenu: xe,
+    onFocus: en,
+    onKeyDown: tn,
+    onKeyUp: nn,
+    onMouseDown: ie,
+    onMouseLeave: Xt,
+    onMouseUp: Kt,
+    onDragLeave: Ht,
+    onTouchEnd: Zt,
+    onTouchMove: Jt,
+    onTouchStart: Yt,
+    ref: on,
+    tabIndex: c ? -1 : I,
+    type: U
+  }, fe, H, {
+    children: [a, F ? (
+      /* TouchRipple is only needed client-side, x2 boost on the server. */
+      /* @__PURE__ */ p.jsx(zt, f({
+        ref: Ve,
+        center: s
+      }, V))
+    ) : null]
+  }));
+});
+process.env.NODE_ENV !== "production" && (ot.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: kn,
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: t.bool,
+  /**
+   * The content of the component.
+   */
+  children: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: wt,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: t.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: t.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: t.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: t.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: t.string,
+  /**
+   * @ignore
+   */
+  href: t.any,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: t.elementType,
+  /**
+   * @ignore
+   */
+  onBlur: t.func,
+  /**
+   * @ignore
+   */
+  onClick: t.func,
+  /**
+   * @ignore
+   */
+  onContextMenu: t.func,
+  /**
+   * @ignore
+   */
+  onDragLeave: t.func,
+  /**
+   * @ignore
+   */
+  onFocus: t.func,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: t.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: t.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: t.func,
+  /**
+   * @ignore
+   */
+  onMouseDown: t.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: t.func,
+  /**
+   * @ignore
+   */
+  onMouseUp: t.func,
+  /**
+   * @ignore
+   */
+  onTouchEnd: t.func,
+  /**
+   * @ignore
+   */
+  onTouchMove: t.func,
+  /**
+   * @ignore
+   */
+  onTouchStart: t.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * @default 0
+   */
+  tabIndex: t.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: t.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: t.oneOfType([t.func, t.shape({
+    current: t.shape({
+      pulsate: t.func.isRequired,
+      start: t.func.isRequired,
+      stop: t.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  type: t.oneOfType([t.oneOf(["button", "reset", "submit"]), t.string])
+});
+function wo(e) {
+  return J("MuiIconButton", e);
+}
+const Mo = X("MuiIconButton", ["root", "disabled", "colorInherit", "colorPrimary", "colorSecondary", "colorError", "colorInfo", "colorSuccess", "colorWarning", "edgeStart", "edgeEnd", "sizeSmall", "sizeMedium", "sizeLarge"]), ko = ["edge", "children", "className", "color", "disabled", "disableFocusRipple", "size"], Po = (e) => {
+  const {
+    classes: n,
+    disabled: o,
+    color: r,
+    edge: i,
+    size: s
+  } = e, a = {
+    root: ["root", o && "disabled", r !== "default" && `color${K(r)}`, i && `edge${K(i)}`, `size${K(s)}`]
+  };
+  return Q(a, wo, n);
+}, Io = P(ot, {
+  name: "MuiIconButton",
+  slot: "Root",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: o
+    } = e;
+    return [n.root, o.color !== "default" && n[`color${K(o.color)}`], o.edge && n[`edge${K(o.edge)}`], n[`size${K(o.size)}`]];
+  }
+})(({
+  theme: e,
+  ownerState: n
+}) => f({
+  textAlign: "center",
+  flex: "0 0 auto",
+  fontSize: e.typography.pxToRem(24),
+  padding: 8,
+  borderRadius: "50%",
+  overflow: "visible",
+  // Explicitly set the default value to solve a bug on IE11.
+  color: (e.vars || e).palette.action.active,
+  transition: e.transitions.create("background-color", {
+    duration: e.transitions.duration.shortest
+  })
+}, !n.disableRipple && {
+  "&:hover": {
+    backgroundColor: e.vars ? `rgba(${e.vars.palette.action.activeChannel} / ${e.vars.palette.action.hoverOpacity})` : $e(e.palette.action.active, e.palette.action.hoverOpacity),
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  }
+}, n.edge === "start" && {
+  marginLeft: n.size === "small" ? -3 : -12
+}, n.edge === "end" && {
+  marginRight: n.size === "small" ? -3 : -12
+}), ({
+  theme: e,
+  ownerState: n
+}) => {
+  var o;
+  const r = (o = (e.vars || e).palette) == null ? void 0 : o[n.color];
+  return f({}, n.color === "inherit" && {
+    color: "inherit"
+  }, n.color !== "inherit" && n.color !== "default" && f({
+    color: r == null ? void 0 : r.main
+  }, !n.disableRipple && {
+    "&:hover": f({}, r && {
+      backgroundColor: e.vars ? `rgba(${r.mainChannel} / ${e.vars.palette.action.hoverOpacity})` : $e(r.main, e.palette.action.hoverOpacity)
+    }, {
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: "transparent"
+      }
+    })
+  }), n.size === "small" && {
+    padding: 5,
+    fontSize: e.typography.pxToRem(18)
+  }, n.size === "large" && {
+    padding: 12,
+    fontSize: e.typography.pxToRem(28)
+  }, {
+    [`&.${Mo.disabled}`]: {
+      backgroundColor: "transparent",
+      color: (e.vars || e).palette.action.disabled
+    }
+  });
+}), Lt = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiIconButton"
+  }), {
+    edge: i = !1,
+    children: s,
+    className: a,
+    color: l = "default",
+    disabled: d = !1,
+    disableFocusRipple: c = !1,
+    size: u = "medium"
+  } = r, g = A(r, ko), h = f({}, r, {
+    edge: i,
+    color: l,
+    disabled: d,
+    disableFocusRipple: c,
+    size: u
+  }), x = Po(h);
+  return /* @__PURE__ */ p.jsx(Io, f({
+    className: w(x.root, a),
+    centerRipple: !0,
+    focusRipple: !c,
+    disabled: d,
+    ref: o
+  }, g, {
+    ownerState: h,
+    children: s
+  }));
+});
+process.env.NODE_ENV !== "production" && (Lt.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: Pe(t.node, (e) => m.Children.toArray(e.children).some((o) => /* @__PURE__ */ m.isValidElement(o) && o.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 <button> will be responsive to click events."].join(`
+`)) : null),
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.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 'default'
+   */
+  color: t.oneOfType([t.oneOf(["inherit", "default", "primary", "secondary", "error", "info", "success", "warning"]), t.string]),
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: t.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: t.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: t.bool,
+  /**
+   * If given, uses a negative margin to counteract the padding on one
+   * side (this is often helpful for aligning the left or right
+   * side of the icon with content above or below, without ruining the border
+   * size and shape).
+   * @default false
+   */
+  edge: t.oneOf(["end", "start", !1]),
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense button styling.
+   * @default 'medium'
+   */
+  size: t.oneOfType([t.oneOf(["small", "medium", "large"]), t.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object])
+});
+const Vo = ve(/* @__PURE__ */ p.jsx("path", {
+  d: "M20,12A8,8 0 0,1 12,20A8,8 0 0,1 4,12A8,8 0 0,1 12,4C12.76,4 13.5,4.11 14.2, 4.31L15.77,2.74C14.61,2.26 13.34,2 12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0, 0 22,12M7.91,10.08L6.5,11.5L11,16L21,6L19.59,4.58L11,13.17L7.91,10.08Z"
+}), "SuccessOutlined"), Ao = ve(/* @__PURE__ */ p.jsx("path", {
+  d: "M12 5.99L19.53 19H4.47L12 5.99M12 2L1 21h22L12 2zm1 14h-2v2h2v-2zm0-6h-2v4h2v-4z"
+}), "ReportProblemOutlined"), Do = ve(/* @__PURE__ */ p.jsx("path", {
+  d: "M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"
+}), "ErrorOutline"), Bo = ve(/* @__PURE__ */ p.jsx("path", {
+  d: "M11,9H13V7H11M12,20C7.59,20 4,16.41 4,12C4,7.59 7.59,4 12,4C16.41,4 20,7.59 20, 12C20,16.41 16.41,20 12,20M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10, 10 0 0,0 12,2M11,17H13V11H11V17Z"
+}), "InfoOutlined"), zo = ve(/* @__PURE__ */ p.jsx("path", {
+  d: "M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"
+}), "Close"), Lo = ["action", "children", "className", "closeText", "color", "components", "componentsProps", "icon", "iconMapping", "onClose", "role", "severity", "slotProps", "slots", "variant"], _o = (e) => {
+  const {
+    variant: n,
+    color: o,
+    severity: r,
+    classes: i
+  } = e, s = {
+    root: ["root", `color${K(o || r)}`, `${n}${K(o || r)}`, `${n}`],
+    icon: ["icon"],
+    message: ["message"],
+    action: ["action"]
+  };
+  return Q(s, lo, i);
+}, Wo = P(et, {
+  name: "MuiAlert",
+  slot: "Root",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: o
+    } = e;
+    return [n.root, n[o.variant], n[`${o.variant}${K(o.color || o.severity)}`]];
+  }
+})(({
+  theme: e
+}) => {
+  const n = e.palette.mode === "light" ? pt : ft, o = e.palette.mode === "light" ? ft : pt;
+  return f({}, e.typography.body2, {
+    backgroundColor: "transparent",
+    display: "flex",
+    padding: "6px 16px",
+    variants: [...Object.entries(e.palette).filter(([, r]) => r.main && r.light).map(([r]) => ({
+      props: {
+        colorSeverity: r,
+        variant: "standard"
+      },
+      style: {
+        color: e.vars ? e.vars.palette.Alert[`${r}Color`] : n(e.palette[r].light, 0.6),
+        backgroundColor: e.vars ? e.vars.palette.Alert[`${r}StandardBg`] : o(e.palette[r].light, 0.9),
+        [`& .${mt.icon}`]: e.vars ? {
+          color: e.vars.palette.Alert[`${r}IconColor`]
+        } : {
+          color: e.palette[r].main
+        }
+      }
+    })), ...Object.entries(e.palette).filter(([, r]) => r.main && r.light).map(([r]) => ({
+      props: {
+        colorSeverity: r,
+        variant: "outlined"
+      },
+      style: {
+        color: e.vars ? e.vars.palette.Alert[`${r}Color`] : n(e.palette[r].light, 0.6),
+        border: `1px solid ${(e.vars || e).palette[r].light}`,
+        [`& .${mt.icon}`]: e.vars ? {
+          color: e.vars.palette.Alert[`${r}IconColor`]
+        } : {
+          color: e.palette[r].main
+        }
+      }
+    })), ...Object.entries(e.palette).filter(([, r]) => r.main && r.dark).map(([r]) => ({
+      props: {
+        colorSeverity: r,
+        variant: "filled"
+      },
+      style: f({
+        fontWeight: e.typography.fontWeightMedium
+      }, e.vars ? {
+        color: e.vars.palette.Alert[`${r}FilledColor`],
+        backgroundColor: e.vars.palette.Alert[`${r}FilledBg`]
+      } : {
+        backgroundColor: e.palette.mode === "dark" ? e.palette[r].dark : e.palette[r].main,
+        color: e.palette.getContrastText(e.palette[r].main)
+      })
+    }))]
+  });
+}), Fo = P("div", {
+  name: "MuiAlert",
+  slot: "Icon",
+  overridesResolver: (e, n) => n.icon
+})({
+  marginRight: 12,
+  padding: "7px 0",
+  display: "flex",
+  fontSize: 22,
+  opacity: 0.9
+}), Uo = P("div", {
+  name: "MuiAlert",
+  slot: "Message",
+  overridesResolver: (e, n) => n.message
+})({
+  padding: "8px 0",
+  minWidth: 0,
+  overflow: "auto"
+}), Tt = P("div", {
+  name: "MuiAlert",
+  slot: "Action",
+  overridesResolver: (e, n) => n.action
+})({
+  display: "flex",
+  alignItems: "flex-start",
+  padding: "4px 0 0 16px",
+  marginLeft: "auto",
+  marginRight: -8
+}), Ct = {
+  success: /* @__PURE__ */ p.jsx(Vo, {
+    fontSize: "inherit"
+  }),
+  warning: /* @__PURE__ */ p.jsx(Ao, {
+    fontSize: "inherit"
+  }),
+  error: /* @__PURE__ */ p.jsx(Do, {
+    fontSize: "inherit"
+  }),
+  info: /* @__PURE__ */ p.jsx(Bo, {
+    fontSize: "inherit"
+  })
+}, _t = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiAlert"
+  }), {
+    action: i,
+    children: s,
+    className: a,
+    closeText: l = "Close",
+    color: d,
+    components: c = {},
+    componentsProps: u = {},
+    icon: g,
+    iconMapping: h = Ct,
+    onClose: x,
+    role: y = "alert",
+    severity: E = "success",
+    slotProps: $ = {},
+    slots: C = {},
+    variant: M = "standard"
+  } = r, j = A(r, Lo), v = f({}, r, {
+    color: d,
+    severity: E,
+    variant: M,
+    colorSeverity: d || E
+  }), N = _o(v), R = {
+    slots: f({
+      closeButton: c.CloseButton,
+      closeIcon: c.CloseIcon
+    }, C),
+    slotProps: f({}, u, $)
+  }, [O, k] = Ge("closeButton", {
+    elementType: Lt,
+    externalForwardedProps: R,
+    ownerState: v
+  }), [W, S] = Ge("closeIcon", {
+    elementType: zo,
+    externalForwardedProps: R,
+    ownerState: v
+  });
+  return /* @__PURE__ */ p.jsxs(Wo, f({
+    role: y,
+    elevation: 0,
+    ownerState: v,
+    className: w(N.root, a),
+    ref: o
+  }, j, {
+    children: [g !== !1 ? /* @__PURE__ */ p.jsx(Fo, {
+      ownerState: v,
+      className: N.icon,
+      children: g || h[E] || Ct[E]
+    }) : null, /* @__PURE__ */ p.jsx(Uo, {
+      ownerState: v,
+      className: N.message,
+      children: s
+    }), i != null ? /* @__PURE__ */ p.jsx(Tt, {
+      ownerState: v,
+      className: N.action,
+      children: i
+    }) : null, i == null && x ? /* @__PURE__ */ p.jsx(Tt, {
+      ownerState: v,
+      className: N.action,
+      children: /* @__PURE__ */ p.jsx(O, f({
+        size: "small",
+        "aria-label": l,
+        title: l,
+        color: "inherit",
+        onClick: x
+      }, k, {
+        children: /* @__PURE__ */ p.jsx(W, f({
+          fontSize: "small"
+        }, S))
+      }))
+    }) : null]
+  }));
+});
+process.env.NODE_ENV !== "production" && (_t.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The action to display. It renders after the message, at the end of the alert.
+   */
+  action: t.node,
+  /**
+   * The content of the component.
+   */
+  children: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * Override the default label for the *close popup* icon button.
+   *
+   * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
+   * @default 'Close'
+   */
+  closeText: t.string,
+  /**
+   * The color of the component. Unless provided, the value is taken from the `severity` prop.
+   * 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).
+   */
+  color: t.oneOfType([t.oneOf(["error", "info", "success", "warning"]), t.string]),
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   *
+   * @default {}
+   */
+  components: t.shape({
+    CloseButton: t.elementType,
+    CloseIcon: t.elementType
+  }),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   *
+   * @default {}
+   */
+  componentsProps: t.shape({
+    closeButton: t.object,
+    closeIcon: t.object
+  }),
+  /**
+   * Override the icon displayed before the children.
+   * Unless provided, the icon is mapped to the value of the `severity` prop.
+   * Set to `false` to remove the `icon`.
+   */
+  icon: t.node,
+  /**
+   * The component maps the `severity` prop to a range of different icons,
+   * for instance success to `<SuccessOutlined>`.
+   * If you wish to change this mapping, you can provide your own.
+   * Alternatively, you can use the `icon` prop to override the icon displayed.
+   */
+  iconMapping: t.shape({
+    error: t.node,
+    info: t.node,
+    success: t.node,
+    warning: t.node
+  }),
+  /**
+   * Callback fired when the component requests to be closed.
+   * When provided and no `action` prop is set, a close icon button is displayed that triggers the callback when clicked.
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   */
+  onClose: t.func,
+  /**
+   * The ARIA role attribute of the element.
+   * @default 'alert'
+   */
+  role: t.string,
+  /**
+   * The severity of the alert. This defines the color and icon used.
+   * @default 'success'
+   */
+  severity: t.oneOfType([t.oneOf(["error", "info", "success", "warning"]), t.string]),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: t.shape({
+    closeButton: t.oneOfType([t.func, t.object]),
+    closeIcon: t.oneOfType([t.func, t.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: t.shape({
+    closeButton: t.elementType,
+    closeIcon: t.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * The variant to use.
+   * @default 'standard'
+   */
+  variant: t.oneOfType([t.oneOf(["filled", "outlined", "standard"]), t.string])
+});
+const Go = ({ triggerResponse: e, showNotification: n, onClose: o }) => e && n ? p.jsxs(_t, { onClose: o, sx: { marginBottom: 20 }, elevation: 6, severity: "success", variant: "filled", children: ["Backend response: ", e] }) : null, Xe = /* @__PURE__ */ m.createContext();
+process.env.NODE_ENV !== "production" && (Xe.displayName = "GridContext");
+function qo(e) {
+  return J("MuiGrid", e);
+}
+const Ho = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], Ko = ["column-reverse", "column", "row-reverse", "row"], Xo = ["nowrap", "wrap-reverse", "wrap"], ge = ["auto", !0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], me = X("MuiGrid", [
+  "root",
+  "container",
+  "item",
+  "zeroMinWidth",
+  // spacings
+  ...Ho.map((e) => `spacing-xs-${e}`),
+  // direction values
+  ...Ko.map((e) => `direction-xs-${e}`),
+  // wrap values
+  ...Xo.map((e) => `wrap-xs-${e}`),
+  // grid sizes for all breakpoints
+  ...ge.map((e) => `grid-xs-${e}`),
+  ...ge.map((e) => `grid-sm-${e}`),
+  ...ge.map((e) => `grid-md-${e}`),
+  ...ge.map((e) => `grid-lg-${e}`),
+  ...ge.map((e) => `grid-xl-${e}`)
+]), Yo = ["className", "columns", "columnSpacing", "component", "container", "direction", "item", "rowSpacing", "spacing", "wrap", "zeroMinWidth"];
+function de(e) {
+  const n = parseFloat(e);
+  return `${n}${String(e).replace(String(n), "") || "px"}`;
+}
+function Zo({
+  theme: e,
+  ownerState: n
+}) {
+  let o;
+  return e.breakpoints.keys.reduce((r, i) => {
+    let s = {};
+    if (n[i] && (o = n[i]), !o)
+      return r;
+    if (o === !0)
+      s = {
+        flexBasis: 0,
+        flexGrow: 1,
+        maxWidth: "100%"
+      };
+    else if (o === "auto")
+      s = {
+        flexBasis: "auto",
+        flexGrow: 0,
+        flexShrink: 0,
+        maxWidth: "none",
+        width: "auto"
+      };
+    else {
+      const a = ke({
+        values: n.columns,
+        breakpoints: e.breakpoints.values
+      }), l = typeof a == "object" ? a[i] : a;
+      if (l == null)
+        return r;
+      const d = `${Math.round(o / l * 1e8) / 1e6}%`;
+      let c = {};
+      if (n.container && n.item && n.columnSpacing !== 0) {
+        const u = e.spacing(n.columnSpacing);
+        if (u !== "0px") {
+          const g = `calc(${d} + ${de(u)})`;
+          c = {
+            flexBasis: g,
+            maxWidth: g
+          };
+        }
+      }
+      s = f({
+        flexBasis: d,
+        flexGrow: 0,
+        maxWidth: d
+      }, c);
+    }
+    return e.breakpoints.values[i] === 0 ? Object.assign(r, s) : r[e.breakpoints.up(i)] = s, r;
+  }, {});
+}
+function Jo({
+  theme: e,
+  ownerState: n
+}) {
+  const o = ke({
+    values: n.direction,
+    breakpoints: e.breakpoints.values
+  });
+  return Ye({
+    theme: e
+  }, o, (r) => {
+    const i = {
+      flexDirection: r
+    };
+    return r.indexOf("column") === 0 && (i[`& > .${me.item}`] = {
+      maxWidth: "none"
+    }), i;
+  });
+}
+function Wt({
+  breakpoints: e,
+  values: n
+}) {
+  let o = "";
+  Object.keys(n).forEach((i) => {
+    o === "" && n[i] !== 0 && (o = i);
+  });
+  const r = Object.keys(e).sort((i, s) => e[i] - e[s]);
+  return r.slice(0, r.indexOf(o));
+}
+function Qo({
+  theme: e,
+  ownerState: n
+}) {
+  const {
+    container: o,
+    rowSpacing: r
+  } = n;
+  let i = {};
+  if (o && r !== 0) {
+    const s = ke({
+      values: r,
+      breakpoints: e.breakpoints.values
+    });
+    let a;
+    typeof s == "object" && (a = Wt({
+      breakpoints: e.breakpoints.values,
+      values: s
+    })), i = Ye({
+      theme: e
+    }, s, (l, d) => {
+      var c;
+      const u = e.spacing(l);
+      return u !== "0px" ? {
+        marginTop: `-${de(u)}`,
+        [`& > .${me.item}`]: {
+          paddingTop: de(u)
+        }
+      } : (c = a) != null && c.includes(d) ? {} : {
+        marginTop: 0,
+        [`& > .${me.item}`]: {
+          paddingTop: 0
+        }
+      };
+    });
+  }
+  return i;
+}
+function er({
+  theme: e,
+  ownerState: n
+}) {
+  const {
+    container: o,
+    columnSpacing: r
+  } = n;
+  let i = {};
+  if (o && r !== 0) {
+    const s = ke({
+      values: r,
+      breakpoints: e.breakpoints.values
+    });
+    let a;
+    typeof s == "object" && (a = Wt({
+      breakpoints: e.breakpoints.values,
+      values: s
+    })), i = Ye({
+      theme: e
+    }, s, (l, d) => {
+      var c;
+      const u = e.spacing(l);
+      return u !== "0px" ? {
+        width: `calc(100% + ${de(u)})`,
+        marginLeft: `-${de(u)}`,
+        [`& > .${me.item}`]: {
+          paddingLeft: de(u)
+        }
+      } : (c = a) != null && c.includes(d) ? {} : {
+        width: "100%",
+        marginLeft: 0,
+        [`& > .${me.item}`]: {
+          paddingLeft: 0
+        }
+      };
+    });
+  }
+  return i;
+}
+function tr(e, n, o = {}) {
+  if (!e || e <= 0)
+    return [];
+  if (typeof e == "string" && !Number.isNaN(Number(e)) || typeof e == "number")
+    return [o[`spacing-xs-${String(e)}`]];
+  const r = [];
+  return n.forEach((i) => {
+    const s = e[i];
+    Number(s) > 0 && r.push(o[`spacing-${i}-${String(s)}`]);
+  }), r;
+}
+const nr = P("div", {
+  name: "MuiGrid",
+  slot: "Root",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: o
+    } = e, {
+      container: r,
+      direction: i,
+      item: s,
+      spacing: a,
+      wrap: l,
+      zeroMinWidth: d,
+      breakpoints: c
+    } = o;
+    let u = [];
+    r && (u = tr(a, c, n));
+    const g = [];
+    return c.forEach((h) => {
+      const x = o[h];
+      x && g.push(n[`grid-${h}-${String(x)}`]);
+    }), [n.root, r && n.container, s && n.item, d && n.zeroMinWidth, ...u, i !== "row" && n[`direction-xs-${String(i)}`], l !== "wrap" && n[`wrap-xs-${String(l)}`], ...g];
+  }
+})(({
+  ownerState: e
+}) => f({
+  boxSizing: "border-box"
+}, e.container && {
+  display: "flex",
+  flexWrap: "wrap",
+  width: "100%"
+}, e.item && {
+  margin: 0
+  // For instance, it's useful when used with a `figure` element.
+}, e.zeroMinWidth && {
+  minWidth: 0
+}, e.wrap !== "wrap" && {
+  flexWrap: e.wrap
+}), Jo, Qo, er, Zo);
+function or(e, n) {
+  if (!e || e <= 0)
+    return [];
+  if (typeof e == "string" && !Number.isNaN(Number(e)) || typeof e == "number")
+    return [`spacing-xs-${String(e)}`];
+  const o = [];
+  return n.forEach((r) => {
+    const i = e[r];
+    if (Number(i) > 0) {
+      const s = `spacing-${r}-${String(i)}`;
+      o.push(s);
+    }
+  }), o;
+}
+const rr = (e) => {
+  const {
+    classes: n,
+    container: o,
+    direction: r,
+    item: i,
+    spacing: s,
+    wrap: a,
+    zeroMinWidth: l,
+    breakpoints: d
+  } = e;
+  let c = [];
+  o && (c = or(s, d));
+  const u = [];
+  d.forEach((h) => {
+    const x = e[h];
+    x && u.push(`grid-${h}-${String(x)}`);
+  });
+  const g = {
+    root: ["root", o && "container", i && "item", l && "zeroMinWidth", ...c, r !== "row" && `direction-xs-${String(r)}`, a !== "wrap" && `wrap-xs-${String(a)}`, ...u]
+  };
+  return Q(g, qo, n);
+}, pe = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiGrid"
+  }), {
+    breakpoints: i
+  } = Qe(), s = $t(r), {
+    className: a,
+    columns: l,
+    columnSpacing: d,
+    component: c = "div",
+    container: u = !1,
+    direction: g = "row",
+    item: h = !1,
+    rowSpacing: x,
+    spacing: y = 0,
+    wrap: E = "wrap",
+    zeroMinWidth: $ = !1
+  } = s, C = A(s, Yo), M = x || y, j = d || y, v = m.useContext(Xe), N = u ? l || 12 : v, R = {}, O = f({}, C);
+  i.keys.forEach((S) => {
+    C[S] != null && (R[S] = C[S], delete O[S]);
+  });
+  const k = f({}, s, {
+    columns: N,
+    container: u,
+    direction: g,
+    item: h,
+    rowSpacing: M,
+    columnSpacing: j,
+    wrap: E,
+    zeroMinWidth: $,
+    spacing: y
+  }, R, {
+    breakpoints: i.keys
+  }), W = rr(k);
+  return /* @__PURE__ */ p.jsx(Xe.Provider, {
+    value: N,
+    children: /* @__PURE__ */ p.jsx(nr, f({
+      ownerState: k,
+      className: w(W.root, a),
+      as: c,
+      ref: o
+    }, O))
+  });
+});
+process.env.NODE_ENV !== "production" && (pe.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: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The number of columns.
+   * @default 12
+   */
+  columns: t.oneOfType([t.arrayOf(t.number), t.number, t.object]),
+  /**
+   * Defines the horizontal space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  columnSpacing: t.oneOfType([t.arrayOf(t.oneOfType([t.number, t.string])), t.number, t.object, t.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: t.elementType,
+  /**
+   * If `true`, the component will have the flex *container* behavior.
+   * You should be wrapping *items* with a *container*.
+   * @default false
+   */
+  container: t.bool,
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'row'
+   */
+  direction: t.oneOfType([t.oneOf(["column-reverse", "column", "row-reverse", "row"]), t.arrayOf(t.oneOf(["column-reverse", "column", "row-reverse", "row"])), t.object]),
+  /**
+   * If `true`, the component will have the flex *item* behavior.
+   * You should be wrapping *items* with a *container*.
+   * @default false
+   */
+  item: t.bool,
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `lg` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  lg: t.oneOfType([t.oneOf(["auto"]), t.number, t.bool]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `md` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  md: t.oneOfType([t.oneOf(["auto"]), t.number, t.bool]),
+  /**
+   * Defines the vertical space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  rowSpacing: t.oneOfType([t.arrayOf(t.oneOfType([t.number, t.string])), t.number, t.object, t.string]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `sm` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  sm: t.oneOfType([t.oneOf(["auto"]), t.number, t.bool]),
+  /**
+   * Defines the space between the type `item` components.
+   * It can only be used on a type `container` component.
+   * @default 0
+   */
+  spacing: t.oneOfType([t.arrayOf(t.oneOfType([t.number, t.string])), t.number, t.object, t.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * Defines the `flex-wrap` style property.
+   * It's applied for all screen sizes.
+   * @default 'wrap'
+   */
+  wrap: t.oneOf(["nowrap", "wrap-reverse", "wrap"]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for the `xl` breakpoint and wider screens if not overridden.
+   * @default false
+   */
+  xl: t.oneOfType([t.oneOf(["auto"]), t.number, t.bool]),
+  /**
+   * If a number, it sets the number of columns the grid item uses.
+   * It can't be greater than the total number of columns of the container (12 by default).
+   * If 'auto', the grid item's width matches its content.
+   * If false, the prop is ignored.
+   * If true, the grid item's width grows to use the space available in the grid container.
+   * The value is applied for all the screen sizes with the lowest priority.
+   * @default false
+   */
+  xs: t.oneOfType([t.oneOf(["auto"]), t.number, t.bool]),
+  /**
+   * If `true`, it sets `min-width: 0` on the item.
+   * Refer to the limitations section of the documentation to better understand the use case.
+   * @default false
+   */
+  zeroMinWidth: t.bool
+});
+if (process.env.NODE_ENV !== "production") {
+  const e = Tn("Grid", pe);
+  pe.propTypes = f({}, pe.propTypes, {
+    direction: e("container"),
+    lg: e("item"),
+    md: e("item"),
+    sm: e("item"),
+    spacing: e("container"),
+    wrap: e("container"),
+    xs: e("item"),
+    zeroMinWidth: e("item")
+  });
+}
+const sr = ({ activeTaskStatuses: e, openMessageChain: n }) => e ? p.jsx(pe, { container: !0, spacing: 2, sx: {
+  marginBottom: 20
+}, children: Object.values(e).map((o) => p.jsx(pe, { item: !0, xs: 6, children: p.jsx(Kn, { taskStatus: o, openMessageChain: n }) }, `task-status-grid-item-${o.id}`)) }) : null;
+function St(e, n) {
+  var o, r;
+  const {
+    timeout: i,
+    easing: s,
+    style: a = {}
+  } = e;
+  return {
+    duration: (o = a.transitionDuration) != null ? o : typeof i == "number" ? i : i[n.mode] || 0,
+    easing: (r = a.transitionTimingFunction) != null ? r : typeof s == "object" ? s[n.mode] : s,
+    delay: a.transitionDelay
+  };
+}
+function ir(e) {
+  return J("MuiCollapse", e);
+}
+X("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const ar = ["addEndListener", "children", "className", "collapsedSize", "component", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "orientation", "style", "timeout", "TransitionComponent"], lr = (e) => {
+  const {
+    orientation: n,
+    classes: o
+  } = e, r = {
+    root: ["root", `${n}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${n}`],
+    wrapperInner: ["wrapperInner", `${n}`]
+  };
+  return Q(r, ir, o);
+}, cr = P("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: o
+    } = e;
+    return [n.root, n[o.orientation], o.state === "entered" && n.entered, o.state === "exited" && !o.in && o.collapsedSize === "0px" && n.hidden];
+  }
+})(({
+  theme: e,
+  ownerState: n
+}) => f({
+  height: 0,
+  overflow: "hidden",
+  transition: e.transitions.create("height")
+}, n.orientation === "horizontal" && {
+  height: "auto",
+  width: 0,
+  transition: e.transitions.create("width")
+}, n.state === "entered" && f({
+  height: "auto",
+  overflow: "visible"
+}, n.orientation === "horizontal" && {
+  width: "auto"
+}), n.state === "exited" && !n.in && n.collapsedSize === "0px" && {
+  visibility: "hidden"
+})), ur = P("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper",
+  overridesResolver: (e, n) => n.wrapper
+})(({
+  ownerState: e
+}) => f({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%"
+}, e.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), dr = P("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (e, n) => n.wrapperInner
+})(({
+  ownerState: e
+}) => f({
+  width: "100%"
+}, e.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), rt = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: i,
+    children: s,
+    className: a,
+    collapsedSize: l = "0px",
+    component: d,
+    easing: c,
+    in: u,
+    onEnter: g,
+    onEntered: h,
+    onEntering: x,
+    onExit: y,
+    onExited: E,
+    onExiting: $,
+    orientation: C = "vertical",
+    style: M,
+    timeout: j = Cn.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: v = te
+  } = r, N = A(r, ar), R = f({}, r, {
+    orientation: C,
+    collapsedSize: l
+  }), O = lr(R), k = Qe(), W = Ot(), S = m.useRef(null), z = m.useRef(), I = typeof l == "number" ? `${l}px` : l, V = C === "horizontal", L = V ? "width" : "height", U = m.useRef(null), H = Oe(o, U), G = (T) => (_) => {
+    if (T) {
+      const F = U.current;
+      _ === void 0 ? T(F) : T(F, _);
+    }
+  }, D = () => S.current ? S.current[V ? "clientWidth" : "clientHeight"] : 0, Ve = G((T, _) => {
+    S.current && V && (S.current.style.position = "absolute"), T.style[L] = I, g && g(T, _);
+  }), be = G((T, _) => {
+    const F = D();
+    S.current && V && (S.current.style.position = "");
+    const {
+      duration: B,
+      easing: ie
+    } = St({
+      style: M,
+      timeout: j,
+      easing: c
+    }, {
+      mode: "enter"
+    });
+    if (j === "auto") {
+      const xe = k.transitions.getAutoHeightDuration(F);
+      T.style.transitionDuration = `${xe}ms`, z.current = xe;
+    } else
+      T.style.transitionDuration = typeof B == "string" ? B : `${B}ms`;
+    T.style[L] = `${F}px`, T.style.transitionTimingFunction = ie, x && x(T, _);
+  }), Ae = G((T, _) => {
+    T.style[L] = "auto", h && h(T, _);
+  }), De = G((T) => {
+    T.style[L] = `${D()}px`, y && y(T);
+  }), Be = G(E), ee = G((T) => {
+    const _ = D(), {
+      duration: F,
+      easing: B
+    } = St({
+      style: M,
+      timeout: j,
+      easing: c
+    }, {
+      mode: "exit"
+    });
+    if (j === "auto") {
+      const ie = k.transitions.getAutoHeightDuration(_);
+      T.style.transitionDuration = `${ie}ms`, z.current = ie;
+    } else
+      T.style.transitionDuration = typeof F == "string" ? F : `${F}ms`;
+    T.style[L] = I, T.style.transitionTimingFunction = B, $ && $(T);
+  }), se = (T) => {
+    j === "auto" && W.start(z.current || 0, T), i && i(U.current, T);
+  };
+  return /* @__PURE__ */ p.jsx(v, f({
+    in: u,
+    onEnter: Ve,
+    onEntered: Ae,
+    onEntering: be,
+    onExit: De,
+    onExited: Be,
+    onExiting: ee,
+    addEndListener: se,
+    nodeRef: U,
+    timeout: j === "auto" ? null : j
+  }, N, {
+    children: (T, _) => /* @__PURE__ */ p.jsx(cr, f({
+      as: d,
+      className: w(O.root, a, {
+        entered: O.entered,
+        exited: !u && I === "0px" && O.hidden
+      }[T]),
+      style: f({
+        [V ? "minWidth" : "minHeight"]: I
+      }, M),
+      ref: H
+    }, _, {
+      // `ownerState` is set after `childProps` to override any existing `ownerState` property in `childProps`
+      // that might have been forwarded from the Transition component.
+      ownerState: f({}, R, {
+        state: T
+      }),
+      children: /* @__PURE__ */ p.jsx(ur, {
+        ownerState: f({}, R, {
+          state: T
+        }),
+        className: O.wrapper,
+        ref: S,
+        children: /* @__PURE__ */ p.jsx(dr, {
+          ownerState: f({}, R, {
+            state: T
+          }),
+          className: O.wrapperInner,
+          children: s
+        })
+      })
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (rt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: t.func,
+  /**
+   * The content node to be collapsed.
+   */
+  children: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The width (horizontal) or height (vertical) of the container when collapsed.
+   * @default '0px'
+   */
+  collapsedSize: t.oneOfType([t.number, t.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: wt,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: t.oneOfType([t.shape({
+    enter: t.string,
+    exit: t.string
+  }), t.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: t.bool,
+  /**
+   * @ignore
+   */
+  onEnter: t.func,
+  /**
+   * @ignore
+   */
+  onEntered: t.func,
+  /**
+   * @ignore
+   */
+  onEntering: t.func,
+  /**
+   * @ignore
+   */
+  onExit: t.func,
+  /**
+   * @ignore
+   */
+  onExited: t.func,
+  /**
+   * @ignore
+   */
+  onExiting: t.func,
+  /**
+   * The transition orientation.
+   * @default 'vertical'
+   */
+  orientation: t.oneOf(["horizontal", "vertical"]),
+  /**
+   * @ignore
+   */
+  style: t.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   *
+   * Set to 'auto' to automatically calculate transition time based on height.
+   * @default duration.standard
+   */
+  timeout: t.oneOfType([t.oneOf(["auto"]), t.number, t.shape({
+    appear: t.number,
+    enter: t.number,
+    exit: t.number
+  })])
+});
+rt.muiSupportAuto = !0;
+const st = /* @__PURE__ */ m.createContext({});
+process.env.NODE_ENV !== "production" && (st.displayName = "AccordionContext");
+function pr(e) {
+  return J("MuiAccordion", e);
+}
+const Ce = X("MuiAccordion", ["root", "rounded", "expanded", "disabled", "gutters", "region"]), fr = ["children", "className", "defaultExpanded", "disabled", "disableGutters", "expanded", "onChange", "square", "slots", "slotProps", "TransitionComponent", "TransitionProps"], gr = (e) => {
+  const {
+    classes: n,
+    square: o,
+    expanded: r,
+    disabled: i,
+    disableGutters: s
+  } = e;
+  return Q({
+    root: ["root", !o && "rounded", r && "expanded", i && "disabled", !s && "gutters"],
+    region: ["region"]
+  }, pr, n);
+}, hr = P(et, {
+  name: "MuiAccordion",
+  slot: "Root",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: o
+    } = e;
+    return [{
+      [`& .${Ce.region}`]: n.region
+    }, n.root, !o.square && n.rounded, !o.disableGutters && n.gutters];
+  }
+})(({
+  theme: e
+}) => {
+  const n = {
+    duration: e.transitions.duration.shortest
+  };
+  return {
+    position: "relative",
+    transition: e.transitions.create(["margin"], n),
+    overflowAnchor: "none",
+    // Keep the same scrolling position
+    "&::before": {
+      position: "absolute",
+      left: 0,
+      top: -1,
+      right: 0,
+      height: 1,
+      content: '""',
+      opacity: 1,
+      backgroundColor: (e.vars || e).palette.divider,
+      transition: e.transitions.create(["opacity", "background-color"], n)
+    },
+    "&:first-of-type": {
+      "&::before": {
+        display: "none"
+      }
+    },
+    [`&.${Ce.expanded}`]: {
+      "&::before": {
+        opacity: 0
+      },
+      "&:first-of-type": {
+        marginTop: 0
+      },
+      "&:last-of-type": {
+        marginBottom: 0
+      },
+      "& + &": {
+        "&::before": {
+          display: "none"
+        }
+      }
+    },
+    [`&.${Ce.disabled}`]: {
+      backgroundColor: (e.vars || e).palette.action.disabledBackground
+    }
+  };
+}, ({
+  theme: e
+}) => ({
+  variants: [{
+    props: (n) => !n.square,
+    style: {
+      borderRadius: 0,
+      "&:first-of-type": {
+        borderTopLeftRadius: (e.vars || e).shape.borderRadius,
+        borderTopRightRadius: (e.vars || e).shape.borderRadius
+      },
+      "&:last-of-type": {
+        borderBottomLeftRadius: (e.vars || e).shape.borderRadius,
+        borderBottomRightRadius: (e.vars || e).shape.borderRadius,
+        // Fix a rendering issue on Edge
+        "@supports (-ms-ime-align: auto)": {
+          borderBottomLeftRadius: 0,
+          borderBottomRightRadius: 0
+        }
+      }
+    }
+  }, {
+    props: (n) => !n.disableGutters,
+    style: {
+      [`&.${Ce.expanded}`]: {
+        margin: "16px 0"
+      }
+    }
+  }]
+})), Ft = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiAccordion"
+  }), {
+    children: i,
+    className: s,
+    defaultExpanded: a = !1,
+    disabled: l = !1,
+    disableGutters: d = !1,
+    expanded: c,
+    onChange: u,
+    square: g = !1,
+    slots: h = {},
+    slotProps: x = {},
+    TransitionComponent: y,
+    TransitionProps: E
+  } = r, $ = A(r, fr), [C, M] = Sn({
+    controlled: c,
+    default: a,
+    name: "Accordion",
+    state: "expanded"
+  }), j = m.useCallback((V) => {
+    M(!C), u && u(V, !C);
+  }, [C, u, M]), [v, ...N] = m.Children.toArray(i), R = m.useMemo(() => ({
+    expanded: C,
+    disabled: l,
+    disableGutters: d,
+    toggle: j
+  }), [C, l, d, j]), O = f({}, r, {
+    square: g,
+    disabled: l,
+    disableGutters: d,
+    expanded: C
+  }), k = gr(O), W = f({
+    transition: y
+  }, h), S = f({
+    transition: E
+  }, x), [z, I] = Ge("transition", {
+    elementType: rt,
+    externalForwardedProps: {
+      slots: W,
+      slotProps: S
+    },
+    ownerState: O
+  });
+  return /* @__PURE__ */ p.jsxs(hr, f({
+    className: w(k.root, s),
+    ref: o,
+    ownerState: O,
+    square: g
+  }, $, {
+    children: [/* @__PURE__ */ p.jsx(st.Provider, {
+      value: R,
+      children: v
+    }), /* @__PURE__ */ p.jsx(z, f({
+      in: C,
+      timeout: "auto"
+    }, I, {
+      children: /* @__PURE__ */ p.jsx("div", {
+        "aria-labelledby": v.props.id,
+        id: v.props["aria-controls"],
+        role: "region",
+        className: k.region,
+        children: N
+      })
+    }))]
+  }));
+});
+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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: Pe(t.node.isRequired, (e) => {
+    const n = m.Children.toArray(e.children)[0];
+    return Rn.isFragment(n) ? new Error("MUI: The Accordion doesn't accept a Fragment as a child. Consider providing an array instead.") : /* @__PURE__ */ m.isValidElement(n) ? null : new Error("MUI: Expected the first child of Accordion to be a valid element.");
+  }),
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * If `true`, expands the accordion by default.
+   * @default false
+   */
+  defaultExpanded: t.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: t.bool,
+  /**
+   * If `true`, it removes the margin between two expanded accordion items and the increase of height.
+   * @default false
+   */
+  disableGutters: t.bool,
+  /**
+   * If `true`, expands the accordion, otherwise collapse it.
+   * Setting this prop enables control over the accordion.
+   */
+  expanded: t.bool,
+  /**
+   * Callback fired when the expand/collapse state is changed.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback. **Warning**: This is a generic event not a change event.
+   * @param {boolean} expanded The `expanded` state of the accordion.
+   */
+  onChange: t.func,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: t.shape({
+    transition: t.oneOfType([t.func, t.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: t.shape({
+    transition: t.elementType
+  }),
+  /**
+   * If `true`, rounded corners are disabled.
+   * @default false
+   */
+  square: t.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @deprecated Use `slots.transition` instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   */
+  TransitionComponent: t.elementType,
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
+   * @deprecated Use `slotProps.transition` instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   */
+  TransitionProps: t.object
+});
+function mr(e) {
+  return J("MuiAccordionDetails", e);
+}
+X("MuiAccordionDetails", ["root"]);
+const vr = ["className"], br = (e) => {
+  const {
+    classes: n
+  } = e;
+  return Q({
+    root: ["root"]
+  }, mr, n);
+}, xr = P("div", {
+  name: "MuiAccordionDetails",
+  slot: "Root",
+  overridesResolver: (e, n) => n.root
+})(({
+  theme: e
+}) => ({
+  padding: e.spacing(1, 2, 2)
+})), Ut = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiAccordionDetails"
+  }), {
+    className: i
+  } = r, s = A(r, vr), a = r, l = br(a);
+  return /* @__PURE__ */ p.jsx(xr, f({
+    className: w(l.root, i),
+    ref: o,
+    ownerState: a
+  }, s));
+});
+process.env.NODE_ENV !== "production" && (Ut.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: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object])
+});
+function yr(e) {
+  return J("MuiAccordionSummary", e);
+}
+const ue = X("MuiAccordionSummary", ["root", "expanded", "focusVisible", "disabled", "gutters", "contentGutters", "content", "expandIconWrapper"]), Er = ["children", "className", "expandIcon", "focusVisibleClassName", "onClick"], Tr = (e) => {
+  const {
+    classes: n,
+    expanded: o,
+    disabled: r,
+    disableGutters: i
+  } = e;
+  return Q({
+    root: ["root", o && "expanded", r && "disabled", !i && "gutters"],
+    focusVisible: ["focusVisible"],
+    content: ["content", o && "expanded", !i && "contentGutters"],
+    expandIconWrapper: ["expandIconWrapper", o && "expanded"]
+  }, yr, n);
+}, Cr = P(ot, {
+  name: "MuiAccordionSummary",
+  slot: "Root",
+  overridesResolver: (e, n) => n.root
+})(({
+  theme: e
+}) => {
+  const n = {
+    duration: e.transitions.duration.shortest
+  };
+  return {
+    display: "flex",
+    minHeight: 48,
+    padding: e.spacing(0, 2),
+    transition: e.transitions.create(["min-height", "background-color"], n),
+    [`&.${ue.focusVisible}`]: {
+      backgroundColor: (e.vars || e).palette.action.focus
+    },
+    [`&.${ue.disabled}`]: {
+      opacity: (e.vars || e).palette.action.disabledOpacity
+    },
+    [`&:hover:not(.${ue.disabled})`]: {
+      cursor: "pointer"
+    },
+    variants: [{
+      props: (o) => !o.disableGutters,
+      style: {
+        [`&.${ue.expanded}`]: {
+          minHeight: 64
+        }
+      }
+    }]
+  };
+}), Sr = P("div", {
+  name: "MuiAccordionSummary",
+  slot: "Content",
+  overridesResolver: (e, n) => n.content
+})(({
+  theme: e
+}) => ({
+  display: "flex",
+  flexGrow: 1,
+  margin: "12px 0",
+  variants: [{
+    props: (n) => !n.disableGutters,
+    style: {
+      transition: e.transitions.create(["margin"], {
+        duration: e.transitions.duration.shortest
+      }),
+      [`&.${ue.expanded}`]: {
+        margin: "20px 0"
+      }
+    }
+  }]
+})), Rr = P("div", {
+  name: "MuiAccordionSummary",
+  slot: "ExpandIconWrapper",
+  overridesResolver: (e, n) => n.expandIconWrapper
+})(({
+  theme: e
+}) => ({
+  display: "flex",
+  color: (e.vars || e).palette.action.active,
+  transform: "rotate(0deg)",
+  transition: e.transitions.create("transform", {
+    duration: e.transitions.duration.shortest
+  }),
+  [`&.${ue.expanded}`]: {
+    transform: "rotate(180deg)"
+  }
+})), Gt = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiAccordionSummary"
+  }), {
+    children: i,
+    className: s,
+    expandIcon: a,
+    focusVisibleClassName: l,
+    onClick: d
+  } = r, c = A(r, Er), {
+    disabled: u = !1,
+    disableGutters: g,
+    expanded: h,
+    toggle: x
+  } = m.useContext(st), y = (C) => {
+    x && x(C), d && d(C);
+  }, E = f({}, r, {
+    expanded: h,
+    disabled: u,
+    disableGutters: g
+  }), $ = Tr(E);
+  return /* @__PURE__ */ p.jsxs(Cr, f({
+    focusRipple: !1,
+    disableRipple: !0,
+    disabled: u,
+    component: "div",
+    "aria-expanded": h,
+    className: w($.root, s),
+    focusVisibleClassName: w($.focusVisible, l),
+    onClick: y,
+    ref: o,
+    ownerState: E
+  }, c, {
+    children: [/* @__PURE__ */ p.jsx(Sr, {
+      className: $.content,
+      ownerState: E,
+      children: i
+    }), a && /* @__PURE__ */ p.jsx(Rr, {
+      className: $.expandIconWrapper,
+      ownerState: E,
+      children: a
+    })]
+  }));
+});
+process.env.NODE_ENV !== "production" && (Gt.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: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The icon to display as the expand indicator.
+   */
+  expandIcon: t.node,
+  /**
+   * 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: t.string,
+  /**
+   * @ignore
+   */
+  onClick: t.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object])
+});
+function Nr(e) {
+  return J("MuiTypography", e);
+}
+X("MuiTypography", ["root", "h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "inherit", "button", "caption", "overline", "alignLeft", "alignRight", "alignCenter", "alignJustify", "noWrap", "gutterBottom", "paragraph"]);
+const Or = ["align", "className", "component", "gutterBottom", "noWrap", "paragraph", "variant", "variantMapping"], $r = (e) => {
+  const {
+    align: n,
+    gutterBottom: o,
+    noWrap: r,
+    paragraph: i,
+    variant: s,
+    classes: a
+  } = e, l = {
+    root: ["root", s, e.align !== "inherit" && `align${K(n)}`, o && "gutterBottom", r && "noWrap", i && "paragraph"]
+  };
+  return Q(l, Nr, a);
+}, jr = P("span", {
+  name: "MuiTypography",
+  slot: "Root",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: o
+    } = e;
+    return [n.root, o.variant && n[o.variant], o.align !== "inherit" && n[`align${K(o.align)}`], o.noWrap && n.noWrap, o.gutterBottom && n.gutterBottom, o.paragraph && n.paragraph];
+  }
+})(({
+  theme: e,
+  ownerState: n
+}) => f({
+  margin: 0
+}, n.variant === "inherit" && {
+  // Some elements, like <button> on Chrome have default font that doesn't inherit, reset this.
+  font: "inherit"
+}, n.variant !== "inherit" && e.typography[n.variant], n.align !== "inherit" && {
+  textAlign: n.align
+}, n.noWrap && {
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap"
+}, n.gutterBottom && {
+  marginBottom: "0.35em"
+}, n.paragraph && {
+  marginBottom: 16
+})), Rt = {
+  h1: "h1",
+  h2: "h2",
+  h3: "h3",
+  h4: "h4",
+  h5: "h5",
+  h6: "h6",
+  subtitle1: "h6",
+  subtitle2: "h6",
+  body1: "p",
+  body2: "p",
+  inherit: "p"
+}, wr = {
+  primary: "primary.main",
+  textPrimary: "text.primary",
+  secondary: "secondary.main",
+  textSecondary: "text.secondary",
+  error: "error.main"
+}, Mr = (e) => wr[e] || e, qt = /* @__PURE__ */ m.forwardRef(function(n, o) {
+  const r = Y({
+    props: n,
+    name: "MuiTypography"
+  }), i = Mr(r.color), s = $t(f({}, r, {
+    color: i
+  })), {
+    align: a = "inherit",
+    className: l,
+    component: d,
+    gutterBottom: c = !1,
+    noWrap: u = !1,
+    paragraph: g = !1,
+    variant: h = "body1",
+    variantMapping: x = Rt
+  } = s, y = A(s, Or), E = f({}, s, {
+    align: a,
+    color: i,
+    className: l,
+    component: d,
+    gutterBottom: c,
+    noWrap: u,
+    paragraph: g,
+    variant: h,
+    variantMapping: x
+  }), $ = d || (g ? "p" : x[h] || Rt[h]) || "span", C = $r(E);
+  return /* @__PURE__ */ p.jsx(jr, f({
+    as: $,
+    ref: o,
+    ownerState: E,
+    className: w(C.root, l)
+  }, y));
+});
+process.env.NODE_ENV !== "production" && (qt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Set the text-align on the component.
+   * @default 'inherit'
+   */
+  align: t.oneOf(["center", "inherit", "justify", "left", "right"]),
+  /**
+   * The content of the component.
+   */
+  children: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: t.elementType,
+  /**
+   * If `true`, the text will have a bottom margin.
+   * @default false
+   */
+  gutterBottom: t.bool,
+  /**
+   * If `true`, the text will not wrap, but instead will truncate with a text overflow ellipsis.
+   *
+   * Note that text overflow can only happen with block or inline-block level elements
+   * (the element needs to have a width in order to overflow).
+   * @default false
+   */
+  noWrap: t.bool,
+  /**
+   * If `true`, the element will be a paragraph element.
+   * @default false
+   */
+  paragraph: t.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * Applies the theme typography styles.
+   * @default 'body1'
+   */
+  variant: t.oneOfType([t.oneOf(["body1", "body2", "button", "caption", "h1", "h2", "h3", "h4", "h5", "h6", "inherit", "overline", "subtitle1", "subtitle2"]), t.string]),
+  /**
+   * The component maps the variant prop to a range of different HTML element types.
+   * For instance, subtitle1 to `<h6>`.
+   * If you wish to change that mapping, you can provide your own.
+   * Alternatively, you can use the `component` prop.
+   * @default {
+   *   h1: 'h1',
+   *   h2: 'h2',
+   *   h3: 'h3',
+   *   h4: 'h4',
+   *   h5: 'h5',
+   *   h6: 'h6',
+   *   subtitle1: 'h6',
+   *   subtitle2: 'h6',
+   *   body1: 'p',
+   *   body2: 'p',
+   *   inherit: 'p',
+   * }
+   */
+  variantMapping: t.object
+});
+const kr = (e) => !isNaN(parseFloat(e)) && !isNaN(Number(e) - 0), Pr = {
+  "java.lang.Integer": !0,
+  "java.lang.Long": !0,
+  "java.lang.Double": !0,
+  "java.lang.Float": !0
+}, Ir = (e, n) => {
+  if (!n.required && !e)
+    return;
+  if (n.required && (!e || e.trim().length === 0))
+    return `${n.name} is mandatory!`;
+  if (Pr[n.type]) {
+    if (!kr(e))
+      return "Value must be numeric!";
+    const i = Number(e);
+    if (n.type === "java.lang.Integer" && !Number.isInteger(i))
+      return "Value must be an Integer!";
+    const s = n.minValue || Number.MIN_VALUE, a = n.maxValue || Number.MAX_VALUE;
+    if (i < s)
+      return `Value too small, must be >= ${s}`;
+    if (i > a)
+      return `Value too large, must be <= ${a}`;
+  }
+  const o = n.minLength || 0, r = n.maxLength;
+  if (e.length < o)
+    return `Value too short, must at least ${o} characters`;
+  if (r && e.length > r)
+    return `Value too long, must be at most ${r} characters`;
+}, Vr = (e) => {
+  const n = {};
+  return e.forEach((o) => {
+    o.required && (n[o.name] = "");
+  }), n;
+}, Ar = ({ triggerName: e, triggerParams: n, triggerAction: o }) => {
+  const [r, i] = Ne({}), [s, a] = Ne(Vr(n)), l = (c) => {
+    const u = { ...s };
+    delete u[c], a(u);
+  }, d = (c, u) => {
+    const { name: g } = c;
+    i({
+      ...r,
+      [g]: u.target.value
+    });
+    const h = Ir(u.target.value, c);
+    h ? a({
+      ...s,
+      [g]: h
+    }) : l(g);
+  };
+  return p.jsx("form", { onSubmit: (c) => {
+    c.preventDefault(), o(e, r);
+  }, children: p.jsxs(fn, { display: "flex", flexWrap: "wrap", gap: 4, rowGap: 4, children: [n.length === 0 ? p.jsx(ce, { children: "Trigger does not support additional parameters" }) : p.jsxs(p.Fragment, { children: [p.jsx(ce, { minWidth: "100%", children: "Trigger parameters" }), n.map((c) => {
+    const { name: u } = c, g = s ? s[u] : void 0;
+    return p.jsx(gn, { sx: { marginBottom: 10 }, error: !!g, id: `${e}-${u}-input`, helperText: g || "", required: c.required, label: u, onChange: (h) => d(c, h) }, `${e}-${u}-input`);
+  })] }), p.jsx(hn, { id: `${e}-submit-btn`, variant: "contained", type: "submit", disabled: s ? Object.keys(s).length > 0 : !1, sx: { marginTop: 10, float: "right", marginLeft: "auto", height: "fit-content" }, children: "Trigger" })] }) });
+}, Dr = ({ triggerables: e, triggerAction: n }) => p.jsx(p.Fragment, { children: Object.entries(e).map(([o, r]) => p.jsxs(Ft, { sx: { width: "100%", marginBottom: "5px" }, children: [p.jsx(Gt, { expandIcon: p.jsx(jt, {}), "aria-controls": `${o}-content`, id: `${o}-header`, children: p.jsx(qt, { sx: { fontSize: 18, flexBasis: "33.33%", flexShrink: 0 }, children: o }) }), p.jsx(Ut, { sx: { flexDirection: "column" }, children: p.jsx(Ar, { triggerName: o, triggerParams: r, triggerAction: n }) })] }, `${o}-container`)) }), Br = ({ activeTaskStatuses: e, triggerables: n, triggerResponse: o, openMessageChain: r, handleTriggerAction: i }) => {
+  const [s, a] = Ne(!0);
+  return p.jsxs(p.Fragment, { children: [p.jsx(Go, { triggerResponse: o, showNotification: s, onClose: () => a(!1) }), p.jsx(sr, { activeTaskStatuses: e, openMessageChain: r }), p.jsx(Dr, { triggerables: n, triggerAction: i })] });
+}, zr = (e) => async () => {
+  try {
+    const n = await Vt(e), o = await Pt(
+      e
+    ), { data: r } = n, { data: i } = o;
+    return { triggerables: r, activeTaskStatuses: i };
+  } catch (n) {
+    throw console.error(n), new Error("Failed to fetch triggerables");
+  }
+}, Xr = zr(), Yr = () => {
+  const e = On(), n = $n(), [o, r] = Ne(), i = jn(), { activeTaskStatuses: s, triggerables: a } = i, l = s.reduce((c, u) => (c[u.id] = u, c), {}), d = async (c, u) => {
+    try {
+      const g = await At(c, u);
+      r(g);
+    } catch (g) {
+      console.error(g), r({
+        status: 500,
+        data: `Failed to trigger ${c}`
+      });
+    }
+    n.revalidate();
+  };
+  return /* @__PURE__ */ p.jsx(
+    Br,
+    {
+      triggerResponse: o == null ? void 0 : o.data,
+      activeTaskStatuses: l,
+      triggerables: a,
+      openMessageChain: (c) => {
+        e(`/message-log/${c}`);
+      },
+      handleTriggerAction: d
+    }
+  );
+};
+export {
+  Yr as T,
+  zr as g,
+  Xr as l
+};
+//# sourceMappingURL=TriggerablesRoute-i4z1o99f.js.map