@hybridcore/ui 1.0.2 → 1.1.0

package/dist/FormControl-C4PmH1vh.js

@@ -0,0 +1,1491 @@
+import { _ as H, a as i } from "./extends-C3382pL0.js";
+import * as l from "react";
+import { G as Ve, P as e, c as L, l as Ue } from "./createTheme-agWfFD64.js";
+import { g as Y, u as Z, c as j, a as J } from "./chainPropTypes-DtBfUj5o.js";
+import { u as te, F as be } from "./useFormControl-CatNKXAi.js";
+import { d as Ge, T as Ke, g as Q, s as B, r as Ye } from "./styled-Iq9jsO4F.js";
+import { jsx as E, jsxs as q } from "react/jsx-runtime";
+import { u as ze, b as pe, e as Ze, r as Je } from "./ButtonBase-B6WYZgVU.js";
+import { o as Re } from "./ownerWindow-niciwP7I.js";
+import { i as Se } from "./isHostComponent-kiaBvYVo.js";
+import { u as Qe } from "./useTheme-C0Dky5rV.js";
+import { T as Xe } from "./Typography-XIiVCSto.js";
+import { i as ue } from "./isMuiElement-CxT3_ACP.js";
+function Ae({
+  styles: o,
+  themeId: n,
+  defaultTheme: t = {}
+}) {
+  const r = Qe(t), s = typeof o == "function" ? o(n && r[n] || r) : o;
+  return /* @__PURE__ */ E(Ve, {
+    styles: s
+  });
+}
+process.env.NODE_ENV !== "production" && (Ae.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  defaultTheme: e.object,
+  /**
+   * @ignore
+   */
+  styles: e.oneOfType([e.array, e.func, e.number, e.object, e.string, e.bool]),
+  /**
+   * @ignore
+   */
+  themeId: e.string
+});
+function eo(o, n = 166) {
+  let t;
+  function r(...s) {
+    const a = () => {
+      o.apply(this, s);
+    };
+    clearTimeout(t), t = setTimeout(a, n);
+  }
+  return r.clear = () => {
+    clearTimeout(t);
+  }, r;
+}
+function he({
+  props: o,
+  states: n,
+  muiFormControl: t
+}) {
+  return n.reduce((r, s) => (r[s] = o[s], t && typeof o[s] > "u" && (r[s] = t[s]), r), {});
+}
+const oo = ["onChange", "maxRows", "minRows", "style", "value"];
+function ne(o) {
+  return parseInt(o, 10) || 0;
+}
+const no = {
+  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 to(o) {
+  return o == null || Object.keys(o).length === 0 || o.outerHeightStyle === 0 && !o.overflowing;
+}
+const ke = /* @__PURE__ */ l.forwardRef(function(n, t) {
+  const {
+    onChange: r,
+    maxRows: s,
+    minRows: a = 1,
+    style: m,
+    value: y
+  } = n, c = H(n, oo), {
+    current: d
+  } = l.useRef(y != null), u = l.useRef(null), g = ze(t, u), p = l.useRef(null), R = l.useRef(null), O = l.useCallback(() => {
+    const v = u.current, C = Re(v).getComputedStyle(v);
+    if (C.width === "0px")
+      return {
+        outerHeightStyle: 0,
+        overflowing: !1
+      };
+    const x = R.current;
+    x.style.width = C.width, x.value = v.value || n.placeholder || "x", x.value.slice(-1) === `
+` && (x.value += " ");
+    const M = C.boxSizing, z = ne(C.paddingBottom) + ne(C.paddingTop), N = ne(C.borderBottomWidth) + ne(C.borderTopWidth), F = x.scrollHeight;
+    x.value = "x";
+    const A = x.scrollHeight;
+    let w = F;
+    a && (w = Math.max(Number(a) * A, w)), s && (w = Math.min(Number(s) * A, w)), w = Math.max(w, A);
+    const W = w + (M === "border-box" ? z + N : 0), V = Math.abs(w - F) <= 1;
+    return {
+      outerHeightStyle: W,
+      overflowing: V
+    };
+  }, [s, a, n.placeholder]), T = l.useCallback(() => {
+    const v = O();
+    if (to(v))
+      return;
+    const b = v.outerHeightStyle, C = u.current;
+    p.current !== b && (p.current = b, C.style.height = `${b}px`), C.style.overflow = v.overflowing ? "hidden" : "";
+  }, [O]);
+  pe(() => {
+    const v = () => {
+      T();
+    };
+    let b;
+    const C = () => {
+      cancelAnimationFrame(b), b = requestAnimationFrame(() => {
+        v();
+      });
+    }, x = eo(v), M = u.current, z = Re(M);
+    z.addEventListener("resize", x);
+    let N;
+    return typeof ResizeObserver < "u" && (N = new ResizeObserver(process.env.NODE_ENV === "test" ? C : v), N.observe(M)), () => {
+      x.clear(), cancelAnimationFrame(b), z.removeEventListener("resize", x), N && N.disconnect();
+    };
+  }, [O, T]), pe(() => {
+    T();
+  });
+  const $ = (v) => {
+    d || T(), r && r(v);
+  };
+  return /* @__PURE__ */ q(l.Fragment, {
+    children: [/* @__PURE__ */ E("textarea", i({
+      value: y,
+      onChange: $,
+      ref: g,
+      rows: a,
+      style: m
+    }, c)), /* @__PURE__ */ E("textarea", {
+      "aria-hidden": !0,
+      className: n.className,
+      readOnly: !0,
+      ref: R,
+      tabIndex: -1,
+      style: i({}, no.shadow, m, {
+        paddingTop: 0,
+        paddingBottom: 0
+      })
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (ke.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 Le(o) {
+  return /* @__PURE__ */ E(Ae, i({}, o, {
+    defaultTheme: Ge,
+    themeId: Ke
+  }));
+}
+process.env.NODE_ENV !== "production" && (Le.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The styles you want to apply globally.
+   */
+  styles: e.oneOfType([e.array, e.func, e.number, e.object, e.string, e.bool])
+});
+function Ne(o) {
+  return o != null && !(Array.isArray(o) && o.length === 0);
+}
+function fe(o, n = !1) {
+  return o && (Ne(o.value) && o.value !== "" || n && Ne(o.defaultValue) && o.defaultValue !== "");
+}
+function ro(o) {
+  return o.startAdornment;
+}
+function so(o) {
+  return Q("MuiInputBase", o);
+}
+const me = Y("MuiInputBase", ["root", "formControl", "focused", "disabled", "adornedStart", "adornedEnd", "error", "sizeSmall", "multiline", "colorSecondary", "fullWidth", "hiddenLabel", "readOnly", "input", "inputSizeSmall", "inputMultiline", "inputTypeSearch", "inputAdornedStart", "inputAdornedEnd", "inputHiddenLabel"]), io = ["aria-describedby", "autoComplete", "autoFocus", "className", "color", "components", "componentsProps", "defaultValue", "disabled", "disableInjectingGlobalStyles", "endAdornment", "error", "fullWidth", "id", "inputComponent", "inputProps", "inputRef", "margin", "maxRows", "minRows", "multiline", "name", "onBlur", "onChange", "onClick", "onFocus", "onKeyDown", "onKeyUp", "placeholder", "readOnly", "renderSuffix", "rows", "size", "slotProps", "slots", "startAdornment", "type", "value"], ao = (o, n) => {
+  const {
+    ownerState: t
+  } = o;
+  return [n.root, t.formControl && n.formControl, t.startAdornment && n.adornedStart, t.endAdornment && n.adornedEnd, t.error && n.error, t.size === "small" && n.sizeSmall, t.multiline && n.multiline, t.color && n[`color${L(t.color)}`], t.fullWidth && n.fullWidth, t.hiddenLabel && n.hiddenLabel];
+}, lo = (o, n) => {
+  const {
+    ownerState: t
+  } = o;
+  return [n.input, t.size === "small" && n.inputSizeSmall, t.multiline && n.inputMultiline, t.type === "search" && n.inputTypeSearch, t.startAdornment && n.inputAdornedStart, t.endAdornment && n.inputAdornedEnd, t.hiddenLabel && n.inputHiddenLabel];
+}, co = (o) => {
+  const {
+    classes: n,
+    color: t,
+    disabled: r,
+    error: s,
+    endAdornment: a,
+    focused: m,
+    formControl: y,
+    fullWidth: c,
+    hiddenLabel: d,
+    multiline: u,
+    readOnly: g,
+    size: p,
+    startAdornment: R,
+    type: O
+  } = o, T = {
+    root: ["root", `color${L(t)}`, r && "disabled", s && "error", c && "fullWidth", m && "focused", y && "formControl", p && p !== "medium" && `size${L(p)}`, u && "multiline", R && "adornedStart", a && "adornedEnd", d && "hiddenLabel", g && "readOnly"],
+    input: ["input", r && "disabled", O === "search" && "inputTypeSearch", u && "inputMultiline", p === "small" && "inputSizeSmall", d && "inputHiddenLabel", R && "inputAdornedStart", a && "inputAdornedEnd", g && "readOnly"]
+  };
+  return J(T, so, n);
+}, uo = B("div", {
+  name: "MuiInputBase",
+  slot: "Root",
+  overridesResolver: ao
+})(({
+  theme: o,
+  ownerState: n
+}) => i({}, 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",
+  [`&.${me.disabled}`]: {
+    color: (o.vars || o).palette.text.disabled,
+    cursor: "default"
+  }
+}, n.multiline && i({
+  padding: "4px 0 5px"
+}, n.size === "small" && {
+  paddingTop: 1
+}), n.fullWidth && {
+  width: "100%"
+})), po = B("input", {
+  name: "MuiInputBase",
+  slot: "Input",
+  overridesResolver: lo
+})(({
+  theme: o,
+  ownerState: n
+}) => {
+  const t = o.palette.mode === "light", r = i({
+    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
+    })
+  }), s = {
+    opacity: "0 !important"
+  }, a = o.vars ? {
+    opacity: o.vars.opacity.inputPlaceholder
+  } : {
+    opacity: t ? 0.42 : 0.5
+  };
+  return i({
+    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%",
+    // Fix IE11 width issue
+    animationName: "mui-auto-fill-cancel",
+    animationDuration: "10ms",
+    "&::-webkit-input-placeholder": r,
+    "&::-moz-placeholder": r,
+    // Firefox 19+
+    "&:-ms-input-placeholder": r,
+    // IE11
+    "&::-ms-input-placeholder": r,
+    // 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] + .${me.formControl} &`]: {
+      "&::-webkit-input-placeholder": s,
+      "&::-moz-placeholder": s,
+      // Firefox 19+
+      "&:-ms-input-placeholder": s,
+      // IE11
+      "&::-ms-input-placeholder": s,
+      // Edge
+      "&:focus::-webkit-input-placeholder": a,
+      "&:focus::-moz-placeholder": a,
+      // Firefox 19+
+      "&:focus:-ms-input-placeholder": a,
+      // IE11
+      "&:focus::-ms-input-placeholder": a
+      // Edge
+    },
+    [`&.${me.disabled}`]: {
+      opacity: 1,
+      // Reset iOS opacity
+      WebkitTextFillColor: (o.vars || o).palette.text.disabled
+      // Fix opacity Safari bug
+    },
+    "&:-webkit-autofill": {
+      animationDuration: "5000s",
+      animationName: "mui-auto-fill"
+    }
+  }, n.size === "small" && {
+    paddingTop: 1
+  }, n.multiline && {
+    height: "auto",
+    resize: "none",
+    padding: 0,
+    paddingTop: 0
+  }, n.type === "search" && {
+    // Improve type search style.
+    MozAppearance: "textfield"
+  });
+}), fo = /* @__PURE__ */ E(Le, {
+  styles: {
+    "@keyframes mui-auto-fill": {
+      from: {
+        display: "block"
+      }
+    },
+    "@keyframes mui-auto-fill-cancel": {
+      from: {
+        display: "block"
+      }
+    }
+  }
+}), mo = /* @__PURE__ */ l.forwardRef(function(n, t) {
+  var r;
+  const s = Z({
+    props: n,
+    name: "MuiInputBase"
+  }), {
+    "aria-describedby": a,
+    autoComplete: m,
+    autoFocus: y,
+    className: c,
+    components: d = {},
+    componentsProps: u = {},
+    defaultValue: g,
+    disabled: p,
+    disableInjectingGlobalStyles: R,
+    endAdornment: O,
+    fullWidth: T = !1,
+    id: $,
+    inputComponent: v = "input",
+    inputProps: b = {},
+    inputRef: C,
+    maxRows: x,
+    minRows: M,
+    multiline: z = !1,
+    name: N,
+    onBlur: F,
+    onChange: A,
+    onClick: w,
+    onFocus: W,
+    onKeyDown: V,
+    onKeyUp: I,
+    placeholder: k,
+    readOnly: D,
+    renderSuffix: ye,
+    rows: X,
+    slotProps: ge = {},
+    slots: ve = {},
+    startAdornment: U,
+    type: xe = "text",
+    value: Pe
+  } = s, We = H(s, io), ee = b.value != null ? b.value : Pe, {
+    current: re
+  } = l.useRef(ee != null), _ = l.useRef(), $e = l.useCallback((f) => {
+    process.env.NODE_ENV !== "production" && f && f.nodeName !== "INPUT" && !f.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(`
+`));
+  }, []), Be = ze(_, C, b.ref, $e), [se, ie] = l.useState(!1), h = te();
+  process.env.NODE_ENV !== "production" && l.useEffect(() => {
+    if (h)
+      return h.registerEffect();
+  }, [h]);
+  const S = he({
+    props: s,
+    muiFormControl: h,
+    states: ["color", "disabled", "error", "hiddenLabel", "size", "required", "filled"]
+  });
+  S.focused = h ? h.focused : se, l.useEffect(() => {
+    !h && p && se && (ie(!1), F && F());
+  }, [h, p, se, F]);
+  const ae = h && h.onFilled, le = h && h.onEmpty, G = l.useCallback((f) => {
+    fe(f) ? ae && ae() : le && le();
+  }, [ae, le]);
+  pe(() => {
+    re && G({
+      value: ee
+    });
+  }, [ee, G, re]);
+  const De = (f) => {
+    if (S.disabled) {
+      f.stopPropagation();
+      return;
+    }
+    W && W(f), b.onFocus && b.onFocus(f), h && h.onFocus ? h.onFocus(f) : ie(!0);
+  }, _e = (f) => {
+    F && F(f), b.onBlur && b.onBlur(f), h && h.onBlur ? h.onBlur(f) : ie(!1);
+  }, je = (f, ...we) => {
+    if (!re) {
+      const Ee = f.target || _.current;
+      if (Ee == 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." : Ue(1));
+      G({
+        value: Ee.value
+      });
+    }
+    b.onChange && b.onChange(f, ...we), A && A(f, ...we);
+  };
+  l.useEffect(() => {
+    G(_.current);
+  }, []);
+  const qe = (f) => {
+    _.current && f.currentTarget === f.target && _.current.focus(), w && w(f);
+  };
+  let de = v, P = b;
+  z && de === "input" && (X ? (process.env.NODE_ENV !== "production" && (M || x) && console.warn("MUI: You can not use the `minRows` or `maxRows` props when the input `rows` prop is set."), P = i({
+    type: void 0,
+    minRows: X,
+    maxRows: X
+  }, P)) : P = i({
+    type: void 0,
+    maxRows: x,
+    minRows: M
+  }, P), de = ke);
+  const He = (f) => {
+    G(f.animationName === "mui-auto-fill-cancel" ? _.current : {
+      value: "x"
+    });
+  };
+  l.useEffect(() => {
+    h && h.setAdornedStart(!!U);
+  }, [h, U]);
+  const oe = i({}, s, {
+    color: S.color || "primary",
+    disabled: S.disabled,
+    endAdornment: O,
+    error: S.error,
+    focused: S.focused,
+    formControl: h,
+    fullWidth: T,
+    hiddenLabel: S.hiddenLabel,
+    multiline: z,
+    size: S.size,
+    startAdornment: U,
+    type: xe
+  }), Ce = co(oe), Oe = ve.root || d.Root || uo, ce = ge.root || u.root || {}, Te = ve.input || d.Input || po;
+  return P = i({}, P, (r = ge.input) != null ? r : u.input), /* @__PURE__ */ q(l.Fragment, {
+    children: [!R && fo, /* @__PURE__ */ q(Oe, i({}, ce, !Se(Oe) && {
+      ownerState: i({}, oe, ce.ownerState)
+    }, {
+      ref: t,
+      onClick: qe
+    }, We, {
+      className: j(Ce.root, ce.className, c, D && "MuiInputBase-readOnly"),
+      children: [U, /* @__PURE__ */ E(be.Provider, {
+        value: null,
+        children: /* @__PURE__ */ E(Te, i({
+          ownerState: oe,
+          "aria-invalid": S.error,
+          "aria-describedby": a,
+          autoComplete: m,
+          autoFocus: y,
+          defaultValue: g,
+          disabled: S.disabled,
+          id: $,
+          onAnimationStart: He,
+          name: N,
+          placeholder: k,
+          readOnly: D,
+          required: S.required,
+          rows: X,
+          value: ee,
+          onKeyDown: V,
+          onKeyUp: I,
+          type: xe
+        }, P, !Se(Te) && {
+          as: de,
+          ownerState: i({}, oe, P.ownerState)
+        }, {
+          ref: Be,
+          className: j(Ce.input, P.className, D && "MuiInputBase-readOnly"),
+          onBlur: _e,
+          onChange: je,
+          onFocus: De
+        }))
+      }), O, ye ? ye(i({}, S, {
+        startAdornment: U
+      })) : null]
+    }))]
+  });
+});
+process.env.NODE_ENV !== "production" && (mo.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.
+   *
+   * This prop is an alias for the `slots` prop.
+   * It's recommended to use the `slots` prop instead.
+   *
+   * @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.
+   *
+   * This prop is an alias for the `slotProps` prop.
+   * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
+   *
+   * @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: Ze,
+  /**
+   * [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: Je,
+  /**
+   * 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](/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 bo(o) {
+  return Q("MuiFormLabel", o);
+}
+const K = Y("MuiFormLabel", ["root", "colorSecondary", "focused", "disabled", "error", "filled", "required", "asterisk"]), ho = ["children", "className", "color", "component", "disabled", "error", "filled", "focused", "required"], yo = (o) => {
+  const {
+    classes: n,
+    color: t,
+    focused: r,
+    disabled: s,
+    error: a,
+    filled: m,
+    required: y
+  } = o, c = {
+    root: ["root", `color${L(t)}`, s && "disabled", a && "error", m && "filled", r && "focused", y && "required"],
+    asterisk: ["asterisk", a && "error"]
+  };
+  return J(c, bo, n);
+}, go = B("label", {
+  name: "MuiFormLabel",
+  slot: "Root",
+  overridesResolver: ({
+    ownerState: o
+  }, n) => i({}, n.root, o.color === "secondary" && n.colorSecondary, o.filled && n.filled)
+})(({
+  theme: o,
+  ownerState: n
+}) => i({
+  color: (o.vars || o).palette.text.secondary
+}, o.typography.body1, {
+  lineHeight: "1.4375em",
+  padding: 0,
+  position: "relative",
+  [`&.${K.focused}`]: {
+    color: (o.vars || o).palette[n.color].main
+  },
+  [`&.${K.disabled}`]: {
+    color: (o.vars || o).palette.text.disabled
+  },
+  [`&.${K.error}`]: {
+    color: (o.vars || o).palette.error.main
+  }
+})), vo = B("span", {
+  name: "MuiFormLabel",
+  slot: "Asterisk",
+  overridesResolver: (o, n) => n.asterisk
+})(({
+  theme: o
+}) => ({
+  [`&.${K.error}`]: {
+    color: (o.vars || o).palette.error.main
+  }
+})), Me = /* @__PURE__ */ l.forwardRef(function(n, t) {
+  const r = Z({
+    props: n,
+    name: "MuiFormLabel"
+  }), {
+    children: s,
+    className: a,
+    component: m = "label"
+  } = r, y = H(r, ho), c = te(), d = he({
+    props: r,
+    muiFormControl: c,
+    states: ["color", "required", "focused", "disabled", "error", "filled"]
+  }), u = i({}, r, {
+    color: d.color || "primary",
+    component: m,
+    disabled: d.disabled,
+    error: d.error,
+    filled: d.filled,
+    focused: d.focused,
+    required: d.required
+  }), g = yo(u);
+  return /* @__PURE__ */ q(go, i({
+    as: m,
+    ownerState: u,
+    className: j(g.root, a),
+    ref: t
+  }, y, {
+    children: [s, d.required && /* @__PURE__ */ q(vo, {
+      ownerState: u,
+      "aria-hidden": !0,
+      className: g.asterisk,
+      children: [" ", "*"]
+    })]
+  }));
+});
+process.env.NODE_ENV !== "production" && (Me.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])
+});
+function xo(o) {
+  return Q("MuiInputLabel", o);
+}
+Y("MuiInputLabel", ["root", "focused", "disabled", "error", "required", "asterisk", "formControl", "sizeSmall", "shrink", "animated", "standard", "filled", "outlined"]);
+const Co = ["disableAnimation", "margin", "shrink", "variant", "className"], Oo = (o) => {
+  const {
+    classes: n,
+    formControl: t,
+    size: r,
+    shrink: s,
+    disableAnimation: a,
+    variant: m,
+    required: y
+  } = o, c = {
+    root: ["root", t && "formControl", !a && "animated", s && "shrink", r && r !== "normal" && `size${L(r)}`, m],
+    asterisk: [y && "asterisk"]
+  }, d = J(c, xo, n);
+  return i({}, n, d);
+}, To = B(Me, {
+  shouldForwardProp: (o) => Ye(o) || o === "classes",
+  name: "MuiInputLabel",
+  slot: "Root",
+  overridesResolver: (o, n) => {
+    const {
+      ownerState: t
+    } = o;
+    return [{
+      [`& .${K.asterisk}`]: n.asterisk
+    }, n.root, t.formControl && n.formControl, t.size === "small" && n.sizeSmall, t.shrink && n.shrink, !t.disableAnimation && n.animated, t.focused && n.focused, n[t.variant]];
+  }
+})(({
+  theme: o,
+  ownerState: n
+}) => i({
+  display: "block",
+  transformOrigin: "top left",
+  whiteSpace: "nowrap",
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  maxWidth: "100%"
+}, n.formControl && {
+  position: "absolute",
+  left: 0,
+  top: 0,
+  // slight alteration to spec spacing to match visual spec result
+  transform: "translate(0, 20px) scale(1)"
+}, n.size === "small" && {
+  // Compensation for the `Input.inputSizeSmall` style.
+  transform: "translate(0, 17px) scale(1)"
+}, n.shrink && {
+  transform: "translate(0, -1.5px) scale(0.75)",
+  transformOrigin: "top left",
+  maxWidth: "133%"
+}, !n.disableAnimation && {
+  transition: o.transitions.create(["color", "transform", "max-width"], {
+    duration: o.transitions.duration.shorter,
+    easing: o.transitions.easing.easeOut
+  })
+}, n.variant === "filled" && i({
+  // 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)"
+}, n.size === "small" && {
+  transform: "translate(12px, 13px) scale(1)"
+}, n.shrink && i({
+  userSelect: "none",
+  pointerEvents: "auto",
+  transform: "translate(12px, 7px) scale(0.75)",
+  maxWidth: "calc(133% - 24px)"
+}, n.size === "small" && {
+  transform: "translate(12px, 4px) scale(0.75)"
+})), n.variant === "outlined" && i({
+  // see comment above on filled.zIndex
+  zIndex: 1,
+  pointerEvents: "none",
+  transform: "translate(14px, 16px) scale(1)",
+  maxWidth: "calc(100% - 24px)"
+}, n.size === "small" && {
+  transform: "translate(14px, 9px) scale(1)"
+}, n.shrink && {
+  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)"
+}))), wo = /* @__PURE__ */ l.forwardRef(function(n, t) {
+  const r = Z({
+    name: "MuiInputLabel",
+    props: n
+  }), {
+    disableAnimation: s = !1,
+    shrink: a,
+    className: m
+  } = r, y = H(r, Co), c = te();
+  let d = a;
+  typeof d > "u" && c && (d = c.filled || c.focused || c.adornedStart);
+  const u = he({
+    props: r,
+    muiFormControl: c,
+    states: ["size", "variant", "required", "focused"]
+  }), g = i({}, r, {
+    disableAnimation: s,
+    formControl: c,
+    shrink: d,
+    size: u.size,
+    variant: u.variant,
+    required: u.required,
+    focused: u.focused
+  }), p = Oo(g);
+  return /* @__PURE__ */ E(To, i({
+    "data-shrink": d,
+    ownerState: g,
+    ref: t,
+    className: j(p.root, m)
+  }, y, {
+    classes: p
+  }));
+});
+process.env.NODE_ENV !== "production" && (wo.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"])
+});
+function Eo(o) {
+  return Q("MuiInputAdornment", o);
+}
+const Fe = Y("MuiInputAdornment", ["root", "filled", "standard", "outlined", "positionStart", "positionEnd", "disablePointerEvents", "hiddenLabel", "sizeSmall"]);
+var Ie;
+const Ro = ["children", "className", "component", "disablePointerEvents", "disableTypography", "position", "variant"], So = (o, n) => {
+  const {
+    ownerState: t
+  } = o;
+  return [n.root, n[`position${L(t.position)}`], t.disablePointerEvents === !0 && n.disablePointerEvents, n[t.variant]];
+}, No = (o) => {
+  const {
+    classes: n,
+    disablePointerEvents: t,
+    hiddenLabel: r,
+    position: s,
+    size: a,
+    variant: m
+  } = o, y = {
+    root: ["root", t && "disablePointerEvents", s && `position${L(s)}`, m, r && "hiddenLabel", a && `size${L(a)}`]
+  };
+  return J(y, Eo, n);
+}, Fo = B("div", {
+  name: "MuiInputAdornment",
+  slot: "Root",
+  overridesResolver: So
+})(({
+  theme: o,
+  ownerState: n
+}) => i({
+  display: "flex",
+  height: "0.01em",
+  // Fix IE11 flexbox alignment. To remove at some point.
+  maxHeight: "2em",
+  alignItems: "center",
+  whiteSpace: "nowrap",
+  color: (o.vars || o).palette.action.active
+}, n.variant === "filled" && {
+  // Styles applied to the root element if `variant="filled"`.
+  [`&.${Fe.positionStart}&:not(.${Fe.hiddenLabel})`]: {
+    marginTop: 16
+  }
+}, n.position === "start" && {
+  // Styles applied to the root element if `position="start"`.
+  marginRight: 8
+}, n.position === "end" && {
+  // Styles applied to the root element if `position="end"`.
+  marginLeft: 8
+}, n.disablePointerEvents === !0 && {
+  // Styles applied to the root element if `disablePointerEvents={true}`.
+  pointerEvents: "none"
+})), Io = /* @__PURE__ */ l.forwardRef(function(n, t) {
+  const r = Z({
+    props: n,
+    name: "MuiInputAdornment"
+  }), {
+    children: s,
+    className: a,
+    component: m = "div",
+    disablePointerEvents: y = !1,
+    disableTypography: c = !1,
+    position: d,
+    variant: u
+  } = r, g = H(r, Ro), p = te() || {};
+  let R = u;
+  u && p.variant && process.env.NODE_ENV !== "production" && u === p.variant && console.error("MUI: The `InputAdornment` variant infers the variant prop you do not have to provide one."), p && !R && (R = p.variant);
+  const O = i({}, r, {
+    hiddenLabel: p.hiddenLabel,
+    size: p.size,
+    disablePointerEvents: y,
+    position: d,
+    variant: R
+  }), T = No(O);
+  return /* @__PURE__ */ E(be.Provider, {
+    value: null,
+    children: /* @__PURE__ */ E(Fo, i({
+      as: m,
+      ownerState: O,
+      className: j(T.root, a),
+      ref: t
+    }, g, {
+      children: typeof s == "string" && !c ? /* @__PURE__ */ E(Xe, {
+        color: "text.secondary",
+        children: s
+      }) : /* @__PURE__ */ q(l.Fragment, {
+        children: [d === "start" ? (
+          /* notranslate needed while Google Translate will not fix zero-width space issue */
+          Ie || (Ie = /* @__PURE__ */ E("span", {
+            className: "notranslate",
+            children: "​"
+          }))
+        ) : null, s]
+      })
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (Io.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, normally an `IconButton` or string.
+   */
+  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,
+  /**
+   * Disable pointer events on the root.
+   * This allows for the content of the adornment to focus the `input` on click.
+   * @default false
+   */
+  disablePointerEvents: e.bool,
+  /**
+   * If children is a string then disable wrapping in a Typography component.
+   * @default false
+   */
+  disableTypography: e.bool,
+  /**
+   * The position this adornment should appear relative to the `Input`.
+   */
+  position: e.oneOf(["end", "start"]).isRequired,
+  /**
+   * 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.
+   * Note: If you are using the `TextField` component or the `FormControl` component
+   * you do not have to set this manually.
+   */
+  variant: e.oneOf(["filled", "outlined", "standard"])
+});
+function zo(o) {
+  return Q("MuiFormControl", o);
+}
+Y("MuiFormControl", ["root", "marginNone", "marginNormal", "marginDense", "fullWidth", "disabled"]);
+const Ao = ["children", "className", "color", "component", "disabled", "error", "focused", "fullWidth", "hiddenLabel", "margin", "required", "size", "variant"], ko = (o) => {
+  const {
+    classes: n,
+    margin: t,
+    fullWidth: r
+  } = o, s = {
+    root: ["root", t !== "none" && `margin${L(t)}`, r && "fullWidth"]
+  };
+  return J(s, zo, n);
+}, Lo = B("div", {
+  name: "MuiFormControl",
+  slot: "Root",
+  overridesResolver: ({
+    ownerState: o
+  }, n) => i({}, n.root, n[`margin${L(o.margin)}`], o.fullWidth && n.fullWidth)
+})(({
+  ownerState: o
+}) => i({
+  display: "inline-flex",
+  flexDirection: "column",
+  position: "relative",
+  // Reset fieldset default style.
+  minWidth: 0,
+  padding: 0,
+  margin: 0,
+  border: 0,
+  verticalAlign: "top"
+}, o.margin === "normal" && {
+  marginTop: 16,
+  marginBottom: 8
+}, o.margin === "dense" && {
+  marginTop: 8,
+  marginBottom: 4
+}, o.fullWidth && {
+  width: "100%"
+})), Mo = /* @__PURE__ */ l.forwardRef(function(n, t) {
+  const r = Z({
+    props: n,
+    name: "MuiFormControl"
+  }), {
+    children: s,
+    className: a,
+    color: m = "primary",
+    component: y = "div",
+    disabled: c = !1,
+    error: d = !1,
+    focused: u,
+    fullWidth: g = !1,
+    hiddenLabel: p = !1,
+    margin: R = "none",
+    required: O = !1,
+    size: T = "medium",
+    variant: $ = "outlined"
+  } = r, v = H(r, Ao), b = i({}, r, {
+    color: m,
+    component: y,
+    disabled: c,
+    error: d,
+    fullWidth: g,
+    hiddenLabel: p,
+    margin: R,
+    required: O,
+    size: T,
+    variant: $
+  }), C = ko(b), [x, M] = l.useState(() => {
+    let I = !1;
+    return s && l.Children.forEach(s, (k) => {
+      if (!ue(k, ["Input", "Select"]))
+        return;
+      const D = ue(k, ["Select"]) ? k.props.input : k;
+      D && ro(D.props) && (I = !0);
+    }), I;
+  }), [z, N] = l.useState(() => {
+    let I = !1;
+    return s && l.Children.forEach(s, (k) => {
+      ue(k, ["Input", "Select"]) && (fe(k.props, !0) || fe(k.props.inputProps, !0)) && (I = !0);
+    }), I;
+  }), [F, A] = l.useState(!1);
+  c && F && A(!1);
+  const w = u !== void 0 && !c ? u : F;
+  let W;
+  if (process.env.NODE_ENV !== "production") {
+    const I = l.useRef(!1);
+    W = () => (I.current && console.error(["MUI: There are multiple `InputBase` components inside a FormControl.", "This creates visual inconsistencies, only use one `InputBase`."].join(`
+`)), I.current = !0, () => {
+      I.current = !1;
+    });
+  }
+  const V = l.useMemo(() => ({
+    adornedStart: x,
+    setAdornedStart: M,
+    color: m,
+    disabled: c,
+    error: d,
+    filled: z,
+    focused: w,
+    fullWidth: g,
+    hiddenLabel: p,
+    size: T,
+    onBlur: () => {
+      A(!1);
+    },
+    onEmpty: () => {
+      N(!1);
+    },
+    onFilled: () => {
+      N(!0);
+    },
+    onFocus: () => {
+      A(!0);
+    },
+    registerEffect: W,
+    required: O,
+    variant: $
+  }), [x, m, c, d, z, w, g, p, W, O, T, $]);
+  return /* @__PURE__ */ E(be.Provider, {
+    value: V,
+    children: /* @__PURE__ */ E(Lo, i({
+      as: y,
+      ownerState: b,
+      className: j(C.root, a),
+      ref: t
+    }, v, {
+      children: s
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (Mo.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"])
+});
+export {
+  Mo as F,
+  wo as I,
+  Io as a,
+  uo as b,
+  po as c,
+  lo as d,
+  mo as e,
+  he as f,
+  eo as g,
+  fe as h,
+  me as i,
+  ao as r
+};