@notificationapi/react 1.4.1 → 1.5.1

package/dist/components/Slack/SlackConnect.js

@@ -0,0 +1,4826 @@
+import { jsxs as q, jsx as y } from "react/jsx-runtime";
+import * as l from "react";
+import { useContext as at, useState as ye, useCallback as Io, useEffect as Ro } from "react";
+import { NotificationAPIContext as it } from "../Provider/context.js";
+import { B as qe } from "../../assets/Box.js";
+import { P as e, g as G, e as Z, h as H, s as M, m as _, u as ee, c as Y, b as J, N as Uo, K as ne, w as mo, a as _e, O as lt } from "../../assets/DefaultPropsProvider.js";
+import { c as ze } from "../../assets/createSimplePaletteValueFilter.js";
+import { k as Vo, c as Ho } from "../../assets/useTheme2.js";
+import { b as Be, e as ct, r as ke, c as dt, B as ut } from "../../assets/ButtonBase.js";
+import { A as ko, B as Ie } from "../../assets/Button.js";
+import { u as We, f as Ue, F as qo, S as io } from "../../assets/Stack.js";
+import { g as pt, T as Ke } from "../../assets/Typography.js";
+import { i as To, a as lo, L as ft, b as Mo } from "../../assets/List.js";
+import { r as bo } from "../../assets/index.js";
+import { u as mt } from "../../assets/Grow.js";
+import { d as bt, P as yt, a as gt } from "../../assets/Popover.js";
+import { o as uo, g as ht } from "../../assets/Modal.js";
+import { u as Te } from "../../assets/resolveComponentProps.js";
+import { o as _o, H as vt, g as Ct } from "../../assets/Portal.js";
+import { u as Eo } from "../../assets/useSlotProps.js";
+import { d as No, a as Po, u as St } from "../../assets/dividerClasses.js";
+import { c as wt } from "../../assets/createSvgIcon.js";
+function Ge(o) {
+  return parseInt(o, 10) || 0;
+}
+const Ot = {
+  shadow: {
+    // Visibility needed to hide the extra text area on iPads
+    visibility: "hidden",
+    // Remove from the content flow
+    position: "absolute",
+    // Ignore the scrollbar width
+    overflow: "hidden",
+    height: 0,
+    top: 0,
+    left: 0,
+    // Create a new layer, increase the isolation of the computed values
+    transform: "translateZ(0)"
+  }
+};
+function xt(o) {
+  return o == null || Object.keys(o).length === 0 || o.outerHeightStyle === 0 && !o.overflowing;
+}
+const Ko = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const {
+    onChange: r,
+    maxRows: i,
+    minRows: d = 1,
+    style: a,
+    value: c,
+    ...f
+  } = t, {
+    current: u
+  } = l.useRef(c != null), m = l.useRef(null), C = Te(n, m), S = l.useRef(null), v = l.useRef(null), x = l.useCallback(() => {
+    const p = m.current, s = uo(p).getComputedStyle(p);
+    if (s.width === "0px")
+      return {
+        outerHeightStyle: 0,
+        overflowing: !1
+      };
+    const b = v.current;
+    b.style.width = s.width, b.value = p.value || t.placeholder || "x", b.value.slice(-1) === `
+` && (b.value += " ");
+    const R = s.boxSizing, L = Ge(s.paddingBottom) + Ge(s.paddingTop), N = Ge(s.borderBottomWidth) + Ge(s.borderTopWidth), k = b.scrollHeight;
+    b.value = "x";
+    const j = b.scrollHeight;
+    let P = k;
+    d && (P = Math.max(Number(d) * j, P)), i && (P = Math.min(Number(i) * j, P)), P = Math.max(P, j);
+    const B = P + (R === "border-box" ? L + N : 0), z = Math.abs(P - k) <= 1;
+    return {
+      outerHeightStyle: B,
+      overflowing: z
+    };
+  }, [i, d, t.placeholder]), I = l.useCallback(() => {
+    const p = x();
+    if (xt(p))
+      return;
+    const h = p.outerHeightStyle, s = m.current;
+    S.current !== h && (S.current = h, s.style.height = `${h}px`), s.style.overflow = p.overflowing ? "hidden" : "";
+  }, [x]);
+  Be(() => {
+    const p = () => {
+      I();
+    };
+    let h;
+    const s = () => {
+      cancelAnimationFrame(h), h = requestAnimationFrame(() => {
+        p();
+      });
+    }, b = bt(p), R = m.current, L = uo(R);
+    L.addEventListener("resize", b);
+    let N;
+    return typeof ResizeObserver < "u" && (N = new ResizeObserver(process.env.NODE_ENV === "test" ? s : p), N.observe(R)), () => {
+      b.clear(), cancelAnimationFrame(h), L.removeEventListener("resize", b), N && N.disconnect();
+    };
+  }, [x, I]), Be(() => {
+    I();
+  });
+  const O = (p) => {
+    u || I(), r && r(p);
+  };
+  return /* @__PURE__ */ q(l.Fragment, {
+    children: [/* @__PURE__ */ y("textarea", {
+      value: c,
+      onChange: O,
+      ref: C,
+      rows: d,
+      style: a,
+      ...f
+    }), /* @__PURE__ */ y("textarea", {
+      "aria-hidden": !0,
+      className: t.className,
+      readOnly: !0,
+      ref: v,
+      tabIndex: -1,
+      style: {
+        ...Ot.shadow,
+        ...a,
+        paddingTop: 0,
+        paddingBottom: 0
+      }
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (Ko.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * Maximum number of rows to display.
+   */
+  maxRows: e.oneOfType([e.number, e.string]),
+  /**
+   * Minimum number of rows to display.
+   * @default 1
+   */
+  minRows: e.oneOfType([e.number, e.string]),
+  /**
+   * @ignore
+   */
+  onChange: e.func,
+  /**
+   * @ignore
+   */
+  placeholder: e.string,
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * @ignore
+   */
+  value: e.oneOfType([e.arrayOf(e.string), e.number, e.string])
+});
+function Fo(o) {
+  return o != null && !(Array.isArray(o) && o.length === 0);
+}
+function Ye(o, t = !1) {
+  return o && (Fo(o.value) && o.value !== "" || t && Fo(o.defaultValue) && o.defaultValue !== "");
+}
+function It(o) {
+  return o.startAdornment;
+}
+function Rt(o) {
+  return Z("MuiInputBase", o);
+}
+const Re = G("MuiInputBase", ["root", "formControl", "focused", "disabled", "adornedStart", "adornedEnd", "error", "sizeSmall", "multiline", "colorSecondary", "fullWidth", "hiddenLabel", "readOnly", "input", "inputSizeSmall", "inputMultiline", "inputTypeSearch", "inputAdornedStart", "inputAdornedEnd", "inputHiddenLabel"]);
+var $o;
+const Ze = (o, t) => {
+  const {
+    ownerState: n
+  } = o;
+  return [t.root, n.formControl && t.formControl, n.startAdornment && t.adornedStart, n.endAdornment && t.adornedEnd, n.error && t.error, n.size === "small" && t.sizeSmall, n.multiline && t.multiline, n.color && t[`color${H(n.color)}`], n.fullWidth && t.fullWidth, n.hiddenLabel && t.hiddenLabel];
+}, Je = (o, t) => {
+  const {
+    ownerState: n
+  } = o;
+  return [t.input, n.size === "small" && t.inputSizeSmall, n.multiline && t.inputMultiline, n.type === "search" && t.inputTypeSearch, n.startAdornment && t.inputAdornedStart, n.endAdornment && t.inputAdornedEnd, n.hiddenLabel && t.inputHiddenLabel];
+}, kt = (o) => {
+  const {
+    classes: t,
+    color: n,
+    disabled: r,
+    error: i,
+    endAdornment: d,
+    focused: a,
+    formControl: c,
+    fullWidth: f,
+    hiddenLabel: u,
+    multiline: m,
+    readOnly: C,
+    size: S,
+    startAdornment: v,
+    type: x
+  } = o, I = {
+    root: ["root", `color${H(n)}`, r && "disabled", i && "error", f && "fullWidth", a && "focused", c && "formControl", S && S !== "medium" && `size${H(S)}`, m && "multiline", v && "adornedStart", d && "adornedEnd", u && "hiddenLabel", C && "readOnly"],
+    input: ["input", r && "disabled", x === "search" && "inputTypeSearch", m && "inputMultiline", S === "small" && "inputSizeSmall", u && "inputHiddenLabel", v && "inputAdornedStart", d && "inputAdornedEnd", C && "readOnly"]
+  };
+  return J(I, Rt, t);
+}, Qe = M("div", {
+  name: "MuiInputBase",
+  slot: "Root",
+  overridesResolver: Ze
+})(_(({
+  theme: o
+}) => ({
+  ...o.typography.body1,
+  color: (o.vars || o).palette.text.primary,
+  lineHeight: "1.4375em",
+  // 23px
+  boxSizing: "border-box",
+  // Prevent padding issue with fullWidth.
+  position: "relative",
+  cursor: "text",
+  display: "inline-flex",
+  alignItems: "center",
+  [`&.${Re.disabled}`]: {
+    color: (o.vars || o).palette.text.disabled,
+    cursor: "default"
+  },
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.multiline,
+    style: {
+      padding: "4px 0 5px"
+    }
+  }, {
+    props: ({
+      ownerState: t,
+      size: n
+    }) => t.multiline && n === "small",
+    style: {
+      paddingTop: 1
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.fullWidth,
+    style: {
+      width: "100%"
+    }
+  }]
+}))), eo = M("input", {
+  name: "MuiInputBase",
+  slot: "Input",
+  overridesResolver: Je
+})(_(({
+  theme: o
+}) => {
+  const t = o.palette.mode === "light", n = {
+    color: "currentColor",
+    ...o.vars ? {
+      opacity: o.vars.opacity.inputPlaceholder
+    } : {
+      opacity: t ? 0.42 : 0.5
+    },
+    transition: o.transitions.create("opacity", {
+      duration: o.transitions.duration.shorter
+    })
+  }, r = {
+    opacity: "0 !important"
+  }, i = o.vars ? {
+    opacity: o.vars.opacity.inputPlaceholder
+  } : {
+    opacity: t ? 0.42 : 0.5
+  };
+  return {
+    font: "inherit",
+    letterSpacing: "inherit",
+    color: "currentColor",
+    padding: "4px 0 5px",
+    border: 0,
+    boxSizing: "content-box",
+    background: "none",
+    height: "1.4375em",
+    // Reset 23pxthe native input line-height
+    margin: 0,
+    // Reset for Safari
+    WebkitTapHighlightColor: "transparent",
+    display: "block",
+    // Make the flex item shrink with Firefox
+    minWidth: 0,
+    width: "100%",
+    "&::-webkit-input-placeholder": n,
+    "&::-moz-placeholder": n,
+    // Firefox 19+
+    "&::-ms-input-placeholder": n,
+    // Edge
+    "&:focus": {
+      outline: 0
+    },
+    // Reset Firefox invalid required input style
+    "&:invalid": {
+      boxShadow: "none"
+    },
+    "&::-webkit-search-decoration": {
+      // Remove the padding when type=search.
+      WebkitAppearance: "none"
+    },
+    // Show and hide the placeholder logic
+    [`label[data-shrink=false] + .${Re.formControl} &`]: {
+      "&::-webkit-input-placeholder": r,
+      "&::-moz-placeholder": r,
+      // Firefox 19+
+      "&::-ms-input-placeholder": r,
+      // Edge
+      "&:focus::-webkit-input-placeholder": i,
+      "&:focus::-moz-placeholder": i,
+      // Firefox 19+
+      "&:focus::-ms-input-placeholder": i
+      // Edge
+    },
+    [`&.${Re.disabled}`]: {
+      opacity: 1,
+      // Reset iOS opacity
+      WebkitTextFillColor: (o.vars || o).palette.text.disabled
+      // Fix opacity Safari bug
+    },
+    variants: [{
+      props: ({
+        ownerState: d
+      }) => !d.disableInjectingGlobalStyles,
+      style: {
+        animationName: "mui-auto-fill-cancel",
+        animationDuration: "10ms",
+        "&:-webkit-autofill": {
+          animationDuration: "5000s",
+          animationName: "mui-auto-fill"
+        }
+      }
+    }, {
+      props: {
+        size: "small"
+      },
+      style: {
+        paddingTop: 1
+      }
+    }, {
+      props: ({
+        ownerState: d
+      }) => d.multiline,
+      style: {
+        height: "auto",
+        resize: "none",
+        padding: 0,
+        paddingTop: 0
+      }
+    }, {
+      props: {
+        type: "search"
+      },
+      style: {
+        MozAppearance: "textfield"
+        // Improve type search style.
+      }
+    }]
+  };
+})), Lo = pt({
+  "@keyframes mui-auto-fill": {
+    from: {
+      display: "block"
+    }
+  },
+  "@keyframes mui-auto-fill-cancel": {
+    from: {
+      display: "block"
+    }
+  }
+}), oo = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    props: t,
+    name: "MuiInputBase"
+  }), {
+    "aria-describedby": i,
+    autoComplete: d,
+    autoFocus: a,
+    className: c,
+    color: f,
+    components: u = {},
+    componentsProps: m = {},
+    defaultValue: C,
+    disabled: S,
+    disableInjectingGlobalStyles: v,
+    endAdornment: x,
+    error: I,
+    fullWidth: O = !1,
+    id: p,
+    inputComponent: h = "input",
+    inputProps: s = {},
+    inputRef: b,
+    margin: R,
+    maxRows: L,
+    minRows: N,
+    multiline: k = !1,
+    name: j,
+    onBlur: P,
+    onChange: B,
+    onClick: z,
+    onFocus: U,
+    onKeyDown: W,
+    onKeyUp: g,
+    placeholder: E,
+    readOnly: F,
+    renderSuffix: Q,
+    rows: $,
+    size: he,
+    slotProps: Me = {},
+    slots: Ve = {},
+    startAdornment: ae,
+    type: oe = "text",
+    value: re,
+    ...to
+  } = r, ie = s.value != null ? s.value : re, {
+    current: Ee
+  } = l.useRef(ie != null), se = l.useRef(), no = l.useCallback((D) => {
+    process.env.NODE_ENV !== "production" && D && D.nodeName !== "INPUT" && !D.focus && console.error(["MUI: You have provided a `inputComponent` to the input component", "that does not correctly handle the `ref` prop.", "Make sure the `ref` prop is called with a HTMLInputElement."].join(`
+`));
+  }, []), ro = Te(se, b, s.ref, no), [le, ce] = l.useState(!1), A = We();
+  process.env.NODE_ENV !== "production" && l.useEffect(() => {
+    if (A)
+      return A.registerEffect();
+  }, [A]);
+  const X = Ue({
+    props: r,
+    muiFormControl: A,
+    states: ["color", "disabled", "error", "hiddenLabel", "size", "required", "filled"]
+  });
+  X.focused = A ? A.focused : le, l.useEffect(() => {
+    !A && S && le && (ce(!1), P && P());
+  }, [A, S, le, P]);
+  const de = A && A.onFilled, Ne = A && A.onEmpty, fe = l.useCallback((D) => {
+    Ye(D) ? de && de() : Ne && Ne();
+  }, [de, Ne]);
+  Be(() => {
+    Ee && fe({
+      value: ie
+    });
+  }, [ie, fe, Ee]);
+  const so = (D) => {
+    U && U(D), s.onFocus && s.onFocus(D), A && A.onFocus ? A.onFocus(D) : ce(!0);
+  }, ve = (D) => {
+    P && P(D), s.onBlur && s.onBlur(D), A && A.onBlur ? A.onBlur(D) : ce(!1);
+  }, ao = (D, ...we) => {
+    if (!Ee) {
+      const Oe = D.target || se.current;
+      if (Oe == null)
+        throw new Error(process.env.NODE_ENV !== "production" ? "MUI: Expected valid input target. Did you use a custom `inputComponent` and forget to forward refs? See https://mui.com/r/input-component-ref-interface for more info." : Uo(1));
+      fe({
+        value: Oe.value
+      });
+    }
+    s.onChange && s.onChange(D, ...we), B && B(D, ...we);
+  };
+  l.useEffect(() => {
+    fe(se.current);
+  }, []);
+  const ue = (D) => {
+    se.current && D.currentTarget === D.target && se.current.focus(), z && z(D);
+  };
+  let Ce = h, K = s;
+  k && Ce === "input" && ($ ? (process.env.NODE_ENV !== "production" && (N || L) && console.warn("MUI: You can not use the `minRows` or `maxRows` props when the input `rows` prop is set."), K = {
+    type: void 0,
+    minRows: $,
+    maxRows: $,
+    ...K
+  }) : K = {
+    type: void 0,
+    maxRows: L,
+    minRows: N,
+    ...K
+  }, Ce = Ko);
+  const Se = (D) => {
+    fe(D.animationName === "mui-auto-fill-cancel" ? se.current : {
+      value: "x"
+    });
+  };
+  l.useEffect(() => {
+    A && A.setAdornedStart(!!ae);
+  }, [A, ae]);
+  const me = {
+    ...r,
+    color: X.color || "primary",
+    disabled: X.disabled,
+    endAdornment: x,
+    error: X.error,
+    focused: X.focused,
+    formControl: A,
+    fullWidth: O,
+    hiddenLabel: X.hiddenLabel,
+    multiline: k,
+    size: X.size,
+    startAdornment: ae,
+    type: oe
+  }, He = kt(me), Pe = Ve.root || u.Root || Qe, be = Me.root || m.root || {}, Fe = Ve.input || u.Input || eo;
+  return K = {
+    ...K,
+    ...Me.input ?? m.input
+  }, /* @__PURE__ */ q(l.Fragment, {
+    children: [!v && typeof Lo == "function" && // For Emotion/Styled-components, InputGlobalStyles will be a function
+    // For Pigment CSS, this has no effect because the InputGlobalStyles will be null.
+    ($o || ($o = /* @__PURE__ */ y(Lo, {}))), /* @__PURE__ */ q(Pe, {
+      ...be,
+      ref: n,
+      onClick: ue,
+      ...to,
+      ...!To(Pe) && {
+        ownerState: {
+          ...me,
+          ...be.ownerState
+        }
+      },
+      className: Y(He.root, be.className, c, F && "MuiInputBase-readOnly"),
+      children: [ae, /* @__PURE__ */ y(qo.Provider, {
+        value: null,
+        children: /* @__PURE__ */ y(Fe, {
+          "aria-invalid": X.error,
+          "aria-describedby": i,
+          autoComplete: d,
+          autoFocus: a,
+          defaultValue: C,
+          disabled: X.disabled,
+          id: p,
+          onAnimationStart: Se,
+          name: j,
+          placeholder: E,
+          readOnly: F,
+          required: X.required,
+          rows: $,
+          value: ie,
+          onKeyDown: W,
+          onKeyUp: g,
+          type: oe,
+          ...K,
+          ...!To(Fe) && {
+            as: Ce,
+            ownerState: {
+              ...me,
+              ...K.ownerState
+            }
+          },
+          ref: ro,
+          className: Y(He.input, K.className, F && "MuiInputBase-readOnly"),
+          onBlur: ve,
+          onChange: ao,
+          onFocus: so
+        })
+      }), x, Q ? Q({
+        ...X,
+        startAdornment: ae
+      }) : null]
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (oo.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  "aria-describedby": e.string,
+  /**
+   * This prop helps users to fill forms faster, especially on mobile devices.
+   * The name can be confusing, as it's more like an autofill.
+   * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
+   */
+  autoComplete: e.string,
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   */
+  autoFocus: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.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).
+   * The prop defaults to the value (`'primary'`) inherited from the parent FormControl component.
+   */
+  color: e.oneOfType([e.oneOf(["primary", "secondary", "error", "info", "success", "warning"]), e.string]),
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Input: e.elementType,
+    Root: e.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. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    input: e.object,
+    root: e.object
+  }),
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: e.any,
+  /**
+   * If `true`, the component is disabled.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, GlobalStyles for the auto-fill keyframes will not be injected/removed on mount/unmount. Make sure to inject them at the top of your application.
+   * This option is intended to help with boosting the initial rendering performance if you are loading a big amount of Input components at once.
+   * @default false
+   */
+  disableInjectingGlobalStyles: e.bool,
+  /**
+   * End `InputAdornment` for this component.
+   */
+  endAdornment: e.node,
+  /**
+   * If `true`, the `input` will indicate an error.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  error: e.bool,
+  /**
+   * If `true`, the `input` will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: e.bool,
+  /**
+   * The id of the `input` element.
+   */
+  id: e.string,
+  /**
+   * The component used for the `input` element.
+   * Either a string to use a HTML element or a component.
+   * @default 'input'
+   */
+  inputComponent: ct,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   * @default {}
+   */
+  inputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: ke,
+  /**
+   * If `dense`, will adjust vertical spacing. This is normally obtained via context from
+   * FormControl.
+   * The prop defaults to the value (`'none'`) inherited from the parent FormControl component.
+   */
+  margin: e.oneOf(["dense", "none"]),
+  /**
+   * Maximum number of rows to display when multiline option is set to true.
+   */
+  maxRows: e.oneOfType([e.number, e.string]),
+  /**
+   * Minimum number of rows to display when multiline option is set to true.
+   */
+  minRows: e.oneOfType([e.number, e.string]),
+  /**
+   * If `true`, a [TextareaAutosize](https://mui.com/material-ui/react-textarea-autosize/) element is rendered.
+   * @default false
+   */
+  multiline: e.bool,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: e.string,
+  /**
+   * Callback fired when the `input` is blurred.
+   *
+   * Notice that the first argument (event) might be undefined.
+   */
+  onBlur: e.func,
+  /**
+   * Callback fired when the value is changed.
+   *
+   * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   */
+  onChange: e.func,
+  /**
+   * @ignore
+   */
+  onClick: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * Callback fired when the `input` doesn't satisfy its constraints.
+   */
+  onInvalid: e.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: e.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: e.func,
+  /**
+   * The short hint displayed in the `input` before the user enters a value.
+   */
+  placeholder: e.string,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   */
+  readOnly: e.bool,
+  /**
+   * @ignore
+   */
+  renderSuffix: e.func,
+  /**
+   * If `true`, the `input` element is required.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  required: e.bool,
+  /**
+   * Number of rows to display when multiline option is set to true.
+   */
+  rows: e.oneOfType([e.number, e.string]),
+  /**
+   * The size of the component.
+   */
+  size: e.oneOfType([e.oneOf(["medium", "small"]), e.string]),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slotProps: e.shape({
+    input: e.object,
+    root: e.object
+  }),
+  /**
+   * The components used for each slot inside.
+   *
+   * This prop is an alias for the `components` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slots: e.shape({
+    input: e.elementType,
+    root: e.elementType
+  }),
+  /**
+   * Start `InputAdornment` for this component.
+   */
+  startAdornment: e.node,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
+   * @default 'text'
+   */
+  type: e.string,
+  /**
+   * The value of the `input` element, required for a controlled component.
+   */
+  value: e.any
+});
+function Tt(o) {
+  return Z("MuiInput", o);
+}
+const $e = {
+  ...Re,
+  ...G("MuiInput", ["root", "underline", "input"])
+};
+function Mt(o) {
+  return Z("MuiOutlinedInput", o);
+}
+const te = {
+  ...Re,
+  ...G("MuiOutlinedInput", ["root", "notchedOutline", "input"])
+};
+function Et(o) {
+  return Z("MuiFilledInput", o);
+}
+const ge = {
+  ...Re,
+  ...G("MuiFilledInput", ["root", "underline", "input", "adornedStart", "adornedEnd", "sizeSmall", "multiline", "hiddenLabel"])
+}, Nt = wt(/* @__PURE__ */ y("path", {
+  d: "M7 10l5 5 5-5z"
+}), "ArrowDropDown");
+function Pt(o) {
+  return Z("MuiCircularProgress", o);
+}
+G("MuiCircularProgress", ["root", "determinate", "indeterminate", "colorPrimary", "colorSecondary", "svg", "circle", "circleDeterminate", "circleIndeterminate", "circleDisableShrink"]);
+const pe = 44, po = Vo`
+  0% {
+    transform: rotate(0deg);
+  }
+
+  100% {
+    transform: rotate(360deg);
+  }
+`, fo = Vo`
+  0% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: 0;
+  }
+
+  50% {
+    stroke-dasharray: 100px, 200px;
+    stroke-dashoffset: -15px;
+  }
+
+  100% {
+    stroke-dasharray: 100px, 200px;
+    stroke-dashoffset: -125px;
+  }
+`, Ft = typeof po != "string" ? Ho`
+        animation: ${po} 1.4s linear infinite;
+      ` : null, $t = typeof fo != "string" ? Ho`
+        animation: ${fo} 1.4s ease-in-out infinite;
+      ` : null, Lt = (o) => {
+  const {
+    classes: t,
+    variant: n,
+    color: r,
+    disableShrink: i
+  } = o, d = {
+    root: ["root", n, `color${H(r)}`],
+    svg: ["svg"],
+    circle: ["circle", `circle${H(n)}`, i && "circleDisableShrink"]
+  };
+  return J(d, Pt, t);
+}, Dt = M("span", {
+  name: "MuiCircularProgress",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [t.root, t[n.variant], t[`color${H(n.color)}`]];
+  }
+})(_(({
+  theme: o
+}) => ({
+  display: "inline-block",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: o.transitions.create("transform")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: Ft || {
+      animation: `${po} 1.4s linear infinite`
+    }
+  }, ...Object.entries(o.palette).filter(ze()).map(([t]) => ({
+    props: {
+      color: t
+    },
+    style: {
+      color: (o.vars || o).palette[t].main
+    }
+  }))]
+}))), At = M("svg", {
+  name: "MuiCircularProgress",
+  slot: "Svg",
+  overridesResolver: (o, t) => t.svg
+})({
+  display: "block"
+  // Keeps the progress centered
+}), jt = M("circle", {
+  name: "MuiCircularProgress",
+  slot: "Circle",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [t.circle, t[`circle${H(n.variant)}`], n.disableShrink && t.circleDisableShrink];
+  }
+})(_(({
+  theme: o
+}) => ({
+  stroke: "currentColor",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: o.transitions.create("stroke-dashoffset")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: {
+      // Some default value that looks fine waiting for the animation to kicks in.
+      strokeDasharray: "80px, 200px",
+      strokeDashoffset: 0
+      // Add the unit to fix a Edge 16 and below bug.
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.variant === "indeterminate" && !t.disableShrink,
+    style: $t || {
+      // At runtime for Pigment CSS, `bufferAnimation` will be null and the generated keyframe will be used.
+      animation: `${fo} 1.4s ease-in-out infinite`
+    }
+  }]
+}))), Xe = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    props: t,
+    name: "MuiCircularProgress"
+  }), {
+    className: i,
+    color: d = "primary",
+    disableShrink: a = !1,
+    size: c = 40,
+    style: f,
+    thickness: u = 3.6,
+    value: m = 0,
+    variant: C = "indeterminate",
+    ...S
+  } = r, v = {
+    ...r,
+    color: d,
+    disableShrink: a,
+    size: c,
+    thickness: u,
+    value: m,
+    variant: C
+  }, x = Lt(v), I = {}, O = {}, p = {};
+  if (C === "determinate") {
+    const h = 2 * Math.PI * ((pe - u) / 2);
+    I.strokeDasharray = h.toFixed(3), p["aria-valuenow"] = Math.round(m), I.strokeDashoffset = `${((100 - m) / 100 * h).toFixed(3)}px`, O.transform = "rotate(-90deg)";
+  }
+  return /* @__PURE__ */ y(Dt, {
+    className: Y(x.root, i),
+    style: {
+      width: c,
+      height: c,
+      ...O,
+      ...f
+    },
+    ownerState: v,
+    ref: n,
+    role: "progressbar",
+    ...p,
+    ...S,
+    children: /* @__PURE__ */ y(At, {
+      className: x.svg,
+      ownerState: v,
+      viewBox: `${pe / 2} ${pe / 2} ${pe} ${pe}`,
+      children: /* @__PURE__ */ y(jt, {
+        className: x.circle,
+        style: I,
+        ownerState: v,
+        cx: pe,
+        cy: pe,
+        r: (pe - u) / 2,
+        fill: "none",
+        strokeWidth: u
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Xe.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: e.oneOfType([e.oneOf(["inherit", "primary", "secondary", "error", "info", "success", "warning"]), e.string]),
+  /**
+   * If `true`, the shrink animation is disabled.
+   * This only works if variant is `indeterminate`.
+   * @default false
+   */
+  disableShrink: dt(e.bool, (o) => o.disableShrink && o.variant && o.variant !== "indeterminate" ? new Error("MUI: You have provided the `disableShrink` prop with a variant other than `indeterminate`. This will have no effect.") : null),
+  /**
+   * The size of the component.
+   * If using a number, the pixel unit is assumed.
+   * If using a string, you need to provide the CSS unit, for example '3rem'.
+   * @default 40
+   */
+  size: e.oneOfType([e.number, e.string]),
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The thickness of the circle.
+   * @default 3.6
+   */
+  thickness: e.number,
+  /**
+   * The value of the progress indicator for the determinate variant.
+   * Value between 0 and 100.
+   * @default 0
+   */
+  value: e.number,
+  /**
+   * The variant to use.
+   * Use indeterminate when there is no progress value.
+   * @default 'indeterminate'
+   */
+  variant: e.oneOf(["determinate", "indeterminate"])
+});
+const Bt = (o) => {
+  const {
+    classes: t,
+    disableUnderline: n,
+    startAdornment: r,
+    endAdornment: i,
+    size: d,
+    hiddenLabel: a,
+    multiline: c
+  } = o, f = {
+    root: ["root", !n && "underline", r && "adornedStart", i && "adornedEnd", d === "small" && `size${H(d)}`, a && "hiddenLabel", c && "multiline"],
+    input: ["input"]
+  }, u = J(f, Et, t);
+  return {
+    ...t,
+    // forward classes to the InputBase
+    ...u
+  };
+}, zt = M(Qe, {
+  shouldForwardProp: (o) => ne(o) || o === "classes",
+  name: "MuiFilledInput",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [...Ze(o, t), !n.disableUnderline && t.underline];
+  }
+})(_(({
+  theme: o
+}) => {
+  const t = o.palette.mode === "light", n = t ? "rgba(0, 0, 0, 0.42)" : "rgba(255, 255, 255, 0.7)", r = t ? "rgba(0, 0, 0, 0.06)" : "rgba(255, 255, 255, 0.09)", i = t ? "rgba(0, 0, 0, 0.09)" : "rgba(255, 255, 255, 0.13)", d = t ? "rgba(0, 0, 0, 0.12)" : "rgba(255, 255, 255, 0.12)";
+  return {
+    position: "relative",
+    backgroundColor: o.vars ? o.vars.palette.FilledInput.bg : r,
+    borderTopLeftRadius: (o.vars || o).shape.borderRadius,
+    borderTopRightRadius: (o.vars || o).shape.borderRadius,
+    transition: o.transitions.create("background-color", {
+      duration: o.transitions.duration.shorter,
+      easing: o.transitions.easing.easeOut
+    }),
+    "&:hover": {
+      backgroundColor: o.vars ? o.vars.palette.FilledInput.hoverBg : i,
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: o.vars ? o.vars.palette.FilledInput.bg : r
+      }
+    },
+    [`&.${ge.focused}`]: {
+      backgroundColor: o.vars ? o.vars.palette.FilledInput.bg : r
+    },
+    [`&.${ge.disabled}`]: {
+      backgroundColor: o.vars ? o.vars.palette.FilledInput.disabledBg : d
+    },
+    variants: [{
+      props: ({
+        ownerState: a
+      }) => !a.disableUnderline,
+      style: {
+        "&::after": {
+          left: 0,
+          bottom: 0,
+          content: '""',
+          position: "absolute",
+          right: 0,
+          transform: "scaleX(0)",
+          transition: o.transitions.create("transform", {
+            duration: o.transitions.duration.shorter,
+            easing: o.transitions.easing.easeOut
+          }),
+          pointerEvents: "none"
+          // Transparent to the hover style.
+        },
+        [`&.${ge.focused}:after`]: {
+          // translateX(0) is a workaround for Safari transform scale bug
+          // See https://github.com/mui/material-ui/issues/31766
+          transform: "scaleX(1) translateX(0)"
+        },
+        [`&.${ge.error}`]: {
+          "&::before, &::after": {
+            borderBottomColor: (o.vars || o).palette.error.main
+          }
+        },
+        "&::before": {
+          borderBottom: `1px solid ${o.vars ? `rgba(${o.vars.palette.common.onBackgroundChannel} / ${o.vars.opacity.inputUnderline})` : n}`,
+          left: 0,
+          bottom: 0,
+          content: '"\\00a0"',
+          position: "absolute",
+          right: 0,
+          transition: o.transitions.create("border-bottom-color", {
+            duration: o.transitions.duration.shorter
+          }),
+          pointerEvents: "none"
+          // Transparent to the hover style.
+        },
+        [`&:hover:not(.${ge.disabled}, .${ge.error}):before`]: {
+          borderBottom: `1px solid ${(o.vars || o).palette.text.primary}`
+        },
+        [`&.${ge.disabled}:before`]: {
+          borderBottomStyle: "dotted"
+        }
+      }
+    }, ...Object.entries(o.palette).filter(ze()).map(([a]) => {
+      var c;
+      return {
+        props: {
+          disableUnderline: !1,
+          color: a
+        },
+        style: {
+          "&::after": {
+            borderBottom: `2px solid ${(c = (o.vars || o).palette[a]) == null ? void 0 : c.main}`
+          }
+        }
+      };
+    }), {
+      props: ({
+        ownerState: a
+      }) => a.startAdornment,
+      style: {
+        paddingLeft: 12
+      }
+    }, {
+      props: ({
+        ownerState: a
+      }) => a.endAdornment,
+      style: {
+        paddingRight: 12
+      }
+    }, {
+      props: ({
+        ownerState: a
+      }) => a.multiline,
+      style: {
+        padding: "25px 12px 8px"
+      }
+    }, {
+      props: ({
+        ownerState: a,
+        size: c
+      }) => a.multiline && c === "small",
+      style: {
+        paddingTop: 21,
+        paddingBottom: 4
+      }
+    }, {
+      props: ({
+        ownerState: a
+      }) => a.multiline && a.hiddenLabel,
+      style: {
+        paddingTop: 16,
+        paddingBottom: 17
+      }
+    }, {
+      props: ({
+        ownerState: a
+      }) => a.multiline && a.hiddenLabel && a.size === "small",
+      style: {
+        paddingTop: 8,
+        paddingBottom: 9
+      }
+    }]
+  };
+})), Wt = M(eo, {
+  name: "MuiFilledInput",
+  slot: "Input",
+  overridesResolver: Je
+})(_(({
+  theme: o
+}) => ({
+  paddingTop: 25,
+  paddingRight: 12,
+  paddingBottom: 8,
+  paddingLeft: 12,
+  ...!o.vars && {
+    "&:-webkit-autofill": {
+      WebkitBoxShadow: o.palette.mode === "light" ? null : "0 0 0 100px #266798 inset",
+      WebkitTextFillColor: o.palette.mode === "light" ? null : "#fff",
+      caretColor: o.palette.mode === "light" ? null : "#fff",
+      borderTopLeftRadius: "inherit",
+      borderTopRightRadius: "inherit"
+    }
+  },
+  ...o.vars && {
+    "&:-webkit-autofill": {
+      borderTopLeftRadius: "inherit",
+      borderTopRightRadius: "inherit"
+    },
+    [o.getColorSchemeSelector("dark")]: {
+      "&:-webkit-autofill": {
+        WebkitBoxShadow: "0 0 0 100px #266798 inset",
+        WebkitTextFillColor: "#fff",
+        caretColor: "#fff"
+      }
+    }
+  },
+  variants: [{
+    props: {
+      size: "small"
+    },
+    style: {
+      paddingTop: 21,
+      paddingBottom: 4
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.hiddenLabel,
+    style: {
+      paddingTop: 16,
+      paddingBottom: 17
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.startAdornment,
+    style: {
+      paddingLeft: 0
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.endAdornment,
+    style: {
+      paddingRight: 0
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.hiddenLabel && t.size === "small",
+    style: {
+      paddingTop: 8,
+      paddingBottom: 9
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.multiline,
+    style: {
+      paddingTop: 0,
+      paddingBottom: 0,
+      paddingLeft: 0,
+      paddingRight: 0
+    }
+  }]
+}))), yo = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    props: t,
+    name: "MuiFilledInput"
+  }), {
+    disableUnderline: i = !1,
+    components: d = {},
+    componentsProps: a,
+    fullWidth: c = !1,
+    hiddenLabel: f,
+    // declare here to prevent spreading to DOM
+    inputComponent: u = "input",
+    multiline: m = !1,
+    slotProps: C,
+    slots: S = {},
+    type: v = "text",
+    ...x
+  } = r, I = {
+    ...r,
+    disableUnderline: i,
+    fullWidth: c,
+    inputComponent: u,
+    multiline: m,
+    type: v
+  }, O = Bt(r), p = {
+    root: {
+      ownerState: I
+    },
+    input: {
+      ownerState: I
+    }
+  }, h = C ?? a ? mo(p, C ?? a) : p, s = S.root ?? d.Root ?? zt, b = S.input ?? d.Input ?? Wt;
+  return /* @__PURE__ */ y(oo, {
+    slots: {
+      root: s,
+      input: b
+    },
+    slotProps: h,
+    fullWidth: c,
+    inputComponent: u,
+    multiline: m,
+    ref: n,
+    type: v,
+    ...x,
+    classes: O
+  });
+});
+process.env.NODE_ENV !== "production" && (yo.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * This prop helps users to fill forms faster, especially on mobile devices.
+   * The name can be confusing, as it's more like an autofill.
+   * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
+   */
+  autoComplete: e.string,
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   */
+  autoFocus: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * 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).
+   * The prop defaults to the value (`'primary'`) inherited from the parent FormControl component.
+   */
+  color: e.oneOfType([e.oneOf(["primary", "secondary"]), e.string]),
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Input: e.elementType,
+    Root: e.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. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    input: e.object,
+    root: e.object
+  }),
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: e.any,
+  /**
+   * If `true`, the component is disabled.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the input will not have an underline.
+   * @default false
+   */
+  disableUnderline: e.bool,
+  /**
+   * End `InputAdornment` for this component.
+   */
+  endAdornment: e.node,
+  /**
+   * If `true`, the `input` will indicate an error.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  error: e.bool,
+  /**
+   * If `true`, the `input` will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: e.bool,
+  /**
+   * If `true`, the label is hidden.
+   * This is used to increase density for a `FilledInput`.
+   * Be sure to add `aria-label` to the `input` element.
+   * @default false
+   */
+  hiddenLabel: e.bool,
+  /**
+   * The id of the `input` element.
+   */
+  id: e.string,
+  /**
+   * The component used for the `input` element.
+   * Either a string to use a HTML element or a component.
+   * @default 'input'
+   */
+  inputComponent: e.elementType,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   * @default {}
+   */
+  inputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: ke,
+  /**
+   * If `dense`, will adjust vertical spacing. This is normally obtained via context from
+   * FormControl.
+   * The prop defaults to the value (`'none'`) inherited from the parent FormControl component.
+   */
+  margin: e.oneOf(["dense", "none"]),
+  /**
+   * Maximum number of rows to display when multiline option is set to true.
+   */
+  maxRows: e.oneOfType([e.number, e.string]),
+  /**
+   * Minimum number of rows to display when multiline option is set to true.
+   */
+  minRows: e.oneOfType([e.number, e.string]),
+  /**
+   * If `true`, a [TextareaAutosize](https://mui.com/material-ui/react-textarea-autosize/) element is rendered.
+   * @default false
+   */
+  multiline: e.bool,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: e.string,
+  /**
+   * Callback fired when the value is changed.
+   *
+   * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   */
+  onChange: e.func,
+  /**
+   * The short hint displayed in the `input` before the user enters a value.
+   */
+  placeholder: e.string,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   */
+  readOnly: e.bool,
+  /**
+   * If `true`, the `input` element is required.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  required: e.bool,
+  /**
+   * Number of rows to display when multiline option is set to true.
+   */
+  rows: e.oneOfType([e.number, e.string]),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slotProps: e.shape({
+    input: e.object,
+    root: e.object
+  }),
+  /**
+   * The components used for each slot inside.
+   *
+   * This prop is an alias for the `components` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slots: e.shape({
+    input: e.elementType,
+    root: e.elementType
+  }),
+  /**
+   * Start `InputAdornment` for this component.
+   */
+  startAdornment: e.node,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
+   * @default 'text'
+   */
+  type: e.string,
+  /**
+   * The value of the `input` element, required for a controlled component.
+   */
+  value: e.any
+});
+yo.muiName = "Input";
+function Ut(o) {
+  return Z("MuiFormControl", o);
+}
+G("MuiFormControl", ["root", "marginNone", "marginNormal", "marginDense", "fullWidth", "disabled"]);
+const Vt = (o) => {
+  const {
+    classes: t,
+    margin: n,
+    fullWidth: r
+  } = o, i = {
+    root: ["root", n !== "none" && `margin${H(n)}`, r && "fullWidth"]
+  };
+  return J(i, Ut, t);
+}, Ht = M("div", {
+  name: "MuiFormControl",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [t.root, t[`margin${H(n.margin)}`], n.fullWidth && t.fullWidth];
+  }
+})({
+  display: "inline-flex",
+  flexDirection: "column",
+  position: "relative",
+  // Reset fieldset default style.
+  minWidth: 0,
+  padding: 0,
+  margin: 0,
+  border: 0,
+  verticalAlign: "top",
+  // Fix alignment issue on Safari.
+  variants: [{
+    props: {
+      margin: "normal"
+    },
+    style: {
+      marginTop: 16,
+      marginBottom: 8
+    }
+  }, {
+    props: {
+      margin: "dense"
+    },
+    style: {
+      marginTop: 8,
+      marginBottom: 4
+    }
+  }, {
+    props: {
+      fullWidth: !0
+    },
+    style: {
+      width: "100%"
+    }
+  }]
+}), Go = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    props: t,
+    name: "MuiFormControl"
+  }), {
+    children: i,
+    className: d,
+    color: a = "primary",
+    component: c = "div",
+    disabled: f = !1,
+    error: u = !1,
+    focused: m,
+    fullWidth: C = !1,
+    hiddenLabel: S = !1,
+    margin: v = "none",
+    required: x = !1,
+    size: I = "medium",
+    variant: O = "outlined",
+    ...p
+  } = r, h = {
+    ...r,
+    color: a,
+    component: c,
+    disabled: f,
+    error: u,
+    fullWidth: C,
+    hiddenLabel: S,
+    margin: v,
+    required: x,
+    size: I,
+    variant: O
+  }, s = Vt(h), [b, R] = l.useState(() => {
+    let W = !1;
+    return i && l.Children.forEach(i, (g) => {
+      if (!lo(g, ["Input", "Select"]))
+        return;
+      const E = lo(g, ["Select"]) ? g.props.input : g;
+      E && It(E.props) && (W = !0);
+    }), W;
+  }), [L, N] = l.useState(() => {
+    let W = !1;
+    return i && l.Children.forEach(i, (g) => {
+      lo(g, ["Input", "Select"]) && (Ye(g.props, !0) || Ye(g.props.inputProps, !0)) && (W = !0);
+    }), W;
+  }), [k, j] = l.useState(!1);
+  f && k && j(!1);
+  const P = m !== void 0 && !f ? m : k;
+  let B;
+  const z = l.useRef(!1);
+  process.env.NODE_ENV !== "production" && (B = () => (z.current && console.error(["MUI: There are multiple `InputBase` components inside a FormControl.", "This creates visual inconsistencies, only use one `InputBase`."].join(`
+`)), z.current = !0, () => {
+    z.current = !1;
+  }));
+  const U = l.useMemo(() => ({
+    adornedStart: b,
+    setAdornedStart: R,
+    color: a,
+    disabled: f,
+    error: u,
+    filled: L,
+    focused: P,
+    fullWidth: C,
+    hiddenLabel: S,
+    size: I,
+    onBlur: () => {
+      j(!1);
+    },
+    onEmpty: () => {
+      N(!1);
+    },
+    onFilled: () => {
+      N(!0);
+    },
+    onFocus: () => {
+      j(!0);
+    },
+    registerEffect: B,
+    required: x,
+    variant: O
+  }), [b, a, f, u, L, P, C, S, B, x, I, O]);
+  return /* @__PURE__ */ y(qo.Provider, {
+    value: U,
+    children: /* @__PURE__ */ y(Ht, {
+      as: c,
+      ownerState: h,
+      className: Y(s.root, d),
+      ref: n,
+      ...p,
+      children: i
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Go.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: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: e.oneOfType([e.oneOf(["primary", "secondary", "error", "info", "success", "warning"]), e.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, the label, input and helper text should be displayed in a disabled state.
+   * @default false
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the label is displayed in an error state.
+   * @default false
+   */
+  error: e.bool,
+  /**
+   * If `true`, the component is displayed in focused state.
+   */
+  focused: e.bool,
+  /**
+   * If `true`, the component will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: e.bool,
+  /**
+   * If `true`, the label is hidden.
+   * This is used to increase density for a `FilledInput`.
+   * Be sure to add `aria-label` to the `input` element.
+   * @default false
+   */
+  hiddenLabel: e.bool,
+  /**
+   * If `dense` or `normal`, will adjust vertical spacing of this and contained components.
+   * @default 'none'
+   */
+  margin: e.oneOf(["dense", "none", "normal"]),
+  /**
+   * If `true`, the label will indicate that the `input` is required.
+   * @default false
+   */
+  required: e.bool,
+  /**
+   * The size of the component.
+   * @default 'medium'
+   */
+  size: e.oneOfType([e.oneOf(["medium", "small"]), e.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The variant to use.
+   * @default 'outlined'
+   */
+  variant: e.oneOf(["filled", "outlined", "standard"])
+});
+function qt(o) {
+  return Z("MuiFormLabel", o);
+}
+const je = G("MuiFormLabel", ["root", "colorSecondary", "focused", "disabled", "error", "filled", "required", "asterisk"]), _t = (o) => {
+  const {
+    classes: t,
+    color: n,
+    focused: r,
+    disabled: i,
+    error: d,
+    filled: a,
+    required: c
+  } = o, f = {
+    root: ["root", `color${H(n)}`, i && "disabled", d && "error", a && "filled", r && "focused", c && "required"],
+    asterisk: ["asterisk", d && "error"]
+  };
+  return J(f, qt, t);
+}, Kt = M("label", {
+  name: "MuiFormLabel",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [t.root, n.color === "secondary" && t.colorSecondary, n.filled && t.filled];
+  }
+})(_(({
+  theme: o
+}) => ({
+  color: (o.vars || o).palette.text.secondary,
+  ...o.typography.body1,
+  lineHeight: "1.4375em",
+  padding: 0,
+  position: "relative",
+  variants: [...Object.entries(o.palette).filter(ze()).map(([t]) => ({
+    props: {
+      color: t
+    },
+    style: {
+      [`&.${je.focused}`]: {
+        color: (o.vars || o).palette[t].main
+      }
+    }
+  })), {
+    props: {},
+    style: {
+      [`&.${je.disabled}`]: {
+        color: (o.vars || o).palette.text.disabled
+      },
+      [`&.${je.error}`]: {
+        color: (o.vars || o).palette.error.main
+      }
+    }
+  }]
+}))), Gt = M("span", {
+  name: "MuiFormLabel",
+  slot: "Asterisk",
+  overridesResolver: (o, t) => t.asterisk
+})(_(({
+  theme: o
+}) => ({
+  [`&.${je.error}`]: {
+    color: (o.vars || o).palette.error.main
+  }
+}))), Xo = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    props: t,
+    name: "MuiFormLabel"
+  }), {
+    children: i,
+    className: d,
+    color: a,
+    component: c = "label",
+    disabled: f,
+    error: u,
+    filled: m,
+    focused: C,
+    required: S,
+    ...v
+  } = r, x = We(), I = Ue({
+    props: r,
+    muiFormControl: x,
+    states: ["color", "required", "focused", "disabled", "error", "filled"]
+  }), O = {
+    ...r,
+    color: I.color || "primary",
+    component: c,
+    disabled: I.disabled,
+    error: I.error,
+    filled: I.filled,
+    focused: I.focused,
+    required: I.required
+  }, p = _t(O);
+  return /* @__PURE__ */ q(Kt, {
+    as: c,
+    ownerState: O,
+    className: Y(p.root, d),
+    ref: n,
+    ...v,
+    children: [i, I.required && /* @__PURE__ */ q(Gt, {
+      ownerState: O,
+      "aria-hidden": !0,
+      className: p.asterisk,
+      children: [" ", "*"]
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (Xo.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: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.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).
+   */
+  color: e.oneOfType([e.oneOf(["error", "info", "primary", "secondary", "success", "warning"]), e.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, the label should be displayed in a disabled state.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the label is displayed in an error state.
+   */
+  error: e.bool,
+  /**
+   * If `true`, the label should use filled classes key.
+   */
+  filled: e.bool,
+  /**
+   * If `true`, the input of this label is focused (used by `FormGroup` components).
+   */
+  focused: e.bool,
+  /**
+   * If `true`, the label will indicate that the `input` is required.
+   */
+  required: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+const Xt = (o) => {
+  const {
+    classes: t,
+    disableUnderline: n
+  } = o, i = J({
+    root: ["root", !n && "underline"],
+    input: ["input"]
+  }, Tt, t);
+  return {
+    ...t,
+    // forward classes to the InputBase
+    ...i
+  };
+}, Yt = M(Qe, {
+  shouldForwardProp: (o) => ne(o) || o === "classes",
+  name: "MuiInput",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [...Ze(o, t), !n.disableUnderline && t.underline];
+  }
+})(_(({
+  theme: o
+}) => {
+  let n = o.palette.mode === "light" ? "rgba(0, 0, 0, 0.42)" : "rgba(255, 255, 255, 0.7)";
+  return o.vars && (n = `rgba(${o.vars.palette.common.onBackgroundChannel} / ${o.vars.opacity.inputUnderline})`), {
+    position: "relative",
+    variants: [{
+      props: ({
+        ownerState: r
+      }) => r.formControl,
+      style: {
+        "label + &": {
+          marginTop: 16
+        }
+      }
+    }, {
+      props: ({
+        ownerState: r
+      }) => !r.disableUnderline,
+      style: {
+        "&::after": {
+          left: 0,
+          bottom: 0,
+          content: '""',
+          position: "absolute",
+          right: 0,
+          transform: "scaleX(0)",
+          transition: o.transitions.create("transform", {
+            duration: o.transitions.duration.shorter,
+            easing: o.transitions.easing.easeOut
+          }),
+          pointerEvents: "none"
+          // Transparent to the hover style.
+        },
+        [`&.${$e.focused}:after`]: {
+          // translateX(0) is a workaround for Safari transform scale bug
+          // See https://github.com/mui/material-ui/issues/31766
+          transform: "scaleX(1) translateX(0)"
+        },
+        [`&.${$e.error}`]: {
+          "&::before, &::after": {
+            borderBottomColor: (o.vars || o).palette.error.main
+          }
+        },
+        "&::before": {
+          borderBottom: `1px solid ${n}`,
+          left: 0,
+          bottom: 0,
+          content: '"\\00a0"',
+          position: "absolute",
+          right: 0,
+          transition: o.transitions.create("border-bottom-color", {
+            duration: o.transitions.duration.shorter
+          }),
+          pointerEvents: "none"
+          // Transparent to the hover style.
+        },
+        [`&:hover:not(.${$e.disabled}, .${$e.error}):before`]: {
+          borderBottom: `2px solid ${(o.vars || o).palette.text.primary}`,
+          // Reset on touch devices, it doesn't add specificity
+          "@media (hover: none)": {
+            borderBottom: `1px solid ${n}`
+          }
+        },
+        [`&.${$e.disabled}:before`]: {
+          borderBottomStyle: "dotted"
+        }
+      }
+    }, ...Object.entries(o.palette).filter(ze()).map(([r]) => ({
+      props: {
+        color: r,
+        disableUnderline: !1
+      },
+      style: {
+        "&::after": {
+          borderBottom: `2px solid ${(o.vars || o).palette[r].main}`
+        }
+      }
+    }))]
+  };
+})), Zt = M(eo, {
+  name: "MuiInput",
+  slot: "Input",
+  overridesResolver: Je
+})({}), go = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    props: t,
+    name: "MuiInput"
+  }), {
+    disableUnderline: i = !1,
+    components: d = {},
+    componentsProps: a,
+    fullWidth: c = !1,
+    inputComponent: f = "input",
+    multiline: u = !1,
+    slotProps: m,
+    slots: C = {},
+    type: S = "text",
+    ...v
+  } = r, x = Xt(r), O = {
+    root: {
+      ownerState: {
+        disableUnderline: i
+      }
+    }
+  }, p = m ?? a ? mo(m ?? a, O) : O, h = C.root ?? d.Root ?? Yt, s = C.input ?? d.Input ?? Zt;
+  return /* @__PURE__ */ y(oo, {
+    slots: {
+      root: h,
+      input: s
+    },
+    slotProps: p,
+    fullWidth: c,
+    inputComponent: f,
+    multiline: u,
+    ref: n,
+    type: S,
+    ...v,
+    classes: x
+  });
+});
+process.env.NODE_ENV !== "production" && (go.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * This prop helps users to fill forms faster, especially on mobile devices.
+   * The name can be confusing, as it's more like an autofill.
+   * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
+   */
+  autoComplete: e.string,
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   */
+  autoFocus: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * 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).
+   * The prop defaults to the value (`'primary'`) inherited from the parent FormControl component.
+   */
+  color: e.oneOfType([e.oneOf(["primary", "secondary"]), e.string]),
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Input: e.elementType,
+    Root: e.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. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    input: e.object,
+    root: e.object
+  }),
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: e.any,
+  /**
+   * If `true`, the component is disabled.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the `input` will not have an underline.
+   * @default false
+   */
+  disableUnderline: e.bool,
+  /**
+   * End `InputAdornment` for this component.
+   */
+  endAdornment: e.node,
+  /**
+   * If `true`, the `input` will indicate an error.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  error: e.bool,
+  /**
+   * If `true`, the `input` will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: e.bool,
+  /**
+   * The id of the `input` element.
+   */
+  id: e.string,
+  /**
+   * The component used for the `input` element.
+   * Either a string to use a HTML element or a component.
+   * @default 'input'
+   */
+  inputComponent: e.elementType,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   * @default {}
+   */
+  inputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: ke,
+  /**
+   * If `dense`, will adjust vertical spacing. This is normally obtained via context from
+   * FormControl.
+   * The prop defaults to the value (`'none'`) inherited from the parent FormControl component.
+   */
+  margin: e.oneOf(["dense", "none"]),
+  /**
+   * Maximum number of rows to display when multiline option is set to true.
+   */
+  maxRows: e.oneOfType([e.number, e.string]),
+  /**
+   * Minimum number of rows to display when multiline option is set to true.
+   */
+  minRows: e.oneOfType([e.number, e.string]),
+  /**
+   * If `true`, a [TextareaAutosize](https://mui.com/material-ui/react-textarea-autosize/) element is rendered.
+   * @default false
+   */
+  multiline: e.bool,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: e.string,
+  /**
+   * Callback fired when the value is changed.
+   *
+   * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   */
+  onChange: e.func,
+  /**
+   * The short hint displayed in the `input` before the user enters a value.
+   */
+  placeholder: e.string,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   */
+  readOnly: e.bool,
+  /**
+   * If `true`, the `input` element is required.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  required: e.bool,
+  /**
+   * Number of rows to display when multiline option is set to true.
+   */
+  rows: e.oneOfType([e.number, e.string]),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slotProps: e.shape({
+    input: e.object,
+    root: e.object
+  }),
+  /**
+   * The components used for each slot inside.
+   *
+   * This prop is an alias for the `components` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slots: e.shape({
+    input: e.elementType,
+    root: e.elementType
+  }),
+  /**
+   * Start `InputAdornment` for this component.
+   */
+  startAdornment: e.node,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
+   * @default 'text'
+   */
+  type: e.string,
+  /**
+   * The value of the `input` element, required for a controlled component.
+   */
+  value: e.any
+});
+go.muiName = "Input";
+function Jt(o) {
+  return Z("MuiInputLabel", o);
+}
+G("MuiInputLabel", ["root", "focused", "disabled", "error", "required", "asterisk", "formControl", "sizeSmall", "shrink", "animated", "standard", "filled", "outlined"]);
+const Qt = (o) => {
+  const {
+    classes: t,
+    formControl: n,
+    size: r,
+    shrink: i,
+    disableAnimation: d,
+    variant: a,
+    required: c
+  } = o, f = {
+    root: ["root", n && "formControl", !d && "animated", i && "shrink", r && r !== "normal" && `size${H(r)}`, a],
+    asterisk: [c && "asterisk"]
+  }, u = J(f, Jt, t);
+  return {
+    ...t,
+    // forward the focused, disabled, etc. classes to the FormLabel
+    ...u
+  };
+}, en = M(Xo, {
+  shouldForwardProp: (o) => ne(o) || o === "classes",
+  name: "MuiInputLabel",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [{
+      [`& .${je.asterisk}`]: t.asterisk
+    }, t.root, n.formControl && t.formControl, n.size === "small" && t.sizeSmall, n.shrink && t.shrink, !n.disableAnimation && t.animated, n.focused && t.focused, t[n.variant]];
+  }
+})(_(({
+  theme: o
+}) => ({
+  display: "block",
+  transformOrigin: "top left",
+  whiteSpace: "nowrap",
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  maxWidth: "100%",
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.formControl,
+    style: {
+      position: "absolute",
+      left: 0,
+      top: 0,
+      // slight alteration to spec spacing to match visual spec result
+      transform: "translate(0, 20px) scale(1)"
+    }
+  }, {
+    props: {
+      size: "small"
+    },
+    style: {
+      // Compensation for the `Input.inputSizeSmall` style.
+      transform: "translate(0, 17px) scale(1)"
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.shrink,
+    style: {
+      transform: "translate(0, -1.5px) scale(0.75)",
+      transformOrigin: "top left",
+      maxWidth: "133%"
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => !t.disableAnimation,
+    style: {
+      transition: o.transitions.create(["color", "transform", "max-width"], {
+        duration: o.transitions.duration.shorter,
+        easing: o.transitions.easing.easeOut
+      })
+    }
+  }, {
+    props: {
+      variant: "filled"
+    },
+    style: {
+      // Chrome's autofill feature gives the input field a yellow background.
+      // Since the input field is behind the label in the HTML tree,
+      // the input field is drawn last and hides the label with an opaque background color.
+      // zIndex: 1 will raise the label above opaque background-colors of input.
+      zIndex: 1,
+      pointerEvents: "none",
+      transform: "translate(12px, 16px) scale(1)",
+      maxWidth: "calc(100% - 24px)"
+    }
+  }, {
+    props: {
+      variant: "filled",
+      size: "small"
+    },
+    style: {
+      transform: "translate(12px, 13px) scale(1)"
+    }
+  }, {
+    props: ({
+      variant: t,
+      ownerState: n
+    }) => t === "filled" && n.shrink,
+    style: {
+      userSelect: "none",
+      pointerEvents: "auto",
+      transform: "translate(12px, 7px) scale(0.75)",
+      maxWidth: "calc(133% - 24px)"
+    }
+  }, {
+    props: ({
+      variant: t,
+      ownerState: n,
+      size: r
+    }) => t === "filled" && n.shrink && r === "small",
+    style: {
+      transform: "translate(12px, 4px) scale(0.75)"
+    }
+  }, {
+    props: {
+      variant: "outlined"
+    },
+    style: {
+      // see comment above on filled.zIndex
+      zIndex: 1,
+      pointerEvents: "none",
+      transform: "translate(14px, 16px) scale(1)",
+      maxWidth: "calc(100% - 24px)"
+    }
+  }, {
+    props: {
+      variant: "outlined",
+      size: "small"
+    },
+    style: {
+      transform: "translate(14px, 9px) scale(1)"
+    }
+  }, {
+    props: ({
+      variant: t,
+      ownerState: n
+    }) => t === "outlined" && n.shrink,
+    style: {
+      userSelect: "none",
+      pointerEvents: "auto",
+      // Theoretically, we should have (8+5)*2/0.75 = 34px
+      // but it feels a better when it bleeds a bit on the left, so 32px.
+      maxWidth: "calc(133% - 32px)",
+      transform: "translate(14px, -9px) scale(0.75)"
+    }
+  }]
+}))), Yo = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    name: "MuiInputLabel",
+    props: t
+  }), {
+    disableAnimation: i = !1,
+    margin: d,
+    shrink: a,
+    variant: c,
+    className: f,
+    ...u
+  } = r, m = We();
+  let C = a;
+  typeof C > "u" && m && (C = m.filled || m.focused || m.adornedStart);
+  const S = Ue({
+    props: r,
+    muiFormControl: m,
+    states: ["size", "variant", "required", "focused"]
+  }), v = {
+    ...r,
+    disableAnimation: i,
+    formControl: m,
+    shrink: C,
+    size: S.size,
+    variant: S.variant,
+    required: S.required,
+    focused: S.focused
+  }, x = Qt(v);
+  return /* @__PURE__ */ y(en, {
+    "data-shrink": C,
+    ref: n,
+    className: Y(x.root, f),
+    ...u,
+    ownerState: v,
+    classes: x
+  });
+});
+process.env.NODE_ENV !== "production" && (Yo.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: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.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).
+   */
+  color: e.oneOfType([e.oneOf(["error", "info", "primary", "secondary", "success", "warning"]), e.string]),
+  /**
+   * If `true`, the transition animation is disabled.
+   * @default false
+   */
+  disableAnimation: e.bool,
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the label is displayed in an error state.
+   */
+  error: e.bool,
+  /**
+   * If `true`, the `input` of this label is focused.
+   */
+  focused: e.bool,
+  /**
+   * If `dense`, will adjust vertical spacing. This is normally obtained via context from
+   * FormControl.
+   */
+  margin: e.oneOf(["dense"]),
+  /**
+   * if `true`, the label will indicate that the `input` is required.
+   */
+  required: e.bool,
+  /**
+   * If `true`, the label is shrunk.
+   */
+  shrink: e.bool,
+  /**
+   * The size of the component.
+   * @default 'normal'
+   */
+  size: e.oneOfType([e.oneOf(["normal", "small"]), e.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The variant to use.
+   */
+  variant: e.oneOf(["filled", "outlined", "standard"])
+});
+const Do = G("MuiListItemIcon", ["root", "alignItemsFlexStart"]), Ao = G("MuiListItemText", ["root", "multiline", "dense", "inset", "primary", "secondary"]);
+function co(o, t, n) {
+  return o === t ? o.firstChild : t && t.nextElementSibling ? t.nextElementSibling : n ? null : o.firstChild;
+}
+function jo(o, t, n) {
+  return o === t ? n ? o.firstChild : o.lastChild : t && t.previousElementSibling ? t.previousElementSibling : n ? null : o.lastChild;
+}
+function Zo(o, t) {
+  if (t === void 0)
+    return !0;
+  let n = o.innerText;
+  return n === void 0 && (n = o.textContent), n = n.trim().toLowerCase(), n.length === 0 ? !1 : t.repeating ? n[0] === t.keys[0] : n.startsWith(t.keys.join(""));
+}
+function Le(o, t, n, r, i, d) {
+  let a = !1, c = i(o, t, t ? n : !1);
+  for (; c; ) {
+    if (c === o.firstChild) {
+      if (a)
+        return !1;
+      a = !0;
+    }
+    const f = r ? !1 : c.disabled || c.getAttribute("aria-disabled") === "true";
+    if (!c.hasAttribute("tabindex") || !Zo(c, d) || f)
+      c = i(o, c, n);
+    else
+      return c.focus(), !0;
+  }
+  return !1;
+}
+const Jo = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const {
+    // private
+    // eslint-disable-next-line react/prop-types
+    actions: r,
+    autoFocus: i = !1,
+    autoFocusItem: d = !1,
+    children: a,
+    className: c,
+    disabledItemsFocusable: f = !1,
+    disableListWrap: u = !1,
+    onKeyDown: m,
+    variant: C = "selectedMenu",
+    ...S
+  } = t, v = l.useRef(null), x = l.useRef({
+    keys: [],
+    repeating: !0,
+    previousKeyMatched: !0,
+    lastTime: null
+  });
+  Be(() => {
+    i && v.current.focus();
+  }, [i]), l.useImperativeHandle(r, () => ({
+    adjustStyleForScrollbar: (s, {
+      direction: b
+    }) => {
+      const R = !v.current.style.width;
+      if (s.clientHeight < v.current.clientHeight && R) {
+        const L = `${ht(uo(s))}px`;
+        v.current.style[b === "rtl" ? "paddingLeft" : "paddingRight"] = L, v.current.style.width = `calc(100% + ${L})`;
+      }
+      return v.current;
+    }
+  }), []);
+  const I = (s) => {
+    const b = v.current, R = s.key;
+    if (s.ctrlKey || s.metaKey || s.altKey) {
+      m && m(s);
+      return;
+    }
+    const N = _o(b).activeElement;
+    if (R === "ArrowDown")
+      s.preventDefault(), Le(b, N, u, f, co);
+    else if (R === "ArrowUp")
+      s.preventDefault(), Le(b, N, u, f, jo);
+    else if (R === "Home")
+      s.preventDefault(), Le(b, null, u, f, co);
+    else if (R === "End")
+      s.preventDefault(), Le(b, null, u, f, jo);
+    else if (R.length === 1) {
+      const k = x.current, j = R.toLowerCase(), P = performance.now();
+      k.keys.length > 0 && (P - k.lastTime > 500 ? (k.keys = [], k.repeating = !0, k.previousKeyMatched = !0) : k.repeating && j !== k.keys[0] && (k.repeating = !1)), k.lastTime = P, k.keys.push(j);
+      const B = N && !k.repeating && Zo(N, k);
+      k.previousKeyMatched && (B || Le(b, N, !1, f, co, k)) ? s.preventDefault() : k.previousKeyMatched = !1;
+    }
+    m && m(s);
+  }, O = Te(v, n);
+  let p = -1;
+  l.Children.forEach(a, (s, b) => {
+    if (!/* @__PURE__ */ l.isValidElement(s)) {
+      p === b && (p += 1, p >= a.length && (p = -1));
+      return;
+    }
+    process.env.NODE_ENV !== "production" && bo.isFragment(s) && console.error(["MUI: The Menu component doesn't accept a Fragment as a child.", "Consider providing an array instead."].join(`
+`)), s.props.disabled || (C === "selectedMenu" && s.props.selected || p === -1) && (p = b), p === b && (s.props.disabled || s.props.muiSkipListHighlight || s.type.muiSkipListHighlight) && (p += 1, p >= a.length && (p = -1));
+  });
+  const h = l.Children.map(a, (s, b) => {
+    if (b === p) {
+      const R = {};
+      return d && (R.autoFocus = !0), s.props.tabIndex === void 0 && C === "selectedMenu" && (R.tabIndex = 0), /* @__PURE__ */ l.cloneElement(s, R);
+    }
+    return s;
+  });
+  return /* @__PURE__ */ y(ft, {
+    role: "menu",
+    ref: O,
+    className: c,
+    onKeyDown: I,
+    tabIndex: i ? 0 : -1,
+    ...S,
+    children: h
+  });
+});
+process.env.NODE_ENV !== "production" && (Jo.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, will focus the `[role="menu"]` container and move into tab order.
+   * @default false
+   */
+  autoFocus: e.bool,
+  /**
+   * If `true`, will focus the first menuitem if `variant="menu"` or selected item
+   * if `variant="selectedMenu"`.
+   * @default false
+   */
+  autoFocusItem: e.bool,
+  /**
+   * MenuList contents, normally `MenuItem`s.
+   */
+  children: e.node,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * If `true`, will allow focus on disabled items.
+   * @default false
+   */
+  disabledItemsFocusable: e.bool,
+  /**
+   * If `true`, the menu items will not wrap focus.
+   * @default false
+   */
+  disableListWrap: e.bool,
+  /**
+   * @ignore
+   */
+  onKeyDown: e.func,
+  /**
+   * The variant to use. Use `menu` to prevent selected items from impacting the initial focus
+   * and the vertical alignment relative to the anchor element.
+   * @default 'selectedMenu'
+   */
+  variant: e.oneOf(["menu", "selectedMenu"])
+});
+function on(o) {
+  return Z("MuiMenu", o);
+}
+G("MuiMenu", ["root", "paper", "list"]);
+const tn = {
+  vertical: "top",
+  horizontal: "right"
+}, nn = {
+  vertical: "top",
+  horizontal: "left"
+}, rn = (o) => {
+  const {
+    classes: t
+  } = o;
+  return J({
+    root: ["root"],
+    paper: ["paper"],
+    list: ["list"]
+  }, on, t);
+}, sn = M(yt, {
+  shouldForwardProp: (o) => ne(o) || o === "classes",
+  name: "MuiMenu",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})({}), an = M(gt, {
+  name: "MuiMenu",
+  slot: "Paper",
+  overridesResolver: (o, t) => t.paper
+})({
+  // specZ: The maximum height of a simple menu should be one or more rows less than the view
+  // height. This ensures a tappable area outside of the simple menu with which to dismiss
+  // the menu.
+  maxHeight: "calc(100% - 96px)",
+  // Add iOS momentum scrolling for iOS < 13.0
+  WebkitOverflowScrolling: "touch"
+}), ln = M(Jo, {
+  name: "MuiMenu",
+  slot: "List",
+  overridesResolver: (o, t) => t.list
+})({
+  // We disable the focus ring for mouse, touch and keyboard users.
+  outline: 0
+}), Qo = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    props: t,
+    name: "MuiMenu"
+  }), {
+    autoFocus: i = !0,
+    children: d,
+    className: a,
+    disableAutoFocusItem: c = !1,
+    MenuListProps: f = {},
+    onClose: u,
+    open: m,
+    PaperProps: C = {},
+    PopoverClasses: S,
+    transitionDuration: v = "auto",
+    TransitionProps: {
+      onEntering: x,
+      ...I
+    } = {},
+    variant: O = "selectedMenu",
+    slots: p = {},
+    slotProps: h = {},
+    ...s
+  } = r, b = mt(), R = {
+    ...r,
+    autoFocus: i,
+    disableAutoFocusItem: c,
+    MenuListProps: f,
+    onEntering: x,
+    PaperProps: C,
+    transitionDuration: v,
+    TransitionProps: I,
+    variant: O
+  }, L = rn(R), N = i && !c && m, k = l.useRef(null), j = (E, F) => {
+    k.current && k.current.adjustStyleForScrollbar(E, {
+      direction: b ? "rtl" : "ltr"
+    }), x && x(E, F);
+  }, P = (E) => {
+    E.key === "Tab" && (E.preventDefault(), u && u(E, "tabKeyDown"));
+  };
+  let B = -1;
+  l.Children.map(d, (E, F) => {
+    /* @__PURE__ */ l.isValidElement(E) && (process.env.NODE_ENV !== "production" && bo.isFragment(E) && console.error(["MUI: The Menu component doesn't accept a Fragment as a child.", "Consider providing an array instead."].join(`
+`)), E.props.disabled || (O === "selectedMenu" && E.props.selected || B === -1) && (B = F));
+  });
+  const z = p.paper ?? an, U = h.paper ?? C, W = Eo({
+    elementType: p.root,
+    externalSlotProps: h.root,
+    ownerState: R,
+    className: [L.root, a]
+  }), g = Eo({
+    elementType: z,
+    externalSlotProps: U,
+    ownerState: R,
+    className: L.paper
+  });
+  return /* @__PURE__ */ y(sn, {
+    onClose: u,
+    anchorOrigin: {
+      vertical: "bottom",
+      horizontal: b ? "right" : "left"
+    },
+    transformOrigin: b ? tn : nn,
+    slots: {
+      paper: z,
+      root: p.root
+    },
+    slotProps: {
+      root: W,
+      paper: g
+    },
+    open: m,
+    ref: n,
+    transitionDuration: v,
+    TransitionProps: {
+      onEntering: j,
+      ...I
+    },
+    ownerState: R,
+    ...s,
+    classes: S,
+    children: /* @__PURE__ */ y(ln, {
+      onKeyDown: P,
+      actions: k,
+      autoFocus: i && (B === -1 || c),
+      autoFocusItem: N,
+      variant: O,
+      ...f,
+      className: Y(L.list, f.className),
+      children: d
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Qo.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * An HTML element, or a function that returns one.
+   * It's used to set the position of the menu.
+   */
+  anchorEl: e.oneOfType([vt, e.func]),
+  /**
+   * If `true` (Default) will focus the `[role="menu"]` if no focusable child is found. Disabled
+   * children are not focusable. If you set this prop to `false` focus will be placed
+   * on the parent modal container. This has severe accessibility implications
+   * and should only be considered if you manage focus otherwise.
+   * @default true
+   */
+  autoFocus: e.bool,
+  /**
+   * Menu contents, normally `MenuItem`s.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * When opening the menu will not focus the active item but the `[role="menu"]`
+   * unless `autoFocus` is also set to `false`. Not using the default means not
+   * following WAI-ARIA authoring practices. Please be considerate about possible
+   * accessibility implications.
+   * @default false
+   */
+  disableAutoFocusItem: e.bool,
+  /**
+   * Props applied to the [`MenuList`](https://mui.com/material-ui/api/menu-list/) element.
+   * @default {}
+   */
+  MenuListProps: e.object,
+  /**
+   * Callback fired when the component requests to be closed.
+   *
+   * @param {object} event The event source of the callback.
+   * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`, `"tabKeyDown"`.
+   */
+  onClose: e.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool.isRequired,
+  /**
+   * @ignore
+   */
+  PaperProps: e.object,
+  /**
+   * `classes` prop applied to the [`Popover`](https://mui.com/material-ui/api/popover/) element.
+   */
+  PopoverClasses: e.object,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    paper: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    paper: e.elementType,
+    root: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The length of the transition in `ms`, or 'auto'
+   * @default 'auto'
+   */
+  transitionDuration: e.oneOfType([e.oneOf(["auto"]), e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })]),
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
+   * @default {}
+   */
+  TransitionProps: e.object,
+  /**
+   * The variant to use. Use `menu` to prevent selected items from impacting the initial focus.
+   * @default 'selectedMenu'
+   */
+  variant: e.oneOf(["menu", "selectedMenu"])
+});
+function cn(o) {
+  return Z("MuiMenuItem", o);
+}
+const De = G("MuiMenuItem", ["root", "focusVisible", "dense", "disabled", "divider", "gutters", "selected"]), dn = (o, t) => {
+  const {
+    ownerState: n
+  } = o;
+  return [t.root, n.dense && t.dense, n.divider && t.divider, !n.disableGutters && t.gutters];
+}, un = (o) => {
+  const {
+    disabled: t,
+    dense: n,
+    divider: r,
+    disableGutters: i,
+    selected: d,
+    classes: a
+  } = o, f = J({
+    root: ["root", n && "dense", t && "disabled", !i && "gutters", r && "divider", d && "selected"]
+  }, cn, a);
+  return {
+    ...a,
+    ...f
+  };
+}, pn = M(ut, {
+  shouldForwardProp: (o) => ne(o) || o === "classes",
+  name: "MuiMenuItem",
+  slot: "Root",
+  overridesResolver: dn
+})(_(({
+  theme: o
+}) => ({
+  ...o.typography.body1,
+  display: "flex",
+  justifyContent: "flex-start",
+  alignItems: "center",
+  position: "relative",
+  textDecoration: "none",
+  minHeight: 48,
+  paddingTop: 6,
+  paddingBottom: 6,
+  boxSizing: "border-box",
+  whiteSpace: "nowrap",
+  "&:hover": {
+    textDecoration: "none",
+    backgroundColor: (o.vars || o).palette.action.hover,
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  },
+  [`&.${De.selected}`]: {
+    backgroundColor: o.vars ? `rgba(${o.vars.palette.primary.mainChannel} / ${o.vars.palette.action.selectedOpacity})` : _e(o.palette.primary.main, o.palette.action.selectedOpacity),
+    [`&.${De.focusVisible}`]: {
+      backgroundColor: o.vars ? `rgba(${o.vars.palette.primary.mainChannel} / calc(${o.vars.palette.action.selectedOpacity} + ${o.vars.palette.action.focusOpacity}))` : _e(o.palette.primary.main, o.palette.action.selectedOpacity + o.palette.action.focusOpacity)
+    }
+  },
+  [`&.${De.selected}:hover`]: {
+    backgroundColor: o.vars ? `rgba(${o.vars.palette.primary.mainChannel} / calc(${o.vars.palette.action.selectedOpacity} + ${o.vars.palette.action.hoverOpacity}))` : _e(o.palette.primary.main, o.palette.action.selectedOpacity + o.palette.action.hoverOpacity),
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: o.vars ? `rgba(${o.vars.palette.primary.mainChannel} / ${o.vars.palette.action.selectedOpacity})` : _e(o.palette.primary.main, o.palette.action.selectedOpacity)
+    }
+  },
+  [`&.${De.focusVisible}`]: {
+    backgroundColor: (o.vars || o).palette.action.focus
+  },
+  [`&.${De.disabled}`]: {
+    opacity: (o.vars || o).palette.action.disabledOpacity
+  },
+  [`& + .${No.root}`]: {
+    marginTop: o.spacing(1),
+    marginBottom: o.spacing(1)
+  },
+  [`& + .${No.inset}`]: {
+    marginLeft: 52
+  },
+  [`& .${Ao.root}`]: {
+    marginTop: 0,
+    marginBottom: 0
+  },
+  [`& .${Ao.inset}`]: {
+    paddingLeft: 36
+  },
+  [`& .${Do.root}`]: {
+    minWidth: 36
+  },
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => !t.disableGutters,
+    style: {
+      paddingLeft: 16,
+      paddingRight: 16
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.divider,
+    style: {
+      borderBottom: `1px solid ${(o.vars || o).palette.divider}`,
+      backgroundClip: "padding-box"
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => !t.dense,
+    style: {
+      [o.breakpoints.up("sm")]: {
+        minHeight: "auto"
+      }
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.dense,
+    style: {
+      minHeight: 32,
+      // https://m2.material.io/components/menus#specs > Dense
+      paddingTop: 4,
+      paddingBottom: 4,
+      ...o.typography.body2,
+      [`& .${Do.root} svg`]: {
+        fontSize: "1.25rem"
+      }
+    }
+  }]
+}))), et = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    props: t,
+    name: "MuiMenuItem"
+  }), {
+    autoFocus: i = !1,
+    component: d = "li",
+    dense: a = !1,
+    divider: c = !1,
+    disableGutters: f = !1,
+    focusVisibleClassName: u,
+    role: m = "menuitem",
+    tabIndex: C,
+    className: S,
+    ...v
+  } = r, x = l.useContext(Mo), I = l.useMemo(() => ({
+    dense: a || x.dense || !1,
+    disableGutters: f
+  }), [x.dense, a, f]), O = l.useRef(null);
+  Be(() => {
+    i && (O.current ? O.current.focus() : process.env.NODE_ENV !== "production" && console.error("MUI: Unable to set focus to a MenuItem whose component has not been rendered."));
+  }, [i]);
+  const p = {
+    ...r,
+    dense: I.dense,
+    divider: c,
+    disableGutters: f
+  }, h = un(r), s = Te(O, n);
+  let b;
+  return r.disabled || (b = C !== void 0 ? C : -1), /* @__PURE__ */ y(Mo.Provider, {
+    value: I,
+    children: /* @__PURE__ */ y(pn, {
+      ref: s,
+      role: m,
+      tabIndex: b,
+      component: d,
+      focusVisibleClassName: Y(h.focusVisible, u),
+      className: Y(h.root, S),
+      ...v,
+      ownerState: p,
+      classes: h
+    })
+  });
+});
+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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the list item is focused during the first mount.
+   * Focus will also be triggered if the value changes from false to true.
+   * @default false
+   */
+  autoFocus: e.bool,
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, compact vertical padding designed for keyboard and mouse input is used.
+   * The prop defaults to the value inherited from the parent Menu component.
+   * @default false
+   */
+  dense: e.bool,
+  /**
+   * @ignore
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the left and right padding is removed.
+   * @default false
+   */
+  disableGutters: e.bool,
+  /**
+   * If `true`, a 1px light border is added to the bottom of the menu item.
+   * @default false
+   */
+  divider: e.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: e.string,
+  /**
+   * @ignore
+   */
+  role: e.string,
+  /**
+   * If `true`, the component is selected.
+   * @default false
+   */
+  selected: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * @default 0
+   */
+  tabIndex: e.number
+});
+function fn(o) {
+  return Z("MuiNativeSelect", o);
+}
+const ho = G("MuiNativeSelect", ["root", "select", "multiple", "filled", "outlined", "standard", "disabled", "icon", "iconOpen", "iconFilled", "iconOutlined", "iconStandard", "nativeInput", "error"]), mn = (o) => {
+  const {
+    classes: t,
+    variant: n,
+    disabled: r,
+    multiple: i,
+    open: d,
+    error: a
+  } = o, c = {
+    select: ["select", n, r && "disabled", i && "multiple", a && "error"],
+    icon: ["icon", `icon${H(n)}`, d && "iconOpen", r && "disabled"]
+  };
+  return J(c, fn, t);
+}, ot = M("select")(({
+  theme: o
+}) => ({
+  // Reset
+  MozAppearance: "none",
+  // Reset
+  WebkitAppearance: "none",
+  // When interacting quickly, the text can end up selected.
+  // Native select can't be selected either.
+  userSelect: "none",
+  // Reset
+  borderRadius: 0,
+  cursor: "pointer",
+  "&:focus": {
+    // Reset Chrome style
+    borderRadius: 0
+  },
+  [`&.${ho.disabled}`]: {
+    cursor: "default"
+  },
+  "&[multiple]": {
+    height: "auto"
+  },
+  "&:not([multiple]) option, &:not([multiple]) optgroup": {
+    backgroundColor: (o.vars || o).palette.background.paper
+  },
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.variant !== "filled" && t.variant !== "outlined",
+    style: {
+      // Bump specificity to allow extending custom inputs
+      "&&&": {
+        paddingRight: 24,
+        minWidth: 16
+        // So it doesn't collapse.
+      }
+    }
+  }, {
+    props: {
+      variant: "filled"
+    },
+    style: {
+      "&&&": {
+        paddingRight: 32
+      }
+    }
+  }, {
+    props: {
+      variant: "outlined"
+    },
+    style: {
+      borderRadius: (o.vars || o).shape.borderRadius,
+      "&:focus": {
+        borderRadius: (o.vars || o).shape.borderRadius
+        // Reset the reset for Chrome style
+      },
+      "&&&": {
+        paddingRight: 32
+      }
+    }
+  }]
+})), bn = M(ot, {
+  name: "MuiNativeSelect",
+  slot: "Select",
+  shouldForwardProp: ne,
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [t.select, t[n.variant], n.error && t.error, {
+      [`&.${ho.multiple}`]: t.multiple
+    }];
+  }
+})({}), tt = M("svg")(({
+  theme: o
+}) => ({
+  // We use a position absolute over a flexbox in order to forward the pointer events
+  // to the input and to support wrapping tags..
+  position: "absolute",
+  right: 0,
+  // Center vertically, height is 1em
+  top: "calc(50% - .5em)",
+  // Don't block pointer events on the select under the icon.
+  pointerEvents: "none",
+  color: (o.vars || o).palette.action.active,
+  [`&.${ho.disabled}`]: {
+    color: (o.vars || o).palette.action.disabled
+  },
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.open,
+    style: {
+      transform: "rotate(180deg)"
+    }
+  }, {
+    props: {
+      variant: "filled"
+    },
+    style: {
+      right: 7
+    }
+  }, {
+    props: {
+      variant: "outlined"
+    },
+    style: {
+      right: 7
+    }
+  }]
+})), yn = M(tt, {
+  name: "MuiNativeSelect",
+  slot: "Icon",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [t.icon, n.variant && t[`icon${H(n.variant)}`], n.open && t.iconOpen];
+  }
+})({}), nt = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const {
+    className: r,
+    disabled: i,
+    error: d,
+    IconComponent: a,
+    inputRef: c,
+    variant: f = "standard",
+    ...u
+  } = t, m = {
+    ...t,
+    disabled: i,
+    variant: f,
+    error: d
+  }, C = mn(m);
+  return /* @__PURE__ */ q(l.Fragment, {
+    children: [/* @__PURE__ */ y(bn, {
+      ownerState: m,
+      className: Y(C.select, r),
+      disabled: i,
+      ref: c || n,
+      ...u
+    }), t.multiple ? null : /* @__PURE__ */ y(yn, {
+      as: a,
+      ownerState: m,
+      className: C.icon
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (nt.propTypes = {
+  /**
+   * The option elements to populate the select with.
+   * Can be some `<option>` elements.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * The CSS class name of the select element.
+   */
+  className: e.string,
+  /**
+   * If `true`, the select is disabled.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the `select input` will indicate an error.
+   */
+  error: e.bool,
+  /**
+   * The icon that displays the arrow.
+   */
+  IconComponent: e.elementType.isRequired,
+  /**
+   * Use that prop to pass a ref to the native select element.
+   * @deprecated
+   */
+  inputRef: ke,
+  /**
+   * @ignore
+   */
+  multiple: e.bool,
+  /**
+   * Name attribute of the `select` or hidden `input` element.
+   */
+  name: e.string,
+  /**
+   * Callback fired when a menu item is selected.
+   *
+   * @param {object} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   */
+  onChange: e.func,
+  /**
+   * The input value.
+   */
+  value: e.any,
+  /**
+   * The variant to use.
+   */
+  variant: e.oneOf(["standard", "outlined", "filled"])
+});
+var Bo;
+const gn = M("fieldset", {
+  shouldForwardProp: ne
+})({
+  textAlign: "left",
+  position: "absolute",
+  bottom: 0,
+  right: 0,
+  top: -5,
+  left: 0,
+  margin: 0,
+  padding: "0 8px",
+  pointerEvents: "none",
+  borderRadius: "inherit",
+  borderStyle: "solid",
+  borderWidth: 1,
+  overflow: "hidden",
+  minWidth: "0%"
+}), hn = M("legend", {
+  shouldForwardProp: ne
+})(_(({
+  theme: o
+}) => ({
+  float: "unset",
+  // Fix conflict with bootstrap
+  width: "auto",
+  // Fix conflict with bootstrap
+  overflow: "hidden",
+  // Fix Horizontal scroll when label too long
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => !t.withLabel,
+    style: {
+      padding: 0,
+      lineHeight: "11px",
+      // sync with `height` in `legend` styles
+      transition: o.transitions.create("width", {
+        duration: 150,
+        easing: o.transitions.easing.easeOut
+      })
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.withLabel,
+    style: {
+      display: "block",
+      // Fix conflict with normalize.css and sanitize.css
+      padding: 0,
+      height: 11,
+      // sync with `lineHeight` in `legend` styles
+      fontSize: "0.75em",
+      visibility: "hidden",
+      maxWidth: 0.01,
+      transition: o.transitions.create("max-width", {
+        duration: 50,
+        easing: o.transitions.easing.easeOut
+      }),
+      whiteSpace: "nowrap",
+      "& > span": {
+        paddingLeft: 5,
+        paddingRight: 5,
+        display: "inline-block",
+        opacity: 0,
+        visibility: "visible"
+      }
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.withLabel && t.notched,
+    style: {
+      maxWidth: "100%",
+      transition: o.transitions.create("max-width", {
+        duration: 100,
+        easing: o.transitions.easing.easeOut,
+        delay: 50
+      })
+    }
+  }]
+})));
+function rt(o) {
+  const {
+    children: t,
+    classes: n,
+    className: r,
+    label: i,
+    notched: d,
+    ...a
+  } = o, c = i != null && i !== "", f = {
+    ...o,
+    notched: d,
+    withLabel: c
+  };
+  return /* @__PURE__ */ y(gn, {
+    "aria-hidden": !0,
+    className: r,
+    ownerState: f,
+    ...a,
+    children: /* @__PURE__ */ y(hn, {
+      ownerState: f,
+      children: c ? /* @__PURE__ */ y("span", {
+        children: i
+      }) : (
+        // notranslate needed while Google Translate will not fix zero-width space issue
+        Bo || (Bo = /* @__PURE__ */ y("span", {
+          className: "notranslate",
+          "aria-hidden": !0,
+          children: "​"
+        }))
+      )
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (rt.propTypes = {
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The label.
+   */
+  label: e.node,
+  /**
+   * If `true`, the outline is notched to accommodate the label.
+   */
+  notched: e.bool.isRequired,
+  /**
+   * @ignore
+   */
+  style: e.object
+});
+const vn = (o) => {
+  const {
+    classes: t
+  } = o, r = J({
+    root: ["root"],
+    notchedOutline: ["notchedOutline"],
+    input: ["input"]
+  }, Mt, t);
+  return {
+    ...t,
+    // forward classes to the InputBase
+    ...r
+  };
+}, Cn = M(Qe, {
+  shouldForwardProp: (o) => ne(o) || o === "classes",
+  name: "MuiOutlinedInput",
+  slot: "Root",
+  overridesResolver: Ze
+})(_(({
+  theme: o
+}) => {
+  const t = o.palette.mode === "light" ? "rgba(0, 0, 0, 0.23)" : "rgba(255, 255, 255, 0.23)";
+  return {
+    position: "relative",
+    borderRadius: (o.vars || o).shape.borderRadius,
+    [`&:hover .${te.notchedOutline}`]: {
+      borderColor: (o.vars || o).palette.text.primary
+    },
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      [`&:hover .${te.notchedOutline}`]: {
+        borderColor: o.vars ? `rgba(${o.vars.palette.common.onBackgroundChannel} / 0.23)` : t
+      }
+    },
+    [`&.${te.focused} .${te.notchedOutline}`]: {
+      borderWidth: 2
+    },
+    variants: [...Object.entries(o.palette).filter(ze()).map(([n]) => ({
+      props: {
+        color: n
+      },
+      style: {
+        [`&.${te.focused} .${te.notchedOutline}`]: {
+          borderColor: (o.vars || o).palette[n].main
+        }
+      }
+    })), {
+      props: {},
+      // to overide the above style
+      style: {
+        [`&.${te.error} .${te.notchedOutline}`]: {
+          borderColor: (o.vars || o).palette.error.main
+        },
+        [`&.${te.disabled} .${te.notchedOutline}`]: {
+          borderColor: (o.vars || o).palette.action.disabled
+        }
+      }
+    }, {
+      props: ({
+        ownerState: n
+      }) => n.startAdornment,
+      style: {
+        paddingLeft: 14
+      }
+    }, {
+      props: ({
+        ownerState: n
+      }) => n.endAdornment,
+      style: {
+        paddingRight: 14
+      }
+    }, {
+      props: ({
+        ownerState: n
+      }) => n.multiline,
+      style: {
+        padding: "16.5px 14px"
+      }
+    }, {
+      props: ({
+        ownerState: n,
+        size: r
+      }) => n.multiline && r === "small",
+      style: {
+        padding: "8.5px 14px"
+      }
+    }]
+  };
+})), Sn = M(rt, {
+  name: "MuiOutlinedInput",
+  slot: "NotchedOutline",
+  overridesResolver: (o, t) => t.notchedOutline
+})(_(({
+  theme: o
+}) => {
+  const t = o.palette.mode === "light" ? "rgba(0, 0, 0, 0.23)" : "rgba(255, 255, 255, 0.23)";
+  return {
+    borderColor: o.vars ? `rgba(${o.vars.palette.common.onBackgroundChannel} / 0.23)` : t
+  };
+})), wn = M(eo, {
+  name: "MuiOutlinedInput",
+  slot: "Input",
+  overridesResolver: Je
+})(_(({
+  theme: o
+}) => ({
+  padding: "16.5px 14px",
+  ...!o.vars && {
+    "&:-webkit-autofill": {
+      WebkitBoxShadow: o.palette.mode === "light" ? null : "0 0 0 100px #266798 inset",
+      WebkitTextFillColor: o.palette.mode === "light" ? null : "#fff",
+      caretColor: o.palette.mode === "light" ? null : "#fff",
+      borderRadius: "inherit"
+    }
+  },
+  ...o.vars && {
+    "&:-webkit-autofill": {
+      borderRadius: "inherit"
+    },
+    [o.getColorSchemeSelector("dark")]: {
+      "&:-webkit-autofill": {
+        WebkitBoxShadow: "0 0 0 100px #266798 inset",
+        WebkitTextFillColor: "#fff",
+        caretColor: "#fff"
+      }
+    }
+  },
+  variants: [{
+    props: {
+      size: "small"
+    },
+    style: {
+      padding: "8.5px 14px"
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.multiline,
+    style: {
+      padding: 0
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.startAdornment,
+    style: {
+      paddingLeft: 0
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.endAdornment,
+    style: {
+      paddingRight: 0
+    }
+  }]
+}))), vo = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  var r;
+  const i = ee({
+    props: t,
+    name: "MuiOutlinedInput"
+  }), {
+    components: d = {},
+    fullWidth: a = !1,
+    inputComponent: c = "input",
+    label: f,
+    multiline: u = !1,
+    notched: m,
+    slots: C = {},
+    type: S = "text",
+    ...v
+  } = i, x = vn(i), I = We(), O = Ue({
+    props: i,
+    muiFormControl: I,
+    states: ["color", "disabled", "error", "focused", "hiddenLabel", "size", "required"]
+  }), p = {
+    ...i,
+    color: O.color || "primary",
+    disabled: O.disabled,
+    error: O.error,
+    focused: O.focused,
+    formControl: I,
+    fullWidth: a,
+    hiddenLabel: O.hiddenLabel,
+    multiline: u,
+    size: O.size,
+    type: S
+  }, h = C.root ?? d.Root ?? Cn, s = C.input ?? d.Input ?? wn;
+  return /* @__PURE__ */ y(oo, {
+    slots: {
+      root: h,
+      input: s
+    },
+    renderSuffix: (b) => /* @__PURE__ */ y(Sn, {
+      ownerState: p,
+      className: x.notchedOutline,
+      label: f != null && f !== "" && O.required ? r || (r = /* @__PURE__ */ q(l.Fragment, {
+        children: [f, " ", "*"]
+      })) : f,
+      notched: typeof m < "u" ? m : !!(b.startAdornment || b.filled || b.focused)
+    }),
+    fullWidth: a,
+    inputComponent: c,
+    multiline: u,
+    ref: n,
+    type: S,
+    ...v,
+    classes: {
+      ...x,
+      notchedOutline: null
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (vo.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * This prop helps users to fill forms faster, especially on mobile devices.
+   * The name can be confusing, as it's more like an autofill.
+   * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
+   */
+  autoComplete: e.string,
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   */
+  autoFocus: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * 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).
+   * The prop defaults to the value (`'primary'`) inherited from the parent FormControl component.
+   */
+  color: e.oneOfType([e.oneOf(["primary", "secondary"]), e.string]),
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Input: e.elementType,
+    Root: e.elementType
+  }),
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: e.any,
+  /**
+   * If `true`, the component is disabled.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  disabled: e.bool,
+  /**
+   * End `InputAdornment` for this component.
+   */
+  endAdornment: e.node,
+  /**
+   * If `true`, the `input` will indicate an error.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  error: e.bool,
+  /**
+   * If `true`, the `input` will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: e.bool,
+  /**
+   * The id of the `input` element.
+   */
+  id: e.string,
+  /**
+   * The component used for the `input` element.
+   * Either a string to use a HTML element or a component.
+   * @default 'input'
+   */
+  inputComponent: e.elementType,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   * @default {}
+   */
+  inputProps: e.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: ke,
+  /**
+   * The label of the `input`. It is only used for layout. The actual labelling
+   * is handled by `InputLabel`.
+   */
+  label: e.node,
+  /**
+   * If `dense`, will adjust vertical spacing. This is normally obtained via context from
+   * FormControl.
+   * The prop defaults to the value (`'none'`) inherited from the parent FormControl component.
+   */
+  margin: e.oneOf(["dense", "none"]),
+  /**
+   * Maximum number of rows to display when multiline option is set to true.
+   */
+  maxRows: e.oneOfType([e.number, e.string]),
+  /**
+   * Minimum number of rows to display when multiline option is set to true.
+   */
+  minRows: e.oneOfType([e.number, e.string]),
+  /**
+   * If `true`, a [TextareaAutosize](https://mui.com/material-ui/react-textarea-autosize/) element is rendered.
+   * @default false
+   */
+  multiline: e.bool,
+  /**
+   * Name attribute of the `input` element.
+   */
+  name: e.string,
+  /**
+   * If `true`, the outline is notched to accommodate the label.
+   */
+  notched: e.bool,
+  /**
+   * Callback fired when the value is changed.
+   *
+   * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (string).
+   */
+  onChange: e.func,
+  /**
+   * The short hint displayed in the `input` before the user enters a value.
+   */
+  placeholder: e.string,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   */
+  readOnly: e.bool,
+  /**
+   * If `true`, the `input` element is required.
+   * The prop defaults to the value (`false`) inherited from the parent FormControl component.
+   */
+  required: e.bool,
+  /**
+   * Number of rows to display when multiline option is set to true.
+   */
+  rows: e.oneOfType([e.number, e.string]),
+  /**
+   * The components used for each slot inside.
+   *
+   * This prop is an alias for the `components` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slots: e.shape({
+    input: e.elementType,
+    root: e.elementType
+  }),
+  /**
+   * Start `InputAdornment` for this component.
+   */
+  startAdornment: e.node,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
+   * @default 'text'
+   */
+  type: e.string,
+  /**
+   * The value of the `input` element, required for a controlled component.
+   */
+  value: e.any
+});
+vo.muiName = "Input";
+function On(o) {
+  return Z("MuiSelect", o);
+}
+const Ae = G("MuiSelect", ["root", "select", "multiple", "filled", "outlined", "standard", "disabled", "focused", "icon", "iconOpen", "iconFilled", "iconOutlined", "iconStandard", "nativeInput", "error"]);
+var zo;
+const xn = M(ot, {
+  name: "MuiSelect",
+  slot: "Select",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [
+      // Win specificity over the input base
+      {
+        [`&.${Ae.select}`]: t.select
+      },
+      {
+        [`&.${Ae.select}`]: t[n.variant]
+      },
+      {
+        [`&.${Ae.error}`]: t.error
+      },
+      {
+        [`&.${Ae.multiple}`]: t.multiple
+      }
+    ];
+  }
+})({
+  // Win specificity over the input base
+  [`&.${Ae.select}`]: {
+    height: "auto",
+    // Resets for multiple select with chips
+    minHeight: "1.4375em",
+    // Required for select\text-field height consistency
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap",
+    overflow: "hidden"
+  }
+}), In = M(tt, {
+  name: "MuiSelect",
+  slot: "Icon",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: n
+    } = o;
+    return [t.icon, n.variant && t[`icon${H(n.variant)}`], n.open && t.iconOpen];
+  }
+})({}), Rn = M("input", {
+  shouldForwardProp: (o) => lt(o) && o !== "classes",
+  name: "MuiSelect",
+  slot: "NativeInput",
+  overridesResolver: (o, t) => t.nativeInput
+})({
+  bottom: 0,
+  left: 0,
+  position: "absolute",
+  opacity: 0,
+  pointerEvents: "none",
+  width: "100%",
+  boxSizing: "border-box"
+});
+function Wo(o, t) {
+  return typeof t == "object" && t !== null ? o === t : String(o) === String(t);
+}
+function kn(o) {
+  return o == null || typeof o == "string" && !o.trim();
+}
+const Tn = (o) => {
+  const {
+    classes: t,
+    variant: n,
+    disabled: r,
+    multiple: i,
+    open: d,
+    error: a
+  } = o, c = {
+    select: ["select", n, r && "disabled", i && "multiple", a && "error"],
+    icon: ["icon", `icon${H(n)}`, d && "iconOpen", r && "disabled"],
+    nativeInput: ["nativeInput"]
+  };
+  return J(c, On, t);
+}, st = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  var Oo;
+  const {
+    "aria-describedby": r,
+    "aria-label": i,
+    autoFocus: d,
+    autoWidth: a,
+    children: c,
+    className: f,
+    defaultOpen: u,
+    defaultValue: m,
+    disabled: C,
+    displayEmpty: S,
+    error: v = !1,
+    IconComponent: x,
+    inputRef: I,
+    labelId: O,
+    MenuProps: p = {},
+    multiple: h,
+    name: s,
+    onBlur: b,
+    onChange: R,
+    onClose: L,
+    onFocus: N,
+    onOpen: k,
+    open: j,
+    readOnly: P,
+    renderValue: B,
+    required: z,
+    SelectDisplayProps: U = {},
+    tabIndex: W,
+    // catching `type` from Input which makes no sense for SelectInput
+    type: g,
+    value: E,
+    variant: F = "standard",
+    ...Q
+  } = t, [$, he] = Po({
+    controlled: E,
+    default: m,
+    name: "Select"
+  }), [Me, Ve] = Po({
+    controlled: j,
+    default: u,
+    name: "Select"
+  }), ae = l.useRef(null), oe = l.useRef(null), [re, to] = l.useState(null), {
+    current: ie
+  } = l.useRef(j != null), [Ee, se] = l.useState(), no = Te(n, I), ro = l.useCallback((w) => {
+    oe.current = w, w && to(w);
+  }, []), le = re == null ? void 0 : re.parentNode;
+  l.useImperativeHandle(no, () => ({
+    focus: () => {
+      oe.current.focus();
+    },
+    node: ae.current,
+    value: $
+  }), [$]), l.useEffect(() => {
+    u && Me && re && !ie && (se(a ? null : le.clientWidth), oe.current.focus());
+  }, [re, a]), l.useEffect(() => {
+    d && oe.current.focus();
+  }, [d]), l.useEffect(() => {
+    if (!O)
+      return;
+    const w = _o(oe.current).getElementById(O);
+    if (w) {
+      const T = () => {
+        getSelection().isCollapsed && oe.current.focus();
+      };
+      return w.addEventListener("click", T), () => {
+        w.removeEventListener("click", T);
+      };
+    }
+  }, [O]);
+  const ce = (w, T) => {
+    w ? k && k(T) : L && L(T), ie || (se(a ? null : le.clientWidth), Ve(w));
+  }, A = (w) => {
+    w.button === 0 && (w.preventDefault(), oe.current.focus(), ce(!0, w));
+  }, X = (w) => {
+    ce(!1, w);
+  }, de = l.Children.toArray(c), Ne = (w) => {
+    const T = de.find((V) => V.props.value === w.target.value);
+    T !== void 0 && (he(T.props.value), R && R(w, T));
+  }, fe = (w) => (T) => {
+    let V;
+    if (T.currentTarget.hasAttribute("tabindex")) {
+      if (h) {
+        V = Array.isArray($) ? $.slice() : [];
+        const xe = $.indexOf(w.props.value);
+        xe === -1 ? V.push(w.props.value) : V.splice(xe, 1);
+      } else
+        V = w.props.value;
+      if (w.props.onClick && w.props.onClick(T), $ !== V && (he(V), R)) {
+        const xe = T.nativeEvent || T, xo = new xe.constructor(xe.type, xe);
+        Object.defineProperty(xo, "target", {
+          writable: !0,
+          value: {
+            value: V,
+            name: s
+          }
+        }), R(xo, w);
+      }
+      h || ce(!1, T);
+    }
+  }, so = (w) => {
+    P || [
+      " ",
+      "ArrowUp",
+      "ArrowDown",
+      // The native select doesn't respond to enter on macOS, but it's recommended by
+      // https://www.w3.org/WAI/ARIA/apg/patterns/combobox/examples/combobox-select-only/
+      "Enter"
+    ].includes(w.key) && (w.preventDefault(), ce(!0, w));
+  }, ve = re !== null && Me, ao = (w) => {
+    !ve && b && (Object.defineProperty(w, "target", {
+      writable: !0,
+      value: {
+        value: $,
+        name: s
+      }
+    }), b(w));
+  };
+  delete Q["aria-invalid"];
+  let ue, Ce;
+  const K = [];
+  let Se = !1, me = !1;
+  (Ye({
+    value: $
+  }) || S) && (B ? ue = B($) : Se = !0);
+  const He = de.map((w) => {
+    if (!/* @__PURE__ */ l.isValidElement(w))
+      return null;
+    process.env.NODE_ENV !== "production" && bo.isFragment(w) && console.error(["MUI: The Select component doesn't accept a Fragment as a child.", "Consider providing an array instead."].join(`
+`));
+    let T;
+    if (h) {
+      if (!Array.isArray($))
+        throw new Error(process.env.NODE_ENV !== "production" ? "MUI: The `value` prop must be an array when using the `Select` component with `multiple`." : Uo(2));
+      T = $.some((V) => Wo(V, w.props.value)), T && Se && K.push(w.props.children);
+    } else
+      T = Wo($, w.props.value), T && Se && (Ce = w.props.children);
+    return T && (me = !0), /* @__PURE__ */ l.cloneElement(w, {
+      "aria-selected": T ? "true" : "false",
+      onClick: fe(w),
+      onKeyUp: (V) => {
+        V.key === " " && V.preventDefault(), w.props.onKeyUp && w.props.onKeyUp(V);
+      },
+      role: "option",
+      selected: T,
+      value: void 0,
+      // The value is most likely not a valid HTML attribute.
+      "data-value": w.props.value
+      // Instead, we provide it as a data attribute.
+    });
+  });
+  process.env.NODE_ENV !== "production" && l.useEffect(() => {
+    if (!me && !h && $ !== "") {
+      const w = de.map((T) => T.props.value);
+      console.warn([`MUI: You have provided an out-of-range value \`${$}\` for the select ${s ? `(name="${s}") ` : ""}component.`, "Consider providing a value that matches one of the available options or ''.", `The available values are ${w.filter((T) => T != null).map((T) => `\`${T}\``).join(", ") || '""'}.`].join(`
+`));
+    }
+  }, [me, de, h, s, $]), Se && (h ? K.length === 0 ? ue = null : ue = K.reduce((w, T, V) => (w.push(T), V < K.length - 1 && w.push(", "), w), []) : ue = Ce);
+  let Pe = Ee;
+  !a && ie && re && (Pe = le.clientWidth);
+  let be;
+  typeof W < "u" ? be = W : be = C ? null : 0;
+  const Fe = U.id || (s ? `mui-component-select-${s}` : void 0), D = {
+    ...t,
+    variant: F,
+    value: $,
+    open: ve,
+    error: v
+  }, we = Tn(D), Oe = {
+    ...p.PaperProps,
+    ...(Oo = p.slotProps) == null ? void 0 : Oo.paper
+  }, wo = St();
+  return /* @__PURE__ */ q(l.Fragment, {
+    children: [/* @__PURE__ */ y(xn, {
+      as: "div",
+      ref: ro,
+      tabIndex: be,
+      role: "combobox",
+      "aria-controls": wo,
+      "aria-disabled": C ? "true" : void 0,
+      "aria-expanded": ve ? "true" : "false",
+      "aria-haspopup": "listbox",
+      "aria-label": i,
+      "aria-labelledby": [O, Fe].filter(Boolean).join(" ") || void 0,
+      "aria-describedby": r,
+      "aria-required": z ? "true" : void 0,
+      "aria-invalid": v ? "true" : void 0,
+      onKeyDown: so,
+      onMouseDown: C || P ? null : A,
+      onBlur: ao,
+      onFocus: N,
+      ...U,
+      ownerState: D,
+      className: Y(U.className, we.select, f),
+      id: Fe,
+      children: kn(ue) ? (
+        // notranslate needed while Google Translate will not fix zero-width space issue
+        zo || (zo = /* @__PURE__ */ y("span", {
+          className: "notranslate",
+          "aria-hidden": !0,
+          children: "​"
+        }))
+      ) : ue
+    }), /* @__PURE__ */ y(Rn, {
+      "aria-invalid": v,
+      value: Array.isArray($) ? $.join(",") : $,
+      name: s,
+      ref: ae,
+      "aria-hidden": !0,
+      onChange: Ne,
+      tabIndex: -1,
+      disabled: C,
+      className: we.nativeInput,
+      autoFocus: d,
+      required: z,
+      ...Q,
+      ownerState: D
+    }), /* @__PURE__ */ y(In, {
+      as: x,
+      className: we.icon,
+      ownerState: D
+    }), /* @__PURE__ */ y(Qo, {
+      id: `menu-${s || ""}`,
+      anchorEl: le,
+      open: ve,
+      onClose: X,
+      anchorOrigin: {
+        vertical: "bottom",
+        horizontal: "center"
+      },
+      transformOrigin: {
+        vertical: "top",
+        horizontal: "center"
+      },
+      ...p,
+      MenuListProps: {
+        "aria-labelledby": O,
+        role: "listbox",
+        "aria-multiselectable": h ? "true" : void 0,
+        disableListWrap: !0,
+        id: wo,
+        ...p.MenuListProps
+      },
+      slotProps: {
+        ...p.slotProps,
+        paper: {
+          ...Oe,
+          style: {
+            minWidth: Pe,
+            ...Oe != null ? Oe.style : null
+          }
+        }
+      },
+      children: He
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (st.propTypes = {
+  /**
+   * @ignore
+   */
+  "aria-describedby": e.string,
+  /**
+   * @ignore
+   */
+  "aria-label": e.string,
+  /**
+   * @ignore
+   */
+  autoFocus: e.bool,
+  /**
+   * If `true`, the width of the popover will automatically be set according to the items inside the
+   * menu, otherwise it will be at least the width of the select input.
+   */
+  autoWidth: e.bool,
+  /**
+   * The option elements to populate the select with.
+   * Can be some `<MenuItem>` elements.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * The CSS class name of the select element.
+   */
+  className: e.string,
+  /**
+   * If `true`, the component is toggled on mount. Use when the component open state is not controlled.
+   * You can only use it when the `native` prop is `false` (default).
+   */
+  defaultOpen: e.bool,
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: e.any,
+  /**
+   * If `true`, the select is disabled.
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the selected item is displayed even if its value is empty.
+   */
+  displayEmpty: e.bool,
+  /**
+   * If `true`, the `select input` will indicate an error.
+   */
+  error: e.bool,
+  /**
+   * The icon that displays the arrow.
+   */
+  IconComponent: e.elementType.isRequired,
+  /**
+   * Imperative handle implementing `{ value: T, node: HTMLElement, focus(): void }`
+   * Equivalent to `ref`
+   */
+  inputRef: ke,
+  /**
+   * The ID of an element that acts as an additional label. The Select will
+   * be labelled by the additional label and the selected value.
+   */
+  labelId: e.string,
+  /**
+   * Props applied to the [`Menu`](/material-ui/api/menu/) element.
+   */
+  MenuProps: e.object,
+  /**
+   * If `true`, `value` must be an array and the menu will support multiple selections.
+   */
+  multiple: e.bool,
+  /**
+   * Name attribute of the `select` or hidden `input` element.
+   */
+  name: e.string,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * Callback fired when a menu item is selected.
+   *
+   * @param {object} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (any).
+   * @param {object} [child] The react element that was selected.
+   */
+  onChange: e.func,
+  /**
+   * Callback fired when the component requests to be closed.
+   * Use in controlled mode (see open).
+   *
+   * @param {object} event The event source of the callback.
+   */
+  onClose: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * Callback fired when the component requests to be opened.
+   * Use in controlled mode (see open).
+   *
+   * @param {object} event The event source of the callback.
+   */
+  onOpen: e.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool,
+  /**
+   * @ignore
+   */
+  readOnly: e.bool,
+  /**
+   * Render the selected value.
+   *
+   * @param {any} value The `value` provided to the component.
+   * @returns {ReactNode}
+   */
+  renderValue: e.func,
+  /**
+   * If `true`, the component is required.
+   */
+  required: e.bool,
+  /**
+   * Props applied to the clickable div element.
+   */
+  SelectDisplayProps: e.object,
+  /**
+   * @ignore
+   */
+  tabIndex: e.oneOfType([e.number, e.string]),
+  /**
+   * @ignore
+   */
+  type: e.any,
+  /**
+   * The input value.
+   */
+  value: e.any,
+  /**
+   * The variant to use.
+   */
+  variant: e.oneOf(["standard", "outlined", "filled"])
+});
+const Mn = (o) => {
+  const {
+    classes: t
+  } = o;
+  return t;
+}, Co = {
+  name: "MuiSelect",
+  overridesResolver: (o, t) => t.root,
+  shouldForwardProp: (o) => ne(o) && o !== "variant",
+  slot: "Root"
+}, En = M(go, Co)(""), Nn = M(vo, Co)(""), Pn = M(yo, Co)(""), So = /* @__PURE__ */ l.forwardRef(function(t, n) {
+  const r = ee({
+    name: "MuiSelect",
+    props: t
+  }), {
+    autoWidth: i = !1,
+    children: d,
+    classes: a = {},
+    className: c,
+    defaultOpen: f = !1,
+    displayEmpty: u = !1,
+    IconComponent: m = Nt,
+    id: C,
+    input: S,
+    inputProps: v,
+    label: x,
+    labelId: I,
+    MenuProps: O,
+    multiple: p = !1,
+    native: h = !1,
+    onClose: s,
+    onOpen: b,
+    open: R,
+    renderValue: L,
+    SelectDisplayProps: N,
+    variant: k = "outlined",
+    ...j
+  } = r, P = h ? nt : st, B = We(), z = Ue({
+    props: r,
+    muiFormControl: B,
+    states: ["variant", "error"]
+  }), U = z.variant || k, W = {
+    ...r,
+    variant: U,
+    classes: a
+  }, g = Mn(W), {
+    root: E,
+    ...F
+  } = g, Q = S || {
+    standard: /* @__PURE__ */ y(En, {
+      ownerState: W
+    }),
+    outlined: /* @__PURE__ */ y(Nn, {
+      label: x,
+      ownerState: W
+    }),
+    filled: /* @__PURE__ */ y(Pn, {
+      ownerState: W
+    })
+  }[U], $ = Te(n, Ct(Q));
+  return /* @__PURE__ */ y(l.Fragment, {
+    children: /* @__PURE__ */ l.cloneElement(Q, {
+      // Most of the logic is implemented in `SelectInput`.
+      // The `Select` component is a simple API wrapper to expose something better to play with.
+      inputComponent: P,
+      inputProps: {
+        children: d,
+        error: z.error,
+        IconComponent: m,
+        variant: U,
+        type: void 0,
+        // We render a select. We can ignore the type provided by the `Input`.
+        multiple: p,
+        ...h ? {
+          id: C
+        } : {
+          autoWidth: i,
+          defaultOpen: f,
+          displayEmpty: u,
+          labelId: I,
+          MenuProps: O,
+          onClose: s,
+          onOpen: b,
+          open: R,
+          renderValue: L,
+          SelectDisplayProps: {
+            id: C,
+            ...N
+          }
+        },
+        ...v,
+        classes: v ? mo(F, v.classes) : F,
+        ...S ? S.props.inputProps : {}
+      },
+      ...(p && h || u) && U === "outlined" ? {
+        notched: !0
+      } : {},
+      ref: $,
+      className: Y(Q.props.className, c, g.root),
+      // If a custom input is provided via 'input' prop, do not allow 'variant' to be propagated to it's root element. See https://github.com/mui/material-ui/issues/33894.
+      ...!S && {
+        variant: U
+      },
+      ...j
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (So.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the width of the popover will automatically be set according to the items inside the
+   * menu, otherwise it will be at least the width of the select input.
+   * @default false
+   */
+  autoWidth: e.bool,
+  /**
+   * The option elements to populate the select with.
+   * Can be some `MenuItem` when `native` is false and `option` when `native` is true.
+   *
+   * ⚠️The `MenuItem` elements **must** be direct descendants when `native` is false.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   * @default {}
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * If `true`, the component is initially open. Use when the component open state is not controlled (i.e. the `open` prop is not defined).
+   * You can only use it when the `native` prop is `false` (default).
+   * @default false
+   */
+  defaultOpen: e.bool,
+  /**
+   * The default value. Use when the component is not controlled.
+   */
+  defaultValue: e.any,
+  /**
+   * If `true`, a value is displayed even if no items are selected.
+   *
+   * In order to display a meaningful value, a function can be passed to the `renderValue` prop which
+   * returns the value to be displayed when no items are selected.
+   *
+   * ⚠️ When using this prop, make sure the label doesn't overlap with the empty displayed value.
+   * The label should either be hidden or forced to a shrunk state.
+   * @default false
+   */
+  displayEmpty: e.bool,
+  /**
+   * The icon that displays the arrow.
+   * @default ArrowDropDownIcon
+   */
+  IconComponent: e.elementType,
+  /**
+   * The `id` of the wrapper element or the `select` element when `native`.
+   */
+  id: e.string,
+  /**
+   * An `Input` element; does not have to be a material-ui specific `Input`.
+   */
+  input: e.element,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   * When `native` is `true`, the attributes are applied on the `select` element.
+   */
+  inputProps: e.object,
+  /**
+   * See [OutlinedInput#label](https://mui.com/material-ui/api/outlined-input/#props)
+   */
+  label: e.node,
+  /**
+   * The ID of an element that acts as an additional label. The Select will
+   * be labelled by the additional label and the selected value.
+   */
+  labelId: e.string,
+  /**
+   * Props applied to the [`Menu`](https://mui.com/material-ui/api/menu/) element.
+   */
+  MenuProps: e.object,
+  /**
+   * If `true`, `value` must be an array and the menu will support multiple selections.
+   * @default false
+   */
+  multiple: e.bool,
+  /**
+   * If `true`, the component uses a native `select` element.
+   * @default false
+   */
+  native: e.bool,
+  /**
+   * Callback fired when a menu item is selected.
+   *
+   * @param {SelectChangeEvent<Value>} event The event source of the callback.
+   * You can pull out the new value by accessing `event.target.value` (any).
+   * **Warning**: This is a generic event, not a change event, unless the change event is caused by browser autofill.
+   * @param {object} [child] The react element that was selected when `native` is `false` (default).
+   */
+  onChange: e.func,
+  /**
+   * Callback fired when the component requests to be closed.
+   * Use it in either controlled (see the `open` prop), or uncontrolled mode (to detect when the Select collapses).
+   *
+   * @param {object} event The event source of the callback.
+   */
+  onClose: e.func,
+  /**
+   * Callback fired when the component requests to be opened.
+   * Use it in either controlled (see the `open` prop), or uncontrolled mode (to detect when the Select expands).
+   *
+   * @param {object} event The event source of the callback.
+   */
+  onOpen: e.func,
+  /**
+   * If `true`, the component is shown.
+   * You can only use it when the `native` prop is `false` (default).
+   */
+  open: e.bool,
+  /**
+   * Render the selected value.
+   * You can only use it when the `native` prop is `false` (default).
+   *
+   * @param {any} value The `value` provided to the component.
+   * @returns {ReactNode}
+   */
+  renderValue: e.func,
+  /**
+   * Props applied to the clickable div element.
+   */
+  SelectDisplayProps: e.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The `input` value. Providing an empty string will select no options.
+   * Set to an empty string `''` if you don't want any of the available options to be selected.
+   *
+   * If the value is an object it must have reference equality with the option in order to be selected.
+   * If the value is not an object, the string representation must match with the string representation of the option in order to be selected.
+   */
+  value: e.oneOfType([e.oneOf([""]), e.any]),
+  /**
+   * The variant to use.
+   * @default 'outlined'
+   */
+  variant: e.oneOf(["filled", "outlined", "standard"])
+});
+So.muiName = "Select";
+function er({
+  description: o = "Connect your Slack workspace to receive notifications directly in Slack.",
+  connectButtonText: t = "Connect Slack",
+  editButtonText: n = "Edit Channel",
+  disconnectButtonText: r = "Disconnect",
+  saveButtonText: i = "Save",
+  cancelButtonText: d = "Cancel",
+  connectedText: a = "Slack notifications will be sent to:",
+  selectChannelText: c = "Choose a channel or user to receive notifications:"
+} = {}) {
+  const f = at(it), u = f == null ? void 0 : f.getClient(), [m, C] = ye(), [S, v] = ye(), [x, I] = ye([]), [O, p] = ye(""), [h, s] = ye(!1), [b, R] = ye(null), [L, N] = ye(!1), k = Io(async () => {
+    if (u)
+      try {
+        s(!0);
+        const g = await u.user.get();
+        g.slackToken && C(g.slackToken), g.slackChannel && v(g.slackChannel);
+      } catch (g) {
+        console.error("Error fetching Slack status:", g);
+      } finally {
+        s(!1);
+      }
+  }, [u]), j = Io(async () => {
+    if (!u || !m) return [];
+    try {
+      s(!0), R(null);
+      const g = await u.slack.getChannels(), E = [
+        ...(g.channels || []).filter((F) => F.id && F.name).map((F) => ({
+          id: F.id,
+          name: F.name,
+          type: "channel"
+        })),
+        ...(g.users || []).filter((F) => F.id && F.name).map((F) => ({
+          id: F.id,
+          name: F.name,
+          type: "user"
+        }))
+      ];
+      return I(E), E;
+    } catch (g) {
+      return console.error("Error loading channels and users:", g), R("Failed to load Slack channels and users. Please try again."), [];
+    } finally {
+      s(!1);
+    }
+  }, [u, m]);
+  Ro(() => {
+    k();
+  }, [k]), Ro(() => {
+    m && !S && !L && j();
+  }, [m, S, L, j]);
+  const P = async () => {
+    if (u)
+      try {
+        s(!0), R(null);
+        const g = await u.slack.getOAuthUrl();
+        window.location.href = g;
+      } catch (g) {
+        console.error("Error connecting to Slack:", g), R("Failed to connect to Slack. Please try again.");
+      } finally {
+        s(!1);
+      }
+  }, B = async () => {
+    if (!(!u || !O))
+      try {
+        s(!0), R(null);
+        const g = x.find((F) => F.id === O);
+        if (!g) {
+          R("Channel not found. Please try again.");
+          return;
+        }
+        const E = `${g.type === "channel" ? "#" : "@"}${g.name}`;
+        await u.slack.setChannel(E), v(E), N(!1), R(null);
+      } catch (g) {
+        console.error("Error saving channel:", g), R("Failed to save channel. Please try again.");
+      } finally {
+        s(!1);
+      }
+  }, z = async () => {
+    if (u)
+      try {
+        s(!0), R(null), await u.identify({
+          // @ts-expect-error - null is not assignable to type string
+          slackToken: null,
+          // @ts-expect-error - null is not assignable to type string
+          slackChannel: null
+        }), C(void 0), v(void 0), p(""), I([]), N(!1);
+      } catch (g) {
+        console.error("Error disconnecting Slack:", g), R("Failed to disconnect Slack. Please try again.");
+      } finally {
+        s(!1);
+      }
+  }, U = async () => {
+    N(!0);
+    let g = x;
+    if (x.length === 0 && (g = await j()), S) {
+      const E = S.startsWith("#"), F = S.substring(1), Q = E ? "channel" : "user", $ = g.find(
+        (he) => he.name === F && he.type === Q
+      );
+      $ && p($.id);
+    }
+  }, W = () => {
+    N(!1), p("");
+  };
+  return u ? h && !m && !x.length ? /* @__PURE__ */ y(qe, { display: "flex", justifyContent: "center", alignItems: "center", p: 3, children: /* @__PURE__ */ y(Xe, {}) }) : m ? !S || L ? /* @__PURE__ */ q(qe, { children: [
+    b && /* @__PURE__ */ y(ko, { severity: "error", sx: { mb: 2 }, children: b }),
+    h ? /* @__PURE__ */ y(qe, { display: "flex", justifyContent: "center", p: 2, children: /* @__PURE__ */ y(Xe, {}) }) : /* @__PURE__ */ q(io, { direction: "row", spacing: 2, alignItems: "center", children: [
+      /* @__PURE__ */ y(Ke, { variant: "body2", color: "text.secondary", children: c }),
+      /* @__PURE__ */ q(Go, { sx: { minWidth: 200 }, size: "small", children: [
+        /* @__PURE__ */ y(Yo, { id: "slack-channel-label", children: "Channel or User" }),
+        /* @__PURE__ */ y(
+          So,
+          {
+            labelId: "slack-channel-label",
+            value: O,
+            label: "Channel or User",
+            onChange: (g) => p(g.target.value),
+            children: x.sort((g, E) => g.type === E.type ? g.name.localeCompare(E.name) : g.type === "channel" ? -1 : 1).map((g) => /* @__PURE__ */ q(et, { value: g.id, children: [
+              g.type === "channel" ? "#" : "@",
+              g.name
+            ] }, g.id))
+          }
+        )
+      ] }),
+      /* @__PURE__ */ y(
+        Ie,
+        {
+          variant: "contained",
+          color: "primary",
+          onClick: B,
+          disabled: !O || h,
+          children: i
+        }
+      ),
+      L && /* @__PURE__ */ y(
+        Ie,
+        {
+          variant: "outlined",
+          onClick: W,
+          disabled: h,
+          children: d
+        }
+      ),
+      /* @__PURE__ */ y(
+        Ie,
+        {
+          variant: "text",
+          color: "error",
+          onClick: z,
+          disabled: h,
+          size: "small",
+          children: r
+        }
+      )
+    ] })
+  ] }) : /* @__PURE__ */ q(io, { direction: "row", spacing: 2, alignItems: "center", children: [
+    /* @__PURE__ */ y(Ke, { variant: "body2", color: "text.secondary", children: a }),
+    /* @__PURE__ */ y(Ke, { variant: "body1", fontWeight: "medium", children: S }),
+    /* @__PURE__ */ y(Ie, { variant: "outlined", onClick: U, disabled: h, children: n }),
+    /* @__PURE__ */ y(
+      Ie,
+      {
+        variant: "text",
+        color: "error",
+        onClick: z,
+        disabled: h,
+        children: r
+      }
+    )
+  ] }) : /* @__PURE__ */ q(qe, { children: [
+    b && /* @__PURE__ */ y(ko, { severity: "error", sx: { mb: 2 }, children: b }),
+    /* @__PURE__ */ q(io, { direction: "row", spacing: 2, alignItems: "center", children: [
+      /* @__PURE__ */ y(Ke, { variant: "body2", color: "text.secondary", children: o }),
+      /* @__PURE__ */ y(
+        Ie,
+        {
+          variant: "contained",
+          color: "primary",
+          onClick: P,
+          disabled: h,
+          children: h ? /* @__PURE__ */ y(Xe, { size: 24 }) : t
+        }
+      )
+    ] })
+  ] }) : null;
+}
+export {
+  er as SlackConnect
+};