jcicl 0.0.0

package/.chunks/Nav.js

@@ -0,0 +1,2138 @@
+import { jsx as s, jsxs as H, Fragment as $t } from "react/jsx-runtime";
+import * as m from "react";
+import { useState as ft, createElement as Zt } from "react";
+import { n as X, i as It } from "./emotion-styled.browser.esm.js";
+import { c as pt } from "./createSvgIcon.js";
+import { P as e, a as J, g as q, s as V, r as Nt, e as Y, u as K, c as j, b as Q, d as it, t as z, h as te } from "./theme.js";
+import { D as ht } from "./Divider.js";
+import { e as ee, H as oe, u as mt, g as ne, o as Ot, T as kt, d as re, r as ie, a as lt, M as se, P as ae, b as le, i as ce, L as _, c as Mt, f as xt, h as pe, j as de, k as ue } from "./Menu.js";
+import { m as tt } from "./memoTheme.js";
+import { c as fe } from "./createSimplePaletteValueFilter.js";
+import { B as he } from "./ButtonBase.js";
+import { f as Dt, c as dt, g as me, e as Bt, b as ge } from "./TransitionGroupContext.js";
+function ye(t, o, n) {
+  const r = o.getBoundingClientRect(), i = n && n.getBoundingClientRect(), c = Ot(o);
+  let a;
+  if (o.fakeTransform)
+    a = o.fakeTransform;
+  else {
+    const p = c.getComputedStyle(o);
+    a = p.getPropertyValue("-webkit-transform") || p.getPropertyValue("transform");
+  }
+  let l = 0, d = 0;
+  if (a && a !== "none" && typeof a == "string") {
+    const p = a.split("(")[1].split(")")[0].split(",");
+    l = parseInt(p[4], 10), d = parseInt(p[5], 10);
+  }
+  return t === "left" ? i ? `translateX(${i.right + l - r.left}px)` : `translateX(${c.innerWidth + l - r.left}px)` : t === "right" ? i ? `translateX(-${r.right - i.left - l}px)` : `translateX(-${r.left + r.width - l}px)` : t === "up" ? i ? `translateY(${i.bottom + d - r.top}px)` : `translateY(${c.innerHeight + d - r.top}px)` : i ? `translateY(-${r.top - i.top + r.height - d}px)` : `translateY(-${r.top + r.height - d}px)`;
+}
+function At(t) {
+  return typeof t == "function" ? t() : t;
+}
+function st(t, o, n) {
+  const r = At(n), i = ye(t, o, r);
+  i && (o.style.webkitTransform = i, o.style.transform = i);
+}
+const zt = /* @__PURE__ */ m.forwardRef(function(o, n) {
+  const r = mt(), i = {
+    enter: r.transitions.easing.easeOut,
+    exit: r.transitions.easing.sharp
+  }, c = {
+    enter: r.transitions.duration.enteringScreen,
+    exit: r.transitions.duration.leavingScreen
+  }, {
+    addEndListener: a,
+    appear: l = !0,
+    children: d,
+    container: p,
+    direction: g = "down",
+    easing: S = i,
+    in: b,
+    onEnter: y,
+    onEntered: h,
+    onEntering: x,
+    onExit: C,
+    onExited: v,
+    onExiting: I,
+    style: E,
+    timeout: k = c,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: F = kt,
+    ...L
+  } = o, w = m.useRef(null), N = dt(ne(d), w, n), M = (u) => (P) => {
+    u && (P === void 0 ? u(w.current) : u(w.current, P));
+  }, T = M((u, P) => {
+    st(g, u, p), ie(u), y && y(u, P);
+  }), R = M((u, P) => {
+    const nt = lt({
+      timeout: k,
+      style: E,
+      easing: S
+    }, {
+      mode: "enter"
+    });
+    u.style.webkitTransition = r.transitions.create("-webkit-transform", {
+      ...nt
+    }), u.style.transition = r.transitions.create("transform", {
+      ...nt
+    }), u.style.webkitTransform = "none", u.style.transform = "none", x && x(u, P);
+  }), D = M(h), $ = M(I), O = M((u) => {
+    const P = lt({
+      timeout: k,
+      style: E,
+      easing: S
+    }, {
+      mode: "exit"
+    });
+    u.style.webkitTransition = r.transitions.create("-webkit-transform", P), u.style.transition = r.transitions.create("transform", P), st(g, u, p), C && C(u);
+  }), B = M((u) => {
+    u.style.webkitTransition = "", u.style.transition = "", v && v(u);
+  }), W = (u) => {
+    a && a(w.current, u);
+  }, U = m.useCallback(() => {
+    w.current && st(g, w.current, p);
+  }, [g, p]);
+  return m.useEffect(() => {
+    if (b || g === "down" || g === "right")
+      return;
+    const u = re(() => {
+      w.current && st(g, w.current, p);
+    }), P = Ot(w.current);
+    return P.addEventListener("resize", u), () => {
+      u.clear(), P.removeEventListener("resize", u);
+    };
+  }, [g, b, p]), m.useEffect(() => {
+    b || U();
+  }, [b, U]), /* @__PURE__ */ s(F, {
+    nodeRef: w,
+    onEnter: T,
+    onEntered: D,
+    onEntering: R,
+    onExit: O,
+    onExited: B,
+    onExiting: $,
+    addEndListener: W,
+    appear: l,
+    in: b,
+    timeout: k,
+    ...L,
+    children: (u, P) => /* @__PURE__ */ m.cloneElement(d, {
+      ref: N,
+      style: {
+        visibility: u === "exited" && !b ? "hidden" : void 0,
+        ...E,
+        ...d.props.style
+      },
+      ...P
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (zt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: e.func,
+  /**
+   * Perform the enter transition when it first mounts if `in` is also `true`.
+   * Set this to `false` to disable this behavior.
+   * @default true
+   */
+  appear: e.bool,
+  /**
+   * A single child content element.
+   */
+  children: ee.isRequired,
+  /**
+   * An HTML element, or a function that returns one.
+   * It's used to set the container the Slide is transitioning from.
+   */
+  container: Dt(e.oneOfType([oe, e.func]), (t) => {
+    if (t.open) {
+      const o = At(t.container);
+      if (o && o.nodeType === 1) {
+        const n = o.getBoundingClientRect();
+        if (process.env.NODE_ENV !== "test" && n.top === 0 && n.left === 0 && n.right === 0 && n.bottom === 0)
+          return new Error(["MUI: The `container` prop provided to the component is invalid.", "The anchor element should be part of the document layout.", "Make sure the element is present in the document or that it's not display none."].join(`
+`));
+      } else if (!o || typeof o.getBoundingClientRect != "function" || o.contextElement != null && o.contextElement.nodeType !== 1)
+        return new Error(["MUI: The `container` prop provided to the component is invalid.", "It should be an HTML element instance."].join(`
+`));
+    }
+    return null;
+  }),
+  /**
+   * Direction the child node will enter from.
+   * @default 'down'
+   */
+  direction: e.oneOf(["down", "left", "right", "up"]),
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   * @default {
+   *   enter: theme.transitions.easing.easeOut,
+   *   exit: theme.transitions.easing.sharp,
+   * }
+   */
+  easing: e.oneOfType([e.shape({
+    enter: e.string,
+    exit: e.string
+  }), e.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: e.bool,
+  /**
+   * @ignore
+   */
+  onEnter: e.func,
+  /**
+   * @ignore
+   */
+  onEntered: e.func,
+  /**
+   * @ignore
+   */
+  onEntering: e.func,
+  /**
+   * @ignore
+   */
+  onExit: e.func,
+  /**
+   * @ignore
+   */
+  onExited: e.func,
+  /**
+   * @ignore
+   */
+  onExiting: e.func,
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   * @default {
+   *   enter: theme.transitions.duration.enteringScreen,
+   *   exit: theme.transitions.duration.leavingScreen,
+   * }
+   */
+  timeout: e.oneOfType([e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+function be(t) {
+  return J("MuiDrawer", t);
+}
+q("MuiDrawer", ["root", "docked", "paper", "paperAnchorLeft", "paperAnchorRight", "paperAnchorTop", "paperAnchorBottom", "paperAnchorDockedLeft", "paperAnchorDockedRight", "paperAnchorDockedTop", "paperAnchorDockedBottom", "modal"]);
+const jt = (t, o) => {
+  const {
+    ownerState: n
+  } = t;
+  return [o.root, (n.variant === "permanent" || n.variant === "persistent") && o.docked, o.modal];
+}, xe = (t) => {
+  const {
+    classes: o,
+    anchor: n,
+    variant: r
+  } = t, i = {
+    root: ["root"],
+    docked: [(r === "permanent" || r === "persistent") && "docked"],
+    modal: ["modal"],
+    paper: ["paper", `paperAnchor${Y(n)}`, r !== "temporary" && `paperAnchorDocked${Y(n)}`]
+  };
+  return Q(i, be, o);
+}, ve = V(se, {
+  name: "MuiDrawer",
+  slot: "Root",
+  overridesResolver: jt
+})(tt(({
+  theme: t
+}) => ({
+  zIndex: (t.vars || t).zIndex.drawer
+}))), vt = V("div", {
+  shouldForwardProp: Nt,
+  name: "MuiDrawer",
+  slot: "Docked",
+  skipVariantsResolver: !1,
+  overridesResolver: jt
+})({
+  flex: "0 0 auto"
+}), we = V(ae, {
+  name: "MuiDrawer",
+  slot: "Paper",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.paper, o[`paperAnchor${Y(n.anchor)}`], n.variant !== "temporary" && o[`paperAnchorDocked${Y(n.anchor)}`]];
+  }
+})(tt(({
+  theme: t
+}) => ({
+  overflowY: "auto",
+  display: "flex",
+  flexDirection: "column",
+  height: "100%",
+  flex: "1 0 auto",
+  zIndex: (t.vars || t).zIndex.drawer,
+  // Add iOS momentum scrolling for iOS < 13.0
+  WebkitOverflowScrolling: "touch",
+  // temporary style
+  position: "fixed",
+  top: 0,
+  // We disable the focus ring for mouse, touch and keyboard users.
+  // At some point, it would be better to keep it for keyboard users.
+  // :focus-ring CSS pseudo-class will help.
+  outline: 0,
+  variants: [{
+    props: {
+      anchor: "left"
+    },
+    style: {
+      left: 0
+    }
+  }, {
+    props: {
+      anchor: "top"
+    },
+    style: {
+      top: 0,
+      left: 0,
+      right: 0,
+      height: "auto",
+      maxHeight: "100%"
+    }
+  }, {
+    props: {
+      anchor: "right"
+    },
+    style: {
+      right: 0
+    }
+  }, {
+    props: {
+      anchor: "bottom"
+    },
+    style: {
+      top: "auto",
+      left: 0,
+      bottom: 0,
+      right: 0,
+      height: "auto",
+      maxHeight: "100%"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.anchor === "left" && o.variant !== "temporary",
+    style: {
+      borderRight: `1px solid ${(t.vars || t).palette.divider}`
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.anchor === "top" && o.variant !== "temporary",
+    style: {
+      borderBottom: `1px solid ${(t.vars || t).palette.divider}`
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.anchor === "right" && o.variant !== "temporary",
+    style: {
+      borderLeft: `1px solid ${(t.vars || t).palette.divider}`
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.anchor === "bottom" && o.variant !== "temporary",
+    style: {
+      borderTop: `1px solid ${(t.vars || t).palette.divider}`
+    }
+  }]
+}))), Vt = {
+  left: "right",
+  right: "left",
+  top: "down",
+  bottom: "up"
+};
+function Ce(t) {
+  return ["left", "right"].includes(t);
+}
+function Te({
+  direction: t
+}, o) {
+  return t === "rtl" && Ce(o) ? Vt[o] : o;
+}
+const Ft = /* @__PURE__ */ m.forwardRef(function(o, n) {
+  const r = K({
+    props: o,
+    name: "MuiDrawer"
+  }), i = mt(), c = le(), a = {
+    enter: i.transitions.duration.enteringScreen,
+    exit: i.transitions.duration.leavingScreen
+  }, {
+    anchor: l = "left",
+    BackdropProps: d,
+    children: p,
+    className: g,
+    elevation: S = 16,
+    hideBackdrop: b = !1,
+    ModalProps: {
+      BackdropProps: y,
+      ...h
+    } = {},
+    onClose: x,
+    open: C = !1,
+    PaperProps: v = {},
+    SlideProps: I,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: E = zt,
+    transitionDuration: k = a,
+    variant: F = "temporary",
+    ...L
+  } = r, w = m.useRef(!1);
+  m.useEffect(() => {
+    w.current = !0;
+  }, []);
+  const N = Te({
+    direction: c ? "rtl" : "ltr"
+  }, l), T = {
+    ...r,
+    anchor: l,
+    elevation: S,
+    open: C,
+    variant: F,
+    ...L
+  }, R = xe(T), D = /* @__PURE__ */ s(we, {
+    elevation: F === "temporary" ? S : 0,
+    square: !0,
+    ...v,
+    className: j(R.paper, v.className),
+    ownerState: T,
+    children: p
+  });
+  if (F === "permanent")
+    return /* @__PURE__ */ s(vt, {
+      className: j(R.root, R.docked, g),
+      ownerState: T,
+      ref: n,
+      ...L,
+      children: D
+    });
+  const $ = /* @__PURE__ */ s(E, {
+    in: C,
+    direction: Vt[N],
+    timeout: k,
+    appear: w.current,
+    ...I,
+    children: D
+  });
+  return F === "persistent" ? /* @__PURE__ */ s(vt, {
+    className: j(R.root, R.docked, g),
+    ownerState: T,
+    ref: n,
+    ...L,
+    children: $
+  }) : /* @__PURE__ */ s(ve, {
+    BackdropProps: {
+      ...d,
+      ...y,
+      transitionDuration: k
+    },
+    className: j(R.root, R.modal, g),
+    open: C,
+    ownerState: T,
+    onClose: x,
+    hideBackdrop: b,
+    ref: n,
+    ...L,
+    ...h,
+    children: $
+  });
+});
+process.env.NODE_ENV !== "production" && (Ft.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Side from which the drawer will appear.
+   * @default 'left'
+   */
+  anchor: e.oneOf(["bottom", "left", "right", "top"]),
+  /**
+   * @ignore
+   */
+  BackdropProps: e.object,
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The elevation of the drawer.
+   * @default 16
+   */
+  elevation: ce,
+  /**
+   * If `true`, the backdrop is not rendered.
+   * @default false
+   */
+  hideBackdrop: e.bool,
+  /**
+   * Props applied to the [`Modal`](https://mui.com/material-ui/api/modal/) element.
+   * @default {}
+   */
+  ModalProps: e.object,
+  /**
+   * Callback fired when the component requests to be closed.
+   * The `reason` parameter can optionally be used to control the response to `onClose`.
+   *
+   * @param {object} event The event source of the callback.
+   * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`.
+   */
+  onClose: e.func,
+  /**
+   * If `true`, the component is shown.
+   * @default false
+   */
+  open: e.bool,
+  /**
+   * Props applied to the [`Paper`](https://mui.com/material-ui/api/paper/) element.
+   * @default {}
+   */
+  PaperProps: e.object,
+  /**
+   * Props applied to the [`Slide`](https://mui.com/material-ui/api/slide/) element.
+   */
+  SlideProps: e.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   * @default {
+   *   enter: theme.transitions.duration.enteringScreen,
+   *   exit: theme.transitions.duration.leavingScreen,
+   * }
+   */
+  transitionDuration: e.oneOfType([e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })]),
+  /**
+   * The variant to use.
+   * @default 'temporary'
+   */
+  variant: e.oneOf(["permanent", "persistent", "temporary"])
+});
+function Ee(t) {
+  return J("MuiListItem", t);
+}
+q("MuiListItem", ["root", "container", "dense", "alignItemsFlexStart", "divider", "gutters", "padding", "secondaryAction"]);
+function Se(t) {
+  return J("MuiListItemButton", t);
+}
+const Z = q("MuiListItemButton", ["root", "focusVisible", "dense", "alignItemsFlexStart", "disabled", "divider", "gutters", "selected"]), Re = (t, o) => {
+  const {
+    ownerState: n
+  } = t;
+  return [o.root, n.dense && o.dense, n.alignItems === "flex-start" && o.alignItemsFlexStart, n.divider && o.divider, !n.disableGutters && o.gutters];
+}, Pe = (t) => {
+  const {
+    alignItems: o,
+    classes: n,
+    dense: r,
+    disabled: i,
+    disableGutters: c,
+    divider: a,
+    selected: l
+  } = t, p = Q({
+    root: ["root", r && "dense", !c && "gutters", a && "divider", i && "disabled", o === "flex-start" && "alignItemsFlexStart", l && "selected"]
+  }, Se, n);
+  return {
+    ...n,
+    ...p
+  };
+}, Le = V(he, {
+  shouldForwardProp: (t) => Nt(t) || t === "classes",
+  name: "MuiListItemButton",
+  slot: "Root",
+  overridesResolver: Re
+})(tt(({
+  theme: t
+}) => ({
+  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: t.transitions.create("background-color", {
+    duration: t.transitions.duration.shortest
+  }),
+  "&:hover": {
+    textDecoration: "none",
+    backgroundColor: (t.vars || t).palette.action.hover,
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  },
+  [`&.${Z.selected}`]: {
+    backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.mainChannel} / ${t.vars.palette.action.selectedOpacity})` : it(t.palette.primary.main, t.palette.action.selectedOpacity),
+    [`&.${Z.focusVisible}`]: {
+      backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.mainChannel} / calc(${t.vars.palette.action.selectedOpacity} + ${t.vars.palette.action.focusOpacity}))` : it(t.palette.primary.main, t.palette.action.selectedOpacity + t.palette.action.focusOpacity)
+    }
+  },
+  [`&.${Z.selected}:hover`]: {
+    backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.mainChannel} / calc(${t.vars.palette.action.selectedOpacity} + ${t.vars.palette.action.hoverOpacity}))` : it(t.palette.primary.main, t.palette.action.selectedOpacity + t.palette.action.hoverOpacity),
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.mainChannel} / ${t.vars.palette.action.selectedOpacity})` : it(t.palette.primary.main, t.palette.action.selectedOpacity)
+    }
+  },
+  [`&.${Z.focusVisible}`]: {
+    backgroundColor: (t.vars || t).palette.action.focus
+  },
+  [`&.${Z.disabled}`]: {
+    opacity: (t.vars || t).palette.action.disabledOpacity
+  },
+  variants: [{
+    props: ({
+      ownerState: o
+    }) => o.divider,
+    style: {
+      borderBottom: `1px solid ${(t.vars || t).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
+    }
+  }]
+}))), Wt = /* @__PURE__ */ m.forwardRef(function(o, n) {
+  const r = K({
+    props: o,
+    name: "MuiListItemButton"
+  }), {
+    alignItems: i = "center",
+    autoFocus: c = !1,
+    component: a = "div",
+    children: l,
+    dense: d = !1,
+    disableGutters: p = !1,
+    divider: g = !1,
+    focusVisibleClassName: S,
+    selected: b = !1,
+    className: y,
+    ...h
+  } = r, x = m.useContext(_), C = m.useMemo(() => ({
+    dense: d || x.dense || !1,
+    alignItems: i,
+    disableGutters: p
+  }), [i, x.dense, d, p]), v = m.useRef(null);
+  me(() => {
+    c && (v.current ? v.current.focus() : process.env.NODE_ENV !== "production" && console.error("MUI: Unable to set focus to a ListItemButton whose component has not been rendered."));
+  }, [c]);
+  const I = {
+    ...r,
+    alignItems: i,
+    dense: C.dense,
+    disableGutters: p,
+    divider: g,
+    selected: b
+  }, E = Pe(I), k = dt(v, n);
+  return /* @__PURE__ */ s(_.Provider, {
+    value: C,
+    children: /* @__PURE__ */ s(Le, {
+      ref: k,
+      href: h.href || h.to,
+      component: (h.href || h.to) && a === "div" ? "button" : a,
+      focusVisibleClassName: j(E.focusVisible, S),
+      ownerState: I,
+      className: j(E.root, y),
+      ...h,
+      classes: E,
+      children: l
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Wt.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])
+});
+function $e(t) {
+  return J("MuiListItemSecondaryAction", t);
+}
+q("MuiListItemSecondaryAction", ["root", "disableGutters"]);
+const Ie = (t) => {
+  const {
+    disableGutters: o,
+    classes: n
+  } = t;
+  return Q({
+    root: ["root", o && "disableGutters"]
+  }, $e, n);
+}, Ne = V("div", {
+  name: "MuiListItemSecondaryAction",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.root, n.disableGutters && o.disableGutters];
+  }
+})({
+  position: "absolute",
+  right: 16,
+  top: "50%",
+  transform: "translateY(-50%)",
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.disableGutters,
+    style: {
+      right: 0
+    }
+  }]
+}), gt = /* @__PURE__ */ m.forwardRef(function(o, n) {
+  const r = K({
+    props: o,
+    name: "MuiListItemSecondaryAction"
+  }), {
+    className: i,
+    ...c
+  } = r, a = m.useContext(_), l = {
+    ...r,
+    disableGutters: a.disableGutters
+  }, d = Ie(l);
+  return /* @__PURE__ */ s(Ne, {
+    className: j(d.root, i),
+    ownerState: l,
+    ref: n,
+    ...c
+  });
+});
+process.env.NODE_ENV !== "production" && (gt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component, normally an `IconButton` or selection control.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+gt.muiName = "ListItemSecondaryAction";
+const Oe = (t, o) => {
+  const {
+    ownerState: n
+  } = t;
+  return [o.root, n.dense && o.dense, n.alignItems === "flex-start" && o.alignItemsFlexStart, n.divider && o.divider, !n.disableGutters && o.gutters, !n.disablePadding && o.padding, n.hasSecondaryAction && o.secondaryAction];
+}, ke = (t) => {
+  const {
+    alignItems: o,
+    classes: n,
+    dense: r,
+    disableGutters: i,
+    disablePadding: c,
+    divider: a,
+    hasSecondaryAction: l
+  } = t;
+  return Q({
+    root: ["root", r && "dense", !i && "gutters", !c && "padding", a && "divider", o === "flex-start" && "alignItemsFlexStart", l && "secondaryAction"],
+    container: ["container"]
+  }, Ee, n);
+}, Me = V("div", {
+  name: "MuiListItem",
+  slot: "Root",
+  overridesResolver: Oe
+})(tt(({
+  theme: t
+}) => ({
+  display: "flex",
+  justifyContent: "flex-start",
+  alignItems: "center",
+  position: "relative",
+  textDecoration: "none",
+  width: "100%",
+  boxSizing: "border-box",
+  textAlign: "left",
+  variants: [{
+    props: ({
+      ownerState: o
+    }) => !o.disablePadding,
+    style: {
+      paddingTop: 8,
+      paddingBottom: 8
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => !o.disablePadding && o.dense,
+    style: {
+      paddingTop: 4,
+      paddingBottom: 4
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => !o.disablePadding && !o.disableGutters,
+    style: {
+      paddingLeft: 16,
+      paddingRight: 16
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => !o.disablePadding && !!o.secondaryAction,
+    style: {
+      // Add some space to avoid collision as `ListItemSecondaryAction`
+      // is absolutely positioned.
+      paddingRight: 48
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => !!o.secondaryAction,
+    style: {
+      [`& > .${Z.root}`]: {
+        paddingRight: 48
+      }
+    }
+  }, {
+    props: {
+      alignItems: "flex-start"
+    },
+    style: {
+      alignItems: "flex-start"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.divider,
+    style: {
+      borderBottom: `1px solid ${(t.vars || t).palette.divider}`,
+      backgroundClip: "padding-box"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.button,
+    style: {
+      transition: t.transitions.create("background-color", {
+        duration: t.transitions.duration.shortest
+      }),
+      "&:hover": {
+        textDecoration: "none",
+        backgroundColor: (t.vars || t).palette.action.hover,
+        // Reset on touch devices, it doesn't add specificity
+        "@media (hover: none)": {
+          backgroundColor: "transparent"
+        }
+      }
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.hasSecondaryAction,
+    style: {
+      // Add some space to avoid collision as `ListItemSecondaryAction`
+      // is absolutely positioned.
+      paddingRight: 48
+    }
+  }]
+}))), De = V("li", {
+  name: "MuiListItem",
+  slot: "Container",
+  overridesResolver: (t, o) => o.container
+})({
+  position: "relative"
+}), ut = /* @__PURE__ */ m.forwardRef(function(o, n) {
+  const r = K({
+    props: o,
+    name: "MuiListItem"
+  }), {
+    alignItems: i = "center",
+    children: c,
+    className: a,
+    component: l,
+    components: d = {},
+    componentsProps: p = {},
+    ContainerComponent: g = "li",
+    ContainerProps: {
+      className: S,
+      ...b
+    } = {},
+    dense: y = !1,
+    disableGutters: h = !1,
+    disablePadding: x = !1,
+    divider: C = !1,
+    secondaryAction: v,
+    slotProps: I = {},
+    slots: E = {},
+    ...k
+  } = r, F = m.useContext(_), L = m.useMemo(() => ({
+    dense: y || F.dense || !1,
+    alignItems: i,
+    disableGutters: h
+  }), [i, F.dense, y, h]), w = m.useRef(null), N = m.Children.toArray(c), M = N.length && Mt(N[N.length - 1], ["ListItemSecondaryAction"]), T = {
+    ...r,
+    alignItems: i,
+    dense: L.dense,
+    disableGutters: h,
+    disablePadding: x,
+    divider: C,
+    hasSecondaryAction: M
+  }, R = ke(T), D = dt(w, n), $ = E.root || d.Root || Me, O = I.root || p.root || {}, B = {
+    className: j(R.root, O.className, a),
+    ...k
+  };
+  let W = l || "li";
+  return M ? (W = !B.component && !l ? "div" : W, g === "li" && (W === "li" ? W = "div" : B.component === "li" && (B.component = "div")), /* @__PURE__ */ s(_.Provider, {
+    value: L,
+    children: /* @__PURE__ */ H(De, {
+      as: g,
+      className: j(R.container, S),
+      ref: D,
+      ownerState: T,
+      ...b,
+      children: [/* @__PURE__ */ s($, {
+        ...O,
+        ...!xt($) && {
+          as: W,
+          ownerState: {
+            ...T,
+            ...O.ownerState
+          }
+        },
+        ...B,
+        children: N
+      }), N.pop()]
+    })
+  })) : /* @__PURE__ */ s(_.Provider, {
+    value: L,
+    children: /* @__PURE__ */ H($, {
+      ...O,
+      as: W,
+      ref: D,
+      ...!xt($) && {
+        ownerState: {
+          ...T,
+          ...O.ownerState
+        }
+      },
+      ...B,
+      children: [N, v && /* @__PURE__ */ s(gt, {
+        children: v
+      })]
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ut.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"]),
+  /**
+   * The content of the component if a `ListItemSecondaryAction` is used it must
+   * be the last child.
+   */
+  children: Dt(e.node, (t) => {
+    const o = m.Children.toArray(t.children);
+    let n = -1;
+    for (let r = o.length - 1; r >= 0; r -= 1) {
+      const i = o[r];
+      if (Mt(i, ["ListItemSecondaryAction"])) {
+        n = r;
+        break;
+      }
+    }
+    return n !== -1 && n !== o.length - 1 ? new Error("MUI: You used an element after ListItemSecondaryAction. For ListItem to detect that it has a secondary action you must pass it as the last child to ListItem.") : null;
+  }),
+  /**
+   * 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,
+  /**
+   * 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({
+    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({
+    root: e.object
+  }),
+  /**
+   * The container component used when a `ListItemSecondaryAction` is the last child.
+   * @default 'li'
+   * @deprecated Use the `component` or `slots.root` 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.
+   */
+  ContainerComponent: Bt,
+  /**
+   * Props applied to the container component if used.
+   * @default {}
+   * @deprecated Use the `slotProps.root` 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.
+   */
+  ContainerProps: e.object,
+  /**
+   * 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 left and right padding is removed.
+   * @default false
+   */
+  disableGutters: e.bool,
+  /**
+   * If `true`, all padding is removed.
+   * @default false
+   */
+  disablePadding: e.bool,
+  /**
+   * If `true`, a 1px light border is added to the bottom of the list item.
+   * @default false
+   */
+  divider: e.bool,
+  /**
+   * The element to display at the end of ListItem.
+   */
+  secondaryAction: e.node,
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * @default {}
+   */
+  slotProps: e.shape({
+    root: e.object
+  }),
+  /**
+   * The components used for each slot inside.
+   *
+   * @default {}
+   */
+  slots: e.shape({
+    root: 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])
+});
+const wt = pt(/* @__PURE__ */ s("path", {
+  d: "M15.41 7.41 14 6l-6 6 6 6 1.41-1.41L10.83 12z"
+}), "ChevronLeft"), Ct = pt(/* @__PURE__ */ s("path", {
+  d: "M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
+}), "ChevronRight");
+function Be(t) {
+  return J("MuiTypography", t);
+}
+const Tt = q("MuiTypography", ["root", "h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "inherit", "button", "caption", "overline", "alignLeft", "alignRight", "alignCenter", "alignJustify", "noWrap", "gutterBottom", "paragraph"]), Ae = {
+  primary: !0,
+  secondary: !0,
+  error: !0,
+  info: !0,
+  success: !0,
+  warning: !0,
+  textPrimary: !0,
+  textSecondary: !0,
+  textDisabled: !0
+}, ze = pe(), je = (t) => {
+  const {
+    align: o,
+    gutterBottom: n,
+    noWrap: r,
+    paragraph: i,
+    variant: c,
+    classes: a
+  } = t, l = {
+    root: ["root", c, t.align !== "inherit" && `align${Y(o)}`, n && "gutterBottom", r && "noWrap", i && "paragraph"]
+  };
+  return Q(l, Be, a);
+}, Ve = V("span", {
+  name: "MuiTypography",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.root, n.variant && o[n.variant], n.align !== "inherit" && o[`align${Y(n.align)}`], n.noWrap && o.noWrap, n.gutterBottom && o.gutterBottom, n.paragraph && o.paragraph];
+  }
+})(tt(({
+  theme: t
+}) => {
+  var o;
+  return {
+    margin: 0,
+    variants: [{
+      props: {
+        variant: "inherit"
+      },
+      style: {
+        // Some elements, like <button> on Chrome have default font that doesn't inherit, reset this.
+        font: "inherit",
+        lineHeight: "inherit",
+        letterSpacing: "inherit"
+      }
+    }, ...Object.entries(t.typography).filter(([n, r]) => n !== "inherit" && r && typeof r == "object").map(([n, r]) => ({
+      props: {
+        variant: n
+      },
+      style: r
+    })), ...Object.entries(t.palette).filter(fe()).map(([n]) => ({
+      props: {
+        color: n
+      },
+      style: {
+        color: (t.vars || t).palette[n].main
+      }
+    })), ...Object.entries(((o = t.palette) == null ? void 0 : o.text) || {}).filter(([, n]) => typeof n == "string").map(([n]) => ({
+      props: {
+        color: `text${Y(n)}`
+      },
+      style: {
+        color: (t.vars || t).palette.text[n]
+      }
+    })), {
+      props: ({
+        ownerState: n
+      }) => n.align !== "inherit",
+      style: {
+        textAlign: "var(--Typography-textAlign)"
+      }
+    }, {
+      props: ({
+        ownerState: n
+      }) => n.noWrap,
+      style: {
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap"
+      }
+    }, {
+      props: ({
+        ownerState: n
+      }) => n.gutterBottom,
+      style: {
+        marginBottom: "0.35em"
+      }
+    }, {
+      props: ({
+        ownerState: n
+      }) => n.paragraph,
+      style: {
+        marginBottom: 16
+      }
+    }]
+  };
+})), Et = {
+  h1: "h1",
+  h2: "h2",
+  h3: "h3",
+  h4: "h4",
+  h5: "h5",
+  h6: "h6",
+  subtitle1: "h6",
+  subtitle2: "h6",
+  body1: "p",
+  body2: "p",
+  inherit: "p"
+}, ot = /* @__PURE__ */ m.forwardRef(function(o, n) {
+  const {
+    color: r,
+    ...i
+  } = K({
+    props: o,
+    name: "MuiTypography"
+  }), c = !Ae[r], a = ze({
+    ...i,
+    ...c && {
+      color: r
+    }
+  }), {
+    align: l = "inherit",
+    className: d,
+    component: p,
+    gutterBottom: g = !1,
+    noWrap: S = !1,
+    paragraph: b = !1,
+    variant: y = "body1",
+    variantMapping: h = Et,
+    ...x
+  } = a, C = {
+    ...a,
+    align: l,
+    color: r,
+    className: d,
+    component: p,
+    gutterBottom: g,
+    noWrap: S,
+    paragraph: b,
+    variant: y,
+    variantMapping: h
+  }, v = p || (b ? "p" : h[y] || Et[y]) || "span", I = je(C);
+  return /* @__PURE__ */ s(Ve, {
+    as: v,
+    ref: n,
+    className: j(I.root, d),
+    ...x,
+    ownerState: C,
+    style: {
+      ...l !== "inherit" && {
+        "--Typography-textAlign": l
+      },
+      ...x.style
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (ot.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Set the text-align on the component.
+   * @default 'inherit'
+   */
+  align: e.oneOf(["center", "inherit", "justify", "left", "right"]),
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   */
+  color: e.oneOfType([e.oneOf(["primary", "secondary", "success", "error", "info", "warning", "textPrimary", "textSecondary", "textDisabled"]), e.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, the text will have a bottom margin.
+   * @default false
+   */
+  gutterBottom: e.bool,
+  /**
+   * If `true`, the text will not wrap, but instead will truncate with a text overflow ellipsis.
+   *
+   * Note that text overflow can only happen with block or inline-block level elements
+   * (the element needs to have a width in order to overflow).
+   * @default false
+   */
+  noWrap: e.bool,
+  /**
+   * If `true`, the element will be a paragraph element.
+   * @default false
+   * @deprecated Use the `component` 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.
+   */
+  paragraph: e.bool,
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * 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]),
+  /**
+   * Applies the theme typography styles.
+   * @default 'body1'
+   */
+  variant: e.oneOfType([e.oneOf(["body1", "body2", "button", "caption", "h1", "h2", "h3", "h4", "h5", "h6", "inherit", "overline", "subtitle1", "subtitle2"]), e.string]),
+  /**
+   * The component maps the variant prop to a range of different HTML element types.
+   * For instance, subtitle1 to `<h6>`.
+   * If you wish to change that mapping, you can provide your own.
+   * Alternatively, you can use the `component` prop.
+   * @default {
+   *   h1: 'h1',
+   *   h2: 'h2',
+   *   h3: 'h3',
+   *   h4: 'h4',
+   *   h5: 'h5',
+   *   h6: 'h6',
+   *   subtitle1: 'h6',
+   *   subtitle2: 'h6',
+   *   body1: 'p',
+   *   body2: 'p',
+   *   inherit: 'p',
+   * }
+   */
+  variantMapping: e.object
+});
+function Fe(t) {
+  return J("MuiListItemText", t);
+}
+const at = q("MuiListItemText", ["root", "multiline", "dense", "inset", "primary", "secondary"]), We = (t) => {
+  const {
+    classes: o,
+    inset: n,
+    primary: r,
+    secondary: i,
+    dense: c
+  } = t;
+  return Q({
+    root: ["root", n && "inset", c && "dense", r && i && "multiline"],
+    primary: ["primary"],
+    secondary: ["secondary"]
+  }, Fe, o);
+}, Ue = V("div", {
+  name: "MuiListItemText",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [{
+      [`& .${at.primary}`]: o.primary
+    }, {
+      [`& .${at.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,
+  [`.${Tt.root}:where(& .${at.primary})`]: {
+    display: "block"
+  },
+  [`.${Tt.root}:where(& .${at.secondary})`]: {
+    display: "block"
+  },
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.primary && t.secondary,
+    style: {
+      marginTop: 6,
+      marginBottom: 6
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.inset,
+    style: {
+      paddingLeft: 56
+    }
+  }]
+}), Ut = /* @__PURE__ */ m.forwardRef(function(o, n) {
+  const r = K({
+    props: o,
+    name: "MuiListItemText"
+  }), {
+    children: i,
+    className: c,
+    disableTypography: a = !1,
+    inset: l = !1,
+    primary: d,
+    primaryTypographyProps: p,
+    secondary: g,
+    secondaryTypographyProps: S,
+    ...b
+  } = r, {
+    dense: y
+  } = m.useContext(_);
+  let h = d ?? i, x = g;
+  const C = {
+    ...r,
+    disableTypography: a,
+    inset: l,
+    primary: !!h,
+    secondary: !!x,
+    dense: y
+  }, v = We(C);
+  return h != null && h.type !== ot && !a && (h = /* @__PURE__ */ s(ot, {
+    variant: y ? "body2" : "body1",
+    className: v.primary,
+    component: p != null && p.variant ? void 0 : "span",
+    ...p,
+    children: h
+  })), x != null && x.type !== ot && !a && (x = /* @__PURE__ */ s(ot, {
+    variant: "body2",
+    className: v.secondary,
+    color: "textSecondary",
+    ...S,
+    children: x
+  })), /* @__PURE__ */ H(Ue, {
+    className: j(v.root, c),
+    ownerState: C,
+    ref: n,
+    ...b,
+    children: [h, x]
+  });
+});
+process.env.NODE_ENV !== "production" && (Ut.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`).
+   */
+  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`).
+   */
+  secondaryTypographyProps: e.object,
+  /**
+   * 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 Gt = X(Ut, {
+  shouldForwardProp: (t) => t !== "collapsed"
+})(({ collapsed: t }) => ({
+  marginLeft: t ? 0 : "10px",
+  height: "24px",
+  whiteSpace: "nowrap",
+  width: t ? 0 : "auto",
+  opacity: t ? 0 : 1,
+  transition: "600ms all ease-in-out"
+})), yt = X(Wt, {
+  shouldForwardProp: (t) => It(t)
+})(({ menuOrientation: t }) => ({
+  "&:hover": {
+    backgroundColor: z.colors.green
+  },
+  color: z.colors.white,
+  paddingRight: t === "horizontal" ? "16px" : "8px"
+})), Ge = X(yt, {
+  shouldForwardProp: (t) => It(t)
+})(({ menuPosition: t }) => ({
+  display: "flex",
+  justifyContent: t === "right" ? "flex-start" : "flex-end",
+  alignItems: "center"
+})), Ht = ({
+  label: t,
+  icon: o,
+  to: n,
+  openInNewTab: r,
+  collapsed: i,
+  menuOrientation: c
+}) => {
+  const a = o;
+  return /* @__PURE__ */ s(ut, { disablePadding: !0, children: /* @__PURE__ */ H(
+    yt,
+    {
+      href: n ?? "",
+      target: n && r ? "_blank" : void 0,
+      menuOrientation: c,
+      children: [
+        a && a,
+        /* @__PURE__ */ s(Gt, { primary: t, collapsed: i })
+      ]
+    }
+  ) }, t);
+};
+function He(t) {
+  return J("MuiCollapse", t);
+}
+q("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const _e = (t) => {
+  const {
+    orientation: o,
+    classes: n
+  } = t, r = {
+    root: ["root", `${o}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${o}`],
+    wrapperInner: ["wrapperInner", `${o}`]
+  };
+  return Q(r, He, n);
+}, Ye = V("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.root, o[n.orientation], n.state === "entered" && o.entered, n.state === "exited" && !n.in && n.collapsedSize === "0px" && o.hidden];
+  }
+})(tt(({
+  theme: t
+}) => ({
+  height: 0,
+  overflow: "hidden",
+  transition: t.transitions.create("height"),
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      height: "auto",
+      width: 0,
+      transition: t.transitions.create("width")
+    }
+  }, {
+    props: {
+      state: "entered"
+    },
+    style: {
+      height: "auto",
+      overflow: "visible"
+    }
+  }, {
+    props: {
+      state: "entered",
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto"
+    }
+  }, {
+    props: ({
+      ownerState: o
+    }) => o.state === "exited" && !o.in && o.collapsedSize === "0px",
+    style: {
+      visibility: "hidden"
+    }
+  }]
+}))), Xe = V("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper",
+  overridesResolver: (t, o) => o.wrapper
+})({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto",
+      height: "100%"
+    }
+  }]
+}), Je = V("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (t, o) => o.wrapperInner
+})({
+  width: "100%",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto",
+      height: "100%"
+    }
+  }]
+}), ct = /* @__PURE__ */ m.forwardRef(function(o, n) {
+  const r = K({
+    props: o,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: i,
+    children: c,
+    className: a,
+    collapsedSize: l = "0px",
+    component: d,
+    easing: p,
+    in: g,
+    onEnter: S,
+    onEntered: b,
+    onEntering: y,
+    onExit: h,
+    onExited: x,
+    onExiting: C,
+    orientation: v = "vertical",
+    style: I,
+    timeout: E = te.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: k = kt,
+    ...F
+  } = r, L = {
+    ...r,
+    orientation: v,
+    collapsedSize: l
+  }, w = _e(L), N = mt(), M = ge(), T = m.useRef(null), R = m.useRef(), D = typeof l == "number" ? `${l}px` : l, $ = v === "horizontal", O = $ ? "width" : "height", B = m.useRef(null), W = dt(n, B), U = (f) => (A) => {
+    if (f) {
+      const G = B.current;
+      A === void 0 ? f(G) : f(G, A);
+    }
+  }, u = () => T.current ? T.current[$ ? "clientWidth" : "clientHeight"] : 0, P = U((f, A) => {
+    T.current && $ && (T.current.style.position = "absolute"), f.style[O] = D, S && S(f, A);
+  }), nt = U((f, A) => {
+    const G = u();
+    T.current && $ && (T.current.style.position = "");
+    const {
+      duration: et,
+      easing: rt
+    } = lt({
+      style: I,
+      timeout: E,
+      easing: p
+    }, {
+      mode: "enter"
+    });
+    if (E === "auto") {
+      const bt = N.transitions.getAutoHeightDuration(G);
+      f.style.transitionDuration = `${bt}ms`, R.current = bt;
+    } else
+      f.style.transitionDuration = typeof et == "string" ? et : `${et}ms`;
+    f.style[O] = `${G}px`, f.style.transitionTimingFunction = rt, y && y(f, A);
+  }), Jt = U((f, A) => {
+    f.style[O] = "auto", b && b(f, A);
+  }), qt = U((f) => {
+    f.style[O] = `${u()}px`, h && h(f);
+  }), Kt = U(x), Qt = U((f) => {
+    const A = u(), {
+      duration: G,
+      easing: et
+    } = lt({
+      style: I,
+      timeout: E,
+      easing: p
+    }, {
+      mode: "exit"
+    });
+    if (E === "auto") {
+      const rt = N.transitions.getAutoHeightDuration(A);
+      f.style.transitionDuration = `${rt}ms`, R.current = rt;
+    } else
+      f.style.transitionDuration = typeof G == "string" ? G : `${G}ms`;
+    f.style[O] = D, f.style.transitionTimingFunction = et, C && C(f);
+  });
+  return /* @__PURE__ */ s(k, {
+    in: g,
+    onEnter: P,
+    onEntered: Jt,
+    onEntering: nt,
+    onExit: qt,
+    onExited: Kt,
+    onExiting: Qt,
+    addEndListener: (f) => {
+      E === "auto" && M.start(R.current || 0, f), i && i(B.current, f);
+    },
+    nodeRef: B,
+    timeout: E === "auto" ? null : E,
+    ...F,
+    children: (f, A) => /* @__PURE__ */ s(Ye, {
+      as: d,
+      className: j(w.root, a, {
+        entered: w.entered,
+        exited: !g && D === "0px" && w.hidden
+      }[f]),
+      style: {
+        [$ ? "minWidth" : "minHeight"]: D,
+        ...I
+      },
+      ref: W,
+      ...A,
+      // `ownerState` is set after `childProps` to override any existing `ownerState` property in `childProps`
+      // that might have been forwarded from the Transition component.
+      ownerState: {
+        ...L,
+        state: f
+      },
+      children: /* @__PURE__ */ s(Xe, {
+        ownerState: {
+          ...L,
+          state: f
+        },
+        className: w.wrapper,
+        ref: T,
+        children: /* @__PURE__ */ s(Je, {
+          ownerState: {
+            ...L,
+            state: f
+          },
+          className: w.wrapperInner,
+          children: c
+        })
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ct.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: e.func,
+  /**
+   * The content node to be collapsed.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The width (horizontal) or height (vertical) of the container when collapsed.
+   * @default '0px'
+   */
+  collapsedSize: e.oneOfType([e.number, e.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: Bt,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: e.oneOfType([e.shape({
+    enter: e.string,
+    exit: e.string
+  }), e.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: e.bool,
+  /**
+   * @ignore
+   */
+  onEnter: e.func,
+  /**
+   * @ignore
+   */
+  onEntered: e.func,
+  /**
+   * @ignore
+   */
+  onEntering: e.func,
+  /**
+   * @ignore
+   */
+  onExit: e.func,
+  /**
+   * @ignore
+   */
+  onExited: e.func,
+  /**
+   * @ignore
+   */
+  onExiting: e.func,
+  /**
+   * The transition orientation.
+   * @default 'vertical'
+   */
+  orientation: e.oneOf(["horizontal", "vertical"]),
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   *
+   * Set to 'auto' to automatically calculate transition time based on height.
+   * @default duration.standard
+   */
+  timeout: e.oneOfType([e.oneOf(["auto"]), e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+ct && (ct.muiSupportAuto = !0);
+const St = pt(/* @__PURE__ */ s("path", {
+  d: "m12 8-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"
+}), "ExpandLess"), Rt = pt(/* @__PURE__ */ s("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), "ExpandMore"), qe = X(de, {
+  shouldForwardProp: (t) => t !== "collapsed"
+})(({ collapsed: t }) => ({
+  paddingLeft: t ? 0 : "2rem",
+  a: {
+    paddingLeft: t ? "3rem" : "1rem"
+  }
+})), Ke = X(ue, { shouldForwardProp: (t) => t !== "collapsed" })`
+  .MuiPaper-root {
+    background-color: ${z.colors.charcoal};
+    ul {
+      display: flex;
+      flex-wrap: wrap;
+      flex-direction: row;
+      align-items: center;
+      padding: 0;
+      width: 100%;
+      li {
+        width: auto;
+      }
+    }
+  }
+`, Pt = ({
+  type: t = "link",
+  menuOrientation: o,
+  menuPosition: n,
+  collapsed: r,
+  ...i
+}) => {
+  switch (t) {
+    case "link":
+      return /* @__PURE__ */ s(Ht, { ...i, menuOrientation: o });
+    case "menu":
+      return /* @__PURE__ */ s(_t, { menuOrientation: o, position: n, collapsed: r, ...i });
+    case "divider":
+      return /* @__PURE__ */ s(
+        ht,
+        {
+          color: z.colors.white,
+          opacity: 0.5,
+          spacing: 0,
+          orientation: o === "horizontal" ? "vertical" : "horizontal"
+        }
+      );
+    default:
+      return null;
+  }
+}, _t = ({
+  label: t,
+  icon: o,
+  navItems: n,
+  menuOrientation: r,
+  collapsed: i,
+  position: c
+}) => {
+  const [a, l] = ft(!1), [d, p] = ft(null), g = o, S = (y) => {
+    l(!a), r === "horizontal" && (p(null), p(y.currentTarget));
+  }, b = () => {
+    l(!1), p(null);
+  };
+  return /* @__PURE__ */ H($t, { children: [
+    /* @__PURE__ */ s(ut, { disablePadding: !0, children: /* @__PURE__ */ H(yt, { onClick: S, menuOrientation: r, children: [
+      g && g,
+      /* @__PURE__ */ s(Gt, { primary: t, collapsed: i }),
+      c !== "bottom" && (a ? /* @__PURE__ */ s(St, { sx: { marginLeft: "8px" } }) : /* @__PURE__ */ s(Rt, { sx: { marginLeft: "8px" } })),
+      c === "bottom" && (a ? /* @__PURE__ */ s(Rt, { sx: { marginLeft: "8px" } }) : /* @__PURE__ */ s(St, { sx: { marginLeft: "8px" } }))
+    ] }) }, t),
+    r === "vertical" && /* @__PURE__ */ s(ct, { in: a, timeout: "auto", unmountOnExit: !0, children: /* @__PURE__ */ s(qe, { component: "div", disablePadding: !0, collapsed: i, children: n == null ? void 0 : n.map((y, h) => /* @__PURE__ */ s(Pt, { ...y, collapsed: i }, `${JSON.stringify(y)}-${h}`)) }) }),
+    r === "horizontal" && /* @__PURE__ */ s(
+      Ke,
+      {
+        anchorEl: d,
+        anchorOrigin: { horizontal: "left", vertical: c === "bottom" ? "top" : "bottom" },
+        open: a,
+        onClose: b,
+        children: n == null ? void 0 : n.map((y, h) => /* @__PURE__ */ s(
+          Pt,
+          {
+            ...y,
+            collapsed: i,
+            menuOrientation: r,
+            menuPosition: c
+          },
+          `${JSON.stringify(y)}-${h}`
+        ))
+      }
+    )
+  ] });
+}, Lt = ({
+  type: t = "link",
+  menuOrientation: o,
+  menuPosition: n,
+  ...r
+}) => {
+  switch (t) {
+    case "link":
+      return /* @__PURE__ */ s(Ht, { ...r, menuOrientation: o });
+    case "menu":
+      return /* @__PURE__ */ s(_t, { menuOrientation: o, position: n, ...r });
+    case "divider":
+      return /* @__PURE__ */ s(
+        ht,
+        {
+          color: z.colors.white,
+          opacity: 0.5,
+          spacing: 0,
+          orientation: o === "horizontal" ? "vertical" : "horizontal"
+        }
+      );
+    default:
+      return null;
+  }
+}, Yt = ["collapsed", "withAppBar"], Xt = X(Ft, { shouldForwardProp: (t) => !Yt.includes(t) })(({ collapsed: t, anchor: o, withAppBar: n }) => ({
+  minWidth: t ? 0 : `${z.constants.navBarWidth}px`,
+  width: t ? "auto" : "81px",
+  transition: "201ms all ease-out",
+  flexShrink: 0,
+  zIndex: 100,
+  ".MuiPaper-root": {
+    padding: 0,
+    transition: "313ms all ease-in-out",
+    minWidth: t ? 0 : `${z.constants.navBarWidth}px`,
+    width: t ? "auto" : "81px",
+    boxSizing: "border-box",
+    backgroundColor: z.colors.midnight,
+    color: z.colors.white,
+    boxShadow: "0px 0px 7px 4px rgba(0, 0, 0, 0.63)",
+    overflowX: "hidden",
+    height: o === "top" || o === "bottom" ? "auto" : n ? `calc(100% - ${z.constants.appBarHeight}px)` : "100%",
+    top: o !== "bottom" ? n ? `${z.constants.appBarHeight}px` : 0 : void 0
+  }
+})), Qe = X(Xt, { shouldForwardProp: (t) => !Yt.includes(t) })`
+  .MuiPaper-root {
+    width: 100%;
+    display: flex;
+    flex-wrap: wrap;
+    flex-direction: row;
+    align-items: center;
+    li {
+      width: auto;
+    }
+  }
+`, uo = ({ navItems: t, anchor: o = "left", collapsible: n, ...r }) => {
+  const [i, c] = ft(!1), a = o === "top" || o === "bottom" ? "horizontal" : "vertical";
+  return a === "horizontal" ? /* @__PURE__ */ s(Qe, { ...r, anchor: o, variant: "permanent", children: t == null ? void 0 : t.map((l, d) => /* @__PURE__ */ Zt(
+    Lt,
+    {
+      ...l,
+      menuOrientation: a,
+      menuPosition: o,
+      key: `${JSON.stringify(l)}-${d}`
+    }
+  )) }) : /* @__PURE__ */ H(Xt, { ...r, anchor: o, variant: "permanent", collapsed: i, children: [
+    n && /* @__PURE__ */ H($t, { children: [
+      /* @__PURE__ */ s(ut, { disablePadding: !0, children: /* @__PURE__ */ H(
+        Ge,
+        {
+          onClick: () => c(!i),
+          menuOrientation: a,
+          menuPosition: o,
+          children: [
+            o === "left" && (i ? /* @__PURE__ */ s(Ct, {}) : /* @__PURE__ */ s(wt, {})),
+            o === "right" && (i ? /* @__PURE__ */ s(wt, {}) : /* @__PURE__ */ s(Ct, {}))
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ s(ht, { color: z.colors.white, opacity: 0.5, spacing: 0 })
+    ] }),
+    t == null ? void 0 : t.map((l, d) => /* @__PURE__ */ s(
+      Lt,
+      {
+        ...l,
+        menuOrientation: a,
+        menuPosition: o,
+        collapsed: i
+      },
+      `${JSON.stringify(l)}-${d}`
+    ))
+  ] });
+};
+export {
+  uo as N
+};