@max-ts/components 0.3.4 → 0.3.6

package/lib/node_modules/.pnpm/@mui_material@6.4.5_@emotion_react@11.14.0_@types_react@19.0.10_react@19.0.0__@emotion__861faf9ddc4761e7658ec96cff5e306a/node_modules/@mui/material/Autocomplete/Autocomplete.mjs

@@ -0,0 +1,1123 @@
+import * as eo from "react";
+import o from "../../../../../../../_virtual/index.mjs";
+import { clsx as k } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.mjs";
+import D from "../Input/inputClasses.mjs";
+import g from "../InputBase/inputBaseClasses.mjs";
+import to from "../OutlinedInput/outlinedInputClasses.mjs";
+import b from "../FilledInput/filledInputClasses.mjs";
+import te from "../internal/svg-icons/Close.mjs";
+import ne from "../internal/svg-icons/ArrowDropDown.mjs";
+import h from "../utils/memoTheme.mjs";
+import t, { getAutocompleteUtilityClass as pe } from "./autocompleteClasses.mjs";
+import E from "../utils/useSlot.mjs";
+import { j as r } from "../../../../../../../_virtual/jsx-runtime.mjs";
+import { useDefaultProps as re } from "../DefaultPropsProvider/DefaultPropsProvider.mjs";
+import ae from "../useAutocomplete/useAutocomplete.mjs";
+import { createFilterOptions as $t } from "../useAutocomplete/useAutocomplete.mjs";
+import s from "../styles/styled.mjs";
+import ao from "../Paper/Paper.mjs";
+import lo from "../Popper/Popper.mjs";
+import le from "../Chip/Chip.mjs";
+import io from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/capitalize/capitalize.mjs";
+import ie from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/composeClasses/composeClasses.mjs";
+import so from "../IconButton/IconButton.mjs";
+import se from "../ListSubheader/ListSubheader.mjs";
+import no from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/chainPropTypes/chainPropTypes.mjs";
+import ce from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/integerPropType/integerPropType.mjs";
+import { alpha as W } from "../../../../../@mui_system@6.4.3_@emotion_react@11.14.0_@types_react@19.0.10_react@19.0.0__@emotion_st_5f10f346196051285cfc2e46c43ad4ff/node_modules/@mui/system/esm/colorManipulator/colorManipulator.mjs";
+var po, ro;
+const ue = (e) => {
+  const {
+    classes: n,
+    disablePortal: u,
+    expanded: i,
+    focused: O,
+    fullWidth: v,
+    hasClearIcon: y,
+    hasPopupIcon: I,
+    inputFocused: A,
+    popupOpen: L,
+    size: S
+  } = e, F = {
+    root: ["root", i && "expanded", O && "focused", v && "fullWidth", y && "hasClearIcon", I && "hasPopupIcon"],
+    inputRoot: ["inputRoot"],
+    input: ["input", A && "inputFocused"],
+    tag: ["tag", `tagSize${io(S)}`],
+    endAdornment: ["endAdornment"],
+    clearIndicator: ["clearIndicator"],
+    popupIndicator: ["popupIndicator", L && "popupIndicatorOpen"],
+    popper: ["popper", u && "popperDisablePortal"],
+    paper: ["paper"],
+    listbox: ["listbox"],
+    loading: ["loading"],
+    noOptions: ["noOptions"],
+    option: ["option"],
+    groupLabel: ["groupLabel"],
+    groupUl: ["groupUl"]
+  };
+  return ie(F, pe, n);
+}, de = s("div", {
+  name: "MuiAutocomplete",
+  slot: "Root",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: u
+    } = e, {
+      fullWidth: i,
+      hasClearIcon: O,
+      hasPopupIcon: v,
+      inputFocused: y,
+      size: I
+    } = u;
+    return [{
+      [`& .${t.tag}`]: n.tag
+    }, {
+      [`& .${t.tag}`]: n[`tagSize${io(I)}`]
+    }, {
+      [`& .${t.inputRoot}`]: n.inputRoot
+    }, {
+      [`& .${t.input}`]: n.input
+    }, {
+      [`& .${t.input}`]: y && n.inputFocused
+    }, n.root, i && n.fullWidth, v && n.hasPopupIcon, O && n.hasClearIcon];
+  }
+})({
+  [`&.${t.focused} .${t.clearIndicator}`]: {
+    visibility: "visible"
+  },
+  /* Avoid double tap issue on iOS */
+  "@media (pointer: fine)": {
+    [`&:hover .${t.clearIndicator}`]: {
+      visibility: "visible"
+    }
+  },
+  [`& .${t.tag}`]: {
+    margin: 3,
+    maxWidth: "calc(100% - 6px)"
+  },
+  [`& .${t.inputRoot}`]: {
+    [`.${t.hasPopupIcon}&, .${t.hasClearIcon}&`]: {
+      paddingRight: 30
+    },
+    [`.${t.hasPopupIcon}.${t.hasClearIcon}&`]: {
+      paddingRight: 56
+    },
+    [`& .${t.input}`]: {
+      width: 0,
+      minWidth: 30
+    }
+  },
+  [`& .${D.root}`]: {
+    paddingBottom: 1,
+    "& .MuiInput-input": {
+      padding: "4px 4px 4px 0px"
+    }
+  },
+  [`& .${D.root}.${g.sizeSmall}`]: {
+    [`& .${D.input}`]: {
+      padding: "2px 4px 3px 0"
+    }
+  },
+  [`& .${to.root}`]: {
+    padding: 9,
+    [`.${t.hasPopupIcon}&, .${t.hasClearIcon}&`]: {
+      paddingRight: 39
+    },
+    [`.${t.hasPopupIcon}.${t.hasClearIcon}&`]: {
+      paddingRight: 65
+    },
+    [`& .${t.input}`]: {
+      padding: "7.5px 4px 7.5px 5px"
+    },
+    [`& .${t.endAdornment}`]: {
+      right: 9
+    }
+  },
+  [`& .${to.root}.${g.sizeSmall}`]: {
+    // Don't specify paddingRight, as it overrides the default value set when there is only
+    // one of the popup or clear icon as the specificity is equal so the latter one wins
+    paddingTop: 6,
+    paddingBottom: 6,
+    paddingLeft: 6,
+    [`& .${t.input}`]: {
+      padding: "2.5px 4px 2.5px 8px"
+    }
+  },
+  [`& .${b.root}`]: {
+    paddingTop: 19,
+    paddingLeft: 8,
+    [`.${t.hasPopupIcon}&, .${t.hasClearIcon}&`]: {
+      paddingRight: 39
+    },
+    [`.${t.hasPopupIcon}.${t.hasClearIcon}&`]: {
+      paddingRight: 65
+    },
+    [`& .${b.input}`]: {
+      padding: "7px 4px"
+    },
+    [`& .${t.endAdornment}`]: {
+      right: 9
+    }
+  },
+  [`& .${b.root}.${g.sizeSmall}`]: {
+    paddingBottom: 1,
+    [`& .${b.input}`]: {
+      padding: "2.5px 4px"
+    }
+  },
+  [`& .${g.hiddenLabel}`]: {
+    paddingTop: 8
+  },
+  [`& .${b.root}.${g.hiddenLabel}`]: {
+    paddingTop: 0,
+    paddingBottom: 0,
+    [`& .${t.input}`]: {
+      paddingTop: 16,
+      paddingBottom: 17
+    }
+  },
+  [`& .${b.root}.${g.hiddenLabel}.${g.sizeSmall}`]: {
+    [`& .${t.input}`]: {
+      paddingTop: 8,
+      paddingBottom: 9
+    }
+  },
+  [`& .${t.input}`]: {
+    flexGrow: 1,
+    textOverflow: "ellipsis",
+    opacity: 0
+  },
+  variants: [{
+    props: {
+      fullWidth: !0
+    },
+    style: {
+      width: "100%"
+    }
+  }, {
+    props: {
+      size: "small"
+    },
+    style: {
+      [`& .${t.tag}`]: {
+        margin: 2,
+        maxWidth: "calc(100% - 4px)"
+      }
+    }
+  }, {
+    props: {
+      inputFocused: !0
+    },
+    style: {
+      [`& .${t.input}`]: {
+        opacity: 1
+      }
+    }
+  }, {
+    props: {
+      multiple: !0
+    },
+    style: {
+      [`& .${t.inputRoot}`]: {
+        flexWrap: "wrap"
+      }
+    }
+  }]
+}), me = s("div", {
+  name: "MuiAutocomplete",
+  slot: "EndAdornment",
+  overridesResolver: (e, n) => n.endAdornment
+})({
+  // We use a position absolute to support wrapping tags.
+  position: "absolute",
+  right: 0,
+  top: "50%",
+  transform: "translate(0, -50%)"
+}), ge = s(so, {
+  name: "MuiAutocomplete",
+  slot: "ClearIndicator",
+  overridesResolver: (e, n) => n.clearIndicator
+})({
+  marginRight: -2,
+  padding: 4,
+  visibility: "hidden"
+}), fe = s(so, {
+  name: "MuiAutocomplete",
+  slot: "PopupIndicator",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: u
+    } = e;
+    return [n.popupIndicator, u.popupOpen && n.popupIndicatorOpen];
+  }
+})({
+  padding: 2,
+  marginRight: -2,
+  variants: [{
+    props: {
+      popupOpen: !0
+    },
+    style: {
+      transform: "rotate(180deg)"
+    }
+  }]
+}), be = s(lo, {
+  name: "MuiAutocomplete",
+  slot: "Popper",
+  overridesResolver: (e, n) => {
+    const {
+      ownerState: u
+    } = e;
+    return [{
+      [`& .${t.option}`]: n.option
+    }, n.popper, u.disablePortal && n.popperDisablePortal];
+  }
+})(h(({
+  theme: e
+}) => ({
+  zIndex: (e.vars || e).zIndex.modal,
+  variants: [{
+    props: {
+      disablePortal: !0
+    },
+    style: {
+      position: "absolute"
+    }
+  }]
+}))), he = s(ao, {
+  name: "MuiAutocomplete",
+  slot: "Paper",
+  overridesResolver: (e, n) => n.paper
+})(h(({
+  theme: e
+}) => ({
+  ...e.typography.body1,
+  overflow: "auto"
+}))), xe = s("div", {
+  name: "MuiAutocomplete",
+  slot: "Loading",
+  overridesResolver: (e, n) => n.loading
+})(h(({
+  theme: e
+}) => ({
+  color: (e.vars || e).palette.text.secondary,
+  padding: "14px 16px"
+}))), Pe = s("div", {
+  name: "MuiAutocomplete",
+  slot: "NoOptions",
+  overridesResolver: (e, n) => n.noOptions
+})(h(({
+  theme: e
+}) => ({
+  color: (e.vars || e).palette.text.secondary,
+  padding: "14px 16px"
+}))), Oe = s("ul", {
+  name: "MuiAutocomplete",
+  slot: "Listbox",
+  overridesResolver: (e, n) => n.listbox
+})(h(({
+  theme: e
+}) => ({
+  listStyle: "none",
+  margin: 0,
+  padding: "8px 0",
+  maxHeight: "40vh",
+  overflow: "auto",
+  position: "relative",
+  [`& .${t.option}`]: {
+    minHeight: 48,
+    display: "flex",
+    overflow: "hidden",
+    justifyContent: "flex-start",
+    alignItems: "center",
+    cursor: "pointer",
+    paddingTop: 6,
+    boxSizing: "border-box",
+    outline: "0",
+    WebkitTapHighlightColor: "transparent",
+    paddingBottom: 6,
+    paddingLeft: 16,
+    paddingRight: 16,
+    [e.breakpoints.up("sm")]: {
+      minHeight: "auto"
+    },
+    [`&.${t.focused}`]: {
+      backgroundColor: (e.vars || e).palette.action.hover,
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: "transparent"
+      }
+    },
+    '&[aria-disabled="true"]': {
+      opacity: (e.vars || e).palette.action.disabledOpacity,
+      pointerEvents: "none"
+    },
+    [`&.${t.focusVisible}`]: {
+      backgroundColor: (e.vars || e).palette.action.focus
+    },
+    '&[aria-selected="true"]': {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / ${e.vars.palette.action.selectedOpacity})` : W(e.palette.primary.main, e.palette.action.selectedOpacity),
+      [`&.${t.focused}`]: {
+        backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.hoverOpacity}))` : W(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.hoverOpacity),
+        // Reset on touch devices, it doesn't add specificity
+        "@media (hover: none)": {
+          backgroundColor: (e.vars || e).palette.action.selected
+        }
+      },
+      [`&.${t.focusVisible}`]: {
+        backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.focusOpacity}))` : W(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.focusOpacity)
+      }
+    }
+  }
+}))), ve = s(se, {
+  name: "MuiAutocomplete",
+  slot: "GroupLabel",
+  overridesResolver: (e, n) => n.groupLabel
+})(h(({
+  theme: e
+}) => ({
+  backgroundColor: (e.vars || e).palette.background.paper,
+  top: -8
+}))), ye = s("ul", {
+  name: "MuiAutocomplete",
+  slot: "GroupUl",
+  overridesResolver: (e, n) => n.groupUl
+})({
+  padding: 0,
+  [`& .${t.option}`]: {
+    paddingLeft: 24
+  }
+}), Ie = /* @__PURE__ */ eo.forwardRef(function(n, u) {
+  const i = re({
+    props: n,
+    name: "MuiAutocomplete"
+  }), {
+    autoComplete: O = !1,
+    autoHighlight: v = !1,
+    autoSelect: y = !1,
+    blurOnSelect: I = !1,
+    ChipProps: A,
+    className: L,
+    clearIcon: S = po || (po = /* @__PURE__ */ r.jsx(te, {
+      fontSize: "small"
+    })),
+    clearOnBlur: F = !i.freeSolo,
+    clearOnEscape: $e = !1,
+    clearText: V = "Clear",
+    closeText: B = "Close",
+    componentsProps: co,
+    defaultValue: Ce = i.multiple ? [] : null,
+    disableClearable: uo = !1,
+    disableCloseOnSelect: Te = !1,
+    disabled: x = !1,
+    disabledItemsFocusable: Ae = !1,
+    disableListWrap: Le = !1,
+    disablePortal: G = !1,
+    filterOptions: Se,
+    filterSelectedOptions: we = !1,
+    forcePopupIcon: H = "auto",
+    freeSolo: U = !1,
+    fullWidth: mo = !1,
+    getLimitTagsText: go = (p) => `+${p}`,
+    getOptionDisabled: Re,
+    getOptionKey: je,
+    getOptionLabel: fo,
+    isOptionEqualToValue: Ne,
+    groupBy: bo,
+    handleHomeEndKeys: ze = !i.freeSolo,
+    id: Me,
+    includeInputInList: ke = !1,
+    inputValue: De,
+    limitTags: w = -1,
+    ListboxComponent: ho,
+    ListboxProps: xo,
+    loading: K = !1,
+    loadingText: Po = "Loading…",
+    multiple: Oo = !1,
+    noOptionsText: vo = "No options",
+    onChange: Ee,
+    onClose: We,
+    onHighlightChange: Fe,
+    onInputChange: Ve,
+    onOpen: Be,
+    open: Ge,
+    openOnFocus: He = !1,
+    openText: q = "Open",
+    options: Ue,
+    PaperComponent: yo,
+    PopperComponent: Io,
+    popupIcon: $o = ro || (ro = /* @__PURE__ */ r.jsx(ne, {})),
+    readOnly: _ = !1,
+    renderGroup: Co,
+    renderInput: To,
+    renderOption: Ao,
+    renderTags: J,
+    selectOnFocus: Ke = !i.freeSolo,
+    size: R = "medium",
+    slots: Lo = {},
+    slotProps: So = {},
+    value: qe,
+    ...wo
+  } = i, {
+    getRootProps: Ro,
+    getInputProps: Q,
+    getInputLabelProps: jo,
+    getPopupIndicatorProps: No,
+    getClearProps: zo,
+    getTagProps: Mo,
+    getListboxProps: ko,
+    getOptionProps: Do,
+    value: j,
+    dirty: Eo,
+    expanded: Wo,
+    id: Fo,
+    popupOpen: $,
+    focused: X,
+    focusedTag: Vo,
+    anchorEl: C,
+    setAnchorEl: Bo,
+    inputValue: Go,
+    groupedOptions: T
+  } = ae({
+    ...i,
+    componentName: "Autocomplete"
+  }), N = !uo && !x && Eo && !_, z = (!U || H === !0) && H !== !1, {
+    onMouseDown: Ho
+  } = Q(), {
+    ref: Uo,
+    ...Ko
+  } = ko(), M = fo || ((p) => p.label ?? p), l = {
+    ...i,
+    disablePortal: G,
+    expanded: Wo,
+    focused: X,
+    fullWidth: mo,
+    getOptionLabel: M,
+    hasClearIcon: N,
+    hasPopupIcon: z,
+    inputFocused: Vo === -1,
+    popupOpen: $,
+    size: R
+  }, a = ue(l), f = {
+    slots: {
+      paper: yo,
+      popper: Io,
+      ...Lo
+    },
+    slotProps: {
+      chip: A,
+      listbox: xo,
+      ...co,
+      ...So
+    }
+  }, [qo, _o] = E("listbox", {
+    elementType: Oe,
+    externalForwardedProps: f,
+    ownerState: l,
+    className: a.listbox,
+    additionalProps: Ko,
+    ref: Uo
+  }), [Jo, Qo] = E("paper", {
+    elementType: ao,
+    externalForwardedProps: f,
+    ownerState: l,
+    className: a.paper
+  }), [Xo, Yo] = E("popper", {
+    elementType: lo,
+    externalForwardedProps: f,
+    ownerState: l,
+    className: a.popper,
+    additionalProps: {
+      disablePortal: G,
+      style: {
+        width: C ? C.clientWidth : null
+      },
+      role: "presentation",
+      anchorEl: C,
+      open: $
+    }
+  });
+  let d;
+  if (Oo && j.length > 0) {
+    const p = (c) => ({
+      className: a.tag,
+      disabled: x,
+      ...Mo(c)
+    });
+    J ? d = J(j, p, l) : d = j.map((c, m) => {
+      const {
+        key: P,
+        ...ee
+      } = p({
+        index: m
+      });
+      return /* @__PURE__ */ r.jsx(le, {
+        label: M(c),
+        size: R,
+        ...ee,
+        ...f.slotProps.chip
+      }, P);
+    });
+  }
+  if (w > -1 && Array.isArray(d)) {
+    const p = d.length - w;
+    !X && p > 0 && (d = d.splice(0, w), d.push(/* @__PURE__ */ r.jsx("span", {
+      className: a.tag,
+      children: go(p)
+    }, d.length)));
+  }
+  const Zo = Co || ((p) => /* @__PURE__ */ r.jsxs("li", {
+    children: [/* @__PURE__ */ r.jsx(ve, {
+      className: a.groupLabel,
+      ownerState: l,
+      component: "div",
+      children: p.group
+    }), /* @__PURE__ */ r.jsx(ye, {
+      className: a.groupUl,
+      ownerState: l,
+      children: p.children
+    })]
+  }, p.key)), oe = Ao || ((p, c) => {
+    const {
+      key: m,
+      ...P
+    } = p;
+    return /* @__PURE__ */ r.jsx("li", {
+      ...P,
+      children: M(c)
+    }, m);
+  }), Y = (p, c) => {
+    const m = Do({
+      option: p,
+      index: c
+    });
+    return oe({
+      ...m,
+      className: a.option
+    }, p, {
+      selected: m["aria-selected"],
+      index: c,
+      inputValue: Go
+    }, l);
+  }, Z = f.slotProps.clearIndicator, oo = f.slotProps.popupIndicator;
+  return /* @__PURE__ */ r.jsxs(eo.Fragment, {
+    children: [/* @__PURE__ */ r.jsx(de, {
+      ref: u,
+      className: k(a.root, L),
+      ownerState: l,
+      ...Ro(wo),
+      children: To({
+        id: Fo,
+        disabled: x,
+        fullWidth: !0,
+        size: R === "small" ? "small" : void 0,
+        InputLabelProps: jo(),
+        InputProps: {
+          ref: Bo,
+          className: a.inputRoot,
+          startAdornment: d,
+          onMouseDown: (p) => {
+            p.target === p.currentTarget && Ho(p);
+          },
+          ...(N || z) && {
+            endAdornment: /* @__PURE__ */ r.jsxs(me, {
+              className: a.endAdornment,
+              ownerState: l,
+              children: [N ? /* @__PURE__ */ r.jsx(ge, {
+                ...zo(),
+                "aria-label": V,
+                title: V,
+                ownerState: l,
+                ...Z,
+                className: k(a.clearIndicator, Z?.className),
+                children: S
+              }) : null, z ? /* @__PURE__ */ r.jsx(fe, {
+                ...No(),
+                disabled: x,
+                "aria-label": $ ? B : q,
+                title: $ ? B : q,
+                ownerState: l,
+                ...oo,
+                className: k(a.popupIndicator, oo?.className),
+                children: $o
+              }) : null]
+            })
+          }
+        },
+        inputProps: {
+          className: a.input,
+          disabled: x,
+          readOnly: _,
+          ...Q()
+        }
+      })
+    }), C ? /* @__PURE__ */ r.jsx(be, {
+      as: Xo,
+      ...Yo,
+      children: /* @__PURE__ */ r.jsxs(he, {
+        as: Jo,
+        ...Qo,
+        children: [K && T.length === 0 ? /* @__PURE__ */ r.jsx(xe, {
+          className: a.loading,
+          ownerState: l,
+          children: Po
+        }) : null, T.length === 0 && !U && !K ? /* @__PURE__ */ r.jsx(Pe, {
+          className: a.noOptions,
+          ownerState: l,
+          role: "presentation",
+          onMouseDown: (p) => {
+            p.preventDefault();
+          },
+          children: vo
+        }) : null, T.length > 0 ? /* @__PURE__ */ r.jsx(qo, {
+          as: ho,
+          ..._o,
+          children: T.map((p, c) => bo ? Zo({
+            key: p.key,
+            group: p.group,
+            children: p.options.map((m, P) => Y(m, p.index + P))
+          }) : Y(p, c))
+        }) : null]
+      })
+    }) : null]
+  });
+});
+process.env.NODE_ENV !== "production" && (Ie.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 portion of the selected suggestion that the user hasn't typed,
+   * known as the completion string, appears inline after the input cursor in the textbox.
+   * The inline completion string is visually highlighted and has a selected state.
+   * @default false
+   */
+  autoComplete: o.bool,
+  /**
+   * If `true`, the first option is automatically highlighted.
+   * @default false
+   */
+  autoHighlight: o.bool,
+  /**
+   * If `true`, the selected option becomes the value of the input
+   * when the Autocomplete loses focus unless the user chooses
+   * a different option or changes the character string in the input.
+   *
+   * When using the `freeSolo` mode, the typed value will be the input value
+   * if the Autocomplete loses focus without highlighting an option.
+   * @default false
+   */
+  autoSelect: o.bool,
+  /**
+   * Control if the input should be blurred when an option is selected:
+   *
+   * - `false` the input is not blurred.
+   * - `true` the input is always blurred.
+   * - `touch` the input is blurred after a touch event.
+   * - `mouse` the input is blurred after a mouse event.
+   * @default false
+   */
+  blurOnSelect: o.oneOfType([o.oneOf(["mouse", "touch"]), o.bool]),
+  /**
+   * Props applied to the [`Chip`](https://mui.com/material-ui/api/chip/) element.
+   * @deprecated Use `slotProps.chip` instead. This prop will be removed in v7. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  ChipProps: o.object,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * The icon to display in place of the default clear icon.
+   * @default <ClearIcon fontSize="small" />
+   */
+  clearIcon: o.node,
+  /**
+   * If `true`, the input's text is cleared on blur if no value is selected.
+   *
+   * Set it to `true` if you want to help the user enter a new value.
+   * Set it to `false` if you want to help the user resume their search.
+   * @default !props.freeSolo
+   */
+  clearOnBlur: o.bool,
+  /**
+   * If `true`, clear all values when the user presses escape and the popup is closed.
+   * @default false
+   */
+  clearOnEscape: o.bool,
+  /**
+   * Override the default text for the *clear* icon button.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Clear'
+   */
+  clearText: o.string,
+  /**
+   * Override the default text for the *close popup* icon button.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Close'
+   */
+  closeText: o.string,
+  /**
+   * The props used for each slot inside.
+   * @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.
+   */
+  componentsProps: o.shape({
+    clearIndicator: o.object,
+    paper: o.object,
+    popper: o.object,
+    popupIndicator: o.object
+  }),
+  /**
+   * The default value. Use when the component is not controlled.
+   * @default props.multiple ? [] : null
+   */
+  defaultValue: no(o.any, (e) => e.multiple && e.defaultValue !== void 0 && !Array.isArray(e.defaultValue) ? new Error(["MUI: The Autocomplete expects the `defaultValue` prop to be an array when `multiple={true}` or undefined.", `However, ${e.defaultValue} was provided.`].join(`
+`)) : null),
+  /**
+   * If `true`, the input can't be cleared.
+   * @default false
+   */
+  disableClearable: o.bool,
+  /**
+   * If `true`, the popup won't close when a value is selected.
+   * @default false
+   */
+  disableCloseOnSelect: o.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: o.bool,
+  /**
+   * If `true`, will allow focus on disabled items.
+   * @default false
+   */
+  disabledItemsFocusable: o.bool,
+  /**
+   * If `true`, the list box in the popup will not wrap focus.
+   * @default false
+   */
+  disableListWrap: o.bool,
+  /**
+   * If `true`, the `Popper` content will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: o.bool,
+  /**
+   * A function that determines the filtered options to be rendered on search.
+   *
+   * @default createFilterOptions()
+   * @param {Value[]} options The options to render.
+   * @param {object} state The state of the component.
+   * @returns {Value[]}
+   */
+  filterOptions: o.func,
+  /**
+   * If `true`, hide the selected options from the list box.
+   * @default false
+   */
+  filterSelectedOptions: o.bool,
+  /**
+   * Force the visibility display of the popup icon.
+   * @default 'auto'
+   */
+  forcePopupIcon: o.oneOfType([o.oneOf(["auto"]), o.bool]),
+  /**
+   * If `true`, the Autocomplete is free solo, meaning that the user input is not bound to provided options.
+   * @default false
+   */
+  freeSolo: o.bool,
+  /**
+   * If `true`, the input will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: o.bool,
+  /**
+   * The label to display when the tags are truncated (`limitTags`).
+   *
+   * @param {number} more The number of truncated tags.
+   * @returns {ReactNode}
+   * @default (more) => `+${more}`
+   */
+  getLimitTagsText: o.func,
+  /**
+   * Used to determine the disabled state for a given option.
+   *
+   * @param {Value} option The option to test.
+   * @returns {boolean}
+   */
+  getOptionDisabled: o.func,
+  /**
+   * Used to determine the key for a given option.
+   * This can be useful when the labels of options are not unique (since labels are used as keys by default).
+   *
+   * @param {Value} option The option to get the key for.
+   * @returns {string | number}
+   */
+  getOptionKey: o.func,
+  /**
+   * Used to determine the string value for a given option.
+   * It's used to fill the input (and the list box options if `renderOption` is not provided).
+   *
+   * If used in free solo mode, it must accept both the type of the options and a string.
+   *
+   * @param {Value} option
+   * @returns {string}
+   * @default (option) => option.label ?? option
+   */
+  getOptionLabel: o.func,
+  /**
+   * If provided, the options will be grouped under the returned string.
+   * The groupBy value is also used as the text for group headings when `renderGroup` is not provided.
+   *
+   * @param {Value} option The Autocomplete option.
+   * @returns {string}
+   */
+  groupBy: o.func,
+  /**
+   * If `true`, the component handles the "Home" and "End" keys when the popup is open.
+   * It should move focus to the first option and last option, respectively.
+   * @default !props.freeSolo
+   */
+  handleHomeEndKeys: o.bool,
+  /**
+   * This prop is used to help implement the accessibility logic.
+   * If you don't provide an id it will fall back to a randomly generated one.
+   */
+  id: o.string,
+  /**
+   * If `true`, the highlight can move to the input.
+   * @default false
+   */
+  includeInputInList: o.bool,
+  /**
+   * The input value.
+   */
+  inputValue: o.string,
+  /**
+   * Used to determine if the option represents the given value.
+   * Uses strict equality by default.
+   * ⚠️ Both arguments need to be handled, an option can only match with one value.
+   *
+   * @param {Value} option The option to test.
+   * @param {Value} value The value to test against.
+   * @returns {boolean}
+   */
+  isOptionEqualToValue: o.func,
+  /**
+   * The maximum number of tags that will be visible when not focused.
+   * Set `-1` to disable the limit.
+   * @default -1
+   */
+  limitTags: ce,
+  /**
+   * The component used to render the listbox.
+   * @default 'ul'
+   * @deprecated Use `slotProps.listbox.component` instead. This prop will be removed in v7. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  ListboxComponent: o.elementType,
+  /**
+   * Props applied to the Listbox element.
+   * @deprecated Use `slotProps.listbox` instead. This prop will be removed in v7. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  ListboxProps: o.object,
+  /**
+   * If `true`, the component is in a loading state.
+   * This shows the `loadingText` in place of suggestions (only if there are no suggestions to show, for example `options` are empty).
+   * @default false
+   */
+  loading: o.bool,
+  /**
+   * Text to display when in a loading state.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Loading…'
+   */
+  loadingText: o.node,
+  /**
+   * If `true`, `value` must be an array and the menu will support multiple selections.
+   * @default false
+   */
+  multiple: o.bool,
+  /**
+   * Text to display when there are no options.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'No options'
+   */
+  noOptionsText: o.node,
+  /**
+   * Callback fired when the value changes.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   * @param {Value|Value[]} value The new value of the component.
+   * @param {string} reason One of "createOption", "selectOption", "removeOption", "blur" or "clear".
+   * @param {string} [details]
+   */
+  onChange: o.func,
+  /**
+   * Callback fired when the popup requests to be closed.
+   * Use in controlled mode (see open).
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   * @param {string} reason Can be: `"toggleInput"`, `"escape"`, `"selectOption"`, `"removeOption"`, `"blur"`.
+   */
+  onClose: o.func,
+  /**
+   * Callback fired when the highlight option changes.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   * @param {Value} option The highlighted option.
+   * @param {string} reason Can be: `"keyboard"`, `"auto"`, `"mouse"`, `"touch"`.
+   */
+  onHighlightChange: o.func,
+  /**
+   * Callback fired when the input value changes.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   * @param {string} value The new value of the text input.
+   * @param {string} reason Can be: `"input"` (user input), `"reset"` (programmatic change), `"clear"`, `"blur"`, `"selectOption"`, `"removeOption"`
+   */
+  onInputChange: o.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: o.func,
+  /**
+   * Callback fired when the popup requests to be opened.
+   * Use in controlled mode (see open).
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   */
+  onOpen: o.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: o.bool,
+  /**
+   * If `true`, the popup will open on input focus.
+   * @default false
+   */
+  openOnFocus: o.bool,
+  /**
+   * Override the default text for the *open popup* icon button.
+   *
+   * For localization purposes, you can use the provided [translations](https://mui.com/material-ui/guides/localization/).
+   * @default 'Open'
+   */
+  openText: o.string,
+  /**
+   * A list of options that will be shown in the Autocomplete.
+   */
+  options: o.array.isRequired,
+  /**
+   * The component used to render the body of the popup.
+   * @default Paper
+   * @deprecated Use `slots.paper` instead. This prop will be removed in v7. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  PaperComponent: o.elementType,
+  /**
+   * The component used to position the popup.
+   * @default Popper
+   * @deprecated Use `slots.popper` instead. This prop will be removed in v7. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  PopperComponent: o.elementType,
+  /**
+   * The icon to display in place of the default popup icon.
+   * @default <ArrowDropDownIcon />
+   */
+  popupIcon: o.node,
+  /**
+   * If `true`, the component becomes readonly. It is also supported for multiple tags where the tag cannot be deleted.
+   * @default false
+   */
+  readOnly: o.bool,
+  /**
+   * Render the group.
+   *
+   * @param {AutocompleteRenderGroupParams} params The group to render.
+   * @returns {ReactNode}
+   */
+  renderGroup: o.func,
+  /**
+   * Render the input.
+   *
+   * @param {object} params
+   * @returns {ReactNode}
+   */
+  renderInput: o.func.isRequired,
+  /**
+   * Render the option, use `getOptionLabel` by default.
+   *
+   * @param {object} props The props to apply on the li element.
+   * @param {Value} option The option to render.
+   * @param {object} state The state of each option.
+   * @param {object} ownerState The state of the Autocomplete component.
+   * @returns {ReactNode}
+   */
+  renderOption: o.func,
+  /**
+   * Render the selected value.
+   *
+   * @param {Value[]} value The `value` provided to the component.
+   * @param {function} getTagProps A tag props getter.
+   * @param {object} ownerState The state of the Autocomplete component.
+   * @returns {ReactNode}
+   */
+  renderTags: o.func,
+  /**
+   * If `true`, the input's text is selected on focus.
+   * It helps the user clear the selected value.
+   * @default !props.freeSolo
+   */
+  selectOnFocus: o.bool,
+  /**
+   * The size of the component.
+   * @default 'medium'
+   */
+  size: o.oneOfType([o.oneOf(["small", "medium"]), o.string]),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: o.shape({
+    chip: o.oneOfType([o.func, o.object]),
+    clearIndicator: o.oneOfType([o.func, o.object]),
+    listbox: o.oneOfType([o.func, o.object]),
+    paper: o.oneOfType([o.func, o.object]),
+    popper: o.oneOfType([o.func, o.object]),
+    popupIndicator: o.oneOfType([o.func, o.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: o.shape({
+    listbox: o.elementType,
+    paper: o.elementType,
+    popper: o.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object]),
+  /**
+   * The value of the autocomplete.
+   *
+   * The value must have reference equality with the option in order to be selected.
+   * You can customize the equality behavior with the `isOptionEqualToValue` prop.
+   */
+  value: no(o.any, (e) => e.multiple && e.value !== void 0 && !Array.isArray(e.value) ? new Error(["MUI: The Autocomplete expects the `value` prop to be an array when `multiple={true}` or undefined.", `However, ${e.value} was provided.`].join(`
+`)) : null)
+});
+export {
+  $t as createFilterOptions,
+  Ie as default
+};