@cgi-learning-hub/ui 1.5.1 → 1.6.0

package/dist/ListItemText-BeyHu1da.js

@@ -0,0 +1,853 @@
+import { P as e } from "./index-Sy88PpwE.js";
+import { u as ae } from "./useTheme-C59wIJ3-.js";
+import * as O from "react";
+import { H as I, Q as ie, n as P } from "./generateUtilityClasses-DngCqveO.js";
+import { jsx as G, jsxs as ce } from "react/jsx-runtime";
+import { s as le, c as pe, g as de } from "./composeClasses-CJKlIaRn.js";
+import { u as fe } from "./useTheme-D9cVynB-.js";
+import { e as ue } from "./extendSxProp-BouzOuB6.js";
+import { u as me } from "./useThemeProps-ggw56DH-.js";
+import { s as F, u as A, c as Y, r as ye } from "./DefaultPropsProvider-hFv1J_xl.js";
+import { m as ge } from "./memoTheme-nmt7i1dS.js";
+import { a as _ } from "./List-BjfdkeEI.js";
+import { b as be, a as N } from "./ListItem-B0EiObKw.js";
+import { a as Oe } from "./useEventCallback-Yoj9nCug.js";
+import { u as Te } from "./useForkRef-u29GSuCu.js";
+import { B as ve } from "./ButtonBase-Chb99sDQ.js";
+import { g as we, l as E } from "./listItemTextClasses-BRj19IXv.js";
+import { u as W } from "./useSlot-BDb1lvxu.js";
+import { T as k, t as H } from "./Typography-DwMlN0K5.js";
+function xe(r, o) {
+  var n, t, s;
+  return /* @__PURE__ */ O.isValidElement(r) && o.indexOf(
+    // For server components `muiName` is avaialble in element.type._payload.value.muiName
+    // relevant info - https://github.com/facebook/react/blob/2807d781a08db8e9873687fccc25c0f12b4fb3d4/packages/react/src/ReactLazy.js#L45
+    // eslint-disable-next-line no-underscore-dangle
+    r.type.muiName ?? ((s = (t = (n = r.type) == null ? void 0 : n._payload) == null ? void 0 : t.value) == null ? void 0 : s.muiName)
+  ) !== -1;
+}
+const he = (r, o) => r.filter((n) => o.includes(n)), j = (r, o, n) => {
+  const t = r.keys[0];
+  Array.isArray(o) ? o.forEach((s, a) => {
+    n((i, u) => {
+      a <= r.keys.length - 1 && (a === 0 ? Object.assign(i, u) : i[r.up(r.keys[a])] = u);
+    }, s);
+  }) : o && typeof o == "object" ? (Object.keys(o).length > r.keys.length ? r.keys : he(r.keys, Object.keys(o))).forEach((a) => {
+    if (r.keys.includes(a)) {
+      const i = o[a];
+      i !== void 0 && n((u, m) => {
+        t === a ? Object.assign(u, m) : u[r.up(a)] = m;
+      }, i);
+    }
+  }) : (typeof o == "number" || typeof o == "string") && n((s, a) => {
+    Object.assign(s, a);
+  }, o);
+};
+function R(r) {
+  return `--Grid-${r}Spacing`;
+}
+function B(r) {
+  return `--Grid-parent-${r}Spacing`;
+}
+const K = "--Grid-columns", C = "--Grid-parent-columns", $e = ({
+  theme: r,
+  ownerState: o
+}) => {
+  const n = {};
+  return j(r.breakpoints, o.size, (t, s) => {
+    let a = {};
+    s === "grow" && (a = {
+      flexBasis: 0,
+      flexGrow: 1,
+      maxWidth: "100%"
+    }), s === "auto" && (a = {
+      flexBasis: "auto",
+      flexGrow: 0,
+      flexShrink: 0,
+      maxWidth: "none",
+      width: "auto"
+    }), typeof s == "number" && (a = {
+      flexGrow: 0,
+      flexBasis: "auto",
+      width: `calc(100% * ${s} / var(${C}) - (var(${C}) - ${s}) * (var(${B("column")}) / var(${C})))`
+    }), t(n, a);
+  }), n;
+}, Se = ({
+  theme: r,
+  ownerState: o
+}) => {
+  const n = {};
+  return j(r.breakpoints, o.offset, (t, s) => {
+    let a = {};
+    s === "auto" && (a = {
+      marginLeft: "auto"
+    }), typeof s == "number" && (a = {
+      marginLeft: s === 0 ? "0px" : `calc(100% * ${s} / var(${C}) + var(${B("column")}) * ${s} / var(${C}))`
+    }), t(n, a);
+  }), n;
+}, Ce = ({
+  theme: r,
+  ownerState: o
+}) => {
+  if (!o.container)
+    return {};
+  const n = {
+    [K]: 12
+  };
+  return j(r.breakpoints, o.columns, (t, s) => {
+    const a = s ?? 12;
+    t(n, {
+      [K]: a,
+      "> *": {
+        [C]: a
+      }
+    });
+  }), n;
+}, je = ({
+  theme: r,
+  ownerState: o
+}) => {
+  if (!o.container)
+    return {};
+  const n = {};
+  return j(r.breakpoints, o.rowSpacing, (t, s) => {
+    var i;
+    const a = typeof s == "string" ? s : (i = r.spacing) == null ? void 0 : i.call(r, s);
+    t(n, {
+      [R("row")]: a,
+      "> *": {
+        [B("row")]: a
+      }
+    });
+  }), n;
+}, Ne = ({
+  theme: r,
+  ownerState: o
+}) => {
+  if (!o.container)
+    return {};
+  const n = {};
+  return j(r.breakpoints, o.columnSpacing, (t, s) => {
+    var i;
+    const a = typeof s == "string" ? s : (i = r.spacing) == null ? void 0 : i.call(r, s);
+    t(n, {
+      [R("column")]: a,
+      "> *": {
+        [B("column")]: a
+      }
+    });
+  }), n;
+}, Ge = ({
+  theme: r,
+  ownerState: o
+}) => {
+  if (!o.container)
+    return {};
+  const n = {};
+  return j(r.breakpoints, o.direction, (t, s) => {
+    t(n, {
+      flexDirection: s
+    });
+  }), 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")})`
+  }
+}), Ee = (r) => {
+  const o = [];
+  return Object.entries(r).forEach(([n, t]) => {
+    t !== !1 && t !== void 0 && o.push(`grid-${n}-${String(t)}`);
+  }), o;
+}, ke = (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(([s, a]) => {
+      n(a) && t.push(`spacing-${s}-${String(a)}`);
+    }), 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.`, Q = [];
+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) => {
+    Q.includes(t) || (Q.push(t), console.warn(`MUI Grid: ${Re(t)}
+`));
+  });
+}
+const Le = ie(), Me = le("div", {
+  name: "MuiGrid",
+  slot: "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 = fe,
+    componentName: s = "MuiGrid"
+  } = r, a = (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), ...Ee(v), ...y ? ke(f, p.breakpoints.keys[0]) : []]
+    };
+    return pe(b, (g) => de(s, 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(Ce, Ne, je, $e, Ge, Pe, Se), m = /* @__PURE__ */ O.forwardRef(function(p, y) {
+    const d = t(), f = n(p), c = ue(f);
+    Be(c, d.breakpoints);
+    const {
+      className: v,
+      children: b,
+      columns: g = 12,
+      container: T = !1,
+      component: w = "div",
+      direction: $ = "row",
+      wrap: L = "wrap",
+      size: M = {},
+      offset: z = {},
+      spacing: x = 0,
+      rowSpacing: D = x,
+      columnSpacing: V = x,
+      unstable_level: S = 0,
+      ...X
+    } = c, Z = i(M, d.breakpoints, (h) => h !== !1), ee = i(z, d.breakpoints), re = p.columns ?? (S ? void 0 : g), oe = p.spacing ?? (S ? void 0 : x), ne = p.rowSpacing ?? p.spacing ?? (S ? void 0 : D), te = p.columnSpacing ?? p.spacing ?? (S ? void 0 : V), U = {
+      ...c,
+      level: S,
+      columns: re,
+      container: T,
+      direction: $,
+      wrap: L,
+      spacing: oe,
+      rowSpacing: ne,
+      columnSpacing: te,
+      size: Z,
+      offset: ee
+    }, se = a(U, d);
+    return /* @__PURE__ */ G(u, {
+      ref: y,
+      as: w,
+      ownerState: U,
+      className: I(se.root, v),
+      ...X,
+      children: O.Children.map(b, (h) => {
+        var q;
+        return /* @__PURE__ */ O.isValidElement(h) && xe(h, ["Grid"]) && T && h.props.container ? /* @__PURE__ */ O.cloneElement(h, {
+          unstable_level: ((q = h.props) == null ? void 0 : q.unstable_level) ?? S + 1
+        }) : h;
+      })
+    });
+  });
+  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;
+}
+function Ve(r, o) {
+  if (process.env.NODE_ENV === "production")
+    return () => null;
+  const n = o ? {
+    ...o.propTypes
+  } : null;
+  return (s) => (a, i, u, m, l, ...p) => {
+    const y = l || i, d = n == null ? void 0 : n[y];
+    if (d) {
+      const f = d(a, i, u, m, l, ...p);
+      if (f)
+        return f;
+    }
+    return typeof a[i] < "u" && !a[s] ? new Error(`The prop \`${y}\` of \`${r}\` can only be used together with the \`${s}\` prop.`) : null;
+  };
+}
+const J = De({
+  createStyledComponent: F("div", {
+    name: "MuiGrid",
+    slot: "Root",
+    overridesResolver: (r, o) => {
+      const {
+        ownerState: n
+      } = r;
+      return [o.root, n.container && o.container];
+    }
+  }),
+  componentName: "MuiGrid",
+  useThemeProps: (r) => A({
+    props: r,
+    name: "MuiGrid"
+  }),
+  useTheme: ae
+});
+process.env.NODE_ENV !== "production" && (J.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 = J, o = Ve("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 We = (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];
+}, _e = (r) => {
+  const {
+    alignItems: o,
+    classes: n,
+    dense: t,
+    disabled: s,
+    disableGutters: a,
+    divider: i,
+    selected: u
+  } = r, l = Y({
+    root: ["root", t && "dense", !a && "gutters", i && "divider", s && "disabled", o === "flex-start" && "alignItemsFlexStart", u && "selected"]
+  }, be, n);
+  return {
+    ...n,
+    ...l
+  };
+}, Fe = F(ve, {
+  shouldForwardProp: (r) => ye(r) || r === "classes",
+  name: "MuiListItemButton",
+  slot: "Root",
+  overridesResolver: We
+})(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"
+    }
+  },
+  [`&.${N.selected}`]: {
+    backgroundColor: r.vars ? `rgba(${r.vars.palette.primary.mainChannel} / ${r.vars.palette.action.selectedOpacity})` : P(r.palette.primary.main, r.palette.action.selectedOpacity),
+    [`&.${N.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)
+    }
+  },
+  [`&.${N.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)
+    }
+  },
+  [`&.${N.focusVisible}`]: {
+    backgroundColor: (r.vars || r).palette.action.focus
+  },
+  [`&.${N.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
+    }
+  }]
+}))), Ae = /* @__PURE__ */ O.forwardRef(function(o, n) {
+  const t = A({
+    props: o,
+    name: "MuiListItemButton"
+  }), {
+    alignItems: s = "center",
+    autoFocus: a = !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 = O.useContext(_), b = O.useMemo(() => ({
+    dense: m || v.dense || !1,
+    alignItems: s,
+    disableGutters: l
+  }), [s, v.dense, m, l]), g = O.useRef(null);
+  Oe(() => {
+    a && (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."));
+  }, [a]);
+  const T = {
+    ...t,
+    alignItems: s,
+    dense: b.dense,
+    disableGutters: l,
+    divider: p,
+    selected: d
+  }, w = _e(T), $ = Te(g, n);
+  return /* @__PURE__ */ G(_.Provider, {
+    value: b,
+    children: /* @__PURE__ */ G(Fe, {
+      ref: $,
+      href: c.href || c.to,
+      component: (c.href || c.to) && i === "div" ? "button" : i,
+      focusVisibleClassName: I(w.focusVisible, y),
+      ownerState: T,
+      className: I(w.root, f),
+      ...c,
+      classes: w,
+      children: u
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Ae.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 Ue = (r) => {
+  const {
+    classes: o,
+    inset: n,
+    primary: t,
+    secondary: s,
+    dense: a
+  } = r;
+  return Y({
+    root: ["root", n && "inset", a && "dense", t && s && "multiline"],
+    primary: ["primary"],
+    secondary: ["secondary"]
+  }, we, o);
+}, qe = F("div", {
+  name: "MuiListItemText",
+  slot: "Root",
+  overridesResolver: (r, o) => {
+    const {
+      ownerState: n
+    } = r;
+    return [{
+      [`& .${E.primary}`]: o.primary
+    }, {
+      [`& .${E.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,
+  [`.${H.root}:where(& .${E.primary})`]: {
+    display: "block"
+  },
+  [`.${H.root}:where(& .${E.secondary})`]: {
+    display: "block"
+  },
+  variants: [{
+    props: ({
+      ownerState: r
+    }) => r.primary && r.secondary,
+    style: {
+      marginTop: 6,
+      marginBottom: 6
+    }
+  }, {
+    props: ({
+      ownerState: r
+    }) => r.inset,
+    style: {
+      paddingLeft: 56
+    }
+  }]
+}), He = /* @__PURE__ */ O.forwardRef(function(o, n) {
+  const t = A({
+    props: o,
+    name: "MuiListItemText"
+  }), {
+    children: s,
+    className: a,
+    disableTypography: i = !1,
+    inset: u = !1,
+    primary: m,
+    primaryTypographyProps: l,
+    secondary: p,
+    secondaryTypographyProps: y,
+    slots: d = {},
+    slotProps: f = {},
+    ...c
+  } = t, {
+    dense: v
+  } = O.useContext(_);
+  let b = m ?? s, g = p;
+  const T = {
+    ...t,
+    disableTypography: i,
+    inset: u,
+    primary: !!b,
+    secondary: !!g,
+    dense: v
+  }, w = Ue(T), $ = {
+    slots: d,
+    slotProps: {
+      primary: l,
+      secondary: y,
+      ...f
+    }
+  }, [L, M] = W("root", {
+    className: I(w.root, a),
+    elementType: qe,
+    externalForwardedProps: {
+      ...$,
+      ...c
+    },
+    ownerState: T,
+    ref: n
+  }), [z, x] = W("primary", {
+    className: w.primary,
+    elementType: k,
+    externalForwardedProps: $,
+    ownerState: T
+  }), [D, V] = W("secondary", {
+    className: w.secondary,
+    elementType: k,
+    externalForwardedProps: $,
+    ownerState: T
+  });
+  return b != null && b.type !== k && !i && (b = /* @__PURE__ */ G(z, {
+    variant: v ? "body2" : "body1",
+    component: x != null && x.variant ? void 0 : "span",
+    ...x,
+    children: b
+  })), g != null && g.type !== k && !i && (g = /* @__PURE__ */ G(D, {
+    variant: "body2",
+    color: "textSecondary",
+    ...V,
+    children: g
+  })), /* @__PURE__ */ ce(L, {
+    ...M,
+    children: [b, g]
+  });
+});
+process.env.NODE_ENV !== "production" && (He.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 {
+  J as G,
+  Ae as L,
+  He as a
+};