@cgi-learning-hub/ui 1.4.0-dev.1742207843 → 1.4.0-dev.1742214247

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

@@ -0,0 +1,1892 @@
+import { jsx as S, jsxs as je } from "react/jsx-runtime";
+import { B as yt } from "../../Box-GMNejc_m.js";
+import * as E from "react";
+import { useState as Ct, useMemo as wt, useEffect as Rt } from "react";
+import { c as St, T as Pt, g as _e, a as $e, b as Ne, d as se, f as vt, e as kt, h as Mt, i as he, j as ge, k as Dt, l as oe, u as H, m as Ke, n as Ot, o as Vt, p as Ue, q as At, r as Ft, s as Lt, t as jt, v as O, C as _t } from "../../CustomTreeItem-PTf-e74x.js";
+import { treeContainerStyle 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-CU1npQuI.js";
+import { H as zt, G as qt, I as Be, P as a, n as ne } from "../../generateUtilityClasses-EXBFO7eY.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-D_xl88AE.js";
+import { C as Wt } from "../../Checkbox-CtRSDqOe.js";
+import { w as xe } from "../../warning-C8W811fV.js";
+import { u as Ee } from "../../useForkRef-C_4o__cU.js";
+import { u as N } from "../../useSlotProps-U2Iu6E0j.js";
+import { r as $, e as Fe } from "../../resolveComponentProps-CIdMNno4.js";
+import { s as ie, c as ze, f as qe } from "../../DefaultPropsProvider-CQixa6JQ.js";
+import { C as Gt } from "../../Collapse-CcMCOZ3q.js";
+import { u as Jt } from "../../unsupportedProp-BuVD30Gh.js";
+import { e as Yt } from "../../elementTypeAcceptingRef-B04tk6ag.js";
+function Qt(e) {
+  return zt("MuiRichTreeView", e);
+}
+qt("MuiRichTreeView", ["root"]);
+const Zt = (e, t) => {
+  const n = E.useRef({}), [r, l] = E.useState(() => {
+    const g = {};
+    return e.forEach((p) => {
+      p.models && Object.entries(p.models).forEach(([m, d]) => {
+        n.current[m] = {
+          isControlled: t[m] !== void 0,
+          getDefaultValue: d.getDefaultValue
+        }, g[m] = d.getDefaultValue(t);
+      });
+    }), g;
+  }), h = Object.fromEntries(Object.entries(n.current).map(([g, p]) => {
+    const m = t[g] ?? r[g];
+    return [g, {
+      value: m,
+      setControlledValue: (d) => {
+        p.isControlled || l((o) => C({}, o, {
+          [g]: d
+        }));
+      }
+    }];
+  }));
+  return process.env.NODE_ENV !== "production" && Object.entries(n.current).forEach(([g, p]) => {
+    const m = t[g], d = p.getDefaultValue(t);
+    E.useEffect(() => {
+      p.isControlled !== (m !== void 0) && console.error([`MUI X: A component is changing the ${p.isControlled ? "" : "un"}controlled ${g} state of TreeView to be ${p.isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${g} 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(`
+`));
+    }, [m]);
+    const {
+      current: o
+    } = E.useRef(d);
+    E.useEffect(() => {
+      !p.isControlled && o !== d && console.error([`MUI X: A component is changing the default ${g} state of an uncontrolled TreeView after being initialized. To suppress this warning opt to use a controlled TreeView.`].join(`
+`));
+    }, [JSON.stringify(d)]);
+  }), h;
+};
+class en {
+  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 h = l.highPriority.size + l.regular.size;
+      h > this.maxListeners && !this.warnOnce && (this.warnOnce = !0, console.warn([`Possible EventEmitter memory leak detected. ${h} ${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()), h = Array.from(r.regular.keys());
+    for (let g = l.length - 1; g >= 0; g -= 1) {
+      const p = l[g];
+      r.highPriority.has(p) && p.apply(this, n);
+    }
+    for (let g = 0; g < h.length; g += 1) {
+      const p = h[g];
+      r.regular.has(p) && p.apply(this, n);
+    }
+  }
+  once(t, n) {
+    const r = this;
+    this.on(t, function l(...h) {
+      r.removeListener(t, l), n.apply(r, h);
+    });
+  }
+}
+const tn = (e) => e.isPropagationStopped !== void 0, He = () => {
+  const [e] = E.useState(() => new en()), t = E.useCallback((...r) => {
+    const [l, h, g = {}] = r;
+    g.defaultMuiPrevented = !1, !(tn(g) && g.isPropagationStopped()) && e.emit(l, h, g);
+  }, [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 ?? St()
+      })
+    }));
+  }, [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 nn = [He, Xe, Te], on = ["slots", "slotProps", "apiRef", "experimentalFeatures"], rn = (e) => {
+  let {
+    props: {
+      slots: t,
+      slotProps: n,
+      apiRef: r,
+      experimentalFeatures: l
+    },
+    plugins: h
+  } = e, g = A(e.props, on);
+  const p = {};
+  h.forEach((f) => {
+    Object.assign(p, f.params);
+  });
+  const m = {}, d = {};
+  Object.keys(g).forEach((f) => {
+    const b = g[f];
+    p[f] ? m[f] = b : d[f] = b;
+  });
+  const o = l ?? {}, s = h.reduce((f, b) => b.getDefaultizedParams ? b.getDefaultizedParams({
+    params: f,
+    experimentalFeatures: o
+  }) : f, m);
+  return {
+    apiRef: r,
+    forwardedProps: d,
+    pluginParams: s,
+    slots: t ?? {},
+    slotProps: n ?? {},
+    experimentalFeatures: o
+  };
+}, sn = ({
+  plugins: e,
+  instance: t,
+  publicAPI: n,
+  rootRef: r
+}) => ({
+  runItemPlugins: (p) => {
+    let m = null, d = null;
+    const o = [], s = {};
+    e.forEach((x) => {
+      if (!x.itemPlugin)
+        return;
+      const c = x.itemPlugin({
+        props: p,
+        rootRef: m,
+        contentRef: d
+      });
+      c != null && c.rootRef && (m = c.rootRef), c != null && c.contentRef && (d = c.contentRef), c != null && c.propsEnhancers && (o.push(c.propsEnhancers), Object.keys(c.propsEnhancers).forEach((i) => {
+        s[i] = !0;
+      }));
+    });
+    const f = (x) => (c) => {
+      const i = {};
+      return o.forEach((u) => {
+        const I = u[x];
+        I != null && Object.assign(i, I(c));
+      }), i;
+    }, b = Object.fromEntries(Object.keys(s).map((x) => [x, f(x)]));
+    return {
+      contentRef: d,
+      rootRef: m,
+      propsEnhancers: b
+    };
+  },
+  wrapItem: ({
+    itemId: p,
+    children: m
+  }) => {
+    let d = m;
+    for (let o = e.length - 1; o >= 0; o -= 1) {
+      const s = e[o];
+      s.wrapItem && (d = s.wrapItem({
+        itemId: p,
+        children: d,
+        instance: t
+      }));
+    }
+    return d;
+  },
+  wrapRoot: ({
+    children: p
+  }) => {
+    let m = p;
+    for (let d = e.length - 1; d >= 0; d -= 1) {
+      const o = e[d];
+      o.wrapRoot && (m = o.wrapRoot({
+        children: m,
+        instance: t
+      }));
+    }
+    return m;
+  },
+  instance: t,
+  rootRef: r,
+  publicAPI: n
+});
+function ln(e) {
+  const t = E.useRef({});
+  return e ? (e.current == null && (e.current = {}), e.current) : t.current;
+}
+const an = ({
+  plugins: e,
+  rootRef: t,
+  props: n
+}) => {
+  const r = [...nn, ...e], {
+    pluginParams: l,
+    forwardedProps: h,
+    apiRef: g,
+    experimentalFeatures: p,
+    slots: m,
+    slotProps: d
+  } = rn({
+    plugins: r,
+    props: n
+  }), o = Zt(r, l), f = E.useRef({}).current, b = ln(g), x = E.useRef(null), c = Ee(x, t), i = sn({
+    plugins: r,
+    instance: f,
+    publicAPI: b,
+    rootRef: x
+  }), [u, I] = E.useState(() => {
+    const R = {};
+    return r.forEach((v) => {
+      v.getInitialState && Object.assign(R, v.getInitialState(l));
+    }), R;
+  }), T = [], P = (R) => {
+    const v = R({
+      instance: f,
+      params: l,
+      slots: m,
+      slotProps: d,
+      experimentalFeatures: p,
+      state: u,
+      setState: I,
+      rootRef: x,
+      models: o,
+      plugins: r
+    });
+    v.getRootProps && T.push(v.getRootProps), v.publicAPI && Object.assign(b, v.publicAPI), v.instance && Object.assign(f, v.instance), v.contextValue && Object.assign(i, v.contextValue);
+  };
+  return r.forEach(P), {
+    getRootProps: (R = {}) => {
+      const v = C({
+        role: "tree"
+      }, h, R, {
+        ref: c
+      });
+      return T.forEach((F) => {
+        Object.assign(v, F(R));
+      }), v;
+    },
+    rootRef: c,
+    contextValue: i,
+    instance: f
+  };
+};
+function cn(e) {
+  const {
+    value: t,
+    children: n
+  } = e;
+  return /* @__PURE__ */ S(Pt.Provider, {
+    value: t,
+    children: t.wrapRoot({
+      children: n,
+      instance: t.instance
+    })
+  });
+}
+const un = (e, t, n) => {
+  e.$$publishEvent(t, n);
+}, K = "__TREE_VIEW_ROOT_PARENT_ID__", dn = (e) => {
+  const t = {};
+  return e.forEach((n, r) => {
+    t[n] = r;
+  }), t;
+}, fn = ["children"], We = ({
+  items: e,
+  isItemDisabled: t,
+  getItemLabel: n,
+  getItemId: r
+}) => {
+  const l = {}, h = {}, g = {
+    [K]: []
+  }, p = (d, o, s) => {
+    var c, i;
+    const f = r ? r(d) : d.id;
+    if (f == 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(d)].join(`
+`));
+    if (l[f] != 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: "${f}"`].join(`
+`));
+    const b = n ? n(d) : d.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(d)].join(`
+`));
+    l[f] = {
+      id: f,
+      label: b,
+      parentId: s,
+      idAttribute: void 0,
+      expandable: !!((c = d.children) != null && c.length),
+      disabled: t ? t(d) : !1,
+      depth: o
+    }, h[f] = d;
+    const x = s ?? K;
+    g[x] || (g[x] = []), g[x].push(f), (i = d.children) == null || i.forEach((u) => p(u, o + 1, f));
+  };
+  e.forEach((d) => p(d, 0, null));
+  const m = {};
+  return Object.keys(g).forEach((d) => {
+    m[d] = dn(g[d]);
+  }), {
+    itemMetaMap: l,
+    itemMap: h,
+    itemOrderedChildrenIds: g,
+    itemChildrenIndexes: m
+  };
+}, X = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: r,
+  experimentalFeatures: l
+}) => {
+  const h = E.useCallback((u) => n.items.itemMetaMap[u], [n.items.itemMetaMap]), g = E.useCallback((u) => n.items.itemMap[u], [n.items.itemMap]), p = E.useCallback(() => {
+    const u = (I) => {
+      const T = n.items.itemMap[I], P = A(T, fn), y = n.items.itemOrderedChildrenIds[I];
+      return y && (P.children = y.map(u)), P;
+    };
+    return n.items.itemOrderedChildrenIds[K].map(u);
+  }, [n.items.itemMap, n.items.itemOrderedChildrenIds]), m = E.useCallback((u) => {
+    if (u == null)
+      return !1;
+    let I = e.getItemMeta(u);
+    if (!I)
+      return !1;
+    if (I.disabled)
+      return !0;
+    for (; I.parentId != null; )
+      if (I = e.getItemMeta(I.parentId), I.disabled)
+        return !0;
+    return !1;
+  }, [e]), d = E.useCallback((u) => {
+    const I = e.getItemMeta(u).parentId ?? K;
+    return n.items.itemChildrenIndexes[I][u];
+  }, [e, n.items.itemChildrenIndexes]), o = E.useCallback((u) => n.items.itemOrderedChildrenIds[u ?? K] ?? [], [n.items.itemOrderedChildrenIds]), s = (u) => {
+    const I = e.getItemMeta(u);
+    return I == null ? null : document.getElementById(_e({
+      treeId: n.id.treeId,
+      itemId: u,
+      id: I.idAttribute
+    }));
+  }, f = (u) => t.disabledItemsFocusable ? !0 : !e.isItemDisabled(u), b = E.useRef(!1), x = E.useCallback(() => {
+    b.current = !0;
+  }, []), c = E.useCallback(() => b.current, []);
+  return E.useEffect(() => {
+    e.areItemUpdatesPrevented() || r((u) => {
+      const I = We({
+        items: t.items,
+        isItemDisabled: t.isItemDisabled,
+        getItemId: t.getItemId,
+        getItemLabel: t.getItemLabel
+      });
+      return Object.values(u.items.itemMetaMap).forEach((T) => {
+        I.itemMetaMap[T.id] || un(e, "removeItem", {
+          id: T.id
+        });
+      }), C({}, u, {
+        items: I
+      });
+    });
+  }, [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: g,
+      getItemDOMElement: s,
+      getItemTree: p,
+      getItemOrderedChildrenIds: o
+    },
+    instance: {
+      getItemMeta: h,
+      getItem: g,
+      getItemTree: p,
+      getItemsToRender: () => {
+        const u = (I) => {
+          var P;
+          const T = n.items.itemMetaMap[I];
+          return {
+            label: T.label,
+            itemId: T.id,
+            id: T.idAttribute,
+            children: (P = n.items.itemOrderedChildrenIds[I]) == null ? void 0 : P.map(u)
+          };
+        };
+        return n.items.itemOrderedChildrenIds[K].map(u);
+      },
+      getItemIndex: d,
+      getItemDOMElement: s,
+      getItemOrderedChildrenIds: o,
+      isItemDisabled: m,
+      isItemNavigable: f,
+      preventItemUpdates: x,
+      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((f) => {
+      s.set(f, !0);
+    }), s;
+  }, [n.expandedItems.value]), l = (s, f) => {
+    var b;
+    (b = t.onExpandedItemsChange) == null || b.call(t, s, f), n.expandedItems.setControlledValue(f);
+  }, h = E.useCallback((s) => r.has(s), [r]), g = E.useCallback((s) => {
+    var f;
+    return !!((f = e.getItemMeta(s)) != null && f.expandable);
+  }, [e]), p = U((s, f) => {
+    const b = e.isItemExpanded(f);
+    e.setItemExpansion(s, f, !b);
+  }), m = U((s, f, b) => {
+    if (e.isItemExpanded(f) === b)
+      return;
+    let c;
+    b ? c = [f].concat(n.expandedItems.value) : c = n.expandedItems.value.filter((i) => i !== f), t.onItemExpansionToggle && t.onItemExpansionToggle(s, f, b), l(s, c);
+  }), d = (s, f) => {
+    const b = e.getItemMeta(f), c = e.getItemOrderedChildrenIds(b.parentId).filter((u) => e.isItemExpandable(u) && !e.isItemExpanded(u)), i = n.expandedItems.value.concat(c);
+    c.length > 0 && (t.onItemExpansionToggle && c.forEach((u) => {
+      t.onItemExpansionToggle(s, u, !0);
+    }), l(s, i));
+  }, o = E.useMemo(() => t.expansionTrigger ? t.expansionTrigger : e.isTreeViewEditable ? "iconContainer" : "content", [t.expansionTrigger, e.isTreeViewEditable]);
+  return {
+    publicAPI: {
+      setItemExpansion: m
+    },
+    instance: {
+      isItemExpanded: h,
+      isItemExpandable: g,
+      setItemExpansion: m,
+      toggleItemExpansion: p,
+      expandAllSiblings: d
+    },
+    contextValue: {
+      expansion: {
+        expansionTrigger: o
+      }
+    }
+  };
+};
+le.models = {
+  expandedItems: {
+    getDefaultValue: (e) => e.defaultExpandedItems
+  }
+};
+const pn = [];
+le.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  defaultExpandedItems: e.defaultExpandedItems ?? pn
+});
+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({}), h = 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]), g = (c, i) => {
+    if (t.onItemSelectionToggle)
+      if (t.multiSelect) {
+        const u = i.filter((T) => !e.isItemSelected(T)), I = n.selectedItems.value.filter((T) => !i.includes(T));
+        u.forEach((T) => {
+          t.onItemSelectionToggle(c, T, !0);
+        }), I.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);
+  }, p = (c) => h.has(c), m = ({
+    event: c,
+    itemId: i,
+    keepExistingSelection: u = !1,
+    shouldBeSelected: I
+  }) => {
+    if (t.disableSelection)
+      return;
+    let T;
+    if (u) {
+      const P = re(n.selectedItems.value), y = e.isItemSelected(i);
+      y && (I === !1 || I == null) ? T = P.filter((R) => R !== i) : !y && (I === !0 || I == null) ? T = [i].concat(P) : T = P;
+    } else
+      I === !1 || I == null && e.isItemSelected(i) ? T = t.multiSelect ? [] : null : T = t.multiSelect ? [i] : i;
+    g(c, T), r.current = i, l.current = {};
+  }, d = (c, [i, u]) => {
+    if (t.disableSelection || !t.multiSelect)
+      return;
+    let I = re(n.selectedItems.value).slice();
+    Object.keys(l.current).length > 0 && (I = I.filter((R) => !l.current[R]));
+    const T = be(I), P = Mt(e, i, u), y = P.filter((R) => !T[R]);
+    I = I.concat(y), g(c, I), l.current = be(P);
+  };
+  return {
+    getRootProps: () => ({
+      "aria-multiselectable": t.multiSelect
+    }),
+    publicAPI: {
+      selectItem: m
+    },
+    instance: {
+      isItemSelected: p,
+      selectItem: m,
+      selectAllNavigableItems: (c) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        const i = kt(e);
+        g(c, i), l.current = be(i);
+      },
+      expandSelectionRange: (c, i) => {
+        if (r.current != null) {
+          const [u, I] = vt(e, i, r.current);
+          d(c, [u, I]);
+        }
+      },
+      selectRangeFromStartToItem: (c, i) => {
+        d(c, [se(e), i]);
+      },
+      selectRangeFromItemToEnd: (c, i) => {
+        d(c, [i, Ne(e)]);
+      },
+      selectItemFromArrowNavigation: (c, i, u) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        let I = re(n.selectedItems.value).slice();
+        Object.keys(l.current).length === 0 ? (I.push(u), l.current = {
+          [i]: !0,
+          [u]: !0
+        }) : (l.current[i] || (l.current = {}), l.current[u] ? (I = I.filter((T) => T !== i), delete l.current[i]) : (I.push(u), l.current[u] = !0)), g(c, I);
+      }
+    },
+    contextValue: {
+      selection: {
+        multiSelect: t.multiSelect,
+        checkboxSelection: t.checkboxSelection,
+        disableSelection: t.disableSelection
+      }
+    }
+  };
+};
+ae.models = {
+  selectedItems: {
+    getDefaultValue: (e) => e.defaultSelectedItems
+  }
+};
+const mn = [];
+ae.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  disableSelection: e.disableSelection ?? !1,
+  multiSelect: e.multiSelect ?? !1,
+  checkboxSelection: e.checkboxSelection ?? !1,
+  defaultSelectedItems: e.defaultSelectedItems ?? (e.multiSelect ? mn : null)
+});
+ae.params = {
+  disableSelection: !0,
+  multiSelect: !0,
+  checkboxSelection: !0,
+  defaultSelectedItems: !0,
+  selectedItems: !0,
+  onSelectedItemsChange: !0,
+  onItemSelectionToggle: !0
+};
+const Le = 1e3;
+class In {
+  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 gn {
+  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 bn {
+}
+function hn(e) {
+  let t = 0;
+  return function(r, l, h) {
+    e.registry === null && (e.registry = typeof FinalizationRegistry < "u" ? new gn() : new In());
+    const [g] = E.useState(new bn()), p = E.useRef(null), m = E.useRef(void 0);
+    m.current = h;
+    const d = E.useRef(null);
+    if (!p.current && m.current) {
+      const o = (s, f) => {
+        var b;
+        f.defaultMuiPrevented || (b = m.current) == null || b.call(m, s, f);
+      };
+      p.current = r.$$subscribeEvent(l, o), t += 1, d.current = {
+        cleanupToken: t
+      }, e.registry.register(
+        g,
+        // The callback below will be called once this reference stops being retained
+        () => {
+          var s;
+          (s = p.current) == null || s.call(p), p.current = null, d.current = null;
+        },
+        d.current
+      );
+    } else !m.current && p.current && (p.current(), p.current = null, d.current && (e.registry.unregister(d.current), d.current = null));
+    E.useEffect(() => {
+      if (!p.current && m.current) {
+        const o = (s, f) => {
+          var b;
+          f.defaultMuiPrevented || (b = m.current) == null || b.call(m, s, f);
+        };
+        p.current = r.$$subscribeEvent(l, o);
+      }
+      return d.current && e.registry && (e.registry.unregister(d.current), d.current = null), () => {
+        var o;
+        (o = p.current) == null || o.call(p), p.current = null;
+      };
+    }, [r, l]);
+  };
+}
+const xn = {
+  registry: null
+}, En = hn(xn), Ge = (e = document) => {
+  const t = e.activeElement;
+  return t ? t.shadowRoot ? Ge(t.shadowRoot) : t : null;
+}, Tn = (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: h
+}) => {
+  const g = Tn(e, l.selectedItems.value), p = U((i) => {
+    const u = typeof i == "function" ? i(n.focusedItemId) : i;
+    n.focusedItemId !== u && r((I) => C({}, I, {
+      focusedItemId: u
+    }));
+  }), m = E.useCallback(() => !!h.current && h.current.contains(Ge(Ht(h.current))), [h]), d = E.useCallback((i) => n.focusedItemId === i && m(), [n.focusedItemId, m]), o = (i) => {
+    const u = e.getItemMeta(i);
+    return u && (u.parentId == null || e.isItemExpanded(u.parentId));
+  }, s = (i, u) => {
+    const I = e.getItemDOMElement(u);
+    I && I.focus(), p(u), t.onItemFocus && t.onItemFocus(i, u);
+  }, f = U((i, u) => {
+    o(u) && s(i, u);
+  }), b = U(() => {
+    if (n.focusedItemId == null)
+      return;
+    if (e.getItemMeta(n.focusedItemId)) {
+      const u = e.getItemDOMElement(n.focusedItemId);
+      u && u.blur();
+    }
+    p(null);
+  }), x = (i) => i === g;
+  En(e, "removeItem", ({
+    id: i
+  }) => {
+    n.focusedItemId === i && s(null, g);
+  });
+  const c = (i) => (u) => {
+    var I;
+    (I = i.onFocus) == null || I.call(i, u), !u.defaultMuiPrevented && u.target === u.currentTarget && s(u, g);
+  };
+  return {
+    getRootProps: (i) => ({
+      onFocus: c(i)
+    }),
+    publicAPI: {
+      focusItem: f
+    },
+    instance: {
+      isItemFocused: d,
+      canItemBeTabbed: x,
+      focusItem: f,
+      removeFocusedItem: b
+    }
+  };
+};
+ye.getInitialState = () => ({
+  focusedItemId: null
+});
+ye.params = {
+  onItemFocus: !0
+};
+function yn(e) {
+  return !!e && e.length === 1 && !!e.match(/\S/);
+}
+const Je = ({
+  instance: e,
+  params: t,
+  state: n
+}) => {
+  const r = Xt(), l = E.useRef({}), h = U((o) => {
+    l.current = o(l.current);
+  });
+  E.useEffect(() => {
+    if (e.areItemUpdatesPrevented())
+      return;
+    const o = {}, s = (f) => {
+      o[f.id] = f.label.substring(0, 1).toLowerCase();
+    };
+    Object.values(n.items.itemMetaMap).forEach(s), l.current = o;
+  }, [n.items.itemMetaMap, t.getItemId, e]);
+  const g = (o, s) => {
+    const f = s.toLowerCase(), b = (u) => {
+      const I = ge(e, u);
+      return I === null ? se(e) : I;
+    };
+    let x = null, c = b(o);
+    const i = {};
+    for (; x == null && !i[c]; )
+      l.current[c] === f ? x = c : (i[c] = !0, c = b(c));
+    return x;
+  }, p = (o) => !t.disableSelection && !e.isItemDisabled(o), m = (o) => !e.isItemDisabled(o) && e.isItemExpandable(o);
+  return {
+    instance: {
+      updateFirstCharMap: h,
+      handleItemKeyDown: (o, s) => {
+        if (o.defaultMuiPrevented || o.altKey || he(o.target, o.currentTarget))
+          return;
+        const f = o.ctrlKey || o.metaKey, b = o.key;
+        switch (!0) {
+          // Select the item when pressing "Space"
+          case (b === " " && p(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) : m(s) ? (e.toggleItemExpansion(o, s), o.preventDefault()) : p(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 x = ge(e, s);
+            x && (o.preventDefault(), e.focusItem(o, x), t.multiSelect && o.shiftKey && p(x) && e.selectItemFromArrowNavigation(o, s, x));
+            break;
+          }
+          // Focuses the previous focusable item
+          case b === "ArrowUp": {
+            const x = Dt(e, s);
+            x && (o.preventDefault(), e.focusItem(o, x), t.multiSelect && o.shiftKey && p(x) && e.selectItemFromArrowNavigation(o, s, x));
+            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 (f)
+              return;
+            if (e.isItemExpanded(s)) {
+              const x = ge(e, s);
+              x && (e.focusItem(o, x), o.preventDefault());
+            } else m(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 (f)
+              return;
+            if (m(s) && e.isItemExpanded(s))
+              e.toggleItemExpansion(o, s), o.preventDefault();
+            else {
+              const x = e.getItemMeta(s).parentId;
+              x && (e.focusItem(o, x), o.preventDefault());
+            }
+            break;
+          }
+          // Focuses the first item in the tree
+          case b === "Home": {
+            p(s) && t.multiSelect && f && o.shiftKey ? e.selectRangeFromStartToItem(o, s) : e.focusItem(o, se(e)), o.preventDefault();
+            break;
+          }
+          // Focuses the last item in the tree
+          case b === "End": {
+            p(s) && t.multiSelect && f && 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" && f && t.multiSelect && !t.disableSelection): {
+            e.selectAllNavigableItems(o), o.preventDefault();
+            break;
+          }
+          // Type-ahead
+          // TODO: Support typing multiple characters
+          case (!f && !o.shiftKey && yn(b)): {
+            const x = g(s, b);
+            x != null && (e.focusItem(o, x), 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 Cn = [X, le, ae, ye, Je, Ye, H];
+function Qe(e) {
+  const {
+    instance: t,
+    items: {
+      onItemClick: n
+    },
+    selection: {
+      multiSelect: r,
+      checkboxSelection: l,
+      disableSelection: h
+    },
+    expansion: {
+      expansionTrigger: g
+    }
+  } = Ke(), p = t.isItemExpandable(e), m = t.isItemExpanded(e), d = t.isItemFocused(e), o = t.isItemSelected(e), s = t.isItemDisabled(e), f = t != null && t.isItemBeingEdited ? t == null ? void 0 : t.isItemBeingEdited(e) : !1, b = t.isItemEditable ? t.isItemEditable(e) : !1, x = (y) => {
+    if (!s) {
+      d || t.focusItem(y, e);
+      const R = r && (y.shiftKey || y.ctrlKey || y.metaKey);
+      p && !(R && t.isItemExpanded(e)) && t.toggleItemExpansion(y, e);
+    }
+  }, c = (y) => {
+    s || (d || 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 (h || 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
+    });
+  }, u = (y) => {
+    (y.shiftKey || y.ctrlKey || y.metaKey || s) && y.preventDefault();
+  }, I = () => {
+    oe(t, H) && t.isItemEditable(e) && (t.isItemBeingEdited(e) ? t.setEditedItemId(null) : t.setEditedItemId(e));
+  };
+  return {
+    disabled: s,
+    expanded: m,
+    selected: o,
+    focused: d,
+    editable: b,
+    editing: f,
+    disableSelection: h,
+    checkboxSelection: l,
+    handleExpansion: x,
+    handleSelection: c,
+    handleCheckboxSelection: i,
+    handleContentClick: n,
+    preventSelection: u,
+    expansionTrigger: g,
+    toggleItemEditing: I,
+    handleSaveItemLabel: (y, R) => {
+      oe(t, H) && t.isItemBeingEditedRef(e) && (t.updateItemLabel(e, R), I(), t.focusItem(y, e));
+    },
+    handleCancelItemLabelEditing: (y) => {
+      oe(t, H) && t.isItemBeingEditedRef(e) && (I(), t.focusItem(y, e));
+    }
+  };
+}
+const wn = ["classes", "className", "displayIcon", "expansionIcon", "icon", "label", "itemId", "onClick", "onMouseDown", "dragAndDropOverlayProps", "labelInputProps"], Ce = /* @__PURE__ */ E.forwardRef(function(t, n) {
+  const {
+    classes: r,
+    className: l,
+    displayIcon: h,
+    expansionIcon: g,
+    icon: p,
+    label: m,
+    itemId: d,
+    onClick: o,
+    onMouseDown: s,
+    dragAndDropOverlayProps: f,
+    labelInputProps: b
+  } = t, x = A(t, wn), {
+    disabled: c,
+    expanded: i,
+    selected: u,
+    focused: I,
+    editing: T,
+    editable: P,
+    disableSelection: y,
+    checkboxSelection: R,
+    handleExpansion: v,
+    handleSelection: F,
+    handleCheckboxSelection: B,
+    handleContentClick: V,
+    preventSelection: L,
+    expansionTrigger: W,
+    toggleItemEditing: G
+  } = Qe(d), j = p || g || h, J = E.useRef(null), ce = (M) => {
+    L(M), s && s(M);
+  }, ue = (M) => {
+    var Y;
+    V == null || V(M, d), !((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({}, x, {
+      className: Be(r.root, l, i && r.expanded, u && r.selected, I && 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: u,
+        onChange: B,
+        disabled: c || y,
+        ref: J,
+        tabIndex: -1
+      }), T ? /* @__PURE__ */ S(Ot, C({}, b, {
+        className: r.labelInput
+      })) : /* @__PURE__ */ S("div", C({
+        className: r.label
+      }, P && {
+        onDoubleClick: de
+      }, {
+        children: m
+      })), f && /* @__PURE__ */ S(Vt, C({}, f))]
+    }))
+  );
+});
+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 Rn = ["children", "className", "slots", "slotProps", "ContentComponent", "ContentProps", "itemId", "id", "label", "onClick", "onMouseDown", "onFocus", "onBlur", "onKeyDown"], Sn = ["ownerState"], Pn = ["ownerState"], vn = ["ownerState"], kn = Ue(), Mn = (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"]
+  }, jt, t);
+}, Dn = ie("li", {
+  name: "MuiTreeItem",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), On = 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))`
+    }
+  }]
+})), Vn = ie(Gt, {
+  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: h,
+      indentationAtItemLevel: g
+    },
+    selection: {
+      disableSelection: p
+    },
+    expansion: {
+      expansionTrigger: m
+    },
+    treeId: d,
+    instance: o
+  } = Ke(), s = E.useContext($e), f = kn({
+    props: t,
+    name: "MuiTreeItem"
+  }), {
+    children: b,
+    className: x,
+    slots: c,
+    slotProps: i,
+    ContentComponent: u = Ce,
+    ContentProps: I,
+    itemId: T,
+    id: P,
+    label: y,
+    onClick: R,
+    onMouseDown: v,
+    onBlur: F,
+    onKeyDown: B
+  } = f, V = A(f, Rn), {
+    expanded: L,
+    focused: W,
+    selected: G,
+    disabled: j,
+    editing: J,
+    handleExpansion: ce,
+    handleCancelItemLabelEditing: ue,
+    handleSaveItemLabel: de
+  } = Qe(T);
+  process.env.NODE_ENV !== "production" && (f.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/."]), f.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(f), Q = E.useRef(null), we = E.useRef(null), nt = Ee(n, Y, Q), ot = Ee(I == null ? void 0 : I.ref, M, we), z = {
+    expandIcon: (c == null ? void 0 : c.expandIcon) ?? r.slots.expandIcon ?? Ft,
+    collapseIcon: (c == null ? void 0 : c.collapseIcon) ?? r.slots.collapseIcon ?? At,
+    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({}, f, {
+    expanded: L,
+    focused: W,
+    selected: G,
+    disabled: j,
+    indentationAtItemLevel: g
+  }), k = Mn(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"
+    }, g ? {
+      indentationAtItemLevel: !0
+    } : {}),
+    className: k.groupTransition
+  }), st = (w) => {
+    m === "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, Sn), 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, Pn), 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, vn), mt = Ie ? /* @__PURE__ */ S(Ie, C({}, pt)) : null;
+  let ee;
+  G ? ee = !0 : p || j ? ee = void 0 : ee = !1;
+  function It(w) {
+    !W && (!j || h) && 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: d,
+    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(I)
+  }))) ?? {}, 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(Lt, {
+    itemId: T,
+    children: /* @__PURE__ */ je(Dn, C({
+      className: Be(k.root, x),
+      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: g ? C({}, V.style, {
+        "--TreeView-itemDepth": typeof s == "function" ? s(T) : s
+      }) : V.style
+    }, Et, {
+      children: [/* @__PURE__ */ S(On, C({
+        as: u,
+        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
+      }, I, Tt, Pe.action == null ? {} : {
+        dragAndDropOverlayProps: Pe
+      }, ve.value == null ? {} : {
+        labelInputProps: ve
+      }, {
+        ref: ot
+      })), b && /* @__PURE__ */ S(Vn, 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: Yt,
+  /**
+   * 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: Jt,
+  /**
+   * 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 An = ["ownerState"];
+function Fn({
+  slots: e,
+  slotProps: t,
+  label: n,
+  id: r,
+  itemId: l,
+  itemsToRender: h
+}) {
+  const g = (e == null ? void 0 : e.item) ?? Ze, p = N({
+    elementType: g,
+    externalSlotProps: t == null ? void 0 : t.item,
+    additionalProps: {
+      itemId: l,
+      id: r,
+      label: n
+    },
+    ownerState: {
+      itemId: l,
+      label: n
+    }
+  }), m = A(p, An), d = E.useMemo(() => h ? /* @__PURE__ */ S(et, {
+    itemsToRender: h,
+    slots: e,
+    slotProps: t
+  }) : null, [h, e, t]);
+  return /* @__PURE__ */ S(g, C({}, m, {
+    children: d
+  }));
+}
+function et(e) {
+  const {
+    itemsToRender: t,
+    slots: n,
+    slotProps: r
+  } = e;
+  return /* @__PURE__ */ S(E.Fragment, {
+    children: t.map((l) => /* @__PURE__ */ S(Fn, {
+      slots: n,
+      slotProps: r,
+      label: l.label,
+      id: l.id,
+      itemId: l.itemId,
+      itemsToRender: l.children
+    }, l.itemId))
+  });
+}
+const Ln = Ue(), jn = (e) => {
+  const {
+    classes: t
+  } = e;
+  return ze({
+    root: ["root"]
+  }, Qt, t);
+}, _n = 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 = Ln({
+    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: h,
+    instance: g
+  } = an({
+    plugins: Cn,
+    rootRef: n,
+    props: r
+  }), {
+    slots: p,
+    slotProps: m
+  } = r, d = jn(r), o = (p == null ? void 0 : p.root) ?? _n, s = N({
+    elementType: o,
+    externalSlotProps: m == null ? void 0 : m.root,
+    className: d.root,
+    getSlotProps: l,
+    ownerState: r
+  });
+  return /* @__PURE__ */ S(cn, {
+    value: h,
+    children: /* @__PURE__ */ S(o, C({}, s, {
+      children: /* @__PURE__ */ S(et, {
+        slots: p,
+        slotProps: m,
+        itemsToRender: g.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 io = ({
+  items: e,
+  selectedItemId: t,
+  handleSelectedItemChange: n,
+  iconColor: r = "primary"
+}) => {
+  const [l, h] = Ct([]), g = wt(() => Kt(e), [e]);
+  return Rt(() => {
+    if (t) {
+      const m = Ut(e, t);
+      if (m) {
+        const d = m.slice(0, -1);
+        h((o) => {
+          const s = d.filter(
+            (f) => !o.includes(f)
+          );
+          return s.length > 0 ? [...o, ...s] : o;
+        });
+      }
+    }
+  }, [t, e]), /* @__PURE__ */ S(yt, { sx: $t, "data-treeview-root": "true", children: /* @__PURE__ */ S(
+    tt,
+    {
+      items: e,
+      selectedItems: t,
+      expandedItems: l,
+      onExpandedItemsChange: (m, d) => {
+        h(d);
+      },
+      itemChildrenIndentation: Nt,
+      onSelectedItemsChange: n,
+      getItemId: Bt,
+      slots: {
+        item: (m) => {
+          const d = m.itemId ? g[m.itemId] : void 0;
+          return /* @__PURE__ */ S(
+            _t,
+            {
+              ...m,
+              itemData: d,
+              iconColor: r
+            }
+          );
+        }
+      }
+    }
+  ) });
+};
+export {
+  io as default
+};