@cgi-learning-hub/ui 1.4.0 → 1.5.0-dev.1743511847

package/dist/components/TreeView/TreeView.es.js

@@ -0,0 +1,1892 @@
+import { jsx as S, jsxs as je } from "react/jsx-runtime";
+import * as E from "react";
+import { useState as yt, useMemo as Ct, useEffect as wt } from "react";
+import { a as Rt, T as St, b as _e, d as $e, e as Ne, f as se, h as Pt, i as vt, j as kt, k as he, l as ge, m as Mt, n as oe, u as H, o as Ke, p as Dt, q as Ot, r as Ue, w as xe, s as Vt, t as At, v as Ft, x as Lt, y as O, C as jt, z as _t } from "../../CustomTreeItem-DhiQBmjt.js";
+import { TreeContainer as $t, DEFAULT_CHILDREN_INDENT as Nt } from "./style.es.js";
+import { buildItemDataMap as Kt, findItemPath as Ut, getItemId as Bt } from "./utils.es.js";
+import { _ as C } from "../../ButtonBase-DYKChljK.js";
+import { H as zt, G as qt, I as Be, P as a, n as ne } from "../../generateUtilityClasses-SJ1QPUag.js";
+import { a as A } from "../../TransitionGroupContext-DbLioz_6.js";
+import { u as U } from "../../useEventCallback-BAQJJ3ye.js";
+import { o as Ht } from "../../ownerDocument-CUrv0DIK.js";
+import { u as Xt } from "../../index-uoOKg_7A.js";
+import { C as Wt } from "../../Checkbox-Vfd8tExZ.js";
+import { u as Ee } from "../../useForkRef-C_4o__cU.js";
+import { u as N } from "../../useSlotProps-Cz_jXqU-.js";
+import { r as $, e as Fe } from "../../resolveComponentProps-BFteOhbz.js";
+import { s as ie, c as ze, f as qe } from "../../DefaultPropsProvider-ZFZfNXyN.js";
+import { u as Gt } from "../../unsupportedProp-BuVD30Gh.js";
+import { e as Jt } from "../../elementTypeAcceptingRef-Cqa8qLE7.js";
+function Yt(e) {
+  return zt("MuiRichTreeView", e);
+}
+qt("MuiRichTreeView", ["root"]);
+const Qt = (e, t) => {
+  const n = E.useRef({}), [r, l] = E.useState(() => {
+    const I = {};
+    return e.forEach((f) => {
+      f.models && Object.entries(f.models).forEach(([g, p]) => {
+        n.current[g] = {
+          isControlled: t[g] !== void 0,
+          getDefaultValue: p.getDefaultValue
+        }, I[g] = p.getDefaultValue(t);
+      });
+    }), I;
+  }), x = Object.fromEntries(Object.entries(n.current).map(([I, f]) => {
+    const g = t[I] ?? r[I];
+    return [I, {
+      value: g,
+      setControlledValue: (p) => {
+        f.isControlled || l((o) => C({}, o, {
+          [I]: p
+        }));
+      }
+    }];
+  }));
+  return process.env.NODE_ENV !== "production" && Object.entries(n.current).forEach(([I, f]) => {
+    const g = t[I], p = f.getDefaultValue(t);
+    E.useEffect(() => {
+      f.isControlled !== (g !== void 0) && console.error([`MUI X: A component is changing the ${f.isControlled ? "" : "un"}controlled ${I} state of TreeView to be ${f.isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${I} 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(`
+`));
+    }, [g]);
+    const {
+      current: o
+    } = E.useRef(p);
+    E.useEffect(() => {
+      !f.isControlled && o !== p && console.error([`MUI X: A component is changing the default ${I} state of an uncontrolled TreeView after being initialized. To suppress this warning opt to use a controlled TreeView.`].join(`
+`));
+    }, [JSON.stringify(p)]);
+  }), x;
+};
+class Zt {
+  constructor() {
+    this.maxListeners = 20, this.warnOnce = !1, this.events = {};
+  }
+  on(t, n, r = {}) {
+    let l = this.events[t];
+    if (l || (l = {
+      highPriority: /* @__PURE__ */ new Map(),
+      regular: /* @__PURE__ */ new Map()
+    }, this.events[t] = l), r.isFirst ? l.highPriority.set(n, !0) : l.regular.set(n, !0), process.env.NODE_ENV !== "production") {
+      const x = l.highPriority.size + l.regular.size;
+      x > this.maxListeners && !this.warnOnce && (this.warnOnce = !0, console.warn([`Possible EventEmitter memory leak detected. ${x} ${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 r = this.events[t];
+    if (!r)
+      return;
+    const l = Array.from(r.highPriority.keys()), x = Array.from(r.regular.keys());
+    for (let I = l.length - 1; I >= 0; I -= 1) {
+      const f = l[I];
+      r.highPriority.has(f) && f.apply(this, n);
+    }
+    for (let I = 0; I < x.length; I += 1) {
+      const f = x[I];
+      r.regular.has(f) && f.apply(this, n);
+    }
+  }
+  once(t, n) {
+    const r = this;
+    this.on(t, function l(...x) {
+      r.removeListener(t, l), n.apply(r, x);
+    });
+  }
+}
+const en = (e) => e.isPropagationStopped !== void 0, He = () => {
+  const [e] = E.useState(() => new Zt()), t = E.useCallback((...r) => {
+    const [l, x, I = {}] = r;
+    I.defaultMuiPrevented = !1, !(en(I) && I.isPropagationStopped()) && e.emit(l, x, I);
+  }, [e]), n = E.useCallback((r, l) => (e.on(r, l), () => {
+    e.removeListener(r, l);
+  }), [e]);
+  return {
+    instance: {
+      $$publishEvent: t,
+      $$subscribeEvent: n
+    }
+  };
+};
+He.params = {};
+const Xe = ({
+  plugins: e
+}) => {
+  const t = new Set(e);
+  return {
+    instance: {
+      getAvailablePlugins: () => t
+    }
+  };
+};
+Xe.params = {};
+const Te = ({
+  params: e,
+  state: t,
+  setState: n
+}) => {
+  E.useEffect(() => {
+    n((l) => l.id.treeId === e.id && l.id.treeId !== void 0 ? l : C({}, l, {
+      id: C({}, l.id, {
+        treeId: e.id ?? Rt()
+      })
+    }));
+  }, [n, e.id]);
+  const r = e.id ?? t.id.treeId;
+  return {
+    getRootProps: () => ({
+      id: r
+    }),
+    contextValue: {
+      treeId: r
+    }
+  };
+};
+Te.params = {
+  id: !0
+};
+Te.getInitialState = ({
+  id: e
+}) => ({
+  id: {
+    treeId: e ?? void 0
+  }
+});
+const tn = [He, Xe, Te], nn = ["slots", "slotProps", "apiRef", "experimentalFeatures"], on = (e) => {
+  let {
+    props: {
+      slots: t,
+      slotProps: n,
+      apiRef: r,
+      experimentalFeatures: l
+    },
+    plugins: x
+  } = e, I = A(e.props, nn);
+  const f = {};
+  x.forEach((u) => {
+    Object.assign(f, u.params);
+  });
+  const g = {}, p = {};
+  Object.keys(I).forEach((u) => {
+    const b = I[u];
+    f[u] ? g[u] = b : p[u] = b;
+  });
+  const o = l ?? {}, s = x.reduce((u, b) => b.getDefaultizedParams ? b.getDefaultizedParams({
+    params: u,
+    experimentalFeatures: o
+  }) : u, g);
+  return {
+    apiRef: r,
+    forwardedProps: p,
+    pluginParams: s,
+    slots: t ?? {},
+    slotProps: n ?? {},
+    experimentalFeatures: o
+  };
+}, rn = ({
+  plugins: e,
+  instance: t,
+  publicAPI: n,
+  rootRef: r
+}) => ({
+  runItemPlugins: (f) => {
+    let g = null, p = null;
+    const o = [], s = {};
+    e.forEach((h) => {
+      if (!h.itemPlugin)
+        return;
+      const c = h.itemPlugin({
+        props: f,
+        rootRef: g,
+        contentRef: p
+      });
+      c != null && c.rootRef && (g = c.rootRef), c != null && c.contentRef && (p = c.contentRef), c != null && c.propsEnhancers && (o.push(c.propsEnhancers), Object.keys(c.propsEnhancers).forEach((i) => {
+        s[i] = !0;
+      }));
+    });
+    const u = (h) => (c) => {
+      const i = {};
+      return o.forEach((d) => {
+        const m = d[h];
+        m != null && Object.assign(i, m(c));
+      }), i;
+    }, b = Object.fromEntries(Object.keys(s).map((h) => [h, u(h)]));
+    return {
+      contentRef: p,
+      rootRef: g,
+      propsEnhancers: b
+    };
+  },
+  wrapItem: ({
+    itemId: f,
+    children: g
+  }) => {
+    let p = g;
+    for (let o = e.length - 1; o >= 0; o -= 1) {
+      const s = e[o];
+      s.wrapItem && (p = s.wrapItem({
+        itemId: f,
+        children: p,
+        instance: t
+      }));
+    }
+    return p;
+  },
+  wrapRoot: ({
+    children: f
+  }) => {
+    let g = f;
+    for (let p = e.length - 1; p >= 0; p -= 1) {
+      const o = e[p];
+      o.wrapRoot && (g = o.wrapRoot({
+        children: g,
+        instance: t
+      }));
+    }
+    return g;
+  },
+  instance: t,
+  rootRef: r,
+  publicAPI: n
+});
+function sn(e) {
+  const t = E.useRef({});
+  return e ? (e.current == null && (e.current = {}), e.current) : t.current;
+}
+const ln = ({
+  plugins: e,
+  rootRef: t,
+  props: n
+}) => {
+  const r = [...tn, ...e], {
+    pluginParams: l,
+    forwardedProps: x,
+    apiRef: I,
+    experimentalFeatures: f,
+    slots: g,
+    slotProps: p
+  } = on({
+    plugins: r,
+    props: n
+  }), o = Qt(r, l), u = E.useRef({}).current, b = sn(I), h = E.useRef(null), c = Ee(h, t), i = rn({
+    plugins: r,
+    instance: u,
+    publicAPI: b,
+    rootRef: h
+  }), [d, m] = E.useState(() => {
+    const R = {};
+    return r.forEach((v) => {
+      v.getInitialState && Object.assign(R, v.getInitialState(l));
+    }), R;
+  }), T = [], P = (R) => {
+    const v = R({
+      instance: u,
+      params: l,
+      slots: g,
+      slotProps: p,
+      experimentalFeatures: f,
+      state: d,
+      setState: m,
+      rootRef: h,
+      models: o,
+      plugins: r
+    });
+    v.getRootProps && T.push(v.getRootProps), v.publicAPI && Object.assign(b, v.publicAPI), v.instance && Object.assign(u, v.instance), v.contextValue && Object.assign(i, v.contextValue);
+  };
+  return r.forEach(P), {
+    getRootProps: (R = {}) => {
+      const v = C({
+        role: "tree"
+      }, x, R, {
+        ref: c
+      });
+      return T.forEach((F) => {
+        Object.assign(v, F(R));
+      }), v;
+    },
+    rootRef: c,
+    contextValue: i,
+    instance: u
+  };
+};
+function an(e) {
+  const {
+    value: t,
+    children: n
+  } = e;
+  return /* @__PURE__ */ S(St.Provider, {
+    value: t,
+    children: t.wrapRoot({
+      children: n,
+      instance: t.instance
+    })
+  });
+}
+const cn = (e, t, n) => {
+  e.$$publishEvent(t, n);
+}, K = "__TREE_VIEW_ROOT_PARENT_ID__", un = (e) => {
+  const t = {};
+  return e.forEach((n, r) => {
+    t[n] = r;
+  }), t;
+}, dn = ["children"], We = ({
+  items: e,
+  isItemDisabled: t,
+  getItemLabel: n,
+  getItemId: r
+}) => {
+  const l = {}, x = {}, I = {
+    [K]: []
+  }, f = (p, o, s) => {
+    var c, i;
+    const u = r ? r(p) : p.id;
+    if (u == 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(p)].join(`
+`));
+    if (l[u] != 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: "${u}"`].join(`
+`));
+    const b = n ? n(p) : p.label;
+    if (b == 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(p)].join(`
+`));
+    l[u] = {
+      id: u,
+      label: b,
+      parentId: s,
+      idAttribute: void 0,
+      expandable: !!((c = p.children) != null && c.length),
+      disabled: t ? t(p) : !1,
+      depth: o
+    }, x[u] = p;
+    const h = s ?? K;
+    I[h] || (I[h] = []), I[h].push(u), (i = p.children) == null || i.forEach((d) => f(d, o + 1, u));
+  };
+  e.forEach((p) => f(p, 0, null));
+  const g = {};
+  return Object.keys(I).forEach((p) => {
+    g[p] = un(I[p]);
+  }), {
+    itemMetaMap: l,
+    itemMap: x,
+    itemOrderedChildrenIds: I,
+    itemChildrenIndexes: g
+  };
+}, X = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: r,
+  experimentalFeatures: l
+}) => {
+  const x = E.useCallback((d) => n.items.itemMetaMap[d], [n.items.itemMetaMap]), I = E.useCallback((d) => n.items.itemMap[d], [n.items.itemMap]), f = E.useCallback(() => {
+    const d = (m) => {
+      const T = n.items.itemMap[m], P = A(T, dn), y = n.items.itemOrderedChildrenIds[m];
+      return y && (P.children = y.map(d)), P;
+    };
+    return n.items.itemOrderedChildrenIds[K].map(d);
+  }, [n.items.itemMap, n.items.itemOrderedChildrenIds]), g = E.useCallback((d) => {
+    if (d == null)
+      return !1;
+    let m = e.getItemMeta(d);
+    if (!m)
+      return !1;
+    if (m.disabled)
+      return !0;
+    for (; m.parentId != null; )
+      if (m = e.getItemMeta(m.parentId), m.disabled)
+        return !0;
+    return !1;
+  }, [e]), p = E.useCallback((d) => {
+    const m = e.getItemMeta(d).parentId ?? K;
+    return n.items.itemChildrenIndexes[m][d];
+  }, [e, n.items.itemChildrenIndexes]), o = E.useCallback((d) => n.items.itemOrderedChildrenIds[d ?? K] ?? [], [n.items.itemOrderedChildrenIds]), s = (d) => {
+    const m = e.getItemMeta(d);
+    return m == null ? null : document.getElementById(_e({
+      treeId: n.id.treeId,
+      itemId: d,
+      id: m.idAttribute
+    }));
+  }, u = (d) => t.disabledItemsFocusable ? !0 : !e.isItemDisabled(d), b = E.useRef(!1), h = E.useCallback(() => {
+    b.current = !0;
+  }, []), c = E.useCallback(() => b.current, []);
+  return E.useEffect(() => {
+    e.areItemUpdatesPrevented() || r((d) => {
+      const m = We({
+        items: t.items,
+        isItemDisabled: t.isItemDisabled,
+        getItemId: t.getItemId,
+        getItemLabel: t.getItemLabel
+      });
+      return Object.values(d.items.itemMetaMap).forEach((T) => {
+        m.itemMetaMap[T.id] || cn(e, "removeItem", {
+          id: T.id
+        });
+      }), C({}, d, {
+        items: m
+      });
+    });
+  }, [e, r, t.items, t.isItemDisabled, t.getItemId, t.getItemLabel]), {
+    getRootProps: () => ({
+      style: {
+        "--TreeView-itemChildrenIndentation": typeof t.itemChildrenIndentation == "number" ? `${t.itemChildrenIndentation}px` : t.itemChildrenIndentation
+      }
+    }),
+    publicAPI: {
+      getItem: I,
+      getItemDOMElement: s,
+      getItemTree: f,
+      getItemOrderedChildrenIds: o
+    },
+    instance: {
+      getItemMeta: x,
+      getItem: I,
+      getItemTree: f,
+      getItemsToRender: () => {
+        const d = (m) => {
+          var P;
+          const T = n.items.itemMetaMap[m];
+          return {
+            label: T.label,
+            itemId: T.id,
+            id: T.idAttribute,
+            children: (P = n.items.itemOrderedChildrenIds[m]) == null ? void 0 : P.map(d)
+          };
+        };
+        return n.items.itemOrderedChildrenIds[K].map(d);
+      },
+      getItemIndex: p,
+      getItemDOMElement: s,
+      getItemOrderedChildrenIds: o,
+      isItemDisabled: g,
+      isItemNavigable: u,
+      preventItemUpdates: h,
+      areItemUpdatesPrevented: c
+    },
+    contextValue: {
+      items: {
+        onItemClick: t.onItemClick,
+        disabledItemsFocusable: t.disabledItemsFocusable,
+        indentationAtItemLevel: l.indentationAtItemLevel ?? !1
+      }
+    }
+  };
+};
+X.getInitialState = (e) => ({
+  items: We({
+    items: e.items,
+    isItemDisabled: e.isItemDisabled,
+    getItemId: e.getItemId,
+    getItemLabel: e.getItemLabel
+  })
+});
+X.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  disabledItemsFocusable: e.disabledItemsFocusable ?? !1,
+  itemChildrenIndentation: e.itemChildrenIndentation ?? "12px"
+});
+X.wrapRoot = ({
+  children: e,
+  instance: t
+}) => /* @__PURE__ */ S($e.Provider, {
+  value: (n) => {
+    var r;
+    return ((r = t.getItemMeta(n)) == null ? void 0 : r.depth) ?? 0;
+  },
+  children: e
+});
+X.params = {
+  disabledItemsFocusable: !0,
+  items: !0,
+  isItemDisabled: !0,
+  getItemLabel: !0,
+  getItemId: !0,
+  onItemClick: !0,
+  itemChildrenIndentation: !0
+};
+const le = ({
+  instance: e,
+  params: t,
+  models: n
+}) => {
+  const r = E.useMemo(() => {
+    const s = /* @__PURE__ */ new Map();
+    return n.expandedItems.value.forEach((u) => {
+      s.set(u, !0);
+    }), s;
+  }, [n.expandedItems.value]), l = (s, u) => {
+    var b;
+    (b = t.onExpandedItemsChange) == null || b.call(t, s, u), n.expandedItems.setControlledValue(u);
+  }, x = E.useCallback((s) => r.has(s), [r]), I = E.useCallback((s) => {
+    var u;
+    return !!((u = e.getItemMeta(s)) != null && u.expandable);
+  }, [e]), f = U((s, u) => {
+    const b = e.isItemExpanded(u);
+    e.setItemExpansion(s, u, !b);
+  }), g = U((s, u, b) => {
+    if (e.isItemExpanded(u) === b)
+      return;
+    let c;
+    b ? c = [u].concat(n.expandedItems.value) : c = n.expandedItems.value.filter((i) => i !== u), t.onItemExpansionToggle && t.onItemExpansionToggle(s, u, b), l(s, c);
+  }), p = (s, u) => {
+    const b = e.getItemMeta(u), c = e.getItemOrderedChildrenIds(b.parentId).filter((d) => e.isItemExpandable(d) && !e.isItemExpanded(d)), i = n.expandedItems.value.concat(c);
+    c.length > 0 && (t.onItemExpansionToggle && c.forEach((d) => {
+      t.onItemExpansionToggle(s, d, !0);
+    }), l(s, i));
+  }, o = E.useMemo(() => t.expansionTrigger ? t.expansionTrigger : e.isTreeViewEditable ? "iconContainer" : "content", [t.expansionTrigger, e.isTreeViewEditable]);
+  return {
+    publicAPI: {
+      setItemExpansion: g
+    },
+    instance: {
+      isItemExpanded: x,
+      isItemExpandable: I,
+      setItemExpansion: g,
+      toggleItemExpansion: f,
+      expandAllSiblings: p
+    },
+    contextValue: {
+      expansion: {
+        expansionTrigger: o
+      }
+    }
+  };
+};
+le.models = {
+  expandedItems: {
+    getDefaultValue: (e) => e.defaultExpandedItems
+  }
+};
+const fn = [];
+le.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  defaultExpandedItems: e.defaultExpandedItems ?? fn
+});
+le.params = {
+  expandedItems: !0,
+  defaultExpandedItems: !0,
+  onExpandedItemsChange: !0,
+  onItemExpansionToggle: !0,
+  expansionTrigger: !0
+};
+const re = (e) => Array.isArray(e) ? e : e != null ? [e] : [], be = (e) => {
+  const t = {};
+  return e.forEach((n) => {
+    t[n] = !0;
+  }), t;
+}, ae = ({
+  instance: e,
+  params: t,
+  models: n
+}) => {
+  const r = E.useRef(null), l = E.useRef({}), x = E.useMemo(() => {
+    const c = /* @__PURE__ */ new Map();
+    return Array.isArray(n.selectedItems.value) ? n.selectedItems.value.forEach((i) => {
+      c.set(i, !0);
+    }) : n.selectedItems.value != null && c.set(n.selectedItems.value, !0), c;
+  }, [n.selectedItems.value]), I = (c, i) => {
+    if (t.onItemSelectionToggle)
+      if (t.multiSelect) {
+        const d = i.filter((T) => !e.isItemSelected(T)), m = n.selectedItems.value.filter((T) => !i.includes(T));
+        d.forEach((T) => {
+          t.onItemSelectionToggle(c, T, !0);
+        }), m.forEach((T) => {
+          t.onItemSelectionToggle(c, T, !1);
+        });
+      } else i !== n.selectedItems.value && (n.selectedItems.value != null && t.onItemSelectionToggle(c, n.selectedItems.value, !1), i != null && t.onItemSelectionToggle(c, i, !0));
+    t.onSelectedItemsChange && t.onSelectedItemsChange(c, i), n.selectedItems.setControlledValue(i);
+  }, f = (c) => x.has(c), g = ({
+    event: c,
+    itemId: i,
+    keepExistingSelection: d = !1,
+    shouldBeSelected: m
+  }) => {
+    if (t.disableSelection)
+      return;
+    let T;
+    if (d) {
+      const P = re(n.selectedItems.value), y = e.isItemSelected(i);
+      y && (m === !1 || m == null) ? T = P.filter((R) => R !== i) : !y && (m === !0 || m == null) ? T = [i].concat(P) : T = P;
+    } else
+      m === !1 || m == null && e.isItemSelected(i) ? T = t.multiSelect ? [] : null : T = t.multiSelect ? [i] : i;
+    I(c, T), r.current = i, l.current = {};
+  }, p = (c, [i, d]) => {
+    if (t.disableSelection || !t.multiSelect)
+      return;
+    let m = re(n.selectedItems.value).slice();
+    Object.keys(l.current).length > 0 && (m = m.filter((R) => !l.current[R]));
+    const T = be(m), P = kt(e, i, d), y = P.filter((R) => !T[R]);
+    m = m.concat(y), I(c, m), l.current = be(P);
+  };
+  return {
+    getRootProps: () => ({
+      "aria-multiselectable": t.multiSelect
+    }),
+    publicAPI: {
+      selectItem: g
+    },
+    instance: {
+      isItemSelected: f,
+      selectItem: g,
+      selectAllNavigableItems: (c) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        const i = vt(e);
+        I(c, i), l.current = be(i);
+      },
+      expandSelectionRange: (c, i) => {
+        if (r.current != null) {
+          const [d, m] = Pt(e, i, r.current);
+          p(c, [d, m]);
+        }
+      },
+      selectRangeFromStartToItem: (c, i) => {
+        p(c, [se(e), i]);
+      },
+      selectRangeFromItemToEnd: (c, i) => {
+        p(c, [i, Ne(e)]);
+      },
+      selectItemFromArrowNavigation: (c, i, d) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        let m = re(n.selectedItems.value).slice();
+        Object.keys(l.current).length === 0 ? (m.push(d), l.current = {
+          [i]: !0,
+          [d]: !0
+        }) : (l.current[i] || (l.current = {}), l.current[d] ? (m = m.filter((T) => T !== i), delete l.current[i]) : (m.push(d), l.current[d] = !0)), I(c, m);
+      }
+    },
+    contextValue: {
+      selection: {
+        multiSelect: t.multiSelect,
+        checkboxSelection: t.checkboxSelection,
+        disableSelection: t.disableSelection
+      }
+    }
+  };
+};
+ae.models = {
+  selectedItems: {
+    getDefaultValue: (e) => e.defaultSelectedItems
+  }
+};
+const pn = [];
+ae.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  disableSelection: e.disableSelection ?? !1,
+  multiSelect: e.multiSelect ?? !1,
+  checkboxSelection: e.checkboxSelection ?? !1,
+  defaultSelectedItems: e.defaultSelectedItems ?? (e.multiSelect ? pn : null)
+});
+ae.params = {
+  disableSelection: !0,
+  multiSelect: !0,
+  checkboxSelection: !0,
+  defaultSelectedItems: !0,
+  selectedItems: !0,
+  onSelectedItemsChange: !0,
+  onItemSelectionToggle: !0
+};
+const Le = 1e3;
+class mn {
+  constructor(t = Le) {
+    this.timeouts = /* @__PURE__ */ new Map(), this.cleanupTimeout = Le, this.cleanupTimeout = t;
+  }
+  register(t, n, r) {
+    this.timeouts || (this.timeouts = /* @__PURE__ */ new Map());
+    const l = setTimeout(() => {
+      typeof n == "function" && n(), this.timeouts.delete(r.cleanupToken);
+    }, this.cleanupTimeout);
+    this.timeouts.set(r.cleanupToken, l);
+  }
+  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 In {
+  constructor() {
+    this.registry = new FinalizationRegistry((t) => {
+      typeof t == "function" && t();
+    });
+  }
+  register(t, n, r) {
+    this.registry.register(t, n, r);
+  }
+  unregister(t) {
+    this.registry.unregister(t);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  reset() {
+  }
+}
+class gn {
+}
+function bn(e) {
+  let t = 0;
+  return function(r, l, x) {
+    e.registry === null && (e.registry = typeof FinalizationRegistry < "u" ? new In() : new mn());
+    const [I] = E.useState(new gn()), f = E.useRef(null), g = E.useRef(void 0);
+    g.current = x;
+    const p = E.useRef(null);
+    if (!f.current && g.current) {
+      const o = (s, u) => {
+        var b;
+        u.defaultMuiPrevented || (b = g.current) == null || b.call(g, s, u);
+      };
+      f.current = r.$$subscribeEvent(l, o), t += 1, p.current = {
+        cleanupToken: t
+      }, e.registry.register(
+        I,
+        // The callback below will be called once this reference stops being retained
+        () => {
+          var s;
+          (s = f.current) == null || s.call(f), f.current = null, p.current = null;
+        },
+        p.current
+      );
+    } else !g.current && f.current && (f.current(), f.current = null, p.current && (e.registry.unregister(p.current), p.current = null));
+    E.useEffect(() => {
+      if (!f.current && g.current) {
+        const o = (s, u) => {
+          var b;
+          u.defaultMuiPrevented || (b = g.current) == null || b.call(g, s, u);
+        };
+        f.current = r.$$subscribeEvent(l, o);
+      }
+      return p.current && e.registry && (e.registry.unregister(p.current), p.current = null), () => {
+        var o;
+        (o = f.current) == null || o.call(f), f.current = null;
+      };
+    }, [r, l]);
+  };
+}
+const hn = {
+  registry: null
+}, xn = bn(hn), Ge = (e = document) => {
+  const t = e.activeElement;
+  return t ? t.shadowRoot ? Ge(t.shadowRoot) : t : null;
+}, En = (e, t) => {
+  let n = re(t).find((r) => {
+    if (!e.isItemNavigable(r))
+      return !1;
+    const l = e.getItemMeta(r);
+    return l && (l.parentId == null || e.isItemExpanded(l.parentId));
+  });
+  return n == null && (n = se(e)), n;
+}, ye = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: r,
+  models: l,
+  rootRef: x
+}) => {
+  const I = En(e, l.selectedItems.value), f = U((i) => {
+    const d = typeof i == "function" ? i(n.focusedItemId) : i;
+    n.focusedItemId !== d && r((m) => C({}, m, {
+      focusedItemId: d
+    }));
+  }), g = E.useCallback(() => !!x.current && x.current.contains(Ge(Ht(x.current))), [x]), p = E.useCallback((i) => n.focusedItemId === i && g(), [n.focusedItemId, g]), o = (i) => {
+    const d = e.getItemMeta(i);
+    return d && (d.parentId == null || e.isItemExpanded(d.parentId));
+  }, s = (i, d) => {
+    const m = e.getItemDOMElement(d);
+    m && m.focus(), f(d), t.onItemFocus && t.onItemFocus(i, d);
+  }, u = U((i, d) => {
+    o(d) && s(i, d);
+  }), b = U(() => {
+    if (n.focusedItemId == null)
+      return;
+    if (e.getItemMeta(n.focusedItemId)) {
+      const d = e.getItemDOMElement(n.focusedItemId);
+      d && d.blur();
+    }
+    f(null);
+  }), h = (i) => i === I;
+  xn(e, "removeItem", ({
+    id: i
+  }) => {
+    n.focusedItemId === i && s(null, I);
+  });
+  const c = (i) => (d) => {
+    var m;
+    (m = i.onFocus) == null || m.call(i, d), !d.defaultMuiPrevented && d.target === d.currentTarget && s(d, I);
+  };
+  return {
+    getRootProps: (i) => ({
+      onFocus: c(i)
+    }),
+    publicAPI: {
+      focusItem: u
+    },
+    instance: {
+      isItemFocused: p,
+      canItemBeTabbed: h,
+      focusItem: u,
+      removeFocusedItem: b
+    }
+  };
+};
+ye.getInitialState = () => ({
+  focusedItemId: null
+});
+ye.params = {
+  onItemFocus: !0
+};
+function Tn(e) {
+  return !!e && e.length === 1 && !!e.match(/\S/);
+}
+const Je = ({
+  instance: e,
+  params: t,
+  state: n
+}) => {
+  const r = Xt(), l = E.useRef({}), x = U((o) => {
+    l.current = o(l.current);
+  });
+  E.useEffect(() => {
+    if (e.areItemUpdatesPrevented())
+      return;
+    const o = {}, s = (u) => {
+      o[u.id] = u.label.substring(0, 1).toLowerCase();
+    };
+    Object.values(n.items.itemMetaMap).forEach(s), l.current = o;
+  }, [n.items.itemMetaMap, t.getItemId, e]);
+  const I = (o, s) => {
+    const u = s.toLowerCase(), b = (d) => {
+      const m = ge(e, d);
+      return m === null ? se(e) : m;
+    };
+    let h = null, c = b(o);
+    const i = {};
+    for (; h == null && !i[c]; )
+      l.current[c] === u ? h = c : (i[c] = !0, c = b(c));
+    return h;
+  }, f = (o) => !t.disableSelection && !e.isItemDisabled(o), g = (o) => !e.isItemDisabled(o) && e.isItemExpandable(o);
+  return {
+    instance: {
+      updateFirstCharMap: x,
+      handleItemKeyDown: (o, s) => {
+        if (o.defaultMuiPrevented || o.altKey || he(o.target, o.currentTarget))
+          return;
+        const u = o.ctrlKey || o.metaKey, b = o.key;
+        switch (!0) {
+          // Select the item when pressing "Space"
+          case (b === " " && f(s)): {
+            o.preventDefault(), t.multiSelect && o.shiftKey ? e.expandSelectionRange(o, s) : e.selectItem({
+              event: o,
+              itemId: s,
+              keepExistingSelection: t.multiSelect,
+              shouldBeSelected: t.multiSelect ? void 0 : !0
+            });
+            break;
+          }
+          // If the focused item has children, we expand it.
+          // If the focused item has no children, we select it.
+          case b === "Enter": {
+            oe(e, H) && e.isItemEditable(s) && !e.isItemBeingEdited(s) ? e.setEditedItemId(s) : g(s) ? (e.toggleItemExpansion(o, s), o.preventDefault()) : f(s) && (t.multiSelect ? (o.preventDefault(), e.selectItem({
+              event: o,
+              itemId: s,
+              keepExistingSelection: !0
+            })) : e.isItemSelected(s) || (e.selectItem({
+              event: o,
+              itemId: s
+            }), o.preventDefault()));
+            break;
+          }
+          // Focus the next focusable item
+          case b === "ArrowDown": {
+            const h = ge(e, s);
+            h && (o.preventDefault(), e.focusItem(o, h), t.multiSelect && o.shiftKey && f(h) && e.selectItemFromArrowNavigation(o, s, h));
+            break;
+          }
+          // Focuses the previous focusable item
+          case b === "ArrowUp": {
+            const h = Mt(e, s);
+            h && (o.preventDefault(), e.focusItem(o, h), t.multiSelect && o.shiftKey && f(h) && e.selectItemFromArrowNavigation(o, s, h));
+            break;
+          }
+          // If the focused item is expanded, we move the focus to its first child
+          // If the focused item is collapsed and has children, we expand it
+          case (b === "ArrowRight" && !r || b === "ArrowLeft" && r): {
+            if (u)
+              return;
+            if (e.isItemExpanded(s)) {
+              const h = ge(e, s);
+              h && (e.focusItem(o, h), o.preventDefault());
+            } else g(s) && (e.toggleItemExpansion(o, s), o.preventDefault());
+            break;
+          }
+          // If the focused item is expanded, we collapse it
+          // If the focused item is collapsed and has a parent, we move the focus to this parent
+          case (b === "ArrowLeft" && !r || b === "ArrowRight" && r): {
+            if (u)
+              return;
+            if (g(s) && e.isItemExpanded(s))
+              e.toggleItemExpansion(o, s), o.preventDefault();
+            else {
+              const h = e.getItemMeta(s).parentId;
+              h && (e.focusItem(o, h), o.preventDefault());
+            }
+            break;
+          }
+          // Focuses the first item in the tree
+          case b === "Home": {
+            f(s) && t.multiSelect && u && o.shiftKey ? e.selectRangeFromStartToItem(o, s) : e.focusItem(o, se(e)), o.preventDefault();
+            break;
+          }
+          // Focuses the last item in the tree
+          case b === "End": {
+            f(s) && t.multiSelect && u && o.shiftKey ? e.selectRangeFromItemToEnd(o, s) : e.focusItem(o, Ne(e)), o.preventDefault();
+            break;
+          }
+          // Expand all siblings that are at the same level as the focused item
+          case b === "*": {
+            e.expandAllSiblings(o, s), o.preventDefault();
+            break;
+          }
+          // Multi select behavior when pressing Ctrl + a
+          // Selects all the items
+          case (String.fromCharCode(o.keyCode) === "A" && u && t.multiSelect && !t.disableSelection): {
+            e.selectAllNavigableItems(o), o.preventDefault();
+            break;
+          }
+          // Type-ahead
+          // TODO: Support typing multiple characters
+          case (!u && !o.shiftKey && Tn(b)): {
+            const h = I(s, b);
+            h != null && (e.focusItem(o, h), o.preventDefault());
+            break;
+          }
+        }
+      }
+    }
+  };
+};
+Je.params = {};
+const Ye = ({
+  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
+      }
+    }
+  }
+});
+Ye.params = {};
+const yn = [X, le, ae, ye, Je, Ye, H];
+function Qe(e) {
+  const {
+    instance: t,
+    items: {
+      onItemClick: n
+    },
+    selection: {
+      multiSelect: r,
+      checkboxSelection: l,
+      disableSelection: x
+    },
+    expansion: {
+      expansionTrigger: I
+    }
+  } = Ke(), f = t.isItemExpandable(e), g = t.isItemExpanded(e), p = t.isItemFocused(e), o = t.isItemSelected(e), s = t.isItemDisabled(e), u = t != null && t.isItemBeingEdited ? t == null ? void 0 : t.isItemBeingEdited(e) : !1, b = t.isItemEditable ? t.isItemEditable(e) : !1, h = (y) => {
+    if (!s) {
+      p || t.focusItem(y, e);
+      const R = r && (y.shiftKey || y.ctrlKey || y.metaKey);
+      f && !(R && t.isItemExpanded(e)) && t.toggleItemExpansion(y, e);
+    }
+  }, c = (y) => {
+    s || (p || t.focusItem(y, e), r && (y.shiftKey || y.ctrlKey || y.metaKey) ? y.shiftKey ? t.expandSelectionRange(y, e) : t.selectItem({
+      event: y,
+      itemId: e,
+      keepExistingSelection: !0
+    }) : t.selectItem({
+      event: y,
+      itemId: e,
+      shouldBeSelected: !0
+    }));
+  }, i = (y) => {
+    if (x || s)
+      return;
+    const R = y.nativeEvent.shiftKey;
+    r && R ? t.expandSelectionRange(y, e) : t.selectItem({
+      event: y,
+      itemId: e,
+      keepExistingSelection: r,
+      shouldBeSelected: y.target.checked
+    });
+  }, d = (y) => {
+    (y.shiftKey || y.ctrlKey || y.metaKey || s) && y.preventDefault();
+  }, m = () => {
+    oe(t, H) && t.isItemEditable(e) && (t.isItemBeingEdited(e) ? t.setEditedItemId(null) : t.setEditedItemId(e));
+  };
+  return {
+    disabled: s,
+    expanded: g,
+    selected: o,
+    focused: p,
+    editable: b,
+    editing: u,
+    disableSelection: x,
+    checkboxSelection: l,
+    handleExpansion: h,
+    handleSelection: c,
+    handleCheckboxSelection: i,
+    handleContentClick: n,
+    preventSelection: d,
+    expansionTrigger: I,
+    toggleItemEditing: m,
+    handleSaveItemLabel: (y, R) => {
+      oe(t, H) && t.isItemBeingEditedRef(e) && (t.updateItemLabel(e, R), m(), t.focusItem(y, e));
+    },
+    handleCancelItemLabelEditing: (y) => {
+      oe(t, H) && t.isItemBeingEditedRef(e) && (m(), t.focusItem(y, e));
+    }
+  };
+}
+const Cn = ["classes", "className", "displayIcon", "expansionIcon", "icon", "label", "itemId", "onClick", "onMouseDown", "dragAndDropOverlayProps", "labelInputProps"], Ce = /* @__PURE__ */ E.forwardRef(function(t, n) {
+  const {
+    classes: r,
+    className: l,
+    displayIcon: x,
+    expansionIcon: I,
+    icon: f,
+    label: g,
+    itemId: p,
+    onClick: o,
+    onMouseDown: s,
+    dragAndDropOverlayProps: u,
+    labelInputProps: b
+  } = t, h = A(t, Cn), {
+    disabled: c,
+    expanded: i,
+    selected: d,
+    focused: m,
+    editing: T,
+    editable: P,
+    disableSelection: y,
+    checkboxSelection: R,
+    handleExpansion: v,
+    handleSelection: F,
+    handleCheckboxSelection: B,
+    handleContentClick: V,
+    preventSelection: L,
+    expansionTrigger: W,
+    toggleItemEditing: G
+  } = Qe(p), j = f || I || x, J = E.useRef(null), ce = (M) => {
+    L(M), s && s(M);
+  }, ue = (M) => {
+    var Y;
+    V == null || V(M, p), !((Y = J.current) != null && Y.contains(M.target)) && (W === "content" && v(M), R || F(M), o && o(M));
+  }, de = (M) => {
+    M.defaultMuiPrevented || G();
+  };
+  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__ */ je("div", C({}, h, {
+      className: Be(r.root, l, i && r.expanded, d && r.selected, m && r.focused, c && r.disabled, T && r.editing, P && r.editable),
+      onClick: ue,
+      onMouseDown: ce,
+      ref: n,
+      children: [/* @__PURE__ */ S("div", {
+        className: r.iconContainer,
+        children: j
+      }), R && /* @__PURE__ */ S(Wt, {
+        className: r.checkbox,
+        checked: d,
+        onChange: B,
+        disabled: c || y,
+        ref: J,
+        tabIndex: -1
+      }), T ? /* @__PURE__ */ S(Dt, C({}, b, {
+        className: r.labelInput
+      })) : /* @__PURE__ */ S("div", C({
+        className: r.label
+      }, P && {
+        onDoubleClick: de
+      }, {
+        children: g
+      })), u && /* @__PURE__ */ S(Ot, C({}, u))]
+    }))
+  );
+});
+process.env.NODE_ENV !== "production" && (Ce.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: a.object.isRequired,
+  className: a.string,
+  /**
+   * The icon to display next to the Tree Item's label. Either a parent or end icon.
+   */
+  displayIcon: a.node,
+  dragAndDropOverlayProps: a.shape({
+    action: a.oneOf(["make-child", "move-to-parent", "reorder-above", "reorder-below"]),
+    style: a.object
+  }),
+  /**
+   * The icon to display next to the Tree Item's label. Either an expansion or collapse icon.
+   */
+  expansionIcon: a.node,
+  /**
+   * The icon to display next to the Tree Item's label.
+   */
+  icon: a.node,
+  /**
+   * The id of the item.
+   */
+  itemId: a.string.isRequired,
+  /**
+   * The Tree Item label.
+   */
+  label: a.node,
+  labelInputProps: a.shape({
+    autoFocus: a.oneOf([!0]),
+    "data-element": a.oneOf(["labelInput"]),
+    onBlur: a.func,
+    onChange: a.func,
+    onKeyDown: a.func,
+    type: a.oneOf(["text"]),
+    value: a.string
+  })
+});
+const wn = ["children", "className", "slots", "slotProps", "ContentComponent", "ContentProps", "itemId", "id", "label", "onClick", "onMouseDown", "onFocus", "onBlur", "onKeyDown"], Rn = ["ownerState"], Sn = ["ownerState"], Pn = ["ownerState"], vn = Ue(), kn = (e) => {
+  const {
+    classes: t
+  } = e;
+  return ze({
+    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"]
+  }, Lt, t);
+}, Mn = ie("li", {
+  name: "MuiTreeItem",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), Dn = ie(Ce, {
+  name: "MuiTreeItem",
+  slot: "Content",
+  overridesResolver: (e, t) => [t.content, t.iconContainer && {
+    [`& .${O.iconContainer}`]: t.iconContainer
+  }, t.label && {
+    [`& .${O.label}`]: t.label
+  }],
+  shouldForwardProp: (e) => qe(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"
+    }
+  },
+  [`&.${O.disabled}`]: {
+    opacity: (e.vars || e).palette.action.disabledOpacity,
+    backgroundColor: "transparent"
+  },
+  [`&.${O.focused}`]: {
+    backgroundColor: (e.vars || e).palette.action.focus
+  },
+  [`&.${O.selected}`]: {
+    backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / ${e.vars.palette.action.selectedOpacity})` : ne(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}))` : ne(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})` : ne(e.palette.primary.main, e.palette.action.selectedOpacity)
+      }
+    },
+    [`&.${O.focused}`]: {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.focusOpacity}))` : ne(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.focusOpacity)
+    }
+  },
+  [`& .${O.iconContainer}`]: {
+    width: 16,
+    display: "flex",
+    flexShrink: 0,
+    justifyContent: "center",
+    "& svg": {
+      fontSize: 18
+    }
+  },
+  [`& .${O.label}`]: C({
+    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),
+  [`& .${O.checkbox}`]: {
+    padding: 0
+  },
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: `calc(${e.spacing(1)} + var(--TreeView-itemChildrenIndentation) * var(--TreeView-itemDepth))`
+    }
+  }]
+})), On = ie(jt, {
+  name: "MuiTreeItem",
+  slot: "GroupTransition",
+  overridesResolver: (e, t) => t.groupTransition,
+  shouldForwardProp: (e) => qe(e) && e !== "indentationAtItemLevel"
+})({
+  margin: 0,
+  padding: 0,
+  paddingLeft: "var(--TreeView-itemChildrenIndentation)",
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: 0
+    }
+  }]
+}), Ze = /* @__PURE__ */ E.forwardRef(function(t, n) {
+  var ke, Me, De, Oe;
+  const {
+    icons: r,
+    runItemPlugins: l,
+    items: {
+      disabledItemsFocusable: x,
+      indentationAtItemLevel: I
+    },
+    selection: {
+      disableSelection: f
+    },
+    expansion: {
+      expansionTrigger: g
+    },
+    treeId: p,
+    instance: o
+  } = Ke(), s = E.useContext($e), u = vn({
+    props: t,
+    name: "MuiTreeItem"
+  }), {
+    children: b,
+    className: h,
+    slots: c,
+    slotProps: i,
+    ContentComponent: d = Ce,
+    ContentProps: m,
+    itemId: T,
+    id: P,
+    label: y,
+    onClick: R,
+    onMouseDown: v,
+    onBlur: F,
+    onKeyDown: B
+  } = u, V = A(u, wn), {
+    expanded: L,
+    focused: W,
+    selected: G,
+    disabled: j,
+    editing: J,
+    handleExpansion: ce,
+    handleCancelItemLabelEditing: ue,
+    handleSaveItemLabel: de
+  } = Qe(T);
+  process.env.NODE_ENV !== "production" && (u.ContentComponent && xe(["MUI X: The ContentComponent prop of the TreeItem component is deprecated and will be removed in the next major release.", "You can use the new TreeItem2 component or the new useTreeItem2 hook to customize the rendering of the content.", "For more detail, see https://mui.com/x/react-tree-view/tree-item-customization/."]), u.ContentProps && xe(["MUI X: The ContentProps prop of the TreeItem component is deprecated and will be removed in the next major release.", "You can use the new TreeItem2 component or the new useTreeItem2 hook to customize the rendering of the content.", "For more detail, see https://mui.com/x/react-tree-view/tree-item-customization/."]));
+  const {
+    contentRef: M,
+    rootRef: Y,
+    propsEnhancers: D
+  } = l(u), Q = E.useRef(null), we = E.useRef(null), nt = Ee(n, Y, Q), ot = Ee(m == null ? void 0 : m.ref, M, we), z = {
+    expandIcon: (c == null ? void 0 : c.expandIcon) ?? r.slots.expandIcon ?? At,
+    collapseIcon: (c == null ? void 0 : c.collapseIcon) ?? r.slots.collapseIcon ?? Vt,
+    endIcon: (c == null ? void 0 : c.endIcon) ?? r.slots.endIcon,
+    icon: c == null ? void 0 : c.icon,
+    groupTransition: c == null ? void 0 : c.groupTransition
+  }, Re = (w) => Array.isArray(w) ? w.length > 0 && w.some(Re) : !!w, Z = Re(b), fe = C({}, u, {
+    expanded: L,
+    focused: W,
+    selected: G,
+    disabled: j,
+    indentationAtItemLevel: I
+  }), k = kn(fe), Se = z.groupTransition ?? void 0, rt = N({
+    elementType: Se,
+    ownerState: {},
+    externalSlotProps: i == null ? void 0 : i.groupTransition,
+    additionalProps: C({
+      unmountOnExit: !0,
+      in: L,
+      component: "ul",
+      role: "group"
+    }, I ? {
+      indentationAtItemLevel: !0
+    } : {}),
+    className: k.groupTransition
+  }), st = (w) => {
+    g === "iconContainer" && ce(w);
+  }, pe = L ? z.collapseIcon : z.expandIcon, it = N({
+    elementType: pe,
+    ownerState: {},
+    externalSlotProps: (w) => L ? C({}, $(r.slotProps.collapseIcon, w), $(i == null ? void 0 : i.collapseIcon, w)) : C({}, $(r.slotProps.expandIcon, w), $(i == null ? void 0 : i.expandIcon, w)),
+    additionalProps: {
+      onClick: st
+    }
+  }), lt = A(it, Rn), at = Z && pe ? /* @__PURE__ */ S(pe, C({}, lt)) : null, me = Z ? void 0 : z.endIcon, ct = N({
+    elementType: me,
+    ownerState: {},
+    externalSlotProps: (w) => Z ? {} : C({}, $(r.slotProps.endIcon, w), $(i == null ? void 0 : i.endIcon, w))
+  }), ut = A(ct, Sn), dt = me ? /* @__PURE__ */ S(me, C({}, ut)) : null, Ie = z.icon, ft = N({
+    elementType: Ie,
+    ownerState: {},
+    externalSlotProps: i == null ? void 0 : i.icon
+  }), pt = A(ft, Pn), mt = Ie ? /* @__PURE__ */ S(Ie, C({}, pt)) : null;
+  let ee;
+  G ? ee = !0 : f || j ? ee = void 0 : ee = !1;
+  function It(w) {
+    !W && (!j || x) && w.currentTarget === w.target && o.focusItem(w, T);
+  }
+  function gt(w) {
+    var _, q, Ve, Ae;
+    F == null || F(w), !(J || // 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
+    w.relatedTarget && he(w.relatedTarget, Q.current) && (w.target && ((q = (_ = w.target) == null ? void 0 : _.dataset) == null ? void 0 : q.element) === "labelInput" && he(w.target, Q.current) || ((Ae = (Ve = w.relatedTarget) == null ? void 0 : Ve.dataset) == null ? void 0 : Ae.element) === "labelInput")) && o.removeFocusedItem();
+  }
+  const bt = (w) => {
+    var _, q;
+    B == null || B(w), ((q = (_ = w.target) == null ? void 0 : _.dataset) == null ? void 0 : q.element) !== "labelInput" && o.handleItemKeyDown(w, T);
+  }, ht = _e({
+    itemId: T,
+    treeId: p,
+    id: P
+  }), xt = o.canItemBeTabbed(T) ? 0 : -1, te = {
+    rootRefObject: Q,
+    contentRefObject: we,
+    interactions: {
+      handleSaveItemLabel: de,
+      handleCancelItemLabelEditing: ue
+    }
+  }, Et = ((ke = D.root) == null ? void 0 : ke.call(D, C({}, te, {
+    externalEventHandlers: Fe(V)
+  }))) ?? {}, Tt = ((Me = D.content) == null ? void 0 : Me.call(D, C({}, te, {
+    externalEventHandlers: Fe(m)
+  }))) ?? {}, Pe = ((De = D.dragAndDropOverlay) == null ? void 0 : De.call(D, C({}, te, {
+    externalEventHandlers: {}
+  }))) ?? {}, ve = ((Oe = D.labelInput) == null ? void 0 : Oe.call(D, C({}, te, {
+    externalEventHandlers: {}
+  }))) ?? {};
+  return /* @__PURE__ */ S(Ft, {
+    itemId: T,
+    children: /* @__PURE__ */ je(Mn, C({
+      className: Be(k.root, h),
+      role: "treeitem",
+      "aria-expanded": Z ? L : void 0,
+      "aria-selected": ee,
+      "aria-disabled": j || void 0,
+      id: ht,
+      tabIndex: xt
+    }, V, {
+      ownerState: fe,
+      onFocus: It,
+      onBlur: gt,
+      onKeyDown: bt,
+      ref: nt,
+      style: I ? C({}, V.style, {
+        "--TreeView-itemDepth": typeof s == "function" ? s(T) : s
+      }) : V.style
+    }, Et, {
+      children: [/* @__PURE__ */ S(Dn, C({
+        as: d,
+        classes: {
+          root: k.content,
+          expanded: k.expanded,
+          selected: k.selected,
+          focused: k.focused,
+          disabled: k.disabled,
+          editable: k.editable,
+          editing: k.editing,
+          iconContainer: k.iconContainer,
+          label: k.label,
+          labelInput: k.labelInput,
+          checkbox: k.checkbox
+        },
+        label: y,
+        itemId: T,
+        onClick: R,
+        onMouseDown: v,
+        icon: mt,
+        expansionIcon: at,
+        displayIcon: dt,
+        ownerState: fe
+      }, m, Tt, Pe.action == null ? {} : {
+        dragAndDropOverlayProps: Pe
+      }, ve.value == null ? {} : {
+        labelInputProps: ve
+      }, {
+        ref: ot
+      })), b && /* @__PURE__ */ S(On, C({
+        as: Se
+      }, rt, {
+        children: b
+      }))]
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (Ze.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: a.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: a.object,
+  className: a.string,
+  /**
+   * The component used to render the content of the item.
+   * @deprecated Consider using the `<TreeItem2 />` component or the `useTreeItem2` hook instead. For more details, see https://mui.com/x/react-tree-view/tree-item-customization/.
+   * @default TreeItemContent
+   */
+  ContentComponent: Jt,
+  /**
+   * Props applied to ContentComponent.
+   * @deprecated Consider using the `<TreeItem2 />` component or the `useTreeItem2` hook instead. For more details, see https://mui.com/x/react-tree-view/tree-item-customization/.
+   */
+  ContentProps: a.object,
+  /**
+   * If `true`, the item is disabled.
+   * @default false
+   */
+  disabled: a.bool,
+  /**
+   * The id of the item.
+   */
+  itemId: a.string.isRequired,
+  /**
+   * The Tree Item label.
+   */
+  label: a.node,
+  /**
+   * This prop isn't supported.
+   * Use the `onItemFocus` callback on the tree if you need to monitor a item's focus.
+   */
+  onFocus: Gt,
+  /**
+   * Callback fired when a key of the keyboard is pressed on the item.
+   */
+  onKeyDown: a.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: a.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: a.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: a.oneOfType([a.arrayOf(a.oneOfType([a.func, a.object, a.bool])), a.func, a.object])
+});
+const Vn = ["ownerState"];
+function An({
+  slots: e,
+  slotProps: t,
+  label: n,
+  id: r,
+  itemId: l,
+  itemsToRender: x
+}) {
+  const I = (e == null ? void 0 : e.item) ?? Ze, f = N({
+    elementType: I,
+    externalSlotProps: t == null ? void 0 : t.item,
+    additionalProps: {
+      itemId: l,
+      id: r,
+      label: n
+    },
+    ownerState: {
+      itemId: l,
+      label: n
+    }
+  }), g = A(f, Vn), p = E.useMemo(() => x ? /* @__PURE__ */ S(et, {
+    itemsToRender: x,
+    slots: e,
+    slotProps: t
+  }) : null, [x, e, t]);
+  return /* @__PURE__ */ S(I, C({}, g, {
+    children: p
+  }));
+}
+function et(e) {
+  const {
+    itemsToRender: t,
+    slots: n,
+    slotProps: r
+  } = e;
+  return /* @__PURE__ */ S(E.Fragment, {
+    children: t.map((l) => /* @__PURE__ */ S(An, {
+      slots: n,
+      slotProps: r,
+      label: l.label,
+      id: l.id,
+      itemId: l.itemId,
+      itemsToRender: l.children
+    }, l.itemId))
+  });
+}
+const Fn = Ue(), Ln = (e) => {
+  const {
+    classes: t
+  } = e;
+  return ze({
+    root: ["root"]
+  }, Yt, t);
+}, jn = ie("ul", {
+  name: "MuiRichTreeView",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  padding: 0,
+  margin: 0,
+  listStyle: "none",
+  outline: 0,
+  position: "relative"
+}), tt = /* @__PURE__ */ E.forwardRef(function(t, n) {
+  const r = Fn({
+    props: t,
+    name: "MuiRichTreeView"
+  });
+  process.env.NODE_ENV !== "production" && r.children != null && xe(["MUI X: The Rich Tree View component does not support JSX children.", "If you want to add items, you need to use the `items` prop.", "Check the documentation for more details: https://mui.com/x/react-tree-view/rich-tree-view/items/."]);
+  const {
+    getRootProps: l,
+    contextValue: x,
+    instance: I
+  } = ln({
+    plugins: yn,
+    rootRef: n,
+    props: r
+  }), {
+    slots: f,
+    slotProps: g
+  } = r, p = Ln(r), o = (f == null ? void 0 : f.root) ?? jn, s = N({
+    elementType: o,
+    externalSlotProps: g == null ? void 0 : g.root,
+    className: p.root,
+    getSlotProps: l,
+    ownerState: r
+  });
+  return /* @__PURE__ */ S(an, {
+    value: x,
+    children: /* @__PURE__ */ S(o, C({}, s, {
+      children: /* @__PURE__ */ S(et, {
+        slots: f,
+        slotProps: g,
+        itemsToRender: I.getItemsToRender()
+      })
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (tt.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: a.shape({
+    current: a.shape({
+      focusItem: a.func.isRequired,
+      getItem: a.func.isRequired,
+      getItemDOMElement: a.func.isRequired,
+      getItemOrderedChildrenIds: a.func.isRequired,
+      getItemTree: a.func.isRequired,
+      selectItem: a.func.isRequired,
+      setItemExpansion: a.func.isRequired,
+      updateItemLabel: a.func.isRequired
+    })
+  }),
+  /**
+   * If `true`, the Tree View renders a checkbox at the left of its label that allows selecting it.
+   * @default false
+   */
+  checkboxSelection: a.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: a.object,
+  className: a.string,
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is not controlled.
+   * @default []
+   */
+  defaultExpandedItems: a.arrayOf(a.string),
+  /**
+   * Selected item ids. (Uncontrolled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   * @default []
+   */
+  defaultSelectedItems: a.any,
+  /**
+   * If `true`, will allow focus on disabled items.
+   * @default false
+   */
+  disabledItemsFocusable: a.bool,
+  /**
+   * If `true` selection is disabled.
+   * @default false
+   */
+  disableSelection: a.bool,
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is controlled.
+   */
+  expandedItems: a.arrayOf(a.string),
+  /**
+   * The slot that triggers the item's expansion when clicked.
+   * @default 'content'
+   */
+  expansionTrigger: a.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: a.shape({
+    indentationAtItemLevel: a.bool,
+    labelEditing: a.bool
+  }),
+  /**
+   * Used to determine the id of a given item.
+   *
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {string} The id of the item.
+   * @default (item) => item.id
+   */
+  getItemId: a.func,
+  /**
+   * Used to determine the string label for a given item.
+   *
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {string} The label of the item.
+   * @default (item) => item.label
+   */
+  getItemLabel: a.func,
+  /**
+   * 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: a.string,
+  /**
+   * Used to determine if a given item should be disabled.
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {boolean} `true` if the item should be disabled.
+   */
+  isItemDisabled: a.func,
+  /**
+   * Determines if a given item is editable or not.
+   * Make sure to also enable the `labelEditing` experimental feature:
+   * `<RichTreeViewPro experimentalFeatures={{ labelEditing: true }}  />`.
+   * By default, the items are not editable.
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {boolean} `true` if the item is editable.
+   */
+  isItemEditable: a.oneOfType([a.func, a.bool]),
+  /**
+   * Horizontal indentation between an item and its children.
+   * Examples: 24, "24px", "2rem", "2em".
+   * @default 12px
+   */
+  itemChildrenIndentation: a.oneOfType([a.number, a.string]),
+  items: a.array.isRequired,
+  /**
+   * If `true`, `ctrl` and `shift` will trigger multiselect.
+   * @default false
+   */
+  multiSelect: a.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: a.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: a.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: a.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: a.func,
+  /**
+   * Callback fired when the label of an item changes.
+   * @param {TreeViewItemId} itemId The id of the item that was edited.
+   * @param {string} newLabel The new label of the items.
+   */
+  onItemLabelChange: a.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: a.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: a.func,
+  /**
+   * Selected item ids. (Controlled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   */
+  selectedItems: a.any,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: a.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: a.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: a.oneOfType([a.arrayOf(a.oneOfType([a.func, a.object, a.bool])), a.func, a.object])
+});
+const no = ({
+  items: e,
+  selectedItemId: t,
+  handleSelectedItemChange: n,
+  iconColor: r = "primary",
+  hasNoIcons: l = !1,
+  maxHeight: x = 300
+}) => {
+  const [I, f] = yt([]), g = Ct(() => Kt(e), [e]);
+  return wt(() => {
+    if (t) {
+      const o = Ut(e, t);
+      if (o) {
+        const s = o.slice(0, -1);
+        f((u) => {
+          const b = s.filter(
+            (h) => !u.includes(h)
+          );
+          return b.length > 0 ? [...u, ...b] : u;
+        });
+      }
+    }
+  }, [t, e]), /* @__PURE__ */ S($t, { maxHeight: x, "data-treeview-root": "true", children: /* @__PURE__ */ S(
+    tt,
+    {
+      items: e,
+      selectedItems: t,
+      expandedItems: I,
+      onExpandedItemsChange: (o, s) => {
+        f(s);
+      },
+      itemChildrenIndentation: Nt,
+      onSelectedItemsChange: n,
+      getItemId: Bt,
+      slots: {
+        item: (o) => {
+          const s = o.itemId ? g[o.itemId] : void 0;
+          return /* @__PURE__ */ S(
+            _t,
+            {
+              ...o,
+              itemData: s,
+              iconColor: r,
+              hasNoIcons: l
+            }
+          );
+        }
+      }
+    }
+  ) });
+};
+export {
+  no as default
+};