@cgi-learning-hub/ui 1.5.0 → 1.5.1-dev.1744639457

package/dist/ListItemText-zFoA_mgx.js

@@ -0,0 +1,845 @@
+import { P as e, H as I, G as ae, R as ie, n as P } from "./identifier-BJqC6EXa.js";
+import { u as ce } from "./useTheme-Dt-VOIyT.js";
+import * as T from "react";
+import { jsx as N, jsxs as le } from "react/jsx-runtime";
+import { s as pe } from "./styled-DpPa0vDp.js";
+import { u as de } from "./useTheme-B1xvds8x.js";
+import { e as fe } from "./extendSxProp-0G38SSpC.js";
+import { i as ue } from "./isMuiElement-DnSE4qG4.js";
+import { u as me } from "./useThemeProps-DSVFwH3A.js";
+import { c as F, s as A, u as U, r as ye } from "./DefaultPropsProvider-Bg-6nX-u.js";
+import { m as ge } from "./memoTheme-D_Qap2ZW.js";
+import { a as _ } from "./List-22h7byk_.js";
+import { b as be, a as G } from "./ListItem-B0syBgS7.js";
+import { a as Oe } from "./useEventCallback-Yoj9nCug.js";
+import { u as Te } from "./useForkRef-u29GSuCu.js";
+import { B as ve } from "./ButtonBase-BZXGvriS.js";
+import { g as we, l as k } from "./listItemTextClasses-DBxyCmso.js";
+import { u as W } from "./useSlot-DhC6EPU2.js";
+import { T as E, t as K } from "./Typography-BNt9mZKm.js";
+function he(r, o) {
+  if (process.env.NODE_ENV === "production")
+    return () => null;
+  const n = o ? {
+    ...o.propTypes
+  } : null;
+  return (a) => (s, i, u, m, l, ...p) => {
+    const y = l || i, d = n == null ? void 0 : n[y];
+    if (d) {
+      const f = d(s, i, u, m, l, ...p);
+      if (f)
+        return f;
+    }
+    return typeof s[i] < "u" && !s[a] ? new Error(`The prop \`${y}\` of \`${r}\` can only be used together with the \`${a}\` prop.`) : null;
+  };
+}
+const xe = (r, o) => r.filter((n) => o.includes(n)), C = (r, o, n) => {
+  const t = r.keys[0];
+  Array.isArray(o) ? o.forEach((a, s) => {
+    n((i, u) => {
+      s <= r.keys.length - 1 && (s === 0 ? Object.assign(i, u) : i[r.up(r.keys[s])] = u);
+    }, a);
+  }) : o && typeof o == "object" ? (Object.keys(o).length > r.keys.length ? r.keys : xe(r.keys, Object.keys(o))).forEach((s) => {
+    if (r.keys.includes(s)) {
+      const i = o[s];
+      i !== void 0 && n((u, m) => {
+        t === s ? Object.assign(u, m) : u[r.up(s)] = m;
+      }, i);
+    }
+  }) : (typeof o == "number" || typeof o == "string") && n((a, s) => {
+    Object.assign(a, s);
+  }, o);
+};
+function R(r) {
+  return `--Grid-${r}Spacing`;
+}
+function B(r) {
+  return `--Grid-parent-${r}Spacing`;
+}
+const Y = "--Grid-columns", j = "--Grid-parent-columns", $e = ({
+  theme: r,
+  ownerState: o
+}) => {
+  const n = {};
+  return C(r.breakpoints, o.size, (t, a) => {
+    let s = {};
+    a === "grow" && (s = {
+      flexBasis: 0,
+      flexGrow: 1,
+      maxWidth: "100%"
+    }), a === "auto" && (s = {
+      flexBasis: "auto",
+      flexGrow: 0,
+      flexShrink: 0,
+      maxWidth: "none",
+      width: "auto"
+    }), typeof a == "number" && (s = {
+      flexGrow: 0,
+      flexBasis: "auto",
+      width: `calc(100% * ${a} / var(${j}) - (var(${j}) - ${a}) * (var(${B("column")}) / var(${j})))`
+    }), t(n, s);
+  }), n;
+}, Se = ({
+  theme: r,
+  ownerState: o
+}) => {
+  const n = {};
+  return C(r.breakpoints, o.offset, (t, a) => {
+    let s = {};
+    a === "auto" && (s = {
+      marginLeft: "auto"
+    }), typeof a == "number" && (s = {
+      marginLeft: a === 0 ? "0px" : `calc(100% * ${a} / var(${j}) + var(${B("column")}) * ${a} / var(${j}))`
+    }), t(n, s);
+  }), n;
+}, je = ({
+  theme: r,
+  ownerState: o
+}) => {
+  if (!o.container)
+    return {};
+  const n = {
+    [Y]: 12
+  };
+  return C(r.breakpoints, o.columns, (t, a) => {
+    const s = a ?? 12;
+    t(n, {
+      [Y]: s,
+      "> *": {
+        [j]: s
+      }
+    });
+  }), n;
+}, Ce = ({
+  theme: r,
+  ownerState: o
+}) => {
+  if (!o.container)
+    return {};
+  const n = {};
+  return C(r.breakpoints, o.rowSpacing, (t, a) => {
+    var i;
+    const s = typeof a == "string" ? a : (i = r.spacing) == null ? void 0 : i.call(r, a);
+    t(n, {
+      [R("row")]: s,
+      "> *": {
+        [B("row")]: s
+      }
+    });
+  }), n;
+}, Ge = ({
+  theme: r,
+  ownerState: o
+}) => {
+  if (!o.container)
+    return {};
+  const n = {};
+  return C(r.breakpoints, o.columnSpacing, (t, a) => {
+    var i;
+    const s = typeof a == "string" ? a : (i = r.spacing) == null ? void 0 : i.call(r, a);
+    t(n, {
+      [R("column")]: s,
+      "> *": {
+        [B("column")]: s
+      }
+    });
+  }), n;
+}, Ne = ({
+  theme: r,
+  ownerState: o
+}) => {
+  if (!o.container)
+    return {};
+  const n = {};
+  return C(r.breakpoints, o.direction, (t, a) => {
+    t(n, {
+      flexDirection: a
+    });
+  }), n;
+}, Pe = ({
+  ownerState: r
+}) => ({
+  minWidth: 0,
+  boxSizing: "border-box",
+  ...r.container && {
+    display: "flex",
+    flexWrap: "wrap",
+    ...r.wrap && r.wrap !== "wrap" && {
+      flexWrap: r.wrap
+    },
+    gap: `var(${R("row")}) var(${R("column")})`
+  }
+}), ke = (r) => {
+  const o = [];
+  return Object.entries(r).forEach(([n, t]) => {
+    t !== !1 && t !== void 0 && o.push(`grid-${n}-${String(t)}`);
+  }), o;
+}, Ee = (r, o = "xs") => {
+  function n(t) {
+    return t === void 0 ? !1 : typeof t == "string" && !Number.isNaN(Number(t)) || typeof t == "number" && t > 0;
+  }
+  if (n(r))
+    return [`spacing-${o}-${String(r)}`];
+  if (typeof r == "object" && !Array.isArray(r)) {
+    const t = [];
+    return Object.entries(r).forEach(([a, s]) => {
+      n(s) && t.push(`spacing-${a}-${String(s)}`);
+    }), t;
+  }
+  return [];
+}, Ie = (r) => r === void 0 ? [] : typeof r == "object" ? Object.entries(r).map(([o, n]) => `direction-${o}-${n}`) : [`direction-xs-${String(r)}`], Re = (r) => ["item", "zeroMinWidth"].includes(r) ? `The \`${r}\` prop has been removed and is no longer necessary. You can safely remove it.` : `The \`${r}\` prop has been removed. See https://mui.com/material-ui/migration/upgrade-to-grid-v2/ for migration instructions.`, J = [];
+function Be(r, o) {
+  const n = [];
+  r.item !== void 0 && (delete r.item, n.push("item")), r.zeroMinWidth !== void 0 && (delete r.zeroMinWidth, n.push("zeroMinWidth")), o.keys.forEach((t) => {
+    r[t] !== void 0 && (n.push(t), delete r[t]);
+  }), process.env.NODE_ENV !== "production" && n.forEach((t) => {
+    J.includes(t) || (J.push(t), console.warn(`MUI Grid: ${Re(t)}
+`));
+  });
+}
+const Le = ie(), Me = pe("div", {
+  name: "MuiGrid",
+  slot: "Root",
+  overridesResolver: (r, o) => o.root
+});
+function ze(r) {
+  return me({
+    props: r,
+    name: "MuiGrid",
+    defaultTheme: Le
+  });
+}
+function De(r = {}) {
+  const {
+    // This will allow adding custom styled fn (for example for custom sx style function)
+    createStyledComponent: o = Me,
+    useThemeProps: n = ze,
+    useTheme: t = de,
+    componentName: a = "MuiGrid"
+  } = r, s = (l, p) => {
+    const {
+      container: y,
+      direction: d,
+      spacing: f,
+      wrap: c,
+      size: v
+    } = l, b = {
+      root: ["root", y && "container", c !== "wrap" && `wrap-xs-${String(c)}`, ...Ie(d), ...ke(v), ...y ? Ee(f, p.breakpoints.keys[0]) : []]
+    };
+    return F(b, (g) => ae(a, g), {});
+  };
+  function i(l, p, y = () => !0) {
+    const d = {};
+    return l === null || (Array.isArray(l) ? l.forEach((f, c) => {
+      f !== null && y(f) && p.keys[c] && (d[p.keys[c]] = f);
+    }) : typeof l == "object" ? Object.keys(l).forEach((f) => {
+      const c = l[f];
+      c != null && y(c) && (d[f] = c);
+    }) : d[p.keys[0]] = l), d;
+  }
+  const u = o(je, Ge, Ce, $e, Ne, Pe, Se), m = /* @__PURE__ */ T.forwardRef(function(p, y) {
+    const d = t(), f = n(p), c = fe(f);
+    Be(c, d.breakpoints);
+    const {
+      className: v,
+      children: b,
+      columns: g = 12,
+      container: O = !1,
+      component: w = "div",
+      direction: $ = "row",
+      wrap: L = "wrap",
+      size: M = {},
+      offset: z = {},
+      spacing: h = 0,
+      rowSpacing: D = h,
+      columnSpacing: V = h,
+      unstable_level: S = 0,
+      ...X
+    } = c, Z = i(M, d.breakpoints, (x) => x !== !1), ee = i(z, d.breakpoints), re = p.columns ?? (S ? void 0 : g), oe = p.spacing ?? (S ? void 0 : h), ne = p.rowSpacing ?? p.spacing ?? (S ? void 0 : D), te = p.columnSpacing ?? p.spacing ?? (S ? void 0 : V), q = {
+      ...c,
+      level: S,
+      columns: re,
+      container: O,
+      direction: $,
+      wrap: L,
+      spacing: oe,
+      rowSpacing: ne,
+      columnSpacing: te,
+      size: Z,
+      offset: ee
+    }, se = s(q, d);
+    return /* @__PURE__ */ N(u, {
+      ref: y,
+      as: w,
+      ownerState: q,
+      className: I(se.root, v),
+      ...X,
+      children: T.Children.map(b, (x) => {
+        var H;
+        return /* @__PURE__ */ T.isValidElement(x) && ue(x, ["Grid"]) && O && x.props.container ? /* @__PURE__ */ T.cloneElement(x, {
+          unstable_level: ((H = x.props) == null ? void 0 : H.unstable_level) ?? S + 1
+        }) : x;
+      })
+    });
+  });
+  return process.env.NODE_ENV !== "production" && (m.propTypes = {
+    children: e.node,
+    className: e.string,
+    columns: e.oneOfType([e.arrayOf(e.number), e.number, e.object]),
+    columnSpacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+    component: e.elementType,
+    container: e.bool,
+    direction: e.oneOfType([e.oneOf(["column-reverse", "column", "row-reverse", "row"]), e.arrayOf(e.oneOf(["column-reverse", "column", "row-reverse", "row"])), e.object]),
+    offset: e.oneOfType([e.string, e.number, e.arrayOf(e.oneOfType([e.string, e.number])), e.object]),
+    rowSpacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+    size: e.oneOfType([e.string, e.bool, e.number, e.arrayOf(e.oneOfType([e.string, e.bool, e.number])), e.object]),
+    spacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    wrap: e.oneOf(["nowrap", "wrap-reverse", "wrap"])
+  }), m.muiName = "Grid", m;
+}
+const Q = De({
+  createStyledComponent: A("div", {
+    name: "MuiGrid",
+    slot: "Root",
+    overridesResolver: (r, o) => {
+      const {
+        ownerState: n
+      } = r;
+      return [o.root, n.container && o.container];
+    }
+  }),
+  componentName: "MuiGrid",
+  useThemeProps: (r) => U({
+    props: r,
+    name: "MuiGrid"
+  }),
+  useTheme: ce
+});
+process.env.NODE_ENV !== "production" && (Q.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * The number of columns.
+   * @default 12
+   */
+  columns: e.oneOfType([e.arrayOf(e.number), e.number, e.object]),
+  /**
+   * Defines the horizontal space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  columnSpacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+  /**
+   * If `true`, the component will have the flex *container* behavior.
+   * You should be wrapping *items* with a *container*.
+   * @default false
+   */
+  container: e.bool,
+  /**
+   * Defines the `flex-direction` style property.
+   * It is applied for all screen sizes.
+   * @default 'row'
+   */
+  direction: e.oneOfType([e.oneOf(["column-reverse", "column", "row-reverse", "row"]), e.arrayOf(e.oneOf(["column-reverse", "column", "row-reverse", "row"])), e.object]),
+  /**
+   * Defines the offset value for the type `item` components.
+   */
+  offset: e.oneOfType([e.string, e.number, e.arrayOf(e.oneOfType([e.string, e.number])), e.object]),
+  /**
+   * Defines the vertical space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  rowSpacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+  /**
+   * Defines the size of the the type `item` components.
+   */
+  size: e.oneOfType([e.string, e.bool, e.number, e.arrayOf(e.oneOfType([e.string, e.bool, e.number])), e.object]),
+  /**
+   * Defines the space between the type `item` components.
+   * It can only be used on a type `container` component.
+   * @default 0
+   */
+  spacing: e.oneOfType([e.arrayOf(e.oneOfType([e.number, e.string])), e.number, e.object, e.string]),
+  /**
+   * @ignore
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * @internal
+   * The level of the grid starts from `0` and increases when the grid nests
+   * inside another grid. Nesting is defined as a container Grid being a direct
+   * child of a container Grid.
+   *
+   * ```js
+   * <Grid container> // level 0
+   *   <Grid container> // level 1
+   *     <Grid container> // level 2
+   * ```
+   *
+   * Only consecutive grid is considered nesting. A grid container will start at
+   * `0` if there are non-Grid container element above it.
+   *
+   * ```js
+   * <Grid container> // level 0
+   *   <div>
+   *     <Grid container> // level 0
+   * ```
+   *
+   * ```js
+   * <Grid container> // level 0
+   *   <Grid>
+   *     <Grid container> // level 0
+   * ```
+   */
+  unstable_level: e.number,
+  /**
+   * Defines the `flex-wrap` style property.
+   * It's applied for all screen sizes.
+   * @default 'wrap'
+   */
+  wrap: e.oneOf(["nowrap", "wrap-reverse", "wrap"])
+});
+if (process.env.NODE_ENV !== "production") {
+  const r = Q, o = he("Grid", r);
+  r.propTypes = {
+    // eslint-disable-next-line react/forbid-foreign-prop-types
+    ...r.propTypes,
+    direction: o("container"),
+    spacing: o("container"),
+    wrap: o("container")
+  };
+}
+const Ve = (r, o) => {
+  const {
+    ownerState: n
+  } = r;
+  return [o.root, n.dense && o.dense, n.alignItems === "flex-start" && o.alignItemsFlexStart, n.divider && o.divider, !n.disableGutters && o.gutters];
+}, We = (r) => {
+  const {
+    alignItems: o,
+    classes: n,
+    dense: t,
+    disabled: a,
+    disableGutters: s,
+    divider: i,
+    selected: u
+  } = r, l = F({
+    root: ["root", t && "dense", !s && "gutters", i && "divider", a && "disabled", o === "flex-start" && "alignItemsFlexStart", u && "selected"]
+  }, be, n);
+  return {
+    ...n,
+    ...l
+  };
+}, _e = A(ve, {
+  shouldForwardProp: (r) => ye(r) || r === "classes",
+  name: "MuiListItemButton",
+  slot: "Root",
+  overridesResolver: Ve
+})(ge(({
+  theme: r
+}) => ({
+  display: "flex",
+  flexGrow: 1,
+  justifyContent: "flex-start",
+  alignItems: "center",
+  position: "relative",
+  textDecoration: "none",
+  minWidth: 0,
+  boxSizing: "border-box",
+  textAlign: "left",
+  paddingTop: 8,
+  paddingBottom: 8,
+  transition: r.transitions.create("background-color", {
+    duration: r.transitions.duration.shortest
+  }),
+  "&:hover": {
+    textDecoration: "none",
+    backgroundColor: (r.vars || r).palette.action.hover,
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  },
+  [`&.${G.selected}`]: {
+    backgroundColor: r.vars ? `rgba(${r.vars.palette.primary.mainChannel} / ${r.vars.palette.action.selectedOpacity})` : P(r.palette.primary.main, r.palette.action.selectedOpacity),
+    [`&.${G.focusVisible}`]: {
+      backgroundColor: r.vars ? `rgba(${r.vars.palette.primary.mainChannel} / calc(${r.vars.palette.action.selectedOpacity} + ${r.vars.palette.action.focusOpacity}))` : P(r.palette.primary.main, r.palette.action.selectedOpacity + r.palette.action.focusOpacity)
+    }
+  },
+  [`&.${G.selected}:hover`]: {
+    backgroundColor: r.vars ? `rgba(${r.vars.palette.primary.mainChannel} / calc(${r.vars.palette.action.selectedOpacity} + ${r.vars.palette.action.hoverOpacity}))` : P(r.palette.primary.main, r.palette.action.selectedOpacity + r.palette.action.hoverOpacity),
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: r.vars ? `rgba(${r.vars.palette.primary.mainChannel} / ${r.vars.palette.action.selectedOpacity})` : P(r.palette.primary.main, r.palette.action.selectedOpacity)
+    }
+  },
+  [`&.${G.focusVisible}`]: {
+    backgroundColor: (r.vars || r).palette.action.focus
+  },
+  [`&.${G.disabled}`]: {
+    opacity: (r.vars || r).palette.action.disabledOpacity
+  },
+  variants: [{
+    props: ({
+      ownerState: o
+    }) => o.divider,
+    style: {
+      borderBottom: `1px solid ${(r.vars || r).palette.divider}`,
+      backgroundClip: "padding-box"
+    }
+  }, {
+    props: {
+      alignItems: "flex-start"
+    },
+    style: {
+      alignItems: "flex-start"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => !o.disableGutters,
+    style: {
+      paddingLeft: 16,
+      paddingRight: 16
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.dense,
+    style: {
+      paddingTop: 4,
+      paddingBottom: 4
+    }
+  }]
+}))), Fe = /* @__PURE__ */ T.forwardRef(function(o, n) {
+  const t = U({
+    props: o,
+    name: "MuiListItemButton"
+  }), {
+    alignItems: a = "center",
+    autoFocus: s = !1,
+    component: i = "div",
+    children: u,
+    dense: m = !1,
+    disableGutters: l = !1,
+    divider: p = !1,
+    focusVisibleClassName: y,
+    selected: d = !1,
+    className: f,
+    ...c
+  } = t, v = T.useContext(_), b = T.useMemo(() => ({
+    dense: m || v.dense || !1,
+    alignItems: a,
+    disableGutters: l
+  }), [a, v.dense, m, l]), g = T.useRef(null);
+  Oe(() => {
+    s && (g.current ? g.current.focus() : process.env.NODE_ENV !== "production" && console.error("MUI: Unable to set focus to a ListItemButton whose component has not been rendered."));
+  }, [s]);
+  const O = {
+    ...t,
+    alignItems: a,
+    dense: b.dense,
+    disableGutters: l,
+    divider: p,
+    selected: d
+  }, w = We(O), $ = Te(g, n);
+  return /* @__PURE__ */ N(_.Provider, {
+    value: b,
+    children: /* @__PURE__ */ N(_e, {
+      ref: $,
+      href: c.href || c.to,
+      component: (c.href || c.to) && i === "div" ? "button" : i,
+      focusVisibleClassName: I(w.focusVisible, y),
+      ownerState: O,
+      className: I(w.root, f),
+      ...c,
+      classes: w,
+      children: u
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Fe.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Defines the `align-items` style property.
+   * @default 'center'
+   */
+  alignItems: e.oneOf(["center", "flex-start"]),
+  /**
+   * If `true`, the list item is focused during the first mount.
+   * Focus will also be triggered if the value changes from false to true.
+   * @default false
+   */
+  autoFocus: e.bool,
+  /**
+   * The content of the component if a `ListItemSecondaryAction` is used it must
+   * be the last child.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, compact vertical padding designed for keyboard and mouse input is used.
+   * The prop defaults to the value inherited from the parent List component.
+   * @default false
+   */
+  dense: e.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the left and right padding is removed.
+   * @default false
+   */
+  disableGutters: e.bool,
+  /**
+   * If `true`, a 1px light border is added to the bottom of the list item.
+   * @default false
+   */
+  divider: e.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: e.string,
+  /**
+   * @ignore
+   */
+  href: e.string,
+  /**
+   * Use to apply selected styling.
+   * @default false
+   */
+  selected: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+const Ae = (r) => {
+  const {
+    classes: o,
+    inset: n,
+    primary: t,
+    secondary: a,
+    dense: s
+  } = r;
+  return F({
+    root: ["root", n && "inset", s && "dense", t && a && "multiline"],
+    primary: ["primary"],
+    secondary: ["secondary"]
+  }, we, o);
+}, Ue = A("div", {
+  name: "MuiListItemText",
+  slot: "Root",
+  overridesResolver: (r, o) => {
+    const {
+      ownerState: n
+    } = r;
+    return [{
+      [`& .${k.primary}`]: o.primary
+    }, {
+      [`& .${k.secondary}`]: o.secondary
+    }, o.root, n.inset && o.inset, n.primary && n.secondary && o.multiline, n.dense && o.dense];
+  }
+})({
+  flex: "1 1 auto",
+  minWidth: 0,
+  marginTop: 4,
+  marginBottom: 4,
+  [`.${K.root}:where(& .${k.primary})`]: {
+    display: "block"
+  },
+  [`.${K.root}:where(& .${k.secondary})`]: {
+    display: "block"
+  },
+  variants: [{
+    props: ({
+      ownerState: r
+    }) => r.primary && r.secondary,
+    style: {
+      marginTop: 6,
+      marginBottom: 6
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.inset,
+    style: {
+      paddingLeft: 56
+    }
+  }]
+}), qe = /* @__PURE__ */ T.forwardRef(function(o, n) {
+  const t = U({
+    props: o,
+    name: "MuiListItemText"
+  }), {
+    children: a,
+    className: s,
+    disableTypography: i = !1,
+    inset: u = !1,
+    primary: m,
+    primaryTypographyProps: l,
+    secondary: p,
+    secondaryTypographyProps: y,
+    slots: d = {},
+    slotProps: f = {},
+    ...c
+  } = t, {
+    dense: v
+  } = T.useContext(_);
+  let b = m ?? a, g = p;
+  const O = {
+    ...t,
+    disableTypography: i,
+    inset: u,
+    primary: !!b,
+    secondary: !!g,
+    dense: v
+  }, w = Ae(O), $ = {
+    slots: d,
+    slotProps: {
+      primary: l,
+      secondary: y,
+      ...f
+    }
+  }, [L, M] = W("root", {
+    className: I(w.root, s),
+    elementType: Ue,
+    externalForwardedProps: {
+      ...$,
+      ...c
+    },
+    ownerState: O,
+    ref: n
+  }), [z, h] = W("primary", {
+    className: w.primary,
+    elementType: E,
+    externalForwardedProps: $,
+    ownerState: O
+  }), [D, V] = W("secondary", {
+    className: w.secondary,
+    elementType: E,
+    externalForwardedProps: $,
+    ownerState: O
+  });
+  return b != null && b.type !== E && !i && (b = /* @__PURE__ */ N(z, {
+    variant: v ? "body2" : "body1",
+    component: h != null && h.variant ? void 0 : "span",
+    ...h,
+    children: b
+  })), g != null && g.type !== E && !i && (g = /* @__PURE__ */ N(D, {
+    variant: "body2",
+    color: "textSecondary",
+    ...V,
+    children: g
+  })), /* @__PURE__ */ le(L, {
+    ...M,
+    children: [b, g]
+  });
+});
+process.env.NODE_ENV !== "production" && (qe.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Alias for the `primary` prop.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * If `true`, the children won't be wrapped by a Typography component.
+   * This can be useful to render an alternative Typography variant by wrapping
+   * the `children` (or `primary`) text, and optional `secondary` text
+   * with the Typography component.
+   * @default false
+   */
+  disableTypography: e.bool,
+  /**
+   * If `true`, the children are indented.
+   * This should be used if there is no left avatar or left icon.
+   * @default false
+   */
+  inset: e.bool,
+  /**
+   * The main content element.
+   */
+  primary: e.node,
+  /**
+   * These props will be forwarded to the primary typography component
+   * (as long as disableTypography is not `true`).
+   * @deprecated Use `slotProps.primary` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  primaryTypographyProps: e.object,
+  /**
+   * The secondary content element.
+   */
+  secondary: e.node,
+  /**
+   * These props will be forwarded to the secondary typography component
+   * (as long as disableTypography is not `true`).
+   * @deprecated Use `slotProps.secondary` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  secondaryTypographyProps: e.object,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    primary: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object]),
+    secondary: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    primary: e.elementType,
+    root: e.elementType,
+    secondary: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+export {
+  Q as G,
+  Fe as L,
+  qe as a
+};