@cgi-learning-hub/ui 1.2.0 → 1.3.0

package/dist/InputBase-5GB2c2J6.js

@@ -0,0 +1,803 @@
+import * as s from "react";
+import { P as e, J as Be, I as Me, L as pe, K as J, Z as He } from "./identifier-Bu3vgTzE.js";
+import { g as Pe } from "./index-DNmEgr4X.js";
+import { m as ge } from "./memoTheme-C4_nd-x4.js";
+import { jsxs as Q, jsx as B } from "react/jsx-runtime";
+import { s as we, u as We, c as De } from "./DefaultPropsProvider-7QnSWHxy.js";
+import { u as ve } from "./useForkRef-D-DyzOXj.js";
+import { u as X, e as Le, r as Ve } from "./refType-DvOnKTmB.js";
+import { o as fe, d as Ue } from "./ownerWindow-BoRkeomM.js";
+const ne = /* @__PURE__ */ s.createContext(void 0);
+process.env.NODE_ENV !== "production" && (ne.displayName = "FormControlContext");
+function _e() {
+  return s.useContext(ne);
+}
+function me(n) {
+  return n != null && !(Array.isArray(n) && n.length === 0);
+}
+function je(n, o = !1) {
+  return n && (me(n.value) && n.value !== "" || o && me(n.defaultValue) && n.defaultValue !== "");
+}
+function cn(n) {
+  return n.startAdornment;
+}
+function Ke({
+  props: n,
+  states: o,
+  muiFormControl: t
+}) {
+  return o.reduce((l, u) => (l[u] = n[u], t && typeof n[u] > "u" && (l[u] = t[u]), l), {});
+}
+function L(n) {
+  return parseInt(n, 10) || 0;
+}
+const $e = {
+  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 qe(n) {
+  return n == null || Object.keys(n).length === 0 || n.outerHeightStyle === 0 && !n.overflowing;
+}
+const Ce = /* @__PURE__ */ s.forwardRef(function(o, t) {
+  const {
+    onChange: l,
+    maxRows: u,
+    minRows: p = 1,
+    style: O,
+    value: E,
+    ...M
+  } = o, {
+    current: C
+  } = s.useRef(E != null), h = s.useRef(null), T = ve(t, h), y = s.useRef(null), S = s.useRef(null), v = s.useCallback(() => {
+    const d = h.current, r = fe(d).getComputedStyle(d);
+    if (r.width === "0px")
+      return {
+        outerHeightStyle: 0,
+        overflowing: !1
+      };
+    const f = S.current;
+    f.style.width = r.width, f.value = d.value || o.placeholder || "x", f.value.slice(-1) === `
+` && (f.value += " ");
+    const z = r.boxSizing, R = L(r.paddingBottom) + L(r.paddingTop), g = L(r.borderBottomWidth) + L(r.borderTopWidth), A = f.scrollHeight;
+    f.value = "x";
+    const N = f.scrollHeight;
+    let c = A;
+    p && (c = Math.max(Number(p) * N, c)), u && (c = Math.min(Number(u) * N, c)), c = Math.max(c, N);
+    const H = c + (z === "border-box" ? R + g : 0), P = Math.abs(c - A) <= 1;
+    return {
+      outerHeightStyle: H,
+      overflowing: P
+    };
+  }, [u, p, o.placeholder]), x = s.useCallback(() => {
+    const d = v();
+    if (qe(d))
+      return;
+    const b = d.outerHeightStyle, r = h.current;
+    y.current !== b && (y.current = b, r.style.height = `${b}px`), r.style.overflow = d.overflowing ? "hidden" : "";
+  }, [v]);
+  X(() => {
+    const d = () => {
+      x();
+    };
+    let b;
+    const r = () => {
+      cancelAnimationFrame(b), b = requestAnimationFrame(() => {
+        d();
+      });
+    }, f = Ue(d), z = h.current, R = fe(z);
+    R.addEventListener("resize", f);
+    let g;
+    return typeof ResizeObserver < "u" && (g = new ResizeObserver(process.env.NODE_ENV === "test" ? r : d), g.observe(z)), () => {
+      f.clear(), cancelAnimationFrame(b), R.removeEventListener("resize", f), g && g.disconnect();
+    };
+  }, [v, x]), X(() => {
+    x();
+  });
+  const V = (d) => {
+    C || x(), l && l(d);
+  };
+  return /* @__PURE__ */ Q(s.Fragment, {
+    children: [/* @__PURE__ */ B("textarea", {
+      value: E,
+      onChange: V,
+      ref: T,
+      rows: p,
+      style: O,
+      ...M
+    }), /* @__PURE__ */ B("textarea", {
+      "aria-hidden": !0,
+      className: o.className,
+      readOnly: !0,
+      ref: S,
+      tabIndex: -1,
+      style: {
+        ...$e.shadow,
+        ...O,
+        paddingTop: 0,
+        paddingBottom: 0
+      }
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (Ce.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 he(n) {
+  return typeof n == "string";
+}
+function Ge(n) {
+  return Me("MuiInputBase", n);
+}
+const ee = Be("MuiInputBase", ["root", "formControl", "focused", "disabled", "adornedStart", "adornedEnd", "error", "sizeSmall", "multiline", "colorSecondary", "fullWidth", "hiddenLabel", "readOnly", "input", "inputSizeSmall", "inputMultiline", "inputTypeSearch", "inputAdornedStart", "inputAdornedEnd", "inputHiddenLabel"]);
+var ye;
+const Ye = (n, o) => {
+  const {
+    ownerState: t
+  } = n;
+  return [o.root, t.formControl && o.formControl, t.startAdornment && o.adornedStart, t.endAdornment && o.adornedEnd, t.error && o.error, t.size === "small" && o.sizeSmall, t.multiline && o.multiline, t.color && o[`color${J(t.color)}`], t.fullWidth && o.fullWidth, t.hiddenLabel && o.hiddenLabel];
+}, Ze = (n, o) => {
+  const {
+    ownerState: t
+  } = n;
+  return [o.input, t.size === "small" && o.inputSizeSmall, t.multiline && o.inputMultiline, t.type === "search" && o.inputTypeSearch, t.startAdornment && o.inputAdornedStart, t.endAdornment && o.inputAdornedEnd, t.hiddenLabel && o.inputHiddenLabel];
+}, Je = (n) => {
+  const {
+    classes: o,
+    color: t,
+    disabled: l,
+    error: u,
+    endAdornment: p,
+    focused: O,
+    formControl: E,
+    fullWidth: M,
+    hiddenLabel: C,
+    multiline: h,
+    readOnly: T,
+    size: y,
+    startAdornment: S,
+    type: v
+  } = n, x = {
+    root: ["root", `color${J(t)}`, l && "disabled", u && "error", M && "fullWidth", O && "focused", E && "formControl", y && y !== "medium" && `size${J(y)}`, h && "multiline", S && "adornedStart", p && "adornedEnd", C && "hiddenLabel", T && "readOnly"],
+    input: ["input", l && "disabled", v === "search" && "inputTypeSearch", h && "inputMultiline", y === "small" && "inputSizeSmall", C && "inputHiddenLabel", S && "inputAdornedStart", p && "inputAdornedEnd", T && "readOnly"]
+  };
+  return De(x, Ge, o);
+}, Qe = we("div", {
+  name: "MuiInputBase",
+  slot: "Root",
+  overridesResolver: Ye
+})(ge(({
+  theme: n
+}) => ({
+  ...n.typography.body1,
+  color: (n.vars || n).palette.text.primary,
+  lineHeight: "1.4375em",
+  // 23px
+  boxSizing: "border-box",
+  // Prevent padding issue with fullWidth.
+  position: "relative",
+  cursor: "text",
+  display: "inline-flex",
+  alignItems: "center",
+  [`&.${ee.disabled}`]: {
+    color: (n.vars || n).palette.text.disabled,
+    cursor: "default"
+  },
+  variants: [{
+    props: ({
+      ownerState: o
+    }) => o.multiline,
+    style: {
+      padding: "4px 0 5px"
+    }
+  }, {
+    props: ({
+      ownerState: o,
+      size: t
+    }) => o.multiline && t === "small",
+    style: {
+      paddingTop: 1
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.fullWidth,
+    style: {
+      width: "100%"
+    }
+  }]
+}))), Xe = we("input", {
+  name: "MuiInputBase",
+  slot: "Input",
+  overridesResolver: Ze
+})(ge(({
+  theme: n
+}) => {
+  const o = n.palette.mode === "light", t = {
+    color: "currentColor",
+    ...n.vars ? {
+      opacity: n.vars.opacity.inputPlaceholder
+    } : {
+      opacity: o ? 0.42 : 0.5
+    },
+    transition: n.transitions.create("opacity", {
+      duration: n.transitions.duration.shorter
+    })
+  }, l = {
+    opacity: "0 !important"
+  }, u = n.vars ? {
+    opacity: n.vars.opacity.inputPlaceholder
+  } : {
+    opacity: o ? 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": t,
+    "&::-moz-placeholder": t,
+    // Firefox 19+
+    "&::-ms-input-placeholder": t,
+    // 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] + .${ee.formControl} &`]: {
+      "&::-webkit-input-placeholder": l,
+      "&::-moz-placeholder": l,
+      // Firefox 19+
+      "&::-ms-input-placeholder": l,
+      // Edge
+      "&:focus::-webkit-input-placeholder": u,
+      "&:focus::-moz-placeholder": u,
+      // Firefox 19+
+      "&:focus::-ms-input-placeholder": u
+      // Edge
+    },
+    [`&.${ee.disabled}`]: {
+      opacity: 1,
+      // Reset iOS opacity
+      WebkitTextFillColor: (n.vars || n).palette.text.disabled
+      // Fix opacity Safari bug
+    },
+    variants: [{
+      props: ({
+        ownerState: p
+      }) => !p.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: p
+      }) => p.multiline,
+      style: {
+        height: "auto",
+        resize: "none",
+        padding: 0,
+        paddingTop: 0
+      }
+    }, {
+      props: {
+        type: "search"
+      },
+      style: {
+        MozAppearance: "textfield"
+        // Improve type search style.
+      }
+    }]
+  };
+})), be = Pe({
+  "@keyframes mui-auto-fill": {
+    from: {
+      display: "block"
+    }
+  },
+  "@keyframes mui-auto-fill-cancel": {
+    from: {
+      display: "block"
+    }
+  }
+}), en = /* @__PURE__ */ s.forwardRef(function(o, t) {
+  const l = We({
+    props: o,
+    name: "MuiInputBase"
+  }), {
+    "aria-describedby": u,
+    autoComplete: p,
+    autoFocus: O,
+    className: E,
+    color: M,
+    components: C = {},
+    componentsProps: h = {},
+    defaultValue: T,
+    disabled: y,
+    disableInjectingGlobalStyles: S,
+    endAdornment: v,
+    error: x,
+    fullWidth: V = !1,
+    id: d,
+    inputComponent: b = "input",
+    inputProps: r = {},
+    inputRef: f,
+    margin: z,
+    maxRows: R,
+    minRows: g,
+    multiline: A = !1,
+    name: N,
+    onBlur: c,
+    onChange: H,
+    onClick: P,
+    onFocus: oe,
+    onKeyDown: Se,
+    onKeyUp: xe,
+    placeholder: Re,
+    readOnly: U,
+    renderSuffix: te,
+    rows: W,
+    size: nn,
+    slotProps: re = {},
+    slots: ie = {},
+    startAdornment: F,
+    type: ae = "text",
+    value: Oe,
+    ...Ee
+  } = l, D = r.value != null ? r.value : Oe, {
+    current: _
+  } = s.useRef(D != null), I = s.useRef(), Te = s.useCallback((i) => {
+    process.env.NODE_ENV !== "production" && i && i.nodeName !== "INPUT" && !i.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(`
+`));
+  }, []), Ie = ve(I, f, r.ref, Te), [j, K] = s.useState(!1), a = _e();
+  process.env.NODE_ENV !== "production" && s.useEffect(() => {
+    if (a)
+      return a.registerEffect();
+  }, [a]);
+  const m = Ke({
+    props: l,
+    muiFormControl: a,
+    states: ["color", "disabled", "error", "hiddenLabel", "size", "required", "filled"]
+  });
+  m.focused = a ? a.focused : j, s.useEffect(() => {
+    !a && y && j && (K(!1), c && c());
+  }, [a, y, j, c]);
+  const $ = a && a.onFilled, q = a && a.onEmpty, k = s.useCallback((i) => {
+    je(i) ? $ && $() : q && q();
+  }, [$, q]);
+  X(() => {
+    _ && k({
+      value: D
+    });
+  }, [D, k, _]);
+  const ze = (i) => {
+    oe && oe(i), r.onFocus && r.onFocus(i), a && a.onFocus ? a.onFocus(i) : K(!0);
+  }, Ae = (i) => {
+    c && c(i), r.onBlur && r.onBlur(i), a && a.onBlur ? a.onBlur(i) : K(!1);
+  }, Ne = (i, ...de) => {
+    if (!_) {
+      const ce = i.target || I.current;
+      if (ce == 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." : He(1));
+      k({
+        value: ce.value
+      });
+    }
+    r.onChange && r.onChange(i, ...de), H && H(i, ...de);
+  };
+  s.useEffect(() => {
+    k(I.current);
+  }, []);
+  const Fe = (i) => {
+    I.current && i.currentTarget === i.target && I.current.focus(), P && P(i);
+  };
+  let G = b, w = r;
+  A && G === "input" && (W ? (process.env.NODE_ENV !== "production" && (g || R) && console.warn("MUI: You can not use the `minRows` or `maxRows` props when the input `rows` prop is set."), w = {
+    type: void 0,
+    minRows: W,
+    maxRows: W,
+    ...w
+  }) : w = {
+    type: void 0,
+    maxRows: R,
+    minRows: g,
+    ...w
+  }, G = Ce);
+  const ke = (i) => {
+    k(i.animationName === "mui-auto-fill-cancel" ? I.current : {
+      value: "x"
+    });
+  };
+  s.useEffect(() => {
+    a && a.setAdornedStart(!!F);
+  }, [a, F]);
+  const Y = {
+    ...l,
+    color: m.color || "primary",
+    disabled: m.disabled,
+    endAdornment: v,
+    error: m.error,
+    focused: m.focused,
+    formControl: a,
+    fullWidth: V,
+    hiddenLabel: m.hiddenLabel,
+    multiline: A,
+    size: m.size,
+    startAdornment: F,
+    type: ae
+  }, se = Je(Y), le = ie.root || C.Root || Qe, Z = re.root || h.root || {}, ue = ie.input || C.Input || Xe;
+  return w = {
+    ...w,
+    ...re.input ?? h.input
+  }, /* @__PURE__ */ Q(s.Fragment, {
+    children: [!S && typeof be == "function" && // For Emotion/Styled-components, InputGlobalStyles will be a function
+    // For Pigment CSS, this has no effect because the InputGlobalStyles will be null.
+    (ye || (ye = /* @__PURE__ */ B(be, {}))), /* @__PURE__ */ Q(le, {
+      ...Z,
+      ref: t,
+      onClick: Fe,
+      ...Ee,
+      ...!he(le) && {
+        ownerState: {
+          ...Y,
+          ...Z.ownerState
+        }
+      },
+      className: pe(se.root, Z.className, E, U && "MuiInputBase-readOnly"),
+      children: [F, /* @__PURE__ */ B(ne.Provider, {
+        value: null,
+        children: /* @__PURE__ */ B(ue, {
+          "aria-invalid": m.error,
+          "aria-describedby": u,
+          autoComplete: p,
+          autoFocus: O,
+          defaultValue: T,
+          disabled: m.disabled,
+          id: d,
+          onAnimationStart: ke,
+          name: N,
+          placeholder: Re,
+          readOnly: U,
+          required: m.required,
+          rows: W,
+          value: D,
+          onKeyDown: Se,
+          onKeyUp: xe,
+          type: ae,
+          ...w,
+          ...!he(ue) && {
+            as: G,
+            ownerState: {
+              ...Y,
+              ...w.ownerState
+            }
+          },
+          ref: Ie,
+          className: pe(se.input, w.className, U && "MuiInputBase-readOnly"),
+          onBlur: Ae,
+          onChange: Ne,
+          onFocus: ze
+        })
+      }), v, te ? te({
+        ...m,
+        startAdornment: F
+      }) : null]
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (en.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: Le,
+  /**
+   * [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: Ve,
+  /**
+   * 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
+});
+export {
+  ne as F,
+  en as I,
+  je as a,
+  ee as b,
+  Qe as c,
+  Xe as d,
+  Ze as e,
+  Ke as f,
+  he as g,
+  cn as i,
+  Ye as r,
+  _e as u
+};