@smart-factor/gem-ui-components 0.0.7 → 0.0.9

package/dist/Tree-DEzkwImd.js

@@ -0,0 +1,2981 @@
+import { jsx as w, jsxs as ve } from "react/jsx-runtime";
+import * as x from "react";
+import { createElement as Qt } from "react";
+import { J as Zt, K as tt, L as en, M as tn, N as nn, k as fe, l as me, m as U, _ as D, p as st, O as on, T as rn, q as Le, r as sn, Q as ln, h as de, t as Ie, P as r, R as lt, v as ge, x as nt, U as an, D as at, f as cn, V as ct, a as ue, b as te, n as dn, d as un, g as G, o as pn, E as fn, u as mn, B as ce, W as In, X as dt, Y as ie, A as ot, e as gn, F as hn, S as bn, H as yn, I as xn } from "./Stack-CrOcI22K.js";
+function je(e, t = 0, n = 1) {
+  return process.env.NODE_ENV !== "production" && (e < t || e > n) && console.error(`MUI: The value provided ${e} is out of range [${t}, ${n}].`), Zt(e, t, n);
+}
+function En(e) {
+  e = e.slice(1);
+  const t = new RegExp(`.{1,${e.length >= 6 ? 2 : 1}}`, "g");
+  let n = e.match(t);
+  return n && n[0].length === 1 && (n = n.map((o) => o + o)), n ? `rgb${n.length === 4 ? "a" : ""}(${n.map((o, s) => s < 3 ? parseInt(o, 16) : Math.round(parseInt(o, 16) / 255 * 1e3) / 1e3).join(", ")})` : "";
+}
+function Me(e) {
+  if (e.type)
+    return e;
+  if (e.charAt(0) === "#")
+    return Me(En(e));
+  const t = e.indexOf("("), n = e.substring(0, t);
+  if (["rgb", "rgba", "hsl", "hsla", "color"].indexOf(n) === -1)
+    throw new Error(process.env.NODE_ENV !== "production" ? `MUI: Unsupported \`${e}\` color.
+The following formats are supported: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().` : tt(9, e));
+  let o = e.substring(t + 1, e.length - 1), s;
+  if (n === "color") {
+    if (o = o.split(" "), s = o.shift(), o.length === 4 && o[3].charAt(0) === "/" && (o[3] = o[3].slice(1)), ["srgb", "display-p3", "a98-rgb", "prophoto-rgb", "rec-2020"].indexOf(s) === -1)
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI: unsupported \`${s}\` color space.
+The following color spaces are supported: srgb, display-p3, a98-rgb, prophoto-rgb, rec-2020.` : tt(10, s));
+  } else
+    o = o.split(",");
+  return o = o.map((d) => parseFloat(d)), {
+    type: n,
+    values: o,
+    colorSpace: s
+  };
+}
+function _e(e) {
+  const {
+    type: t,
+    colorSpace: n
+  } = e;
+  let {
+    values: o
+  } = e;
+  return t.indexOf("rgb") !== -1 ? o = o.map((s, d) => d < 3 ? parseInt(s, 10) : s) : t.indexOf("hsl") !== -1 && (o[1] = `${o[1]}%`, o[2] = `${o[2]}%`), t.indexOf("color") !== -1 ? o = `${n} ${o.join(" ")}` : o = `${o.join(", ")}`, `${t}(${o})`;
+}
+function X(e, t) {
+  return e = Me(e), t = je(t), (e.type === "rgb" || e.type === "hsl") && (e.type += "a"), e.type === "color" ? e.values[3] = `/${t}` : e.values[3] = t, _e(e);
+}
+function Xo(e, t) {
+  if (e = Me(e), t = je(t), e.type.indexOf("hsl") !== -1)
+    e.values[2] *= 1 - t;
+  else if (e.type.indexOf("rgb") !== -1 || e.type.indexOf("color") !== -1)
+    for (let n = 0; n < 3; n += 1)
+      e.values[n] *= 1 - t;
+  return _e(e);
+}
+function Wo(e, t) {
+  if (e = Me(e), t = je(t), e.type.indexOf("hsl") !== -1)
+    e.values[2] += (100 - e.values[2]) * t;
+  else if (e.type.indexOf("rgb") !== -1)
+    for (let n = 0; n < 3; n += 1)
+      e.values[n] += (255 - e.values[n]) * t;
+  else if (e.type.indexOf("color") !== -1)
+    for (let n = 0; n < 3; n += 1)
+      e.values[n] += (1 - e.values[n]) * t;
+  return _e(e);
+}
+function Cn({
+  props: e,
+  name: t
+}) {
+  return en({
+    props: e,
+    name: t,
+    defaultTheme: tn,
+    themeId: nn
+  });
+}
+function Tn(e) {
+  return fe("MuiCollapse", e);
+}
+me("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const wn = ["addEndListener", "children", "className", "collapsedSize", "component", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "orientation", "style", "timeout", "TransitionComponent"], vn = (e) => {
+  const {
+    orientation: t,
+    classes: n
+  } = e, o = {
+    root: ["root", `${t}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${t}`],
+    wrapperInner: ["wrapperInner", `${t}`]
+  };
+  return ge(o, Tn, n);
+}, Mn = U("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (e, t) => {
+    const {
+      ownerState: n
+    } = e;
+    return [t.root, t[n.orientation], n.state === "entered" && t.entered, n.state === "exited" && !n.in && n.collapsedSize === "0px" && t.hidden];
+  }
+})(({
+  theme: e,
+  ownerState: t
+}) => D({
+  height: 0,
+  overflow: "hidden",
+  transition: e.transitions.create("height")
+}, t.orientation === "horizontal" && {
+  height: "auto",
+  width: 0,
+  transition: e.transitions.create("width")
+}, t.state === "entered" && D({
+  height: "auto",
+  overflow: "visible"
+}, t.orientation === "horizontal" && {
+  width: "auto"
+}), t.state === "exited" && !t.in && t.collapsedSize === "0px" && {
+  visibility: "hidden"
+})), Sn = U("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper",
+  overridesResolver: (e, t) => t.wrapper
+})(({
+  ownerState: e
+}) => D({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%"
+}, e.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), Rn = U("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (e, t) => t.wrapperInner
+})(({
+  ownerState: e
+}) => D({
+  width: "100%"
+}, e.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), Be = /* @__PURE__ */ x.forwardRef(function(t, n) {
+  const o = st({
+    props: t,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: s,
+    children: d,
+    className: c,
+    collapsedSize: i = "0px",
+    component: p,
+    easing: u,
+    in: l,
+    onEnter: a,
+    onEntered: m,
+    onEntering: I,
+    onExit: h,
+    onExited: f,
+    onExiting: g,
+    orientation: b = "vertical",
+    style: y,
+    timeout: C = on.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: O = rn
+  } = o, T = Le(o, wn), v = D({}, o, {
+    orientation: b,
+    collapsedSize: i
+  }), R = vn(v), B = sn(), K = ln(), V = x.useRef(null), A = x.useRef(), z = typeof i == "number" ? `${i}px` : i, j = b === "horizontal", q = j ? "width" : "height", N = x.useRef(null), H = de(n, N), L = (M) => (F) => {
+    if (M) {
+      const _ = N.current;
+      F === void 0 ? M(_) : M(_, F);
+    }
+  }, W = () => V.current ? V.current[j ? "clientWidth" : "clientHeight"] : 0, k = L((M, F) => {
+    V.current && j && (V.current.style.position = "absolute"), M.style[q] = z, a && a(M, F);
+  }), P = L((M, F) => {
+    const _ = W();
+    V.current && j && (V.current.style.position = "");
+    const {
+      duration: $,
+      easing: Y
+    } = nt({
+      style: y,
+      timeout: C,
+      easing: u
+    }, {
+      mode: "enter"
+    });
+    if (C === "auto") {
+      const xe = B.transitions.getAutoHeightDuration(_);
+      M.style.transitionDuration = `${xe}ms`, A.current = xe;
+    } else
+      M.style.transitionDuration = typeof $ == "string" ? $ : `${$}ms`;
+    M.style[q] = `${_}px`, M.style.transitionTimingFunction = Y, I && I(M, F);
+  }), ne = L((M, F) => {
+    M.style[q] = "auto", m && m(M, F);
+  }), ye = L((M) => {
+    M.style[q] = `${W()}px`, h && h(M);
+  }), Oe = L(f), ke = L((M) => {
+    const F = W(), {
+      duration: _,
+      easing: $
+    } = nt({
+      style: y,
+      timeout: C,
+      easing: u
+    }, {
+      mode: "exit"
+    });
+    if (C === "auto") {
+      const Y = B.transitions.getAutoHeightDuration(F);
+      M.style.transitionDuration = `${Y}ms`, A.current = Y;
+    } else
+      M.style.transitionDuration = typeof _ == "string" ? _ : `${_}ms`;
+    M.style[q] = z, M.style.transitionTimingFunction = $, g && g(M);
+  });
+  return /* @__PURE__ */ w(O, D({
+    in: l,
+    onEnter: k,
+    onEntered: ne,
+    onEntering: P,
+    onExit: ye,
+    onExited: Oe,
+    onExiting: ke,
+    addEndListener: (M) => {
+      C === "auto" && K.start(A.current || 0, M), s && s(N.current, M);
+    },
+    nodeRef: N,
+    timeout: C === "auto" ? null : C
+  }, T, {
+    children: (M, F) => /* @__PURE__ */ w(Mn, D({
+      as: p,
+      className: Ie(R.root, c, {
+        entered: R.entered,
+        exited: !l && z === "0px" && R.hidden
+      }[M]),
+      style: D({
+        [j ? "minWidth" : "minHeight"]: z
+      }, y),
+      ref: H
+    }, F, {
+      // `ownerState` is set after `childProps` to override any existing `ownerState` property in `childProps`
+      // that might have been forwarded from the Transition component.
+      ownerState: D({}, v, {
+        state: M
+      }),
+      children: /* @__PURE__ */ w(Sn, {
+        ownerState: D({}, v, {
+          state: M
+        }),
+        className: R.wrapper,
+        ref: V,
+        children: /* @__PURE__ */ w(Rn, {
+          ownerState: D({}, v, {
+            state: M
+          }),
+          className: R.wrapperInner,
+          children: d
+        })
+      })
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (Be.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: r.func,
+  /**
+   * The content node to be collapsed.
+   */
+  children: r.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * @ignore
+   */
+  className: r.string,
+  /**
+   * The width (horizontal) or height (vertical) of the container when collapsed.
+   * @default '0px'
+   */
+  collapsedSize: r.oneOfType([r.number, r.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: lt,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: r.oneOfType([r.shape({
+    enter: r.string,
+    exit: r.string
+  }), r.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: r.bool,
+  /**
+   * @ignore
+   */
+  onEnter: r.func,
+  /**
+   * @ignore
+   */
+  onEntered: r.func,
+  /**
+   * @ignore
+   */
+  onEntering: r.func,
+  /**
+   * @ignore
+   */
+  onExit: r.func,
+  /**
+   * @ignore
+   */
+  onExited: r.func,
+  /**
+   * @ignore
+   */
+  onExiting: r.func,
+  /**
+   * The transition orientation.
+   * @default 'vertical'
+   */
+  orientation: r.oneOf(["horizontal", "vertical"]),
+  /**
+   * @ignore
+   */
+  style: r.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.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: r.oneOfType([r.oneOf(["auto"]), r.number, r.shape({
+    appear: r.number,
+    enter: r.number,
+    exit: r.number
+  })])
+});
+Be.muiSupportAuto = !0;
+const ut = /* @__PURE__ */ x.createContext(void 0);
+process.env.NODE_ENV !== "production" && (ut.displayName = "FormControlContext");
+function On() {
+  return x.useContext(ut);
+}
+function kn(e) {
+  return fe("PrivateSwitchBase", e);
+}
+me("PrivateSwitchBase", ["root", "checked", "disabled", "input", "edgeStart", "edgeEnd"]);
+const Pn = ["autoFocus", "checked", "checkedIcon", "className", "defaultChecked", "disabled", "disableFocusRipple", "edge", "icon", "id", "inputProps", "inputRef", "name", "onBlur", "onChange", "onFocus", "readOnly", "required", "tabIndex", "type", "value"], Dn = (e) => {
+  const {
+    classes: t,
+    checked: n,
+    disabled: o,
+    edge: s
+  } = e, d = {
+    root: ["root", n && "checked", o && "disabled", s && `edge${ue(s)}`],
+    input: ["input"]
+  };
+  return ge(d, kn, t);
+}, Vn = U(an)(({
+  ownerState: e
+}) => D({
+  padding: 9,
+  borderRadius: "50%"
+}, e.edge === "start" && {
+  marginLeft: e.size === "small" ? -3 : -12
+}, e.edge === "end" && {
+  marginRight: e.size === "small" ? -3 : -12
+})), $n = U("input", {
+  shouldForwardProp: at
+})({
+  cursor: "inherit",
+  position: "absolute",
+  opacity: 0,
+  width: "100%",
+  height: "100%",
+  top: 0,
+  left: 0,
+  margin: 0,
+  padding: 0,
+  zIndex: 1
+}), pt = /* @__PURE__ */ x.forwardRef(function(t, n) {
+  const {
+    autoFocus: o,
+    checked: s,
+    checkedIcon: d,
+    className: c,
+    defaultChecked: i,
+    disabled: p,
+    disableFocusRipple: u = !1,
+    edge: l = !1,
+    icon: a,
+    id: m,
+    inputProps: I,
+    inputRef: h,
+    name: f,
+    onBlur: g,
+    onChange: b,
+    onFocus: y,
+    readOnly: C,
+    required: O = !1,
+    tabIndex: T,
+    type: v,
+    value: R
+  } = t, B = Le(t, Pn), [K, V] = cn({
+    controlled: s,
+    default: !!i,
+    name: "SwitchBase",
+    state: "checked"
+  }), A = On(), z = (k) => {
+    y && y(k), A && A.onFocus && A.onFocus(k);
+  }, j = (k) => {
+    g && g(k), A && A.onBlur && A.onBlur(k);
+  }, q = (k) => {
+    if (k.nativeEvent.defaultPrevented)
+      return;
+    const P = k.target.checked;
+    V(P), b && b(k, P);
+  };
+  let N = p;
+  A && typeof N > "u" && (N = A.disabled);
+  const H = v === "checkbox" || v === "radio", L = D({}, t, {
+    checked: K,
+    disabled: N,
+    disableFocusRipple: u,
+    edge: l
+  }), W = Dn(L);
+  return /* @__PURE__ */ ve(Vn, D({
+    component: "span",
+    className: Ie(W.root, c),
+    centerRipple: !0,
+    focusRipple: !u,
+    disabled: N,
+    tabIndex: null,
+    role: void 0,
+    onFocus: z,
+    onBlur: j,
+    ownerState: L,
+    ref: n
+  }, B, {
+    children: [/* @__PURE__ */ w($n, D({
+      autoFocus: o,
+      checked: s,
+      defaultChecked: i,
+      className: W.input,
+      disabled: N,
+      id: H ? m : void 0,
+      name: f,
+      onChange: q,
+      readOnly: C,
+      ref: h,
+      required: O,
+      ownerState: L,
+      tabIndex: T,
+      type: v
+    }, v === "checkbox" && R === void 0 ? {} : {
+      value: R
+    }, I)), K ? d : a]
+  }));
+});
+process.env.NODE_ENV !== "production" && (pt.propTypes = {
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   */
+  autoFocus: r.bool,
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: r.bool,
+  /**
+   * The icon to display when the component is checked.
+   */
+  checkedIcon: r.node.isRequired,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * @ignore
+   */
+  className: r.string,
+  /**
+   * @ignore
+   */
+  defaultChecked: r.bool,
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: r.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: r.bool,
+  /**
+   * If given, uses a negative margin to counteract the padding on one
+   * side (this is often helpful for aligning the left or right
+   * side of the icon with content above or below, without ruining the border
+   * size and shape).
+   * @default false
+   */
+  edge: r.oneOf(["end", "start", !1]),
+  /**
+   * The icon to display when the component is unchecked.
+   */
+  icon: r.node.isRequired,
+  /**
+   * The id of the `input` element.
+   */
+  id: r.string,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: r.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: ct,
+  /*
+   * @ignore
+   */
+  name: r.string,
+  /**
+   * @ignore
+   */
+  onBlur: r.func,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {object} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: r.func,
+  /**
+   * @ignore
+   */
+  onFocus: r.func,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   */
+  readOnly: r.bool,
+  /**
+   * If `true`, the `input` element is required.
+   */
+  required: r.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.object,
+  /**
+   * @ignore
+   */
+  tabIndex: r.oneOfType([r.number, r.string]),
+  /**
+   * The input component prop `type`.
+   */
+  type: r.string.isRequired,
+  /**
+   * The value of the component.
+   */
+  value: r.any
+});
+const An = te(/* @__PURE__ */ w("path", {
+  d: "M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"
+}), "CheckBoxOutlineBlank"), Fn = te(/* @__PURE__ */ w("path", {
+  d: "M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"
+}), "CheckBox"), Nn = te(/* @__PURE__ */ w("path", {
+  d: "M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"
+}), "IndeterminateCheckBox");
+function Ln(e) {
+  return fe("MuiCheckbox", e);
+}
+const Ae = me("MuiCheckbox", ["root", "checked", "disabled", "indeterminate", "colorPrimary", "colorSecondary", "sizeSmall", "sizeMedium"]), jn = ["checkedIcon", "color", "icon", "indeterminate", "indeterminateIcon", "inputProps", "size", "className"], _n = (e) => {
+  const {
+    classes: t,
+    indeterminate: n,
+    color: o,
+    size: s
+  } = e, d = {
+    root: ["root", n && "indeterminate", `color${ue(o)}`, `size${ue(s)}`]
+  }, c = ge(d, Ln, t);
+  return D({}, t, c);
+}, Bn = U(pt, {
+  shouldForwardProp: (e) => at(e) || e === "classes",
+  name: "MuiCheckbox",
+  slot: "Root",
+  overridesResolver: (e, t) => {
+    const {
+      ownerState: n
+    } = e;
+    return [t.root, n.indeterminate && t.indeterminate, t[`size${ue(n.size)}`], n.color !== "default" && t[`color${ue(n.color)}`]];
+  }
+})(({
+  theme: e,
+  ownerState: t
+}) => D({
+  color: (e.vars || e).palette.text.secondary
+}, !t.disableRipple && {
+  "&:hover": {
+    backgroundColor: e.vars ? `rgba(${t.color === "default" ? e.vars.palette.action.activeChannel : e.vars.palette[t.color].mainChannel} / ${e.vars.palette.action.hoverOpacity})` : dn(t.color === "default" ? e.palette.action.active : e.palette[t.color].main, e.palette.action.hoverOpacity),
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  }
+}, t.color !== "default" && {
+  [`&.${Ae.checked}, &.${Ae.indeterminate}`]: {
+    color: (e.vars || e).palette[t.color].main
+  },
+  [`&.${Ae.disabled}`]: {
+    color: (e.vars || e).palette.action.disabled
+  }
+})), zn = /* @__PURE__ */ w(Fn, {}), Un = /* @__PURE__ */ w(An, {}), Kn = /* @__PURE__ */ w(Nn, {}), ft = /* @__PURE__ */ x.forwardRef(function(t, n) {
+  var o, s;
+  const d = st({
+    props: t,
+    name: "MuiCheckbox"
+  }), {
+    checkedIcon: c = zn,
+    color: i = "primary",
+    icon: p = Un,
+    indeterminate: u = !1,
+    indeterminateIcon: l = Kn,
+    inputProps: a,
+    size: m = "medium",
+    className: I
+  } = d, h = Le(d, jn), f = u ? l : p, g = u ? l : c, b = D({}, d, {
+    color: i,
+    indeterminate: u,
+    size: m
+  }), y = _n(b);
+  return /* @__PURE__ */ w(Bn, D({
+    type: "checkbox",
+    inputProps: D({
+      "data-indeterminate": u
+    }, a),
+    icon: /* @__PURE__ */ x.cloneElement(f, {
+      fontSize: (o = f.props.fontSize) != null ? o : m
+    }),
+    checkedIcon: /* @__PURE__ */ x.cloneElement(g, {
+      fontSize: (s = g.props.fontSize) != null ? s : m
+    }),
+    ownerState: b,
+    ref: n,
+    className: Ie(y.root, I)
+  }, h, {
+    classes: y
+  }));
+});
+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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: r.bool,
+  /**
+   * The icon to display when the component is checked.
+   * @default <CheckBoxIcon />
+   */
+  checkedIcon: r.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * @ignore
+   */
+  className: r.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).
+   * @default 'primary'
+   */
+  color: r.oneOfType([r.oneOf(["default", "primary", "secondary", "error", "info", "success", "warning"]), r.string]),
+  /**
+   * The default checked state. Use when the component is not controlled.
+   */
+  defaultChecked: r.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: r.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   * @default false
+   */
+  disableRipple: r.bool,
+  /**
+   * The icon to display when the component is unchecked.
+   * @default <CheckBoxOutlineBlankIcon />
+   */
+  icon: r.node,
+  /**
+   * The id of the `input` element.
+   */
+  id: r.string,
+  /**
+   * If `true`, the component appears indeterminate.
+   * This does not set the native input element to indeterminate due
+   * to inconsistent behavior across browsers.
+   * However, we set a `data-indeterminate` attribute on the `input`.
+   * @default false
+   */
+  indeterminate: r.bool,
+  /**
+   * The icon to display when the component is indeterminate.
+   * @default <IndeterminateCheckBoxIcon />
+   */
+  indeterminateIcon: r.node,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+   */
+  inputProps: r.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: ct,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: r.func,
+  /**
+   * If `true`, the `input` element is required.
+   * @default false
+   */
+  required: r.bool,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense checkbox styling.
+   * @default 'medium'
+   */
+  size: r.oneOfType([r.oneOf(["medium", "small"]), r.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  /**
+   * The value of the component. The DOM API casts this to a string.
+   * The browser uses "on" as the default value.
+   */
+  value: r.any
+});
+const qn = te(/* @__PURE__ */ w("path", {
+  d: "M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5M12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5m0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3"
+}), "Visibility"), Xn = te(/* @__PURE__ */ w("path", {
+  d: "M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7M2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2m4.31-.78 3.15 3.15.02-.16c0-1.66-1.34-3-3-3z"
+}), "VisibilityOff");
+function E() {
+  return E = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var o in n) ({}).hasOwnProperty.call(n, o) && (e[o] = n[o]);
+    }
+    return e;
+  }, E.apply(null, arguments);
+}
+function mt(e) {
+  return Cn;
+}
+const rt = /* @__PURE__ */ new Set();
+function It(e, t = "warning") {
+  if (process.env.NODE_ENV === "production")
+    return;
+  const n = Array.isArray(e) ? e.join(`
+`) : e;
+  rt.has(n) || (rt.add(n), t === "error" ? console.error(n) : console.warn(n));
+}
+function Wn(e) {
+  return fe("MuiSimpleTreeView", e);
+}
+me("MuiSimpleTreeView", ["root"]);
+const Jn = (e, t) => {
+  const n = x.useRef({}), [o, s] = x.useState(() => {
+    const c = {};
+    return e.forEach((i) => {
+      i.models && Object.entries(i.models).forEach(([p, u]) => {
+        n.current[p] = {
+          isControlled: t[p] !== void 0,
+          getDefaultValue: u.getDefaultValue
+        }, c[p] = u.getDefaultValue(t);
+      });
+    }), c;
+  }), d = Object.fromEntries(Object.entries(n.current).map(([c, i]) => {
+    const p = t[c] ?? o[c];
+    return [c, {
+      value: p,
+      setControlledValue: (u) => {
+        i.isControlled || s((l) => E({}, l, {
+          [c]: u
+        }));
+      }
+    }];
+  }));
+  return process.env.NODE_ENV !== "production" && Object.entries(n.current).forEach(([c, i]) => {
+    const p = t[c], u = i.getDefaultValue(t);
+    x.useEffect(() => {
+      i.isControlled !== (p !== void 0) && console.error([`MUI X: A component is changing the ${i.isControlled ? "" : "un"}controlled ${c} state of TreeView to be ${i.isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${c} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [p]);
+    const {
+      current: l
+    } = x.useRef(u);
+    x.useEffect(() => {
+      !i.isControlled && l !== u && console.error([`MUI X: A component is changing the default ${c} state of an uncontrolled TreeView after being initialized. To suppress this warning opt to use a controlled TreeView.`].join(`
+`));
+    }, [JSON.stringify(u)]);
+  }), d;
+};
+class Gn {
+  constructor() {
+    this.maxListeners = 20, this.warnOnce = !1, this.events = {};
+  }
+  on(t, n, o = {}) {
+    let s = this.events[t];
+    if (s || (s = {
+      highPriority: /* @__PURE__ */ new Map(),
+      regular: /* @__PURE__ */ new Map()
+    }, this.events[t] = s), o.isFirst ? s.highPriority.set(n, !0) : s.regular.set(n, !0), process.env.NODE_ENV !== "production") {
+      const d = s.highPriority.size + s.regular.size;
+      d > this.maxListeners && !this.warnOnce && (this.warnOnce = !0, console.warn([`Possible EventEmitter memory leak detected. ${d} ${t} listeners added.`].join(`
+`)));
+    }
+  }
+  removeListener(t, n) {
+    this.events[t] && (this.events[t].regular.delete(n), this.events[t].highPriority.delete(n));
+  }
+  removeAllListeners() {
+    this.events = {};
+  }
+  emit(t, ...n) {
+    const o = this.events[t];
+    if (!o)
+      return;
+    const s = Array.from(o.highPriority.keys()), d = Array.from(o.regular.keys());
+    for (let c = s.length - 1; c >= 0; c -= 1) {
+      const i = s[c];
+      o.highPriority.has(i) && i.apply(this, n);
+    }
+    for (let c = 0; c < d.length; c += 1) {
+      const i = d[c];
+      o.regular.has(i) && i.apply(this, n);
+    }
+  }
+  once(t, n) {
+    const o = this;
+    this.on(t, function s(...d) {
+      o.removeListener(t, s), n.apply(o, d);
+    });
+  }
+}
+const Hn = (e) => e.isPropagationStopped !== void 0, gt = () => {
+  const [e] = x.useState(() => new Gn()), t = x.useCallback((...o) => {
+    const [s, d, c = {}] = o;
+    c.defaultMuiPrevented = !1, !(Hn(c) && c.isPropagationStopped()) && e.emit(s, d, c);
+  }, [e]), n = x.useCallback((o, s) => (e.on(o, s), () => {
+    e.removeListener(o, s);
+  }), [e]);
+  return {
+    instance: {
+      $$publishEvent: t,
+      $$subscribeEvent: n
+    }
+  };
+};
+gt.params = {};
+const ht = ({
+  plugins: e
+}) => {
+  const t = new Set(e);
+  return {
+    instance: {
+      getAvailablePlugins: () => t
+    }
+  };
+};
+ht.params = {};
+const bt = ({
+  params: e
+}) => {
+  const t = un(e.id), n = x.useCallback((o, s) => s ?? `${t}-${o}`, [t]);
+  return {
+    getRootProps: () => ({
+      id: t
+    }),
+    instance: {
+      getTreeItemIdAttribute: n
+    }
+  };
+};
+bt.params = {
+  id: !0
+};
+const Yn = [gt, ht, bt];
+function Q(e, t) {
+  if (e == null) return {};
+  var n = {};
+  for (var o in e) if ({}.hasOwnProperty.call(e, o)) {
+    if (t.includes(o)) continue;
+    n[o] = e[o];
+  }
+  return n;
+}
+const Qn = ["slots", "slotProps", "apiRef", "experimentalFeatures"], Zn = (e) => {
+  let {
+    props: {
+      slots: t,
+      slotProps: n,
+      apiRef: o,
+      experimentalFeatures: s
+    },
+    plugins: d
+  } = e, c = Q(e.props, Qn);
+  const i = {};
+  d.forEach((a) => {
+    Object.assign(i, a.params);
+  });
+  const p = {}, u = {};
+  Object.keys(c).forEach((a) => {
+    const m = c[a];
+    i[a] ? p[a] = m : u[a] = m;
+  });
+  const l = d.reduce((a, m) => m.getDefaultizedParams ? m.getDefaultizedParams(a) : a, p);
+  return {
+    apiRef: o,
+    forwardedProps: u,
+    pluginParams: l,
+    slots: t ?? {},
+    slotProps: n ?? {},
+    experimentalFeatures: s ?? {}
+  };
+}, eo = ({
+  plugins: e,
+  instance: t,
+  publicAPI: n,
+  rootRef: o
+}) => ({
+  runItemPlugins: (i) => {
+    let p = null, u = null;
+    const l = [], a = {};
+    e.forEach((h) => {
+      if (!h.itemPlugin)
+        return;
+      const f = h.itemPlugin({
+        props: i,
+        rootRef: p,
+        contentRef: u
+      });
+      f != null && f.rootRef && (p = f.rootRef), f != null && f.contentRef && (u = f.contentRef), f != null && f.propsEnhancers && (l.push(f.propsEnhancers), Object.keys(f.propsEnhancers).forEach((g) => {
+        a[g] = !0;
+      }));
+    });
+    const m = (h) => (f) => {
+      const g = {};
+      return l.forEach((b) => {
+        const y = b[h];
+        y != null && Object.assign(g, y(f));
+      }), g;
+    }, I = Object.fromEntries(Object.keys(a).map((h) => [h, m(h)]));
+    return {
+      contentRef: u,
+      rootRef: p,
+      propsEnhancers: I
+    };
+  },
+  wrapItem: ({
+    itemId: i,
+    children: p
+  }) => {
+    let u = p;
+    for (let l = e.length - 1; l >= 0; l -= 1) {
+      const a = e[l];
+      a.wrapItem && (u = a.wrapItem({
+        itemId: i,
+        children: u,
+        instance: t
+      }));
+    }
+    return u;
+  },
+  wrapRoot: ({
+    children: i
+  }) => {
+    let p = i;
+    for (let u = e.length - 1; u >= 0; u -= 1) {
+      const l = e[u];
+      l.wrapRoot && (p = l.wrapRoot({
+        children: p,
+        instance: t
+      }));
+    }
+    return p;
+  },
+  instance: t,
+  rootRef: o,
+  publicAPI: n
+});
+function to(e) {
+  const t = x.useRef({});
+  return e ? (e.current == null && (e.current = {}), e.current) : t.current;
+}
+const no = ({
+  plugins: e,
+  rootRef: t,
+  props: n
+}) => {
+  const o = [...Yn, ...e], {
+    pluginParams: s,
+    forwardedProps: d,
+    apiRef: c,
+    experimentalFeatures: i,
+    slots: p,
+    slotProps: u
+  } = Zn({
+    plugins: o,
+    props: n
+  }), l = Jn(o, s), m = x.useRef({}).current, I = to(c), h = x.useRef(null), f = de(h, t), g = eo({
+    plugins: o,
+    instance: m,
+    publicAPI: I,
+    rootRef: h
+  }), [b, y] = x.useState(() => {
+    const v = {};
+    return o.forEach((R) => {
+      R.getInitialState && Object.assign(v, R.getInitialState(s));
+    }), v;
+  }), C = [], O = (v) => {
+    const R = v({
+      instance: m,
+      params: s,
+      slots: p,
+      slotProps: u,
+      experimentalFeatures: i,
+      state: b,
+      setState: y,
+      rootRef: h,
+      models: l,
+      plugins: o
+    });
+    R.getRootProps && C.push(R.getRootProps), R.publicAPI && Object.assign(I, R.publicAPI), R.instance && Object.assign(m, R.instance), R.contextValue && Object.assign(g, R.contextValue);
+  };
+  return o.forEach(O), {
+    getRootProps: (v = {}) => {
+      const R = E({
+        role: "tree"
+      }, d, v, {
+        ref: f
+      });
+      return C.forEach((B) => {
+        Object.assign(R, B(v));
+      }), R;
+    },
+    rootRef: f,
+    contextValue: g,
+    instance: m
+  };
+}, ze = /* @__PURE__ */ x.createContext(null);
+process.env.NODE_ENV !== "production" && (ze.displayName = "TreeViewContext");
+function oo(e) {
+  const {
+    value: t,
+    children: n
+  } = e;
+  return /* @__PURE__ */ w(ze.Provider, {
+    value: t,
+    children: t.wrapRoot({
+      children: n
+    })
+  });
+}
+const le = () => {
+  const e = x.useContext(ze);
+  if (e == null)
+    throw new Error(["MUI X: Could not find the Tree View context.", "It looks like you rendered your component outside of a SimpleTreeView or RichTreeView parent component.", "This can also happen if you are bundling multiple versions of the Tree View."].join(`
+`));
+  return e;
+}, yt = (e, t, n) => {
+  e.$$publishEvent(t, n);
+}, Z = "__TREE_VIEW_ROOT_PARENT_ID__", xt = (e) => {
+  const t = {};
+  return e.forEach((n, o) => {
+    t[n] = o;
+  }), t;
+}, se = /* @__PURE__ */ x.createContext(() => -1);
+process.env.NODE_ENV !== "production" && (se.displayName = "TreeViewItemDepthContext");
+const ro = ["children"], Et = ({
+  items: e,
+  isItemDisabled: t,
+  getItemLabel: n,
+  getItemId: o
+}) => {
+  const s = {}, d = {}, c = {
+    [Z]: []
+  }, i = (u, l, a) => {
+    var f, g;
+    const m = o ? o(u) : u.id;
+    if (m == null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", "An item was provided without id in the `items` prop:", JSON.stringify(u)].join(`
+`));
+    if (s[m] != null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", `Two items were provided with the same id in the \`items\` prop: "${m}"`].join(`
+`));
+    const I = n ? n(u) : u.label;
+    if (I == null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a `label` property.", "Alternatively, you can use the `getItemLabel` prop to specify a custom label for each item.", "An item was provided without label in the `items` prop:", JSON.stringify(u)].join(`
+`));
+    s[m] = {
+      id: m,
+      label: I,
+      parentId: a,
+      idAttribute: void 0,
+      expandable: !!((f = u.children) != null && f.length),
+      disabled: t ? t(u) : !1,
+      depth: l
+    }, d[m] = u;
+    const h = a ?? Z;
+    c[h] || (c[h] = []), c[h].push(m), (g = u.children) == null || g.forEach((b) => i(b, l + 1, m));
+  };
+  e.forEach((u) => i(u, 0, null));
+  const p = {};
+  return Object.keys(c).forEach((u) => {
+    p[u] = xt(c[u]);
+  }), {
+    itemMetaMap: s,
+    itemMap: d,
+    itemOrderedChildrenIds: c,
+    itemChildrenIndexes: p
+  };
+}, he = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: o,
+  experimentalFeatures: s
+}) => {
+  const d = x.useCallback((b) => n.items.itemMetaMap[b], [n.items.itemMetaMap]), c = x.useCallback((b) => n.items.itemMap[b], [n.items.itemMap]), i = x.useCallback(() => {
+    const b = (y) => {
+      const C = n.items.itemMap[y], O = Q(C, ro), T = n.items.itemOrderedChildrenIds[y];
+      return T && (O.children = T.map(b)), O;
+    };
+    return n.items.itemOrderedChildrenIds[Z].map(b);
+  }, [n.items.itemMap, n.items.itemOrderedChildrenIds]), p = x.useCallback((b) => {
+    if (b == null)
+      return !1;
+    let y = e.getItemMeta(b);
+    if (!y)
+      return !1;
+    if (y.disabled)
+      return !0;
+    for (; y.parentId != null; )
+      if (y = e.getItemMeta(y.parentId), y.disabled)
+        return !0;
+    return !1;
+  }, [e]), u = x.useCallback((b) => {
+    const y = e.getItemMeta(b).parentId ?? Z;
+    return n.items.itemChildrenIndexes[y][b];
+  }, [e, n.items.itemChildrenIndexes]), l = x.useCallback((b) => n.items.itemOrderedChildrenIds[b ?? Z] ?? [], [n.items.itemOrderedChildrenIds]), a = (b) => {
+    const y = e.getItemMeta(b);
+    return y == null ? null : document.getElementById(e.getTreeItemIdAttribute(b, y.idAttribute));
+  }, m = (b) => t.disabledItemsFocusable ? !0 : !e.isItemDisabled(b), I = x.useRef(!1), h = x.useCallback(() => {
+    I.current = !0;
+  }, []), f = x.useCallback(() => I.current, []);
+  return x.useEffect(() => {
+    e.areItemUpdatesPrevented() || o((b) => {
+      const y = Et({
+        items: t.items,
+        isItemDisabled: t.isItemDisabled,
+        getItemId: t.getItemId,
+        getItemLabel: t.getItemLabel
+      });
+      return Object.values(b.items.itemMetaMap).forEach((C) => {
+        y.itemMetaMap[C.id] || yt(e, "removeItem", {
+          id: C.id
+        });
+      }), E({}, b, {
+        items: y
+      });
+    });
+  }, [e, o, t.items, t.isItemDisabled, t.getItemId, t.getItemLabel]), {
+    getRootProps: () => ({
+      style: {
+        "--TreeView-itemChildrenIndentation": typeof t.itemChildrenIndentation == "number" ? `${t.itemChildrenIndentation}px` : t.itemChildrenIndentation
+      }
+    }),
+    publicAPI: {
+      getItem: c,
+      getItemDOMElement: a,
+      getItemTree: i,
+      getItemOrderedChildrenIds: l
+    },
+    instance: {
+      getItemMeta: d,
+      getItem: c,
+      getItemTree: i,
+      getItemsToRender: () => {
+        const b = (y) => {
+          var O;
+          const C = n.items.itemMetaMap[y];
+          return {
+            label: C.label,
+            itemId: C.id,
+            id: C.idAttribute,
+            children: (O = n.items.itemOrderedChildrenIds[y]) == null ? void 0 : O.map(b)
+          };
+        };
+        return n.items.itemOrderedChildrenIds[Z].map(b);
+      },
+      getItemIndex: u,
+      getItemDOMElement: a,
+      getItemOrderedChildrenIds: l,
+      isItemDisabled: p,
+      isItemNavigable: m,
+      preventItemUpdates: h,
+      areItemUpdatesPrevented: f
+    },
+    contextValue: {
+      items: {
+        onItemClick: t.onItemClick,
+        disabledItemsFocusable: t.disabledItemsFocusable,
+        indentationAtItemLevel: s.indentationAtItemLevel ?? !1
+      }
+    }
+  };
+};
+he.getInitialState = (e) => ({
+  items: Et({
+    items: e.items,
+    isItemDisabled: e.isItemDisabled,
+    getItemId: e.getItemId,
+    getItemLabel: e.getItemLabel
+  })
+});
+he.getDefaultizedParams = (e) => E({}, e, {
+  disabledItemsFocusable: e.disabledItemsFocusable ?? !1,
+  itemChildrenIndentation: e.itemChildrenIndentation ?? "12px"
+});
+he.wrapRoot = ({
+  children: e,
+  instance: t
+}) => /* @__PURE__ */ w(se.Provider, {
+  value: (n) => {
+    var o;
+    return ((o = t.getItemMeta(n)) == null ? void 0 : o.depth) ?? 0;
+  },
+  children: e
+});
+he.params = {
+  disabledItemsFocusable: !0,
+  items: !0,
+  isItemDisabled: !0,
+  getItemLabel: !0,
+  getItemId: !0,
+  onItemClick: !0,
+  itemChildrenIndentation: !0
+};
+const Se = ({
+  instance: e,
+  params: t,
+  models: n
+}) => {
+  const o = x.useMemo(() => {
+    const a = /* @__PURE__ */ new Map();
+    return n.expandedItems.value.forEach((m) => {
+      a.set(m, !0);
+    }), a;
+  }, [n.expandedItems.value]), s = (a, m) => {
+    var I;
+    (I = t.onExpandedItemsChange) == null || I.call(t, a, m), n.expandedItems.setControlledValue(m);
+  }, d = x.useCallback((a) => o.has(a), [o]), c = x.useCallback((a) => {
+    var m;
+    return !!((m = e.getItemMeta(a)) != null && m.expandable);
+  }, [e]), i = G((a, m) => {
+    const I = e.isItemExpanded(m);
+    e.setItemExpansion(a, m, !I);
+  }), p = G((a, m, I) => {
+    if (e.isItemExpanded(m) === I)
+      return;
+    let f;
+    I ? f = [m].concat(n.expandedItems.value) : f = n.expandedItems.value.filter((g) => g !== m), t.onItemExpansionToggle && t.onItemExpansionToggle(a, m, I), s(a, f);
+  }), u = (a, m) => {
+    const I = e.getItemMeta(m), f = e.getItemOrderedChildrenIds(I.parentId).filter((b) => e.isItemExpandable(b) && !e.isItemExpanded(b)), g = n.expandedItems.value.concat(f);
+    f.length > 0 && (t.onItemExpansionToggle && f.forEach((b) => {
+      t.onItemExpansionToggle(a, b, !0);
+    }), s(a, g));
+  }, l = x.useMemo(() => t.expansionTrigger ? t.expansionTrigger : e.isTreeViewEditable ? "iconContainer" : "content", [t.expansionTrigger, e.isTreeViewEditable]);
+  return {
+    publicAPI: {
+      setItemExpansion: p
+    },
+    instance: {
+      isItemExpanded: d,
+      isItemExpandable: c,
+      setItemExpansion: p,
+      toggleItemExpansion: i,
+      expandAllSiblings: u
+    },
+    contextValue: {
+      expansion: {
+        expansionTrigger: l
+      }
+    }
+  };
+};
+Se.models = {
+  expandedItems: {
+    getDefaultValue: (e) => e.defaultExpandedItems
+  }
+};
+const io = [];
+Se.getDefaultizedParams = (e) => E({}, e, {
+  defaultExpandedItems: e.defaultExpandedItems ?? io
+});
+Se.params = {
+  expandedItems: !0,
+  defaultExpandedItems: !0,
+  onExpandedItemsChange: !0,
+  onItemExpansionToggle: !0,
+  expansionTrigger: !0
+};
+const Ct = (e, t) => {
+  let n = t.length - 1;
+  for (; n >= 0 && !e.isItemNavigable(t[n]); )
+    n -= 1;
+  if (n !== -1)
+    return t[n];
+}, Tt = (e, t) => {
+  const n = e.getItemMeta(t), o = e.getItemOrderedChildrenIds(n.parentId), s = e.getItemIndex(t);
+  if (s === 0)
+    return n.parentId;
+  let d = s - 1;
+  for (; !e.isItemNavigable(o[d]) && d >= 0; )
+    d -= 1;
+  if (d === -1)
+    return n.parentId == null ? null : Tt(e, n.parentId);
+  let c = o[d], i = Ct(e, e.getItemOrderedChildrenIds(c));
+  for (; e.isItemExpanded(c) && i != null; )
+    c = i, i = e.getItemOrderedChildrenIds(c).find(e.isItemNavigable);
+  return c;
+}, Ce = (e, t) => {
+  if (e.isItemExpanded(t)) {
+    const o = e.getItemOrderedChildrenIds(t).find(e.isItemNavigable);
+    if (o != null)
+      return o;
+  }
+  let n = e.getItemMeta(t);
+  for (; n != null; ) {
+    const o = e.getItemOrderedChildrenIds(n.parentId), s = e.getItemIndex(n.id);
+    if (s < o.length - 1) {
+      let d = s + 1;
+      for (; !e.isItemNavigable(o[d]) && d < o.length - 1; )
+        d += 1;
+      if (e.isItemNavigable(o[d]))
+        return o[d];
+    }
+    n = e.getItemMeta(n.parentId);
+  }
+  return null;
+}, wt = (e) => {
+  let t = null;
+  for (; t == null || e.isItemExpanded(t); ) {
+    const n = e.getItemOrderedChildrenIds(t), o = Ct(e, n);
+    if (o == null)
+      return t;
+    t = o;
+  }
+  return t;
+}, pe = (e) => e.getItemOrderedChildrenIds(null).find(e.isItemNavigable), vt = (e, t, n) => {
+  if (t === n)
+    return [t, n];
+  const o = e.getItemMeta(t), s = e.getItemMeta(n);
+  if (o.parentId === s.id || s.parentId === o.id)
+    return s.parentId === o.id ? [o.id, s.id] : [s.id, o.id];
+  const d = [o.id], c = [s.id];
+  let i = o.parentId, p = s.parentId, u = c.indexOf(i) !== -1, l = d.indexOf(p) !== -1, a = !0, m = !0;
+  for (; !l && !u; )
+    a && (d.push(i), u = c.indexOf(i) !== -1, a = i !== null, !u && a && (i = e.getItemMeta(i).parentId)), m && !u && (c.push(p), l = d.indexOf(p) !== -1, m = p !== null, !l && m && (p = e.getItemMeta(p).parentId));
+  const I = u ? i : p, h = e.getItemOrderedChildrenIds(I), f = d[d.indexOf(I) - 1], g = c[c.indexOf(I) - 1];
+  return h.indexOf(f) < h.indexOf(g) ? [t, n] : [n, t];
+}, so = (e, t, n) => {
+  const o = (p) => {
+    if (e.isItemExpandable(p) && e.isItemExpanded(p))
+      return e.getItemOrderedChildrenIds(p)[0];
+    let u = e.getItemMeta(p);
+    for (; u != null; ) {
+      const l = e.getItemOrderedChildrenIds(u.parentId), a = e.getItemIndex(u.id);
+      if (a < l.length - 1)
+        return l[a + 1];
+      u = e.getItemMeta(u.parentId);
+    }
+    throw new Error("Invalid range");
+  }, [s, d] = vt(e, t, n), c = [s];
+  let i = s;
+  for (; i !== d; )
+    i = o(i), e.isItemDisabled(i) || c.push(i);
+  return c;
+}, lo = (e) => {
+  let t = pe(e);
+  const n = [];
+  for (; t != null; )
+    n.push(t), t = Ce(e, t);
+  return n;
+}, Ne = (e, t) => t !== e.closest('*[role="treeitem"]'), Te = (e) => Array.isArray(e) ? e : e != null ? [e] : [], Fe = (e) => {
+  const t = {};
+  return e.forEach((n) => {
+    t[n] = !0;
+  }), t;
+}, Re = ({
+  instance: e,
+  params: t,
+  models: n
+}) => {
+  const o = x.useRef(null), s = x.useRef({}), d = x.useMemo(() => {
+    const f = /* @__PURE__ */ new Map();
+    return Array.isArray(n.selectedItems.value) ? n.selectedItems.value.forEach((g) => {
+      f.set(g, !0);
+    }) : n.selectedItems.value != null && f.set(n.selectedItems.value, !0), f;
+  }, [n.selectedItems.value]), c = (f, g) => {
+    if (t.onItemSelectionToggle)
+      if (t.multiSelect) {
+        const b = g.filter((C) => !e.isItemSelected(C)), y = n.selectedItems.value.filter((C) => !g.includes(C));
+        b.forEach((C) => {
+          t.onItemSelectionToggle(f, C, !0);
+        }), y.forEach((C) => {
+          t.onItemSelectionToggle(f, C, !1);
+        });
+      } else g !== n.selectedItems.value && (n.selectedItems.value != null && t.onItemSelectionToggle(f, n.selectedItems.value, !1), g != null && t.onItemSelectionToggle(f, g, !0));
+    t.onSelectedItemsChange && t.onSelectedItemsChange(f, g), n.selectedItems.setControlledValue(g);
+  }, i = (f) => d.has(f), p = ({
+    event: f,
+    itemId: g,
+    keepExistingSelection: b = !1,
+    shouldBeSelected: y
+  }) => {
+    if (t.disableSelection)
+      return;
+    let C;
+    if (b) {
+      const O = Te(n.selectedItems.value), T = e.isItemSelected(g);
+      T && (y === !1 || y == null) ? C = O.filter((v) => v !== g) : !T && (y === !0 || y == null) ? C = [g].concat(O) : C = O;
+    } else
+      y === !1 || y == null && e.isItemSelected(g) ? C = t.multiSelect ? [] : null : C = t.multiSelect ? [g] : g;
+    c(f, C), o.current = g, s.current = {};
+  }, u = (f, [g, b]) => {
+    if (t.disableSelection || !t.multiSelect)
+      return;
+    let y = Te(n.selectedItems.value).slice();
+    Object.keys(s.current).length > 0 && (y = y.filter((v) => !s.current[v]));
+    const C = Fe(y), O = so(e, g, b), T = O.filter((v) => !C[v]);
+    y = y.concat(T), c(f, y), s.current = Fe(O);
+  };
+  return {
+    getRootProps: () => ({
+      "aria-multiselectable": t.multiSelect
+    }),
+    publicAPI: {
+      selectItem: p
+    },
+    instance: {
+      isItemSelected: i,
+      selectItem: p,
+      selectAllNavigableItems: (f) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        const g = lo(e);
+        c(f, g), s.current = Fe(g);
+      },
+      expandSelectionRange: (f, g) => {
+        if (o.current != null) {
+          const [b, y] = vt(e, g, o.current);
+          u(f, [b, y]);
+        }
+      },
+      selectRangeFromStartToItem: (f, g) => {
+        u(f, [pe(e), g]);
+      },
+      selectRangeFromItemToEnd: (f, g) => {
+        u(f, [g, wt(e)]);
+      },
+      selectItemFromArrowNavigation: (f, g, b) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        let y = Te(n.selectedItems.value).slice();
+        Object.keys(s.current).length === 0 ? (y.push(b), s.current = {
+          [g]: !0,
+          [b]: !0
+        }) : (s.current[g] || (s.current = {}), s.current[b] ? (y = y.filter((C) => C !== g), delete s.current[g]) : (y.push(b), s.current[b] = !0)), c(f, y);
+      }
+    },
+    contextValue: {
+      selection: {
+        multiSelect: t.multiSelect,
+        checkboxSelection: t.checkboxSelection,
+        disableSelection: t.disableSelection
+      }
+    }
+  };
+};
+Re.models = {
+  selectedItems: {
+    getDefaultValue: (e) => e.defaultSelectedItems
+  }
+};
+const ao = [];
+Re.getDefaultizedParams = (e) => E({}, e, {
+  disableSelection: e.disableSelection ?? !1,
+  multiSelect: e.multiSelect ?? !1,
+  checkboxSelection: e.checkboxSelection ?? !1,
+  defaultSelectedItems: e.defaultSelectedItems ?? (e.multiSelect ? ao : null)
+});
+Re.params = {
+  disableSelection: !0,
+  multiSelect: !0,
+  checkboxSelection: !0,
+  defaultSelectedItems: !0,
+  selectedItems: !0,
+  onSelectedItemsChange: !0,
+  onItemSelectionToggle: !0
+};
+const it = 1e3;
+class co {
+  constructor(t = it) {
+    this.timeouts = /* @__PURE__ */ new Map(), this.cleanupTimeout = it, this.cleanupTimeout = t;
+  }
+  register(t, n, o) {
+    this.timeouts || (this.timeouts = /* @__PURE__ */ new Map());
+    const s = setTimeout(() => {
+      typeof n == "function" && n(), this.timeouts.delete(o.cleanupToken);
+    }, this.cleanupTimeout);
+    this.timeouts.set(o.cleanupToken, s);
+  }
+  unregister(t) {
+    const n = this.timeouts.get(t.cleanupToken);
+    n && (this.timeouts.delete(t.cleanupToken), clearTimeout(n));
+  }
+  reset() {
+    this.timeouts && (this.timeouts.forEach((t, n) => {
+      this.unregister({
+        cleanupToken: n
+      });
+    }), this.timeouts = void 0);
+  }
+}
+class uo {
+  constructor() {
+    this.registry = new FinalizationRegistry((t) => {
+      typeof t == "function" && t();
+    });
+  }
+  register(t, n, o) {
+    this.registry.register(t, n, o);
+  }
+  unregister(t) {
+    this.registry.unregister(t);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  reset() {
+  }
+}
+class po {
+}
+function fo(e) {
+  let t = 0;
+  return function(o, s, d) {
+    e.registry === null && (e.registry = typeof FinalizationRegistry < "u" ? new uo() : new co());
+    const [c] = x.useState(new po()), i = x.useRef(null), p = x.useRef();
+    p.current = d;
+    const u = x.useRef(null);
+    if (!i.current && p.current) {
+      const l = (a, m) => {
+        var I;
+        m.defaultMuiPrevented || (I = p.current) == null || I.call(p, a, m);
+      };
+      i.current = o.$$subscribeEvent(s, l), t += 1, u.current = {
+        cleanupToken: t
+      }, e.registry.register(
+        c,
+        // The callback below will be called once this reference stops being retained
+        () => {
+          var a;
+          (a = i.current) == null || a.call(i), i.current = null, u.current = null;
+        },
+        u.current
+      );
+    } else !p.current && i.current && (i.current(), i.current = null, u.current && (e.registry.unregister(u.current), u.current = null));
+    x.useEffect(() => {
+      if (!i.current && p.current) {
+        const l = (a, m) => {
+          var I;
+          m.defaultMuiPrevented || (I = p.current) == null || I.call(p, a, m);
+        };
+        i.current = o.$$subscribeEvent(s, l);
+      }
+      return u.current && e.registry && (e.registry.unregister(u.current), u.current = null), () => {
+        var l;
+        (l = i.current) == null || l.call(i), i.current = null;
+      };
+    }, [o, s]);
+  };
+}
+const mo = {
+  registry: null
+}, Io = fo(mo), Mt = (e = document) => {
+  const t = e.activeElement;
+  return t ? t.shadowRoot ? Mt(t.shadowRoot) : t : null;
+};
+function go(e) {
+  return e.replace(/["\\]/g, "\\$&");
+}
+const ho = (e, t) => {
+  let n = Te(t).find((o) => {
+    if (!e.isItemNavigable(o))
+      return !1;
+    const s = e.getItemMeta(o);
+    return s && (s.parentId == null || e.isItemExpanded(s.parentId));
+  });
+  return n == null && (n = pe(e)), n;
+}, Ue = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: o,
+  models: s,
+  rootRef: d
+}) => {
+  const c = ho(e, s.selectedItems.value), i = G((g) => {
+    const b = typeof g == "function" ? g(n.focusedItemId) : g;
+    n.focusedItemId !== b && o((y) => E({}, y, {
+      focusedItemId: b
+    }));
+  }), p = x.useCallback(() => !!d.current && d.current.contains(Mt(pn(d.current))), [d]), u = x.useCallback((g) => n.focusedItemId === g && p(), [n.focusedItemId, p]), l = (g) => {
+    const b = e.getItemMeta(g);
+    return b && (b.parentId == null || e.isItemExpanded(b.parentId));
+  }, a = (g, b) => {
+    const y = e.getItemDOMElement(b);
+    y && y.focus(), i(b), t.onItemFocus && t.onItemFocus(g, b);
+  }, m = G((g, b) => {
+    l(b) && a(g, b);
+  }), I = G(() => {
+    if (n.focusedItemId == null)
+      return;
+    const g = e.getItemMeta(n.focusedItemId);
+    if (g) {
+      const b = document.getElementById(e.getTreeItemIdAttribute(n.focusedItemId, g.idAttribute));
+      b && b.blur();
+    }
+    i(null);
+  }), h = (g) => g === c;
+  Io(e, "removeItem", ({
+    id: g
+  }) => {
+    n.focusedItemId === g && a(null, c);
+  });
+  const f = (g) => (b) => {
+    var y;
+    (y = g.onFocus) == null || y.call(g, b), !b.defaultMuiPrevented && b.target === b.currentTarget && a(b, c);
+  };
+  return {
+    getRootProps: (g) => ({
+      onFocus: f(g)
+    }),
+    publicAPI: {
+      focusItem: m
+    },
+    instance: {
+      isItemFocused: u,
+      canItemBeTabbed: h,
+      focusItem: m,
+      removeFocusedItem: I
+    }
+  };
+};
+Ue.getInitialState = () => ({
+  focusedItemId: null
+});
+Ue.params = {
+  onItemFocus: !0
+};
+const we = (e, t) => e.getAvailablePlugins().has(t), bo = ({
+  props: e
+}) => {
+  const {
+    instance: t
+  } = le(), {
+    label: n,
+    itemId: o
+  } = e, [s, d] = x.useState(n), c = t.isItemBeingEdited(o);
+  return x.useEffect(() => {
+    c || d(n);
+  }, [c, n]), {
+    propsEnhancers: {
+      labelInput: ({
+        externalEventHandlers: i,
+        interactions: p
+      }) => t.isItemEditable(o) ? {
+        value: s ?? "",
+        "data-element": "labelInput",
+        onChange: (I) => {
+          var h;
+          (h = i.onChange) == null || h.call(i, I), d(I.target.value);
+        },
+        onKeyDown: (I) => {
+          var f;
+          if ((f = i.onKeyDown) == null || f.call(i, I), I.defaultMuiPrevented)
+            return;
+          const h = I.target;
+          I.key === "Enter" && h.value ? p.handleSaveItemLabel(I, h.value) : I.key === "Escape" && p.handleCancelItemLabelEditing(I);
+        },
+        onBlur: (I) => {
+          var h;
+          (h = i.onBlur) == null || h.call(i, I), !I.defaultMuiPrevented && I.target.value && p.handleSaveItemLabel(I, I.target.value);
+        },
+        autoFocus: !0,
+        type: "text"
+      } : {}
+    }
+  };
+}, ee = ({
+  instance: e,
+  state: t,
+  setState: n,
+  params: o,
+  experimentalFeatures: s
+}) => {
+  process.env.NODE_ENV !== "production" && o.isItemEditable && !(s != null && s.labelEditing) && It(["MUI X: The label editing feature requires the `labelEditing` experimental feature to be enabled.", "You can do it by passing `experimentalFeatures={{ labelEditing: true}}` to the `RichTreeViewPro` component.", "Check the documentation for more details: https://mui.com/x/react-tree-view/rich-tree-view/editing/"]);
+  const d = x.useRef(t.editedItemId), c = (m) => d.current === m, i = (m) => {
+    n((I) => E({}, I, {
+      editedItemId: m
+    })), d.current = m;
+  }, p = (m) => m === t.editedItemId, u = !!o.isItemEditable && !!s.labelEditing, l = (m) => {
+    if (m == null || !u)
+      return !1;
+    const I = e.getItem(m);
+    return I ? typeof o.isItemEditable == "function" ? o.isItemEditable(I) : !!o.isItemEditable : !1;
+  }, a = (m, I) => {
+    if (!I)
+      throw new Error(["MUI X: The Tree View component requires all items to have a `label` property.", "The label of an item cannot be empty.", m].join(`
+`));
+    n((h) => {
+      const f = h.items.itemMetaMap[m];
+      return f.label !== I ? E({}, h, {
+        items: E({}, h.items, {
+          itemMetaMap: E({}, h.items.itemMetaMap, {
+            [m]: E({}, f, {
+              label: I
+            })
+          })
+        })
+      }) : h;
+    }), o.onItemLabelChange && o.onItemLabelChange(m, I);
+  };
+  return {
+    instance: {
+      setEditedItemId: i,
+      isItemBeingEdited: p,
+      updateItemLabel: a,
+      isItemEditable: l,
+      isTreeViewEditable: u,
+      isItemBeingEditedRef: c
+    },
+    publicAPI: {
+      updateItemLabel: a
+    }
+  };
+};
+ee.itemPlugin = bo;
+ee.getInitialState = () => ({
+  editedItemId: null
+});
+ee.params = {
+  onItemLabelChange: !0,
+  isItemEditable: !0
+};
+function yo(e) {
+  return !!e && e.length === 1 && !!e.match(/\S/);
+}
+const St = ({
+  instance: e,
+  params: t,
+  state: n
+}) => {
+  const o = fn(), s = x.useRef({}), d = G((l) => {
+    s.current = l(s.current);
+  });
+  x.useEffect(() => {
+    if (e.areItemUpdatesPrevented())
+      return;
+    const l = {}, a = (m) => {
+      l[m.id] = m.label.substring(0, 1).toLowerCase();
+    };
+    Object.values(n.items.itemMetaMap).forEach(a), s.current = l;
+  }, [n.items.itemMetaMap, t.getItemId, e]);
+  const c = (l, a) => {
+    const m = a.toLowerCase(), I = (b) => {
+      const y = Ce(e, b);
+      return y === null ? pe(e) : y;
+    };
+    let h = null, f = I(l);
+    const g = {};
+    for (; h == null && !g[f]; )
+      s.current[f] === m ? h = f : (g[f] = !0, f = I(f));
+    return h;
+  }, i = (l) => !t.disableSelection && !e.isItemDisabled(l), p = (l) => !e.isItemDisabled(l) && e.isItemExpandable(l);
+  return {
+    instance: {
+      updateFirstCharMap: d,
+      handleItemKeyDown: (l, a) => {
+        if (l.defaultMuiPrevented || l.altKey || Ne(l.target, l.currentTarget))
+          return;
+        const m = l.ctrlKey || l.metaKey, I = l.key;
+        switch (!0) {
+          case (I === " " && i(a)): {
+            l.preventDefault(), t.multiSelect && l.shiftKey ? e.expandSelectionRange(l, a) : e.selectItem({
+              event: l,
+              itemId: a,
+              keepExistingSelection: t.multiSelect,
+              shouldBeSelected: t.multiSelect ? void 0 : !0
+            });
+            break;
+          }
+          case I === "Enter": {
+            we(e, ee) && e.isItemEditable(a) && !e.isItemBeingEdited(a) ? e.setEditedItemId(a) : p(a) ? (e.toggleItemExpansion(l, a), l.preventDefault()) : i(a) && (t.multiSelect ? (l.preventDefault(), e.selectItem({
+              event: l,
+              itemId: a,
+              keepExistingSelection: !0
+            })) : e.isItemSelected(a) || (e.selectItem({
+              event: l,
+              itemId: a
+            }), l.preventDefault()));
+            break;
+          }
+          case I === "ArrowDown": {
+            const h = Ce(e, a);
+            h && (l.preventDefault(), e.focusItem(l, h), t.multiSelect && l.shiftKey && i(h) && e.selectItemFromArrowNavigation(l, a, h));
+            break;
+          }
+          case I === "ArrowUp": {
+            const h = Tt(e, a);
+            h && (l.preventDefault(), e.focusItem(l, h), t.multiSelect && l.shiftKey && i(h) && e.selectItemFromArrowNavigation(l, a, h));
+            break;
+          }
+          case (I === "ArrowRight" && !o || I === "ArrowLeft" && o): {
+            if (e.isItemExpanded(a)) {
+              const h = Ce(e, a);
+              h && (e.focusItem(l, h), l.preventDefault());
+            } else p(a) && (e.toggleItemExpansion(l, a), l.preventDefault());
+            break;
+          }
+          case (I === "ArrowLeft" && !o || I === "ArrowRight" && o): {
+            if (p(a) && e.isItemExpanded(a))
+              e.toggleItemExpansion(l, a), l.preventDefault();
+            else {
+              const h = e.getItemMeta(a).parentId;
+              h && (e.focusItem(l, h), l.preventDefault());
+            }
+            break;
+          }
+          case I === "Home": {
+            i(a) && t.multiSelect && m && l.shiftKey ? e.selectRangeFromStartToItem(l, a) : e.focusItem(l, pe(e)), l.preventDefault();
+            break;
+          }
+          case I === "End": {
+            i(a) && t.multiSelect && m && l.shiftKey ? e.selectRangeFromItemToEnd(l, a) : e.focusItem(l, wt(e)), l.preventDefault();
+            break;
+          }
+          case I === "*": {
+            e.expandAllSiblings(l, a), l.preventDefault();
+            break;
+          }
+          case (I === "a" && m && t.multiSelect && !t.disableSelection): {
+            e.selectAllNavigableItems(l), l.preventDefault();
+            break;
+          }
+          case (!m && !l.shiftKey && yo(I)): {
+            const h = c(a, I);
+            h != null && (e.focusItem(l, h), l.preventDefault());
+            break;
+          }
+        }
+      }
+    }
+  };
+};
+St.params = {};
+const Rt = ({
+  slots: e,
+  slotProps: t
+}) => ({
+  contextValue: {
+    icons: {
+      slots: {
+        collapseIcon: e.collapseIcon,
+        expandIcon: e.expandIcon,
+        endIcon: e.endIcon
+      },
+      slotProps: {
+        collapseIcon: t.collapseIcon,
+        expandIcon: t.expandIcon,
+        endIcon: t.endIcon
+      }
+    }
+  }
+});
+Rt.params = {};
+const Ke = /* @__PURE__ */ x.createContext(null);
+process.env.NODE_ENV !== "production" && (Ke.displayName = "TreeViewChildrenItemContext");
+function qe(e) {
+  const {
+    children: t,
+    itemId: n = null
+  } = e, {
+    instance: o,
+    rootRef: s
+  } = le(), d = x.useRef(/* @__PURE__ */ new Map());
+  x.useEffect(() => {
+    if (!s.current)
+      return;
+    let i = null;
+    if (n == null)
+      i = s.current.id;
+    else {
+      const I = o.getItemMeta(n);
+      I !== void 0 && (i = o.getTreeItemIdAttribute(n, I.idAttribute));
+    }
+    if (i == null)
+      return;
+    const p = o.getItemOrderedChildrenIds(n ?? null) ?? [], u = go(i), l = s.current.querySelectorAll(`${n == null ? "" : `*[id="${u}"] `}[role="treeitem"]:not(*[id="${u}"] [role="treeitem"] [role="treeitem"])`), a = Array.from(l).map((I) => d.current.get(I.id));
+    (a.length !== p.length || a.some((I, h) => I !== p[h])) && o.setJSXItemsOrderedChildrenIds(n ?? null, a);
+  });
+  const c = x.useMemo(() => ({
+    registerChild: (i, p) => d.current.set(i, p),
+    unregisterChild: (i) => d.current.delete(i),
+    parentId: n
+  }), [n]);
+  return /* @__PURE__ */ w(Ke.Provider, {
+    value: c,
+    children: t
+  });
+}
+process.env.NODE_ENV !== "production" && (qe.propTypes = {
+  children: r.node,
+  id: r.string
+});
+const be = ({
+  instance: e,
+  setState: t
+}) => {
+  e.preventItemUpdates();
+  const n = G((d) => (t((c) => {
+    if (c.items.itemMetaMap[d.id] != null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", `Two items were provided with the same id in the \`items\` prop: "${d.id}"`].join(`
+`));
+    return E({}, c, {
+      items: E({}, c.items, {
+        itemMetaMap: E({}, c.items.itemMetaMap, {
+          [d.id]: d
+        }),
+        // For `SimpleTreeView`, we don't have a proper `item` object, so we create a very basic one.
+        itemMap: E({}, c.items.itemMap, {
+          [d.id]: {
+            id: d.id,
+            label: d.label
+          }
+        })
+      })
+    });
+  }), () => {
+    t((c) => {
+      const i = E({}, c.items.itemMetaMap), p = E({}, c.items.itemMap);
+      return delete i[d.id], delete p[d.id], E({}, c, {
+        items: E({}, c.items, {
+          itemMetaMap: i,
+          itemMap: p
+        })
+      });
+    }), yt(e, "removeItem", {
+      id: d.id
+    });
+  })), o = (d, c) => {
+    const i = d ?? Z;
+    t((p) => E({}, p, {
+      items: E({}, p.items, {
+        itemOrderedChildrenIds: E({}, p.items.itemOrderedChildrenIds, {
+          [i]: c
+        }),
+        itemChildrenIndexes: E({}, p.items.itemChildrenIndexes, {
+          [i]: xt(c)
+        })
+      })
+    }));
+  }, s = G((d, c) => (e.updateFirstCharMap((i) => (i[d] = c, i)), () => {
+    e.updateFirstCharMap((i) => {
+      const p = E({}, i);
+      return delete p[d], p;
+    });
+  }));
+  return {
+    instance: {
+      insertJSXItem: n,
+      setJSXItemsOrderedChildrenIds: o,
+      mapFirstCharFromJSX: s
+    }
+  };
+}, Ot = (e) => Array.isArray(e) ? e.length > 0 && e.some(Ot) : !!e, xo = ({
+  props: e,
+  rootRef: t,
+  contentRef: n
+}) => {
+  const {
+    instance: o
+  } = le(), {
+    children: s,
+    disabled: d = !1,
+    label: c,
+    itemId: i,
+    id: p
+  } = e, u = x.useContext(Ke);
+  if (u == null)
+    throw new Error(["MUI X: Could not find the Tree View Children Item context.", "It looks like you rendered your component outside of a SimpleTreeView parent component.", "This can also happen if you are bundling multiple versions of the Tree View."].join(`
+`));
+  const {
+    registerChild: l,
+    unregisterChild: a,
+    parentId: m
+  } = u, I = Ot(s), h = x.useRef(null), f = de(h, n);
+  return mn(() => {
+    const g = o.getTreeItemIdAttribute(i, p);
+    return l(g, i), () => {
+      a(g);
+    };
+  }, [o, l, a, i, p]), x.useEffect(() => o.insertJSXItem({
+    id: i,
+    idAttribute: p,
+    parentId: m,
+    expandable: I,
+    disabled: d
+  }), [o, m, i, I, d, p]), x.useEffect(() => {
+    var g;
+    if (c)
+      return o.mapFirstCharFromJSX(i, (((g = h.current) == null ? void 0 : g.textContent) ?? "").substring(0, 1).toLowerCase());
+  }, [o, i, c]), {
+    contentRef: f,
+    rootRef: t
+  };
+};
+be.itemPlugin = xo;
+be.wrapItem = ({
+  children: e,
+  itemId: t
+}) => {
+  const n = x.useContext(se);
+  return /* @__PURE__ */ w(qe, {
+    itemId: t,
+    children: /* @__PURE__ */ w(se.Provider, {
+      value: n + 1,
+      children: e
+    })
+  });
+};
+be.wrapRoot = ({
+  children: e
+}) => /* @__PURE__ */ w(qe, {
+  children: /* @__PURE__ */ w(se.Provider, {
+    value: 0,
+    children: e
+  })
+});
+be.params = {};
+const Eo = [he, Se, Re, Ue, St, Rt, be], Co = mt(), To = (e) => {
+  const {
+    classes: t
+  } = e;
+  return ge({
+    root: ["root"]
+  }, Wn, t);
+}, wo = U("ul", {
+  name: "MuiSimpleTreeView",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  padding: 0,
+  margin: 0,
+  listStyle: "none",
+  outline: 0,
+  position: "relative"
+}), vo = [], kt = /* @__PURE__ */ x.forwardRef(function(t, n) {
+  const o = Co({
+    props: t,
+    name: "MuiSimpleTreeView"
+  }), s = o;
+  process.env.NODE_ENV !== "production" && o.items != null && It(["MUI X: The `SimpleTreeView` component does not support the `items` prop.", "If you want to add items, you need to pass them as JSX children.", "Check the documentation for more details: https://mui.com/x/react-tree-view/simple-tree-view/items/."]);
+  const {
+    getRootProps: d,
+    contextValue: c
+  } = no({
+    plugins: Eo,
+    rootRef: n,
+    props: E({}, o, {
+      items: vo
+    })
+  }), {
+    slots: i,
+    slotProps: p
+  } = o, u = To(o), l = (i == null ? void 0 : i.root) ?? wo, a = ce({
+    elementType: l,
+    externalSlotProps: p == null ? void 0 : p.root,
+    className: u.root,
+    getSlotProps: d,
+    ownerState: s
+  });
+  return /* @__PURE__ */ w(oo, {
+    value: c,
+    children: /* @__PURE__ */ w(l, E({}, a))
+  });
+});
+process.env.NODE_ENV !== "production" && (kt.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The ref object that allows Tree View manipulation. Can be instantiated with `useTreeViewApiRef()`.
+   */
+  apiRef: r.shape({
+    current: r.shape({
+      focusItem: r.func.isRequired,
+      getItem: r.func.isRequired,
+      getItemDOMElement: r.func.isRequired,
+      getItemOrderedChildrenIds: r.func.isRequired,
+      getItemTree: r.func.isRequired,
+      selectItem: r.func.isRequired,
+      setItemExpansion: r.func.isRequired
+    })
+  }),
+  /**
+   * If `true`, the tree view renders a checkbox at the left of its label that allows selecting it.
+   * @default false
+   */
+  checkboxSelection: r.bool,
+  /**
+   * The content of the component.
+   */
+  children: r.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  className: r.string,
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is not controlled.
+   * @default []
+   */
+  defaultExpandedItems: r.arrayOf(r.string),
+  /**
+   * Selected item ids. (Uncontrolled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   * @default []
+   */
+  defaultSelectedItems: r.any,
+  /**
+   * If `true`, will allow focus on disabled items.
+   * @default false
+   */
+  disabledItemsFocusable: r.bool,
+  /**
+   * If `true` selection is disabled.
+   * @default false
+   */
+  disableSelection: r.bool,
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is controlled.
+   */
+  expandedItems: r.arrayOf(r.string),
+  /**
+   * The slot that triggers the item's expansion when clicked.
+   * @default 'content'
+   */
+  expansionTrigger: r.oneOf(["content", "iconContainer"]),
+  /**
+   * Unstable features, breaking changes might be introduced.
+   * For each feature, if the flag is not explicitly set to `true`,
+   * the feature will be fully disabled and any property / method call will not have any effect.
+   */
+  experimentalFeatures: r.shape({
+    indentationAtItemLevel: r.bool
+  }),
+  /**
+   * This prop is used to help implement the accessibility logic.
+   * If you don't provide this prop. It falls back to a randomly generated id.
+   */
+  id: r.string,
+  /**
+   * Horizontal indentation between an item and its children.
+   * Examples: 24, "24px", "2rem", "2em".
+   * @default 12px
+   */
+  itemChildrenIndentation: r.oneOfType([r.number, r.string]),
+  /**
+   * If `true`, `ctrl` and `shift` will trigger multiselect.
+   * @default false
+   */
+  multiSelect: r.bool,
+  /**
+   * Callback fired when tree items are expanded/collapsed.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {array} itemIds The ids of the expanded items.
+   */
+  onExpandedItemsChange: r.func,
+  /**
+   * Callback fired when the `content` slot of a given tree item is clicked.
+   * @param {React.MouseEvent} event The DOM event that triggered the change.
+   * @param {string} itemId The id of the focused item.
+   */
+  onItemClick: r.func,
+  /**
+   * Callback fired when a tree item is expanded or collapsed.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {array} itemId The itemId of the modified item.
+   * @param {array} isExpanded `true` if the item has just been expanded, `false` if it has just been collapsed.
+   */
+  onItemExpansionToggle: r.func,
+  /**
+   * Callback fired when a given tree item is focused.
+   * @param {React.SyntheticEvent | null} event The DOM event that triggered the change. **Warning**: This is a generic event not a focus event.
+   * @param {string} itemId The id of the focused item.
+   */
+  onItemFocus: r.func,
+  /**
+   * Callback fired when a tree item is selected or deselected.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {array} itemId The itemId of the modified item.
+   * @param {array} isSelected `true` if the item has just been selected, `false` if it has just been deselected.
+   */
+  onItemSelectionToggle: r.func,
+  /**
+   * Callback fired when tree items are selected/deselected.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {string[] | string} itemIds The ids of the selected items.
+   * When `multiSelect` is `true`, this is an array of strings; when false (default) a string.
+   */
+  onSelectedItemsChange: r.func,
+  /**
+   * Selected item ids. (Controlled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   */
+  selectedItems: r.any,
+  /**
+   * The props used for each component slot.
+   */
+  slotProps: r.object,
+  /**
+   * Overridable component slots.
+   */
+  slots: r.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object])
+});
+function Pt(e) {
+  const {
+    instance: t,
+    items: {
+      onItemClick: n
+    },
+    selection: {
+      multiSelect: o,
+      checkboxSelection: s,
+      disableSelection: d
+    },
+    expansion: {
+      expansionTrigger: c
+    }
+  } = le(), i = t.isItemExpandable(e), p = t.isItemExpanded(e), u = t.isItemFocused(e), l = t.isItemSelected(e), a = t.isItemDisabled(e), m = t != null && t.isItemBeingEdited ? t == null ? void 0 : t.isItemBeingEdited(e) : !1, I = t.isItemEditable ? t.isItemEditable(e) : !1, h = (T) => {
+    if (!a) {
+      u || t.focusItem(T, e);
+      const v = o && (T.shiftKey || T.ctrlKey || T.metaKey);
+      i && !(v && t.isItemExpanded(e)) && t.toggleItemExpansion(T, e);
+    }
+  }, f = (T) => {
+    a || (u || t.focusItem(T, e), o && (T.shiftKey || T.ctrlKey || T.metaKey) ? T.shiftKey ? t.expandSelectionRange(T, e) : t.selectItem({
+      event: T,
+      itemId: e,
+      keepExistingSelection: !0
+    }) : t.selectItem({
+      event: T,
+      itemId: e,
+      shouldBeSelected: !0
+    }));
+  }, g = (T) => {
+    if (d || a)
+      return;
+    const v = T.nativeEvent.shiftKey;
+    o && v ? t.expandSelectionRange(T, e) : t.selectItem({
+      event: T,
+      itemId: e,
+      keepExistingSelection: o,
+      shouldBeSelected: T.target.checked
+    });
+  }, b = (T) => {
+    (T.shiftKey || T.ctrlKey || T.metaKey || a) && T.preventDefault();
+  }, y = () => {
+    we(t, ee) && t.isItemEditable(e) && (t.isItemBeingEdited(e) ? t.setEditedItemId(null) : t.setEditedItemId(e));
+  };
+  return {
+    disabled: a,
+    expanded: p,
+    selected: l,
+    focused: u,
+    editable: I,
+    editing: m,
+    disableSelection: d,
+    checkboxSelection: s,
+    handleExpansion: h,
+    handleSelection: f,
+    handleCheckboxSelection: g,
+    handleContentClick: n,
+    preventSelection: b,
+    expansionTrigger: c,
+    toggleItemEditing: y,
+    handleSaveItemLabel: (T, v) => {
+      we(t, ee) && t.isItemBeingEditedRef(e) && (t.updateItemLabel(e, v), y(), t.focusItem(T, e));
+    },
+    handleCancelItemLabelEditing: (T) => {
+      we(t, ee) && t.isItemBeingEditedRef(e) && (y(), t.focusItem(T, e));
+    }
+  };
+}
+const Mo = U("div", {
+  name: "MuiTreeItem2DragAndDropOverlay",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root,
+  shouldForwardProp: (e) => In(e) && e !== "action"
+})(({
+  theme: e
+}) => ({
+  position: "absolute",
+  left: 0,
+  display: "flex",
+  top: 0,
+  bottom: 0,
+  right: 0,
+  pointerEvents: "none",
+  variants: [{
+    props: {
+      action: "make-child"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderRadius: e.shape.borderRadius,
+      backgroundColor: X((e.vars || e).palette.primary.dark, 0.15)
+    }
+  }, {
+    props: {
+      action: "reorder-above"
+    },
+    style: E({
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderTop: `1px solid ${X((e.vars || e).palette.grey[900], 0.6)}`
+    }, e.applyStyles("dark", {
+      borderTopColor: X((e.vars || e).palette.grey[100], 0.6)
+    }))
+  }, {
+    props: {
+      action: "reorder-below"
+    },
+    style: E({
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderBottom: `1px solid ${X((e.vars || e).palette.grey[900], 0.6)}`
+    }, e.applyStyles("dark", {
+      borderBottomColor: X((e.vars || e).palette.grey[100], 0.6)
+    }))
+  }, {
+    props: {
+      action: "move-to-parent"
+    },
+    style: E({
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * calc(var(--TreeView-itemDepth) - 1))",
+      borderBottom: `1px solid ${X((e.vars || e).palette.grey[900], 0.6)}`
+    }, e.applyStyles("dark", {
+      borderBottomColor: X((e.vars || e).palette.grey[900], 0.6)
+    }))
+  }]
+}));
+function So(e) {
+  return e.action == null ? null : /* @__PURE__ */ w(Mo, E({}, e));
+}
+const Ro = U("input", {
+  name: "MuiTreeItem2",
+  slot: "LabelInput",
+  overridesResolver: (e, t) => t.labelInput
+})(({
+  theme: e
+}) => E({}, e.typography.body1, {
+  width: "100%",
+  backgroundColor: e.palette.background.paper,
+  borderRadius: e.shape.borderRadius,
+  border: "none",
+  padding: "0 2px",
+  boxSizing: "border-box",
+  "&:focus": {
+    outline: `1px solid ${e.palette.primary.main}`
+  }
+})), Oo = ["classes", "className", "displayIcon", "expansionIcon", "icon", "label", "itemId", "onClick", "onMouseDown", "dragAndDropOverlayProps", "labelInputProps"], Xe = /* @__PURE__ */ x.forwardRef(function(t, n) {
+  const {
+    classes: o,
+    className: s,
+    displayIcon: d,
+    expansionIcon: c,
+    icon: i,
+    label: p,
+    itemId: u,
+    onClick: l,
+    onMouseDown: a,
+    dragAndDropOverlayProps: m,
+    labelInputProps: I
+  } = t, h = Q(t, Oo), {
+    disabled: f,
+    expanded: g,
+    selected: b,
+    focused: y,
+    editing: C,
+    editable: O,
+    disableSelection: T,
+    checkboxSelection: v,
+    handleExpansion: R,
+    handleSelection: B,
+    handleCheckboxSelection: K,
+    handleContentClick: V,
+    preventSelection: A,
+    expansionTrigger: z,
+    toggleItemEditing: j
+  } = Pt(u), q = i || c || d, N = x.useRef(null), H = (k) => {
+    A(k), a && a(k);
+  }, L = (k) => {
+    var P;
+    V == null || V(k, u), !((P = N.current) != null && P.contains(k.target)) && (z === "content" && R(k), v || B(k), l && l(k));
+  }, W = (k) => {
+    k.defaultMuiPrevented || j();
+  };
+  return (
+    /* eslint-disable-next-line jsx-a11y/click-events-have-key-events,jsx-a11y/no-static-element-interactions -- Key event is handled by the TreeView */
+    /* @__PURE__ */ ve("div", E({}, h, {
+      className: Ie(s, o.root, g && o.expanded, b && o.selected, y && o.focused, f && o.disabled, C && o.editing, O && o.editable),
+      onClick: L,
+      onMouseDown: H,
+      ref: n,
+      children: [/* @__PURE__ */ w("div", {
+        className: o.iconContainer,
+        children: q
+      }), v && /* @__PURE__ */ w(ft, {
+        className: o.checkbox,
+        checked: b,
+        onChange: K,
+        disabled: f || T,
+        ref: N,
+        tabIndex: -1
+      }), C ? /* @__PURE__ */ w(Ro, E({}, I, {
+        className: o.labelInput
+      })) : /* @__PURE__ */ w("div", E({
+        className: o.label
+      }, O && {
+        onDoubleClick: W
+      }, {
+        children: p
+      })), m && /* @__PURE__ */ w(So, E({}, m))]
+    }))
+  );
+});
+process.env.NODE_ENV !== "production" && (Xe.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object.isRequired,
+  className: r.string,
+  /**
+   * The icon to display next to the tree item's label. Either a parent or end icon.
+   */
+  displayIcon: r.node,
+  dragAndDropOverlayProps: r.shape({
+    action: r.oneOf(["make-child", "move-to-parent", "reorder-above", "reorder-below"]),
+    style: r.object
+  }),
+  /**
+   * The icon to display next to the tree item's label. Either an expansion or collapse icon.
+   */
+  expansionIcon: r.node,
+  /**
+   * The icon to display next to the tree item's label.
+   */
+  icon: r.node,
+  /**
+   * The id of the item.
+   */
+  itemId: r.string.isRequired,
+  /**
+   * The tree item label.
+   */
+  label: r.node,
+  labelInputProps: r.shape({
+    autoFocus: r.oneOf([!0]),
+    "data-element": r.oneOf(["labelInput"]),
+    onBlur: r.func,
+    onChange: r.func,
+    onKeyDown: r.func,
+    type: r.oneOf(["text"]),
+    value: r.string
+  })
+});
+function ko(e) {
+  return fe("MuiTreeItem", e);
+}
+const J = me("MuiTreeItem", ["root", "groupTransition", "content", "expanded", "selected", "focused", "disabled", "iconContainer", "label", "checkbox", "labelInput", "editable", "editing", "dragAndDropOverlay"]), Po = te(/* @__PURE__ */ w("path", {
+  d: "M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
+}), "TreeViewExpandIcon"), Do = te(/* @__PURE__ */ w("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), "TreeViewCollapseIcon");
+function Dt(e) {
+  const {
+    children: t,
+    itemId: n
+  } = e, {
+    wrapItem: o,
+    instance: s
+  } = le();
+  return o({
+    children: t,
+    itemId: n,
+    instance: s
+  });
+}
+Dt.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  children: r.node,
+  itemId: r.string.isRequired
+};
+const Vo = ["children", "className", "slots", "slotProps", "ContentComponent", "ContentProps", "itemId", "id", "label", "onClick", "onMouseDown", "onFocus", "onBlur", "onKeyDown"], $o = ["ownerState"], Ao = ["ownerState"], Fo = ["ownerState"], No = mt(), Lo = (e) => {
+  const {
+    classes: t
+  } = e;
+  return ge({
+    root: ["root"],
+    content: ["content"],
+    expanded: ["expanded"],
+    selected: ["selected"],
+    focused: ["focused"],
+    disabled: ["disabled"],
+    iconContainer: ["iconContainer"],
+    checkbox: ["checkbox"],
+    label: ["label"],
+    labelInput: ["labelInput"],
+    editing: ["editing"],
+    editable: ["editable"],
+    groupTransition: ["groupTransition"]
+  }, ko, t);
+}, jo = U("li", {
+  name: "MuiTreeItem",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), _o = U(Xe, {
+  name: "MuiTreeItem",
+  slot: "Content",
+  overridesResolver: (e, t) => [t.content, t.iconContainer && {
+    [`& .${J.iconContainer}`]: t.iconContainer
+  }, t.label && {
+    [`& .${J.label}`]: t.label
+  }],
+  shouldForwardProp: (e) => dt(e) && e !== "indentationAtItemLevel"
+})(({
+  theme: e
+}) => ({
+  padding: e.spacing(0.5, 1),
+  borderRadius: e.shape.borderRadius,
+  width: "100%",
+  boxSizing: "border-box",
+  // prevent width + padding to overflow
+  position: "relative",
+  display: "flex",
+  alignItems: "center",
+  gap: e.spacing(1),
+  cursor: "pointer",
+  WebkitTapHighlightColor: "transparent",
+  "&:hover": {
+    backgroundColor: (e.vars || e).palette.action.hover,
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  },
+  [`&.${J.disabled}`]: {
+    opacity: (e.vars || e).palette.action.disabledOpacity,
+    backgroundColor: "transparent"
+  },
+  [`&.${J.focused}`]: {
+    backgroundColor: (e.vars || e).palette.action.focus
+  },
+  [`&.${J.selected}`]: {
+    backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / ${e.vars.palette.action.selectedOpacity})` : X(e.palette.primary.main, e.palette.action.selectedOpacity),
+    "&:hover": {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.hoverOpacity}))` : X(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.hoverOpacity),
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / ${e.vars.palette.action.selectedOpacity})` : X(e.palette.primary.main, e.palette.action.selectedOpacity)
+      }
+    },
+    [`&.${J.focused}`]: {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.focusOpacity}))` : X(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.focusOpacity)
+    }
+  },
+  [`& .${J.iconContainer}`]: {
+    width: 16,
+    display: "flex",
+    flexShrink: 0,
+    justifyContent: "center",
+    "& svg": {
+      fontSize: 18
+    }
+  },
+  [`& .${J.label}`]: E({
+    width: "100%",
+    boxSizing: "border-box",
+    // prevent width + padding to overflow
+    // fixes overflow - see https://github.com/mui/material-ui/issues/27372
+    minWidth: 0,
+    position: "relative"
+  }, e.typography.body1),
+  [`& .${J.checkbox}`]: {
+    padding: 0
+  },
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: `calc(${e.spacing(1)} + var(--TreeView-itemChildrenIndentation) * var(--TreeView-itemDepth))`
+    }
+  }]
+})), Bo = U(Be, {
+  name: "MuiTreeItem",
+  slot: "GroupTransition",
+  overridesResolver: (e, t) => t.groupTransition,
+  shouldForwardProp: (e) => dt(e) && e !== "indentationAtItemLevel"
+})({
+  margin: 0,
+  padding: 0,
+  paddingLeft: "var(--TreeView-itemChildrenIndentation)",
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: 0
+    }
+  }]
+}), Vt = /* @__PURE__ */ x.forwardRef(function(t, n) {
+  var Ge, He, Ye, Qe;
+  const {
+    icons: o,
+    runItemPlugins: s,
+    items: {
+      disabledItemsFocusable: d,
+      indentationAtItemLevel: c
+    },
+    selection: {
+      multiSelect: i
+    },
+    expansion: {
+      expansionTrigger: p
+    },
+    instance: u
+  } = le(), l = x.useContext(se), a = No({
+    props: t,
+    name: "MuiTreeItem"
+  }), {
+    children: m,
+    className: I,
+    slots: h,
+    slotProps: f,
+    ContentComponent: g = Xe,
+    ContentProps: b,
+    itemId: y,
+    id: C,
+    label: O,
+    onClick: T,
+    onMouseDown: v,
+    onBlur: R,
+    onKeyDown: B
+  } = a, K = Q(a, Vo), {
+    expanded: V,
+    focused: A,
+    selected: z,
+    disabled: j,
+    editing: q,
+    handleExpansion: N,
+    handleCancelItemLabelEditing: H,
+    handleSaveItemLabel: L
+  } = Pt(y), {
+    contentRef: W,
+    rootRef: k,
+    propsEnhancers: P
+  } = s(a), ne = x.useRef(null), ye = x.useRef(null), Oe = de(n, k, ne), ke = de(b == null ? void 0 : b.ref, W, ye), oe = {
+    expandIcon: (h == null ? void 0 : h.expandIcon) ?? o.slots.expandIcon ?? Po,
+    collapseIcon: (h == null ? void 0 : h.collapseIcon) ?? o.slots.collapseIcon ?? Do,
+    endIcon: (h == null ? void 0 : h.endIcon) ?? o.slots.endIcon,
+    icon: h == null ? void 0 : h.icon,
+    groupTransition: h == null ? void 0 : h.groupTransition
+  }, M = (S) => Array.isArray(S) ? S.length > 0 && S.some(M) : !!S, F = M(m), _ = E({}, a, {
+    expanded: V,
+    focused: A,
+    selected: z,
+    disabled: j,
+    indentationAtItemLevel: c
+  }), $ = Lo(_), Y = oe.groupTransition ?? void 0, xe = ce({
+    elementType: Y,
+    ownerState: {},
+    externalSlotProps: f == null ? void 0 : f.groupTransition,
+    additionalProps: E({
+      unmountOnExit: !0,
+      in: V,
+      component: "ul",
+      role: "group"
+    }, c ? {
+      indentationAtItemLevel: !0
+    } : {}),
+    className: $.groupTransition
+  }), At = (S) => {
+    p === "iconContainer" && N(S);
+  }, Pe = V ? oe.collapseIcon : oe.expandIcon, Ft = ce({
+    elementType: Pe,
+    ownerState: {},
+    externalSlotProps: (S) => V ? E({}, ie(o.slotProps.collapseIcon, S), ie(f == null ? void 0 : f.collapseIcon, S)) : E({}, ie(o.slotProps.expandIcon, S), ie(f == null ? void 0 : f.expandIcon, S)),
+    additionalProps: {
+      onClick: At
+    }
+  }), Nt = Q(Ft, $o), Lt = F && Pe ? /* @__PURE__ */ w(Pe, E({}, Nt)) : null, De = F ? void 0 : oe.endIcon, jt = ce({
+    elementType: De,
+    ownerState: {},
+    externalSlotProps: (S) => F ? {} : E({}, ie(o.slotProps.endIcon, S), ie(f == null ? void 0 : f.endIcon, S))
+  }), _t = Q(jt, Ao), Bt = De ? /* @__PURE__ */ w(De, E({}, _t)) : null, Ve = oe.icon, zt = ce({
+    elementType: Ve,
+    ownerState: {},
+    externalSlotProps: f == null ? void 0 : f.icon
+  }), Ut = Q(zt, Fo), Kt = Ve ? /* @__PURE__ */ w(Ve, E({}, Ut)) : null;
+  let $e;
+  i ? $e = z : z && ($e = !0);
+  function qt(S) {
+    !A && (!j || d) && S.currentTarget === S.target && u.focusItem(S, y);
+  }
+  function Xt(S) {
+    var re, ae, Ze, et;
+    R == null || R(S), !(q || // we can exit the editing state by clicking outside the input (within the tree item) or by pressing Enter or Escape -> we don't want to remove the focused item from the state in these cases
+    // we can also exit the editing state by clicking on the root itself -> want to remove the focused item from the state in this case
+    S.relatedTarget && Ne(S.relatedTarget, ne.current) && (S.target && ((ae = (re = S.target) == null ? void 0 : re.dataset) == null ? void 0 : ae.element) === "labelInput" && Ne(S.target, ne.current) || ((et = (Ze = S.relatedTarget) == null ? void 0 : Ze.dataset) == null ? void 0 : et.element) === "labelInput")) && u.removeFocusedItem();
+  }
+  const Wt = (S) => {
+    var re, ae;
+    B == null || B(S), ((ae = (re = S.target) == null ? void 0 : re.dataset) == null ? void 0 : ae.element) !== "labelInput" && u.handleItemKeyDown(S, y);
+  }, Jt = u.getTreeItemIdAttribute(y, C), Gt = u.canItemBeTabbed(y) ? 0 : -1, Ee = {
+    rootRefObject: ne,
+    contentRefObject: ye,
+    interactions: {
+      handleSaveItemLabel: L,
+      handleCancelItemLabelEditing: H
+    }
+  }, Ht = ((Ge = P.root) == null ? void 0 : Ge.call(P, E({}, Ee, {
+    externalEventHandlers: ot(K)
+  }))) ?? {}, Yt = ((He = P.content) == null ? void 0 : He.call(P, E({}, Ee, {
+    externalEventHandlers: ot(b)
+  }))) ?? {}, We = ((Ye = P.dragAndDropOverlay) == null ? void 0 : Ye.call(P, E({}, Ee, {
+    externalEventHandlers: {}
+  }))) ?? {}, Je = ((Qe = P.labelInput) == null ? void 0 : Qe.call(P, E({}, Ee, {
+    externalEventHandlers: {}
+  }))) ?? {};
+  return /* @__PURE__ */ w(Dt, {
+    itemId: y,
+    children: /* @__PURE__ */ ve(jo, E({
+      className: Ie($.root, I),
+      role: "treeitem",
+      "aria-expanded": F ? V : void 0,
+      "aria-selected": $e,
+      "aria-disabled": j || void 0,
+      id: Jt,
+      tabIndex: Gt
+    }, K, {
+      ownerState: _,
+      onFocus: qt,
+      onBlur: Xt,
+      onKeyDown: Wt,
+      ref: Oe,
+      style: c ? E({}, K.style, {
+        "--TreeView-itemDepth": typeof l == "function" ? l(y) : l
+      }) : K.style
+    }, Ht, {
+      children: [/* @__PURE__ */ w(_o, E({
+        as: g,
+        classes: {
+          root: $.content,
+          expanded: $.expanded,
+          selected: $.selected,
+          focused: $.focused,
+          disabled: $.disabled,
+          editable: $.editable,
+          editing: $.editing,
+          iconContainer: $.iconContainer,
+          label: $.label,
+          labelInput: $.labelInput,
+          checkbox: $.checkbox
+        },
+        label: O,
+        itemId: y,
+        onClick: T,
+        onMouseDown: v,
+        icon: Kt,
+        expansionIcon: Lt,
+        displayIcon: Bt,
+        ownerState: _
+      }, b, Yt, We.action == null ? {} : {
+        dragAndDropOverlayProps: We
+      }, Je.value == null ? {} : {
+        labelInputProps: Je
+      }, {
+        ref: ke
+      })), m && /* @__PURE__ */ w(Bo, E({
+        as: Y
+      }, xe, {
+        children: m
+      }))]
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (Vt.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: r.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  className: r.string,
+  /**
+   * The component used to render the content of the item.
+   * @default TreeItemContent
+   */
+  ContentComponent: lt,
+  /**
+   * Props applied to ContentComponent.
+   */
+  ContentProps: r.object,
+  /**
+   * If `true`, the item is disabled.
+   * @default false
+   */
+  disabled: r.bool,
+  /**
+   * The id of the item.
+   */
+  itemId: r.string.isRequired,
+  /**
+   * The tree item label.
+   */
+  label: r.node,
+  /**
+   * This prop isn't supported.
+   * Use the `onItemFocus` callback on the tree if you need to monitor a item's focus.
+   */
+  onFocus: gn,
+  /**
+   * Callback fired when a key of the keyboard is pressed on the item.
+   */
+  onKeyDown: r.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: r.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: r.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object])
+});
+const Jo = ({
+  items: e,
+  handleCheck: t,
+  width: n = "250px",
+  height: o = "350px",
+  expanded: s
+}) => /* @__PURE__ */ w(hn, { width: n, height: o, children: /* @__PURE__ */ w(kt, { expandedItems: s, children: $t(e, t) }) }), $t = (e, t) => e.map((n) => /* @__PURE__ */ Qt(zo, { ...n, key: n.id, handleCheck: t })), zo = ({
+  id: e,
+  checked: t,
+  children: n,
+  label: o,
+  handleCheck: s
+}) => /* @__PURE__ */ w(
+  Vt,
+  {
+    itemId: e,
+    label: /* @__PURE__ */ ve(bn, { flexDirection: "row", alignItems: "center", children: [
+      /* @__PURE__ */ w(yn, { children: o }),
+      s && /* @__PURE__ */ w(
+        xn,
+        {
+          disableRipple: !0,
+          sx: { marginLeft: "auto" },
+          onClick: (d) => {
+            d.stopPropagation(), s(e, !t);
+          },
+          "data-testid": `toggle-visibility-${e}`,
+          children: t ? /* @__PURE__ */ w(qn, { "data-testid": `visibility-icon-${e}` }) : /* @__PURE__ */ w(Xn, { "data-testid": `visibility-off-icon-${e}` })
+        }
+      )
+    ] }),
+    children: n.length > 0 && $t(n, s)
+  }
+);
+export {
+  Be as C,
+  ut as F,
+  Jo as T,
+  X as a,
+  Cn as b,
+  Xo as c,
+  Me as d,
+  ft as e,
+  Wo as l,
+  _e as r,
+  On as u
+};