@cgi-learning-hub/ui 1.4.0-dev.1741956837 → 1.4.0-dev.1741972878

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

@@ -0,0 +1,2882 @@
+import { jsx as v, jsxs as de } from "react/jsx-runtime";
+import { D as Yt } from "../../Delete-CbtdIdDB.js";
+import { c as ue } from "../../createSvgIcon-K1Hd8ryN.js";
+import { B as it } from "../../Box-DgqaLb7j.js";
+import * as E from "react";
+import { forwardRef as Zt, useMemo as nt, useEffect as Ht } from "react";
+import { _ as C } from "../../ButtonBase-IZ_QjbpE.js";
+import { w as ve } from "../../warning-C8W811fV.js";
+import { u as Ie } from "../../useForkRef-C_4o__cU.js";
+import { r as H, e as U } from "../../resolveComponentProps-CPmhKPdH.js";
+import { I as st, H as lt, n as J, P as d, G as $e } from "../../generateUtilityClasses-DotvgSDH.js";
+import { a as G } from "../../TransitionGroupContext-DbLioz_6.js";
+import { u as en } from "../../useThemeProps-BTfGtNci.js";
+import { s as _, f as pe, c as Ne } from "../../DefaultPropsProvider-Cqcb4sws.js";
+import { C as at } from "../../Collapse-CLl0D4CI.js";
+import { C as ct } from "../../Checkbox-DgU-0k3O.js";
+import { u as dt } from "../../unsupportedProp-BuVD30Gh.js";
+import { u as tn, a as V } from "../../useSlotProps-C9tsxDNg.js";
+import { u as ce } from "../../useEventCallback-BAQJJ3ye.js";
+import { o as nn } from "../../ownerDocument-CUrv0DIK.js";
+import { e as on } from "../../elementTypeAcceptingRef-5ESWTE79.js";
+const Ve = ue(/* @__PURE__ */ v("path", {
+  d: "M10 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2h-8z"
+}), "Folder"), rn = ue(/* @__PURE__ */ v("path", {
+  d: "M7.41 8.59 12 13.17l4.59-4.58L18 10l-6 6-6-6z"
+}), "KeyboardArrowDown"), sn = ue(/* @__PURE__ */ v("path", {
+  d: "M8.59 16.59 13.17 12 8.59 7.41 10 6l6 6-6 6z"
+}), "KeyboardArrowRight"), ln = ue(/* @__PURE__ */ v("path", {
+  d: "M18 16.08c-.76 0-1.44.3-1.96.77L8.91 12.7c.05-.23.09-.46.09-.7s-.04-.47-.09-.7l7.05-4.11c.54.5 1.25.81 2.04.81 1.66 0 3-1.34 3-3s-1.34-3-3-3-3 1.34-3 3c0 .24.04.47.09.7L8.04 9.81C7.5 9.31 6.79 9 6 9c-1.66 0-3 1.34-3 3s1.34 3 3 3c.79 0 1.5-.31 2.04-.81l7.12 4.16c-.05.21-.08.43-.08.65 0 1.61 1.31 2.92 2.92 2.92s2.92-1.31 2.92-2.92-1.31-2.92-2.92-2.92"
+}), "Share");
+function an(e) {
+  return st("MuiRichTreeView", e);
+}
+lt("MuiRichTreeView", ["root"]);
+function je(e) {
+  return en;
+}
+const cn = (e, t) => {
+  const n = E.useRef({}), [o, r] = E.useState(() => {
+    const p = {};
+    return e.forEach((s) => {
+      s.models && Object.entries(s.models).forEach(([u, c]) => {
+        n.current[u] = {
+          isControlled: t[u] !== void 0,
+          getDefaultValue: c.getDefaultValue
+        }, p[u] = c.getDefaultValue(t);
+      });
+    }), p;
+  }), I = Object.fromEntries(Object.entries(n.current).map(([p, s]) => {
+    const u = t[p] ?? o[p];
+    return [p, {
+      value: u,
+      setControlledValue: (c) => {
+        s.isControlled || r((i) => C({}, i, {
+          [p]: c
+        }));
+      }
+    }];
+  }));
+  return process.env.NODE_ENV !== "production" && Object.entries(n.current).forEach(([p, s]) => {
+    const u = t[p], c = s.getDefaultValue(t);
+    E.useEffect(() => {
+      s.isControlled !== (u !== void 0) && console.error([`MUI X: A component is changing the ${s.isControlled ? "" : "un"}controlled ${p} state of TreeView to be ${s.isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${p} 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(`
+`));
+    }, [u]);
+    const {
+      current: i
+    } = E.useRef(c);
+    E.useEffect(() => {
+      !s.isControlled && i !== c && console.error([`MUI X: A component is changing the default ${p} state of an uncontrolled TreeView after being initialized. To suppress this warning opt to use a controlled TreeView.`].join(`
+`));
+    }, [JSON.stringify(c)]);
+  }), I;
+};
+class dn {
+  constructor() {
+    this.maxListeners = 20, this.warnOnce = !1, this.events = {};
+  }
+  on(t, n, o = {}) {
+    let r = this.events[t];
+    if (r || (r = {
+      highPriority: /* @__PURE__ */ new Map(),
+      regular: /* @__PURE__ */ new Map()
+    }, this.events[t] = r), o.isFirst ? r.highPriority.set(n, !0) : r.regular.set(n, !0), process.env.NODE_ENV !== "production") {
+      const I = r.highPriority.size + r.regular.size;
+      I > this.maxListeners && !this.warnOnce && (this.warnOnce = !0, console.warn([`Possible EventEmitter memory leak detected. ${I} ${t} listeners added.`].join(`
+`)));
+    }
+  }
+  removeListener(t, n) {
+    this.events[t] && (this.events[t].regular.delete(n), this.events[t].highPriority.delete(n));
+  }
+  removeAllListeners() {
+    this.events = {};
+  }
+  emit(t, ...n) {
+    const o = this.events[t];
+    if (!o)
+      return;
+    const r = Array.from(o.highPriority.keys()), I = Array.from(o.regular.keys());
+    for (let p = r.length - 1; p >= 0; p -= 1) {
+      const s = r[p];
+      o.highPriority.has(s) && s.apply(this, n);
+    }
+    for (let p = 0; p < I.length; p += 1) {
+      const s = I[p];
+      o.regular.has(s) && s.apply(this, n);
+    }
+  }
+  once(t, n) {
+    const o = this;
+    this.on(t, function r(...I) {
+      o.removeListener(t, r), n.apply(o, I);
+    });
+  }
+}
+const un = (e) => e.isPropagationStopped !== void 0, ut = () => {
+  const [e] = E.useState(() => new dn()), t = E.useCallback((...o) => {
+    const [r, I, p = {}] = o;
+    p.defaultMuiPrevented = !1, !(un(p) && p.isPropagationStopped()) && e.emit(r, I, p);
+  }, [e]), n = E.useCallback((o, r) => (e.on(o, r), () => {
+    e.removeListener(o, r);
+  }), [e]);
+  return {
+    instance: {
+      $$publishEvent: t,
+      $$subscribeEvent: n
+    }
+  };
+};
+ut.params = {};
+const pt = ({
+  plugins: e
+}) => {
+  const t = new Set(e);
+  return {
+    instance: {
+      getAvailablePlugins: () => t
+    }
+  };
+};
+pt.params = {};
+let ot = 0;
+const pn = () => (ot += 1, `mui-tree-view-${ot}`), Ke = ({
+  id: e,
+  treeId: t = "",
+  itemId: n
+}) => e ?? `${t}-${n}`, _e = ({
+  params: e,
+  state: t,
+  setState: n
+}) => {
+  E.useEffect(() => {
+    n((r) => r.id.treeId === e.id && r.id.treeId !== void 0 ? r : C({}, r, {
+      id: C({}, r.id, {
+        treeId: e.id ?? pn()
+      })
+    }));
+  }, [n, e.id]);
+  const o = e.id ?? t.id.treeId;
+  return {
+    getRootProps: () => ({
+      id: o
+    }),
+    contextValue: {
+      treeId: o
+    }
+  };
+};
+_e.params = {
+  id: !0
+};
+_e.getInitialState = ({
+  id: e
+}) => ({
+  id: {
+    treeId: e ?? void 0
+  }
+});
+const fn = [ut, pt, _e], mn = ["slots", "slotProps", "apiRef", "experimentalFeatures"], In = (e) => {
+  let {
+    props: {
+      slots: t,
+      slotProps: n,
+      apiRef: o,
+      experimentalFeatures: r
+    },
+    plugins: I
+  } = e, p = G(e.props, mn);
+  const s = {};
+  I.forEach((m) => {
+    Object.assign(s, m.params);
+  });
+  const u = {}, c = {};
+  Object.keys(p).forEach((m) => {
+    const a = p[m];
+    s[m] ? u[m] = a : c[m] = a;
+  });
+  const i = r ?? {}, l = I.reduce((m, a) => a.getDefaultizedParams ? a.getDefaultizedParams({
+    params: m,
+    experimentalFeatures: i
+  }) : m, u);
+  return {
+    apiRef: o,
+    forwardedProps: c,
+    pluginParams: l,
+    slots: t ?? {},
+    slotProps: n ?? {},
+    experimentalFeatures: i
+  };
+}, gn = ({
+  plugins: e,
+  instance: t,
+  publicAPI: n,
+  rootRef: o
+}) => ({
+  runItemPlugins: (s) => {
+    let u = null, c = null;
+    const i = [], l = {};
+    e.forEach((h) => {
+      if (!h.itemPlugin)
+        return;
+      const g = h.itemPlugin({
+        props: s,
+        rootRef: u,
+        contentRef: c
+      });
+      g != null && g.rootRef && (u = g.rootRef), g != null && g.contentRef && (c = g.contentRef), g != null && g.propsEnhancers && (i.push(g.propsEnhancers), Object.keys(g.propsEnhancers).forEach((f) => {
+        l[f] = !0;
+      }));
+    });
+    const m = (h) => (g) => {
+      const f = {};
+      return i.forEach((b) => {
+        const x = b[h];
+        x != null && Object.assign(f, x(g));
+      }), f;
+    }, a = Object.fromEntries(Object.keys(l).map((h) => [h, m(h)]));
+    return {
+      contentRef: c,
+      rootRef: u,
+      propsEnhancers: a
+    };
+  },
+  wrapItem: ({
+    itemId: s,
+    children: u
+  }) => {
+    let c = u;
+    for (let i = e.length - 1; i >= 0; i -= 1) {
+      const l = e[i];
+      l.wrapItem && (c = l.wrapItem({
+        itemId: s,
+        children: c,
+        instance: t
+      }));
+    }
+    return c;
+  },
+  wrapRoot: ({
+    children: s
+  }) => {
+    let u = s;
+    for (let c = e.length - 1; c >= 0; c -= 1) {
+      const i = e[c];
+      i.wrapRoot && (u = i.wrapRoot({
+        children: u,
+        instance: t
+      }));
+    }
+    return u;
+  },
+  instance: t,
+  rootRef: o,
+  publicAPI: n
+});
+function bn(e) {
+  const t = E.useRef({});
+  return e ? (e.current == null && (e.current = {}), e.current) : t.current;
+}
+const hn = ({
+  plugins: e,
+  rootRef: t,
+  props: n
+}) => {
+  const o = [...fn, ...e], {
+    pluginParams: r,
+    forwardedProps: I,
+    apiRef: p,
+    experimentalFeatures: s,
+    slots: u,
+    slotProps: c
+  } = In({
+    plugins: o,
+    props: n
+  }), i = cn(o, r), m = E.useRef({}).current, a = bn(p), h = E.useRef(null), g = Ie(h, t), f = gn({
+    plugins: o,
+    instance: m,
+    publicAPI: a,
+    rootRef: h
+  }), [b, x] = E.useState(() => {
+    const P = {};
+    return o.forEach((D) => {
+      D.getInitialState && Object.assign(P, D.getInitialState(r));
+    }), P;
+  }), R = [], M = (P) => {
+    const D = P({
+      instance: m,
+      params: r,
+      slots: u,
+      slotProps: c,
+      experimentalFeatures: s,
+      state: b,
+      setState: x,
+      rootRef: h,
+      models: i,
+      plugins: o
+    });
+    D.getRootProps && R.push(D.getRootProps), D.publicAPI && Object.assign(a, D.publicAPI), D.instance && Object.assign(m, D.instance), D.contextValue && Object.assign(f, D.contextValue);
+  };
+  return o.forEach(M), {
+    getRootProps: (P = {}) => {
+      const D = C({
+        role: "tree"
+      }, I, P, {
+        ref: g
+      });
+      return R.forEach((N) => {
+        Object.assign(D, N(P));
+      }), D;
+    },
+    rootRef: g,
+    contextValue: f,
+    instance: m
+  };
+}, Be = /* @__PURE__ */ E.createContext(null);
+process.env.NODE_ENV !== "production" && (Be.displayName = "TreeViewContext");
+function xn(e) {
+  const {
+    value: t,
+    children: n
+  } = e;
+  return /* @__PURE__ */ v(Be.Provider, {
+    value: t,
+    children: t.wrapRoot({
+      children: n,
+      instance: t.instance
+    })
+  });
+}
+const ie = () => {
+  const e = E.useContext(Be);
+  if (e == null)
+    throw new Error(["MUI X: Could not find the Tree View context.", "It looks like you rendered your component outside of a SimpleTreeView or RichTreeView parent component.", "This can also happen if you are bundling multiple versions of the Tree View."].join(`
+`));
+  return e;
+}, yn = (e, t, n) => {
+  e.$$publishEvent(t, n);
+}, ae = "__TREE_VIEW_ROOT_PARENT_ID__", Tn = (e) => {
+  const t = {};
+  return e.forEach((n, o) => {
+    t[n] = o;
+  }), t;
+}, Pe = /* @__PURE__ */ E.createContext(() => -1);
+process.env.NODE_ENV !== "production" && (Pe.displayName = "TreeViewItemDepthContext");
+const Cn = ["children"], ft = ({
+  items: e,
+  isItemDisabled: t,
+  getItemLabel: n,
+  getItemId: o
+}) => {
+  const r = {}, I = {}, p = {
+    [ae]: []
+  }, s = (c, i, l) => {
+    var g, f;
+    const m = o ? o(c) : c.id;
+    if (m == null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", "An item was provided without id in the `items` prop:", JSON.stringify(c)].join(`
+`));
+    if (r[m] != null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", `Two items were provided with the same id in the \`items\` prop: "${m}"`].join(`
+`));
+    const a = n ? n(c) : c.label;
+    if (a == 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(c)].join(`
+`));
+    r[m] = {
+      id: m,
+      label: a,
+      parentId: l,
+      idAttribute: void 0,
+      expandable: !!((g = c.children) != null && g.length),
+      disabled: t ? t(c) : !1,
+      depth: i
+    }, I[m] = c;
+    const h = l ?? ae;
+    p[h] || (p[h] = []), p[h].push(m), (f = c.children) == null || f.forEach((b) => s(b, i + 1, m));
+  };
+  e.forEach((c) => s(c, 0, null));
+  const u = {};
+  return Object.keys(p).forEach((c) => {
+    u[c] = Tn(p[c]);
+  }), {
+    itemMetaMap: r,
+    itemMap: I,
+    itemOrderedChildrenIds: p,
+    itemChildrenIndexes: u
+  };
+}, he = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: o,
+  experimentalFeatures: r
+}) => {
+  const I = E.useCallback((b) => n.items.itemMetaMap[b], [n.items.itemMetaMap]), p = E.useCallback((b) => n.items.itemMap[b], [n.items.itemMap]), s = E.useCallback(() => {
+    const b = (x) => {
+      const R = n.items.itemMap[x], M = G(R, Cn), w = n.items.itemOrderedChildrenIds[x];
+      return w && (M.children = w.map(b)), M;
+    };
+    return n.items.itemOrderedChildrenIds[ae].map(b);
+  }, [n.items.itemMap, n.items.itemOrderedChildrenIds]), u = E.useCallback((b) => {
+    if (b == null)
+      return !1;
+    let x = e.getItemMeta(b);
+    if (!x)
+      return !1;
+    if (x.disabled)
+      return !0;
+    for (; x.parentId != null; )
+      if (x = e.getItemMeta(x.parentId), x.disabled)
+        return !0;
+    return !1;
+  }, [e]), c = E.useCallback((b) => {
+    const x = e.getItemMeta(b).parentId ?? ae;
+    return n.items.itemChildrenIndexes[x][b];
+  }, [e, n.items.itemChildrenIndexes]), i = E.useCallback((b) => n.items.itemOrderedChildrenIds[b ?? ae] ?? [], [n.items.itemOrderedChildrenIds]), l = (b) => {
+    const x = e.getItemMeta(b);
+    return x == null ? null : document.getElementById(Ke({
+      treeId: n.id.treeId,
+      itemId: b,
+      id: x.idAttribute
+    }));
+  }, m = (b) => t.disabledItemsFocusable ? !0 : !e.isItemDisabled(b), a = E.useRef(!1), h = E.useCallback(() => {
+    a.current = !0;
+  }, []), g = E.useCallback(() => a.current, []);
+  return E.useEffect(() => {
+    e.areItemUpdatesPrevented() || o((b) => {
+      const x = ft({
+        items: t.items,
+        isItemDisabled: t.isItemDisabled,
+        getItemId: t.getItemId,
+        getItemLabel: t.getItemLabel
+      });
+      return Object.values(b.items.itemMetaMap).forEach((R) => {
+        x.itemMetaMap[R.id] || yn(e, "removeItem", {
+          id: R.id
+        });
+      }), C({}, b, {
+        items: x
+      });
+    });
+  }, [e, o, t.items, t.isItemDisabled, t.getItemId, t.getItemLabel]), {
+    getRootProps: () => ({
+      style: {
+        "--TreeView-itemChildrenIndentation": typeof t.itemChildrenIndentation == "number" ? `${t.itemChildrenIndentation}px` : t.itemChildrenIndentation
+      }
+    }),
+    publicAPI: {
+      getItem: p,
+      getItemDOMElement: l,
+      getItemTree: s,
+      getItemOrderedChildrenIds: i
+    },
+    instance: {
+      getItemMeta: I,
+      getItem: p,
+      getItemTree: s,
+      getItemsToRender: () => {
+        const b = (x) => {
+          var M;
+          const R = n.items.itemMetaMap[x];
+          return {
+            label: R.label,
+            itemId: R.id,
+            id: R.idAttribute,
+            children: (M = n.items.itemOrderedChildrenIds[x]) == null ? void 0 : M.map(b)
+          };
+        };
+        return n.items.itemOrderedChildrenIds[ae].map(b);
+      },
+      getItemIndex: c,
+      getItemDOMElement: l,
+      getItemOrderedChildrenIds: i,
+      isItemDisabled: u,
+      isItemNavigable: m,
+      preventItemUpdates: h,
+      areItemUpdatesPrevented: g
+    },
+    contextValue: {
+      items: {
+        onItemClick: t.onItemClick,
+        disabledItemsFocusable: t.disabledItemsFocusable,
+        indentationAtItemLevel: r.indentationAtItemLevel ?? !1
+      }
+    }
+  };
+};
+he.getInitialState = (e) => ({
+  items: ft({
+    items: e.items,
+    isItemDisabled: e.isItemDisabled,
+    getItemId: e.getItemId,
+    getItemLabel: e.getItemLabel
+  })
+});
+he.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  disabledItemsFocusable: e.disabledItemsFocusable ?? !1,
+  itemChildrenIndentation: e.itemChildrenIndentation ?? "12px"
+});
+he.wrapRoot = ({
+  children: e,
+  instance: t
+}) => /* @__PURE__ */ v(Pe.Provider, {
+  value: (n) => {
+    var o;
+    return ((o = t.getItemMeta(n)) == null ? void 0 : o.depth) ?? 0;
+  },
+  children: e
+});
+he.params = {
+  disabledItemsFocusable: !0,
+  items: !0,
+  isItemDisabled: !0,
+  getItemLabel: !0,
+  getItemId: !0,
+  onItemClick: !0,
+  itemChildrenIndentation: !0
+};
+const Se = ({
+  instance: e,
+  params: t,
+  models: n
+}) => {
+  const o = E.useMemo(() => {
+    const l = /* @__PURE__ */ new Map();
+    return n.expandedItems.value.forEach((m) => {
+      l.set(m, !0);
+    }), l;
+  }, [n.expandedItems.value]), r = (l, m) => {
+    var a;
+    (a = t.onExpandedItemsChange) == null || a.call(t, l, m), n.expandedItems.setControlledValue(m);
+  }, I = E.useCallback((l) => o.has(l), [o]), p = E.useCallback((l) => {
+    var m;
+    return !!((m = e.getItemMeta(l)) != null && m.expandable);
+  }, [e]), s = ce((l, m) => {
+    const a = e.isItemExpanded(m);
+    e.setItemExpansion(l, m, !a);
+  }), u = ce((l, m, a) => {
+    if (e.isItemExpanded(m) === a)
+      return;
+    let g;
+    a ? g = [m].concat(n.expandedItems.value) : g = n.expandedItems.value.filter((f) => f !== m), t.onItemExpansionToggle && t.onItemExpansionToggle(l, m, a), r(l, g);
+  }), c = (l, m) => {
+    const a = e.getItemMeta(m), g = e.getItemOrderedChildrenIds(a.parentId).filter((b) => e.isItemExpandable(b) && !e.isItemExpanded(b)), f = n.expandedItems.value.concat(g);
+    g.length > 0 && (t.onItemExpansionToggle && g.forEach((b) => {
+      t.onItemExpansionToggle(l, b, !0);
+    }), r(l, f));
+  }, i = E.useMemo(() => t.expansionTrigger ? t.expansionTrigger : e.isTreeViewEditable ? "iconContainer" : "content", [t.expansionTrigger, e.isTreeViewEditable]);
+  return {
+    publicAPI: {
+      setItemExpansion: u
+    },
+    instance: {
+      isItemExpanded: I,
+      isItemExpandable: p,
+      setItemExpansion: u,
+      toggleItemExpansion: s,
+      expandAllSiblings: c
+    },
+    contextValue: {
+      expansion: {
+        expansionTrigger: i
+      }
+    }
+  };
+};
+Se.models = {
+  expandedItems: {
+    getDefaultValue: (e) => e.defaultExpandedItems
+  }
+};
+const En = [];
+Se.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  defaultExpandedItems: e.defaultExpandedItems ?? En
+});
+Se.params = {
+  expandedItems: !0,
+  defaultExpandedItems: !0,
+  onExpandedItemsChange: !0,
+  onItemExpansionToggle: !0,
+  expansionTrigger: !0
+};
+const mt = (e, t) => {
+  let n = t.length - 1;
+  for (; n >= 0 && !e.isItemNavigable(t[n]); )
+    n -= 1;
+  if (n !== -1)
+    return t[n];
+}, It = (e, t) => {
+  const n = e.getItemMeta(t), o = e.getItemOrderedChildrenIds(n.parentId), r = e.getItemIndex(t);
+  if (r === 0)
+    return n.parentId;
+  let I = r - 1;
+  for (; !e.isItemNavigable(o[I]) && I >= 0; )
+    I -= 1;
+  if (I === -1)
+    return n.parentId == null ? null : It(e, n.parentId);
+  let p = o[I], s = mt(e, e.getItemOrderedChildrenIds(p));
+  for (; e.isItemExpanded(p) && s != null; )
+    p = s, s = e.getItemOrderedChildrenIds(p).find(e.isItemNavigable);
+  return p;
+}, we = (e, t) => {
+  if (e.isItemExpanded(t)) {
+    const o = e.getItemOrderedChildrenIds(t).find(e.isItemNavigable);
+    if (o != null)
+      return o;
+  }
+  let n = e.getItemMeta(t);
+  for (; n != null; ) {
+    const o = e.getItemOrderedChildrenIds(n.parentId), r = e.getItemIndex(n.id);
+    if (r < o.length - 1) {
+      let I = r + 1;
+      for (; !e.isItemNavigable(o[I]) && I < o.length - 1; )
+        I += 1;
+      if (e.isItemNavigable(o[I]))
+        return o[I];
+    }
+    n = e.getItemMeta(n.parentId);
+  }
+  return null;
+}, gt = (e) => {
+  let t = null;
+  for (; t == null || e.isItemExpanded(t); ) {
+    const n = e.getItemOrderedChildrenIds(t), o = mt(e, n);
+    if (o == null)
+      return t;
+    t = o;
+  }
+  return t;
+}, ge = (e) => e.getItemOrderedChildrenIds(null).find(e.isItemNavigable), bt = (e, t, n) => {
+  if (t === n)
+    return [t, n];
+  const o = e.getItemMeta(t), r = e.getItemMeta(n);
+  if (o.parentId === r.id || r.parentId === o.id)
+    return r.parentId === o.id ? [o.id, r.id] : [r.id, o.id];
+  const I = [o.id], p = [r.id];
+  let s = o.parentId, u = r.parentId, c = p.indexOf(s) !== -1, i = I.indexOf(u) !== -1, l = !0, m = !0;
+  for (; !i && !c; )
+    l && (I.push(s), c = p.indexOf(s) !== -1, l = s !== null, !c && l && (s = e.getItemMeta(s).parentId)), m && !c && (p.push(u), i = I.indexOf(u) !== -1, m = u !== null, !i && m && (u = e.getItemMeta(u).parentId));
+  const a = c ? s : u, h = e.getItemOrderedChildrenIds(a), g = I[I.indexOf(a) - 1], f = p[p.indexOf(a) - 1];
+  return h.indexOf(g) < h.indexOf(f) ? [t, n] : [n, t];
+}, wn = (e, t, n) => {
+  const o = (u) => {
+    if (e.isItemExpandable(u) && e.isItemExpanded(u))
+      return e.getItemOrderedChildrenIds(u)[0];
+    let c = e.getItemMeta(u);
+    for (; c != null; ) {
+      const i = e.getItemOrderedChildrenIds(c.parentId), l = e.getItemIndex(c.id);
+      if (l < i.length - 1)
+        return i[l + 1];
+      c = e.getItemMeta(c.parentId);
+    }
+    throw new Error("Invalid range");
+  }, [r, I] = bt(e, t, n), p = [r];
+  let s = r;
+  for (; s !== I; )
+    s = o(s), e.isItemDisabled(s) || p.push(s);
+  return p;
+}, Rn = (e) => {
+  let t = ge(e);
+  const n = [];
+  for (; t != null; )
+    n.push(t), t = we(e, t);
+  return n;
+}, be = (e, t) => t !== e.closest('*[role="treeitem"]'), Re = (e) => Array.isArray(e) ? e : e != null ? [e] : [], Fe = (e) => {
+  const t = {};
+  return e.forEach((n) => {
+    t[n] = !0;
+  }), t;
+}, Me = ({
+  instance: e,
+  params: t,
+  models: n
+}) => {
+  const o = E.useRef(null), r = E.useRef({}), I = E.useMemo(() => {
+    const g = /* @__PURE__ */ new Map();
+    return Array.isArray(n.selectedItems.value) ? n.selectedItems.value.forEach((f) => {
+      g.set(f, !0);
+    }) : n.selectedItems.value != null && g.set(n.selectedItems.value, !0), g;
+  }, [n.selectedItems.value]), p = (g, f) => {
+    if (t.onItemSelectionToggle)
+      if (t.multiSelect) {
+        const b = f.filter((R) => !e.isItemSelected(R)), x = n.selectedItems.value.filter((R) => !f.includes(R));
+        b.forEach((R) => {
+          t.onItemSelectionToggle(g, R, !0);
+        }), x.forEach((R) => {
+          t.onItemSelectionToggle(g, R, !1);
+        });
+      } else f !== n.selectedItems.value && (n.selectedItems.value != null && t.onItemSelectionToggle(g, n.selectedItems.value, !1), f != null && t.onItemSelectionToggle(g, f, !0));
+    t.onSelectedItemsChange && t.onSelectedItemsChange(g, f), n.selectedItems.setControlledValue(f);
+  }, s = (g) => I.has(g), u = ({
+    event: g,
+    itemId: f,
+    keepExistingSelection: b = !1,
+    shouldBeSelected: x
+  }) => {
+    if (t.disableSelection)
+      return;
+    let R;
+    if (b) {
+      const M = Re(n.selectedItems.value), w = e.isItemSelected(f);
+      w && (x === !1 || x == null) ? R = M.filter((P) => P !== f) : !w && (x === !0 || x == null) ? R = [f].concat(M) : R = M;
+    } else
+      x === !1 || x == null && e.isItemSelected(f) ? R = t.multiSelect ? [] : null : R = t.multiSelect ? [f] : f;
+    p(g, R), o.current = f, r.current = {};
+  }, c = (g, [f, b]) => {
+    if (t.disableSelection || !t.multiSelect)
+      return;
+    let x = Re(n.selectedItems.value).slice();
+    Object.keys(r.current).length > 0 && (x = x.filter((P) => !r.current[P]));
+    const R = Fe(x), M = wn(e, f, b), w = M.filter((P) => !R[P]);
+    x = x.concat(w), p(g, x), r.current = Fe(M);
+  };
+  return {
+    getRootProps: () => ({
+      "aria-multiselectable": t.multiSelect
+    }),
+    publicAPI: {
+      selectItem: u
+    },
+    instance: {
+      isItemSelected: s,
+      selectItem: u,
+      selectAllNavigableItems: (g) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        const f = Rn(e);
+        p(g, f), r.current = Fe(f);
+      },
+      expandSelectionRange: (g, f) => {
+        if (o.current != null) {
+          const [b, x] = bt(e, f, o.current);
+          c(g, [b, x]);
+        }
+      },
+      selectRangeFromStartToItem: (g, f) => {
+        c(g, [ge(e), f]);
+      },
+      selectRangeFromItemToEnd: (g, f) => {
+        c(g, [f, gt(e)]);
+      },
+      selectItemFromArrowNavigation: (g, f, b) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        let x = Re(n.selectedItems.value).slice();
+        Object.keys(r.current).length === 0 ? (x.push(b), r.current = {
+          [f]: !0,
+          [b]: !0
+        }) : (r.current[f] || (r.current = {}), r.current[b] ? (x = x.filter((R) => R !== f), delete r.current[f]) : (x.push(b), r.current[b] = !0)), p(g, x);
+      }
+    },
+    contextValue: {
+      selection: {
+        multiSelect: t.multiSelect,
+        checkboxSelection: t.checkboxSelection,
+        disableSelection: t.disableSelection
+      }
+    }
+  };
+};
+Me.models = {
+  selectedItems: {
+    getDefaultValue: (e) => e.defaultSelectedItems
+  }
+};
+const vn = [];
+Me.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  disableSelection: e.disableSelection ?? !1,
+  multiSelect: e.multiSelect ?? !1,
+  checkboxSelection: e.checkboxSelection ?? !1,
+  defaultSelectedItems: e.defaultSelectedItems ?? (e.multiSelect ? vn : null)
+});
+Me.params = {
+  disableSelection: !0,
+  multiSelect: !0,
+  checkboxSelection: !0,
+  defaultSelectedItems: !0,
+  selectedItems: !0,
+  onSelectedItemsChange: !0,
+  onItemSelectionToggle: !0
+};
+const rt = 1e3;
+class Pn {
+  constructor(t = rt) {
+    this.timeouts = /* @__PURE__ */ new Map(), this.cleanupTimeout = rt, this.cleanupTimeout = t;
+  }
+  register(t, n, o) {
+    this.timeouts || (this.timeouts = /* @__PURE__ */ new Map());
+    const r = setTimeout(() => {
+      typeof n == "function" && n(), this.timeouts.delete(o.cleanupToken);
+    }, this.cleanupTimeout);
+    this.timeouts.set(o.cleanupToken, r);
+  }
+  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 Sn {
+  constructor() {
+    this.registry = new FinalizationRegistry((t) => {
+      typeof t == "function" && t();
+    });
+  }
+  register(t, n, o) {
+    this.registry.register(t, n, o);
+  }
+  unregister(t) {
+    this.registry.unregister(t);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  reset() {
+  }
+}
+class Mn {
+}
+function kn(e) {
+  let t = 0;
+  return function(o, r, I) {
+    e.registry === null && (e.registry = typeof FinalizationRegistry < "u" ? new Sn() : new Pn());
+    const [p] = E.useState(new Mn()), s = E.useRef(null), u = E.useRef(void 0);
+    u.current = I;
+    const c = E.useRef(null);
+    if (!s.current && u.current) {
+      const i = (l, m) => {
+        var a;
+        m.defaultMuiPrevented || (a = u.current) == null || a.call(u, l, m);
+      };
+      s.current = o.$$subscribeEvent(r, i), t += 1, c.current = {
+        cleanupToken: t
+      }, e.registry.register(
+        p,
+        // The callback below will be called once this reference stops being retained
+        () => {
+          var l;
+          (l = s.current) == null || l.call(s), s.current = null, c.current = null;
+        },
+        c.current
+      );
+    } else !u.current && s.current && (s.current(), s.current = null, c.current && (e.registry.unregister(c.current), c.current = null));
+    E.useEffect(() => {
+      if (!s.current && u.current) {
+        const i = (l, m) => {
+          var a;
+          m.defaultMuiPrevented || (a = u.current) == null || a.call(u, l, m);
+        };
+        s.current = o.$$subscribeEvent(r, i);
+      }
+      return c.current && e.registry && (e.registry.unregister(c.current), c.current = null), () => {
+        var i;
+        (i = s.current) == null || i.call(s), s.current = null;
+      };
+    }, [o, r]);
+  };
+}
+const Dn = {
+  registry: null
+}, On = kn(Dn), ht = (e = document) => {
+  const t = e.activeElement;
+  return t ? t.shadowRoot ? ht(t.shadowRoot) : t : null;
+}, An = (e, t) => {
+  let n = Re(t).find((o) => {
+    if (!e.isItemNavigable(o))
+      return !1;
+    const r = e.getItemMeta(o);
+    return r && (r.parentId == null || e.isItemExpanded(r.parentId));
+  });
+  return n == null && (n = ge(e)), n;
+}, Ue = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: o,
+  models: r,
+  rootRef: I
+}) => {
+  const p = An(e, r.selectedItems.value), s = ce((f) => {
+    const b = typeof f == "function" ? f(n.focusedItemId) : f;
+    n.focusedItemId !== b && o((x) => C({}, x, {
+      focusedItemId: b
+    }));
+  }), u = E.useCallback(() => !!I.current && I.current.contains(ht(nn(I.current))), [I]), c = E.useCallback((f) => n.focusedItemId === f && u(), [n.focusedItemId, u]), i = (f) => {
+    const b = e.getItemMeta(f);
+    return b && (b.parentId == null || e.isItemExpanded(b.parentId));
+  }, l = (f, b) => {
+    const x = e.getItemDOMElement(b);
+    x && x.focus(), s(b), t.onItemFocus && t.onItemFocus(f, b);
+  }, m = ce((f, b) => {
+    i(b) && l(f, b);
+  }), a = ce(() => {
+    if (n.focusedItemId == null)
+      return;
+    if (e.getItemMeta(n.focusedItemId)) {
+      const b = e.getItemDOMElement(n.focusedItemId);
+      b && b.blur();
+    }
+    s(null);
+  }), h = (f) => f === p;
+  On(e, "removeItem", ({
+    id: f
+  }) => {
+    n.focusedItemId === f && l(null, p);
+  });
+  const g = (f) => (b) => {
+    var x;
+    (x = f.onFocus) == null || x.call(f, b), !b.defaultMuiPrevented && b.target === b.currentTarget && l(b, p);
+  };
+  return {
+    getRootProps: (f) => ({
+      onFocus: g(f)
+    }),
+    publicAPI: {
+      focusItem: m
+    },
+    instance: {
+      isItemFocused: c,
+      canItemBeTabbed: h,
+      focusItem: m,
+      removeFocusedItem: a
+    }
+  };
+};
+Ue.getInitialState = () => ({
+  focusedItemId: null
+});
+Ue.params = {
+  onItemFocus: !0
+};
+const re = (e, t) => e.getAvailablePlugins().has(t), Ln = ({
+  props: e
+}) => {
+  const {
+    instance: t
+  } = ie(), {
+    label: n,
+    itemId: o
+  } = e, [r, I] = E.useState(n), p = t.isItemBeingEdited(o);
+  return E.useEffect(() => {
+    p || I(n);
+  }, [p, n]), {
+    propsEnhancers: {
+      labelInput: ({
+        externalEventHandlers: s,
+        interactions: u
+      }) => t.isItemEditable(o) ? {
+        value: r ?? "",
+        "data-element": "labelInput",
+        onChange: (a) => {
+          var h;
+          (h = s.onChange) == null || h.call(s, a), I(a.target.value);
+        },
+        onKeyDown: (a) => {
+          var g;
+          if ((g = s.onKeyDown) == null || g.call(s, a), a.defaultMuiPrevented)
+            return;
+          const h = a.target;
+          a.key === "Enter" && h.value ? u.handleSaveItemLabel(a, h.value) : a.key === "Escape" && u.handleCancelItemLabelEditing(a);
+        },
+        onBlur: (a) => {
+          var h;
+          (h = s.onBlur) == null || h.call(s, a), !a.defaultMuiPrevented && a.target.value && u.handleSaveItemLabel(a, a.target.value);
+        },
+        autoFocus: !0,
+        type: "text"
+      } : {}
+    }
+  };
+}, K = ({
+  instance: e,
+  state: t,
+  setState: n,
+  params: o
+}) => {
+  const r = E.useRef(t.editedItemId), I = (l) => r.current === l, p = (l) => {
+    n((m) => C({}, m, {
+      editedItemId: l
+    })), r.current = l;
+  }, s = (l) => l === t.editedItemId, u = !!o.isItemEditable, c = (l) => {
+    if (l == null || !u)
+      return !1;
+    const m = e.getItem(l);
+    return m ? typeof o.isItemEditable == "function" ? o.isItemEditable(m) : !!o.isItemEditable : !1;
+  }, i = (l, m) => {
+    if (!m)
+      throw new Error(["MUI X: The Tree View component requires all items to have a `label` property.", "The label of an item cannot be empty.", l].join(`
+`));
+    n((a) => {
+      const h = a.items.itemMetaMap[l];
+      return h.label !== m ? C({}, a, {
+        items: C({}, a.items, {
+          itemMetaMap: C({}, a.items.itemMetaMap, {
+            [l]: C({}, h, {
+              label: m
+            })
+          })
+        })
+      }) : a;
+    }), o.onItemLabelChange && o.onItemLabelChange(l, m);
+  };
+  return {
+    instance: {
+      setEditedItemId: p,
+      isItemBeingEdited: s,
+      updateItemLabel: i,
+      isItemEditable: c,
+      isTreeViewEditable: u,
+      isItemBeingEditedRef: I
+    },
+    publicAPI: {
+      updateItemLabel: i
+    }
+  };
+};
+K.itemPlugin = Ln;
+K.getDefaultizedParams = ({
+  params: e,
+  experimentalFeatures: t
+}) => {
+  const n = t == null ? void 0 : t.labelEditing;
+  return process.env.NODE_ENV !== "production" && e.isItemEditable && !n && ve(["MUI X: The label editing feature requires the `labelEditing` experimental feature to be enabled.", "You can do it by passing `experimentalFeatures={{ labelEditing: true}}` to the Rich Tree View Pro component.", "Check the documentation for more details: https://mui.com/x/react-tree-view/rich-tree-view/editing/"]), C({}, e, {
+    isItemEditable: n ? e.isItemEditable ?? !1 : !1
+  });
+};
+K.getInitialState = () => ({
+  editedItemId: null
+});
+K.params = {
+  onItemLabelChange: !0,
+  isItemEditable: !0
+};
+function Vn(e) {
+  return !!e && e.length === 1 && !!e.match(/\S/);
+}
+const xt = ({
+  instance: e,
+  params: t,
+  state: n
+}) => {
+  const o = tn(), r = E.useRef({}), I = ce((i) => {
+    r.current = i(r.current);
+  });
+  E.useEffect(() => {
+    if (e.areItemUpdatesPrevented())
+      return;
+    const i = {}, l = (m) => {
+      i[m.id] = m.label.substring(0, 1).toLowerCase();
+    };
+    Object.values(n.items.itemMetaMap).forEach(l), r.current = i;
+  }, [n.items.itemMetaMap, t.getItemId, e]);
+  const p = (i, l) => {
+    const m = l.toLowerCase(), a = (b) => {
+      const x = we(e, b);
+      return x === null ? ge(e) : x;
+    };
+    let h = null, g = a(i);
+    const f = {};
+    for (; h == null && !f[g]; )
+      r.current[g] === m ? h = g : (f[g] = !0, g = a(g));
+    return h;
+  }, s = (i) => !t.disableSelection && !e.isItemDisabled(i), u = (i) => !e.isItemDisabled(i) && e.isItemExpandable(i);
+  return {
+    instance: {
+      updateFirstCharMap: I,
+      handleItemKeyDown: (i, l) => {
+        if (i.defaultMuiPrevented || i.altKey || be(i.target, i.currentTarget))
+          return;
+        const m = i.ctrlKey || i.metaKey, a = i.key;
+        switch (!0) {
+          // Select the item when pressing "Space"
+          case (a === " " && s(l)): {
+            i.preventDefault(), t.multiSelect && i.shiftKey ? e.expandSelectionRange(i, l) : e.selectItem({
+              event: i,
+              itemId: l,
+              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 a === "Enter": {
+            re(e, K) && e.isItemEditable(l) && !e.isItemBeingEdited(l) ? e.setEditedItemId(l) : u(l) ? (e.toggleItemExpansion(i, l), i.preventDefault()) : s(l) && (t.multiSelect ? (i.preventDefault(), e.selectItem({
+              event: i,
+              itemId: l,
+              keepExistingSelection: !0
+            })) : e.isItemSelected(l) || (e.selectItem({
+              event: i,
+              itemId: l
+            }), i.preventDefault()));
+            break;
+          }
+          // Focus the next focusable item
+          case a === "ArrowDown": {
+            const h = we(e, l);
+            h && (i.preventDefault(), e.focusItem(i, h), t.multiSelect && i.shiftKey && s(h) && e.selectItemFromArrowNavigation(i, l, h));
+            break;
+          }
+          // Focuses the previous focusable item
+          case a === "ArrowUp": {
+            const h = It(e, l);
+            h && (i.preventDefault(), e.focusItem(i, h), t.multiSelect && i.shiftKey && s(h) && e.selectItemFromArrowNavigation(i, l, 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 (a === "ArrowRight" && !o || a === "ArrowLeft" && o): {
+            if (m)
+              return;
+            if (e.isItemExpanded(l)) {
+              const h = we(e, l);
+              h && (e.focusItem(i, h), i.preventDefault());
+            } else u(l) && (e.toggleItemExpansion(i, l), i.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 (a === "ArrowLeft" && !o || a === "ArrowRight" && o): {
+            if (m)
+              return;
+            if (u(l) && e.isItemExpanded(l))
+              e.toggleItemExpansion(i, l), i.preventDefault();
+            else {
+              const h = e.getItemMeta(l).parentId;
+              h && (e.focusItem(i, h), i.preventDefault());
+            }
+            break;
+          }
+          // Focuses the first item in the tree
+          case a === "Home": {
+            s(l) && t.multiSelect && m && i.shiftKey ? e.selectRangeFromStartToItem(i, l) : e.focusItem(i, ge(e)), i.preventDefault();
+            break;
+          }
+          // Focuses the last item in the tree
+          case a === "End": {
+            s(l) && t.multiSelect && m && i.shiftKey ? e.selectRangeFromItemToEnd(i, l) : e.focusItem(i, gt(e)), i.preventDefault();
+            break;
+          }
+          // Expand all siblings that are at the same level as the focused item
+          case a === "*": {
+            e.expandAllSiblings(i, l), i.preventDefault();
+            break;
+          }
+          // Multi select behavior when pressing Ctrl + a
+          // Selects all the items
+          case (String.fromCharCode(i.keyCode) === "A" && m && t.multiSelect && !t.disableSelection): {
+            e.selectAllNavigableItems(i), i.preventDefault();
+            break;
+          }
+          // Type-ahead
+          // TODO: Support typing multiple characters
+          case (!m && !i.shiftKey && Vn(a)): {
+            const h = p(l, a);
+            h != null && (e.focusItem(i, h), i.preventDefault());
+            break;
+          }
+        }
+      }
+    }
+  };
+};
+xt.params = {};
+const yt = ({
+  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
+      }
+    }
+  }
+});
+yt.params = {};
+const Fn = [he, Se, Me, Ue, xt, yt, K];
+function Tt(e) {
+  const {
+    instance: t,
+    items: {
+      onItemClick: n
+    },
+    selection: {
+      multiSelect: o,
+      checkboxSelection: r,
+      disableSelection: I
+    },
+    expansion: {
+      expansionTrigger: p
+    }
+  } = ie(), s = t.isItemExpandable(e), u = t.isItemExpanded(e), c = t.isItemFocused(e), i = t.isItemSelected(e), l = t.isItemDisabled(e), m = t != null && t.isItemBeingEdited ? t == null ? void 0 : t.isItemBeingEdited(e) : !1, a = t.isItemEditable ? t.isItemEditable(e) : !1, h = (w) => {
+    if (!l) {
+      c || t.focusItem(w, e);
+      const P = o && (w.shiftKey || w.ctrlKey || w.metaKey);
+      s && !(P && t.isItemExpanded(e)) && t.toggleItemExpansion(w, e);
+    }
+  }, g = (w) => {
+    l || (c || t.focusItem(w, e), o && (w.shiftKey || w.ctrlKey || w.metaKey) ? w.shiftKey ? t.expandSelectionRange(w, e) : t.selectItem({
+      event: w,
+      itemId: e,
+      keepExistingSelection: !0
+    }) : t.selectItem({
+      event: w,
+      itemId: e,
+      shouldBeSelected: !0
+    }));
+  }, f = (w) => {
+    if (I || l)
+      return;
+    const P = w.nativeEvent.shiftKey;
+    o && P ? t.expandSelectionRange(w, e) : t.selectItem({
+      event: w,
+      itemId: e,
+      keepExistingSelection: o,
+      shouldBeSelected: w.target.checked
+    });
+  }, b = (w) => {
+    (w.shiftKey || w.ctrlKey || w.metaKey || l) && w.preventDefault();
+  }, x = () => {
+    re(t, K) && t.isItemEditable(e) && (t.isItemBeingEdited(e) ? t.setEditedItemId(null) : t.setEditedItemId(e));
+  };
+  return {
+    disabled: l,
+    expanded: u,
+    selected: i,
+    focused: c,
+    editable: a,
+    editing: m,
+    disableSelection: I,
+    checkboxSelection: r,
+    handleExpansion: h,
+    handleSelection: g,
+    handleCheckboxSelection: f,
+    handleContentClick: n,
+    preventSelection: b,
+    expansionTrigger: p,
+    toggleItemEditing: x,
+    handleSaveItemLabel: (w, P) => {
+      re(t, K) && t.isItemBeingEditedRef(e) && (t.updateItemLabel(e, P), x(), t.focusItem(w, e));
+    },
+    handleCancelItemLabelEditing: (w) => {
+      re(t, K) && t.isItemBeingEditedRef(e) && (x(), t.focusItem(w, e));
+    }
+  };
+}
+const $n = _("div", {
+  name: "MuiTreeItem2DragAndDropOverlay",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root,
+  shouldForwardProp: (e) => pe(e) && e !== "action"
+})(({
+  theme: e
+}) => ({
+  position: "absolute",
+  left: 0,
+  display: "flex",
+  top: 0,
+  bottom: 0,
+  right: 0,
+  pointerEvents: "none",
+  variants: [{
+    props: {
+      action: "make-child"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderRadius: e.shape.borderRadius,
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.darkChannel} / ${e.vars.palette.action.focusOpacity})` : J(e.palette.primary.dark, e.palette.action.focusOpacity)
+    }
+  }, {
+    props: {
+      action: "reorder-above"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderTop: `1px solid ${(e.vars || e).palette.action.active}`
+    }
+  }, {
+    props: {
+      action: "reorder-below"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderBottom: `1px solid ${(e.vars || e).palette.action.active}`
+    }
+  }, {
+    props: {
+      action: "move-to-parent"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * calc(var(--TreeView-itemDepth) - 1))",
+      borderBottom: `1px solid ${(e.vars || e).palette.action.active}`
+    }
+  }]
+}));
+function ze(e) {
+  return e.action == null ? null : /* @__PURE__ */ v($n, C({}, e));
+}
+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"  |
+  // ----------------------------------------------------------------------
+  action: d.oneOf(["make-child", "move-to-parent", "reorder-above", "reorder-below"]),
+  style: d.object
+});
+const Ct = _("input", {
+  name: "MuiTreeItem2",
+  slot: "LabelInput",
+  overridesResolver: (e, t) => t.labelInput
+})(({
+  theme: e
+}) => C({}, e.typography.body1, {
+  width: "100%",
+  backgroundColor: e.palette.background.paper,
+  borderRadius: e.shape.borderRadius,
+  border: "none",
+  padding: "0 2px",
+  boxSizing: "border-box",
+  "&:focus": {
+    outline: `1px solid ${e.palette.primary.main}`
+  }
+})), Nn = ["classes", "className", "displayIcon", "expansionIcon", "icon", "label", "itemId", "onClick", "onMouseDown", "dragAndDropOverlayProps", "labelInputProps"], qe = /* @__PURE__ */ E.forwardRef(function(t, n) {
+  const {
+    classes: o,
+    className: r,
+    displayIcon: I,
+    expansionIcon: p,
+    icon: s,
+    label: u,
+    itemId: c,
+    onClick: i,
+    onMouseDown: l,
+    dragAndDropOverlayProps: m,
+    labelInputProps: a
+  } = t, h = G(t, Nn), {
+    disabled: g,
+    expanded: f,
+    selected: b,
+    focused: x,
+    editing: R,
+    editable: M,
+    disableSelection: w,
+    checkboxSelection: P,
+    handleExpansion: D,
+    handleSelection: N,
+    handleCheckboxSelection: z,
+    handleContentClick: $,
+    preventSelection: j,
+    expansionTrigger: Q,
+    toggleItemEditing: B
+  } = Tt(c), q = s || p || I, X = E.useRef(null), ee = (A) => {
+    j(A), l && l(A);
+  }, Y = (A) => {
+    var Z;
+    $ == null || $(A, c), !((Z = X.current) != null && Z.contains(A.target)) && (Q === "content" && D(A), P || N(A), i && i(A));
+  }, te = (A) => {
+    A.defaultMuiPrevented || B();
+  };
+  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__ */ de("div", C({}, h, {
+      className: $e(o.root, r, f && o.expanded, b && o.selected, x && o.focused, g && o.disabled, R && o.editing, M && o.editable),
+      onClick: Y,
+      onMouseDown: ee,
+      ref: n,
+      children: [/* @__PURE__ */ v("div", {
+        className: o.iconContainer,
+        children: q
+      }), P && /* @__PURE__ */ v(ct, {
+        className: o.checkbox,
+        checked: b,
+        onChange: z,
+        disabled: g || w,
+        ref: X,
+        tabIndex: -1
+      }), R ? /* @__PURE__ */ v(Ct, C({}, a, {
+        className: o.labelInput
+      })) : /* @__PURE__ */ v("div", C({
+        className: o.label
+      }, M && {
+        onDoubleClick: te
+      }, {
+        children: u
+      })), m && /* @__PURE__ */ v(ze, C({}, m))]
+    }))
+  );
+});
+process.env.NODE_ENV !== "production" && (qe.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: d.object.isRequired,
+  className: d.string,
+  /**
+   * The icon to display next to the Tree Item's label. Either a parent or end icon.
+   */
+  displayIcon: d.node,
+  dragAndDropOverlayProps: d.shape({
+    action: d.oneOf(["make-child", "move-to-parent", "reorder-above", "reorder-below"]),
+    style: d.object
+  }),
+  /**
+   * The icon to display next to the Tree Item's label. Either an expansion or collapse icon.
+   */
+  expansionIcon: d.node,
+  /**
+   * The icon to display next to the Tree Item's label.
+   */
+  icon: d.node,
+  /**
+   * The id of the item.
+   */
+  itemId: d.string.isRequired,
+  /**
+   * The Tree Item label.
+   */
+  label: d.node,
+  labelInputProps: d.shape({
+    autoFocus: d.oneOf([!0]),
+    "data-element": d.oneOf(["labelInput"]),
+    onBlur: d.func,
+    onChange: d.func,
+    onKeyDown: d.func,
+    type: d.oneOf(["text"]),
+    value: d.string
+  })
+});
+function Et(e) {
+  return st("MuiTreeItem", e);
+}
+const W = lt("MuiTreeItem", ["root", "groupTransition", "content", "expanded", "selected", "focused", "disabled", "iconContainer", "label", "checkbox", "labelInput", "editable", "editing", "dragAndDropOverlay"]), wt = ue(/* @__PURE__ */ v("path", {
+  d: "M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
+}), "TreeViewExpandIcon"), Rt = ue(/* @__PURE__ */ v("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), "TreeViewCollapseIcon");
+function ke(e) {
+  const {
+    children: t,
+    itemId: n
+  } = e, {
+    wrapItem: o,
+    instance: r
+  } = ie();
+  return o({
+    children: t,
+    itemId: n,
+    instance: r
+  });
+}
+ke.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  children: d.node,
+  itemId: d.string.isRequired
+};
+const jn = ["children", "className", "slots", "slotProps", "ContentComponent", "ContentProps", "itemId", "id", "label", "onClick", "onMouseDown", "onFocus", "onBlur", "onKeyDown"], Kn = ["ownerState"], _n = ["ownerState"], Bn = ["ownerState"], Un = je(), zn = (e) => {
+  const {
+    classes: t
+  } = e;
+  return Ne({
+    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"]
+  }, Et, t);
+}, qn = _("li", {
+  name: "MuiTreeItem",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), Gn = _(qe, {
+  name: "MuiTreeItem",
+  slot: "Content",
+  overridesResolver: (e, t) => [t.content, t.iconContainer && {
+    [`& .${W.iconContainer}`]: t.iconContainer
+  }, t.label && {
+    [`& .${W.label}`]: t.label
+  }],
+  shouldForwardProp: (e) => pe(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"
+    }
+  },
+  [`&.${W.disabled}`]: {
+    opacity: (e.vars || e).palette.action.disabledOpacity,
+    backgroundColor: "transparent"
+  },
+  [`&.${W.focused}`]: {
+    backgroundColor: (e.vars || e).palette.action.focus
+  },
+  [`&.${W.selected}`]: {
+    backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / ${e.vars.palette.action.selectedOpacity})` : J(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}))` : J(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})` : J(e.palette.primary.main, e.palette.action.selectedOpacity)
+      }
+    },
+    [`&.${W.focused}`]: {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.focusOpacity}))` : J(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.focusOpacity)
+    }
+  },
+  [`& .${W.iconContainer}`]: {
+    width: 16,
+    display: "flex",
+    flexShrink: 0,
+    justifyContent: "center",
+    "& svg": {
+      fontSize: 18
+    }
+  },
+  [`& .${W.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),
+  [`& .${W.checkbox}`]: {
+    padding: 0
+  },
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: `calc(${e.spacing(1)} + var(--TreeView-itemChildrenIndentation) * var(--TreeView-itemDepth))`
+    }
+  }]
+})), Xn = _(at, {
+  name: "MuiTreeItem",
+  slot: "GroupTransition",
+  overridesResolver: (e, t) => t.groupTransition,
+  shouldForwardProp: (e) => pe(e) && e !== "indentationAtItemLevel"
+})({
+  margin: 0,
+  padding: 0,
+  paddingLeft: "var(--TreeView-itemChildrenIndentation)",
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: 0
+    }
+  }]
+}), vt = /* @__PURE__ */ E.forwardRef(function(t, n) {
+  var Qe, Ye, Ze, He;
+  const {
+    icons: o,
+    runItemPlugins: r,
+    items: {
+      disabledItemsFocusable: I,
+      indentationAtItemLevel: p
+    },
+    selection: {
+      disableSelection: s
+    },
+    expansion: {
+      expansionTrigger: u
+    },
+    treeId: c,
+    instance: i
+  } = ie(), l = E.useContext(Pe), m = Un({
+    props: t,
+    name: "MuiTreeItem"
+  }), {
+    children: a,
+    className: h,
+    slots: g,
+    slotProps: f,
+    ContentComponent: b = qe,
+    ContentProps: x,
+    itemId: R,
+    id: M,
+    label: w,
+    onClick: P,
+    onMouseDown: D,
+    onBlur: N,
+    onKeyDown: z
+  } = m, $ = G(m, jn), {
+    expanded: j,
+    focused: Q,
+    selected: B,
+    disabled: q,
+    editing: X,
+    handleExpansion: ee,
+    handleCancelItemLabelEditing: Y,
+    handleSaveItemLabel: te
+  } = Tt(R);
+  process.env.NODE_ENV !== "production" && (m.ContentComponent && ve(["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/."]), m.ContentProps && ve(["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: A,
+    rootRef: Z,
+    propsEnhancers: L
+  } = r(m), ne = E.useRef(null), De = E.useRef(null), Ge = Ie(n, Z, ne), Xe = Ie(x == null ? void 0 : x.ref, A, De), se = {
+    expandIcon: (g == null ? void 0 : g.expandIcon) ?? o.slots.expandIcon ?? wt,
+    collapseIcon: (g == null ? void 0 : g.collapseIcon) ?? o.slots.collapseIcon ?? Rt,
+    endIcon: (g == null ? void 0 : g.endIcon) ?? o.slots.endIcon,
+    icon: g == null ? void 0 : g.icon,
+    groupTransition: g == null ? void 0 : g.groupTransition
+  }, Oe = (k) => Array.isArray(k) ? k.length > 0 && k.some(Oe) : !!k, fe = Oe(a), xe = C({}, m, {
+    expanded: j,
+    focused: Q,
+    selected: B,
+    disabled: q,
+    indentationAtItemLevel: p
+  }), T = zn(xe), y = se.groupTransition ?? void 0, S = V({
+    elementType: y,
+    ownerState: {},
+    externalSlotProps: f == null ? void 0 : f.groupTransition,
+    additionalProps: C({
+      unmountOnExit: !0,
+      in: j,
+      component: "ul",
+      role: "group"
+    }, p ? {
+      indentationAtItemLevel: !0
+    } : {}),
+    className: T.groupTransition
+  }), O = (k) => {
+    u === "iconContainer" && ee(k);
+  }, F = j ? se.collapseIcon : se.expandIcon, oe = V({
+    elementType: F,
+    ownerState: {},
+    externalSlotProps: (k) => j ? C({}, H(o.slotProps.collapseIcon, k), H(f == null ? void 0 : f.collapseIcon, k)) : C({}, H(o.slotProps.expandIcon, k), H(f == null ? void 0 : f.expandIcon, k)),
+    additionalProps: {
+      onClick: O
+    }
+  }), ye = G(oe, Kn), Te = fe && F ? /* @__PURE__ */ v(F, C({}, ye)) : null, Ae = fe ? void 0 : se.endIcon, Nt = V({
+    elementType: Ae,
+    ownerState: {},
+    externalSlotProps: (k) => fe ? {} : C({}, H(o.slotProps.endIcon, k), H(f == null ? void 0 : f.endIcon, k))
+  }), jt = G(Nt, _n), Kt = Ae ? /* @__PURE__ */ v(Ae, C({}, jt)) : null, Le = se.icon, _t = V({
+    elementType: Le,
+    ownerState: {},
+    externalSlotProps: f == null ? void 0 : f.icon
+  }), Bt = G(_t, Bn), Ut = Le ? /* @__PURE__ */ v(Le, C({}, Bt)) : null;
+  let Ce;
+  B ? Ce = !0 : s || q ? Ce = void 0 : Ce = !1;
+  function zt(k) {
+    !Q && (!q || I) && k.currentTarget === k.target && i.focusItem(k, R);
+  }
+  function qt(k) {
+    var le, me, et, tt;
+    N == null || N(k), !(X || // 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
+    k.relatedTarget && be(k.relatedTarget, ne.current) && (k.target && ((me = (le = k.target) == null ? void 0 : le.dataset) == null ? void 0 : me.element) === "labelInput" && be(k.target, ne.current) || ((tt = (et = k.relatedTarget) == null ? void 0 : et.dataset) == null ? void 0 : tt.element) === "labelInput")) && i.removeFocusedItem();
+  }
+  const Gt = (k) => {
+    var le, me;
+    z == null || z(k), ((me = (le = k.target) == null ? void 0 : le.dataset) == null ? void 0 : me.element) !== "labelInput" && i.handleItemKeyDown(k, R);
+  }, Xt = Ke({
+    itemId: R,
+    treeId: c,
+    id: M
+  }), Wt = i.canItemBeTabbed(R) ? 0 : -1, Ee = {
+    rootRefObject: ne,
+    contentRefObject: De,
+    interactions: {
+      handleSaveItemLabel: te,
+      handleCancelItemLabelEditing: Y
+    }
+  }, Jt = ((Qe = L.root) == null ? void 0 : Qe.call(L, C({}, Ee, {
+    externalEventHandlers: U($)
+  }))) ?? {}, Qt = ((Ye = L.content) == null ? void 0 : Ye.call(L, C({}, Ee, {
+    externalEventHandlers: U(x)
+  }))) ?? {}, We = ((Ze = L.dragAndDropOverlay) == null ? void 0 : Ze.call(L, C({}, Ee, {
+    externalEventHandlers: {}
+  }))) ?? {}, Je = ((He = L.labelInput) == null ? void 0 : He.call(L, C({}, Ee, {
+    externalEventHandlers: {}
+  }))) ?? {};
+  return /* @__PURE__ */ v(ke, {
+    itemId: R,
+    children: /* @__PURE__ */ de(qn, C({
+      className: $e(T.root, h),
+      role: "treeitem",
+      "aria-expanded": fe ? j : void 0,
+      "aria-selected": Ce,
+      "aria-disabled": q || void 0,
+      id: Xt,
+      tabIndex: Wt
+    }, $, {
+      ownerState: xe,
+      onFocus: zt,
+      onBlur: qt,
+      onKeyDown: Gt,
+      ref: Ge,
+      style: p ? C({}, $.style, {
+        "--TreeView-itemDepth": typeof l == "function" ? l(R) : l
+      }) : $.style
+    }, Jt, {
+      children: [/* @__PURE__ */ v(Gn, C({
+        as: b,
+        classes: {
+          root: T.content,
+          expanded: T.expanded,
+          selected: T.selected,
+          focused: T.focused,
+          disabled: T.disabled,
+          editable: T.editable,
+          editing: T.editing,
+          iconContainer: T.iconContainer,
+          label: T.label,
+          labelInput: T.labelInput,
+          checkbox: T.checkbox
+        },
+        label: w,
+        itemId: R,
+        onClick: P,
+        onMouseDown: D,
+        icon: Ut,
+        expansionIcon: Te,
+        displayIcon: Kt,
+        ownerState: xe
+      }, x, Qt, We.action == null ? {} : {
+        dragAndDropOverlayProps: We
+      }, Je.value == null ? {} : {
+        labelInputProps: Je
+      }, {
+        ref: Xe
+      })), a && /* @__PURE__ */ v(Xn, C({
+        as: y
+      }, S, {
+        children: a
+      }))]
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (vt.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The content of the component.
+   */
+  children: d.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: d.object,
+  className: d.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: on,
+  /**
+   * 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: d.object,
+  /**
+   * If `true`, the item is disabled.
+   * @default false
+   */
+  disabled: d.bool,
+  /**
+   * The id of the item.
+   */
+  itemId: d.string.isRequired,
+  /**
+   * The Tree Item label.
+   */
+  label: d.node,
+  /**
+   * This prop isn't supported.
+   * Use the `onItemFocus` callback on the tree if you need to monitor a item's focus.
+   */
+  onFocus: dt,
+  /**
+   * Callback fired when a key of the keyboard is pressed on the item.
+   */
+  onKeyDown: d.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: d.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: d.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: d.oneOfType([d.arrayOf(d.oneOfType([d.func, d.object, d.bool])), d.func, d.object])
+});
+const Wn = ["ownerState"];
+function Jn({
+  slots: e,
+  slotProps: t,
+  label: n,
+  id: o,
+  itemId: r,
+  itemsToRender: I
+}) {
+  const p = (e == null ? void 0 : e.item) ?? vt, s = V({
+    elementType: p,
+    externalSlotProps: t == null ? void 0 : t.item,
+    additionalProps: {
+      itemId: r,
+      id: o,
+      label: n
+    },
+    ownerState: {
+      itemId: r,
+      label: n
+    }
+  }), u = G(s, Wn), c = E.useMemo(() => I ? /* @__PURE__ */ v(Pt, {
+    itemsToRender: I,
+    slots: e,
+    slotProps: t
+  }) : null, [I, e, t]);
+  return /* @__PURE__ */ v(p, C({}, u, {
+    children: c
+  }));
+}
+function Pt(e) {
+  const {
+    itemsToRender: t,
+    slots: n,
+    slotProps: o
+  } = e;
+  return /* @__PURE__ */ v(E.Fragment, {
+    children: t.map((r) => /* @__PURE__ */ v(Jn, {
+      slots: n,
+      slotProps: o,
+      label: r.label,
+      id: r.id,
+      itemId: r.itemId,
+      itemsToRender: r.children
+    }, r.itemId))
+  });
+}
+const Qn = je(), Yn = (e) => {
+  const {
+    classes: t
+  } = e;
+  return Ne({
+    root: ["root"]
+  }, an, t);
+}, Zn = _("ul", {
+  name: "MuiRichTreeView",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  padding: 0,
+  margin: 0,
+  listStyle: "none",
+  outline: 0,
+  position: "relative"
+}), St = /* @__PURE__ */ E.forwardRef(function(t, n) {
+  const o = Qn({
+    props: t,
+    name: "MuiRichTreeView"
+  });
+  process.env.NODE_ENV !== "production" && o.children != null && ve(["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: r,
+    contextValue: I,
+    instance: p
+  } = hn({
+    plugins: Fn,
+    rootRef: n,
+    props: o
+  }), {
+    slots: s,
+    slotProps: u
+  } = o, c = Yn(o), i = (s == null ? void 0 : s.root) ?? Zn, l = V({
+    elementType: i,
+    externalSlotProps: u == null ? void 0 : u.root,
+    className: c.root,
+    getSlotProps: r,
+    ownerState: o
+  });
+  return /* @__PURE__ */ v(xn, {
+    value: I,
+    children: /* @__PURE__ */ v(i, C({}, l, {
+      children: /* @__PURE__ */ v(Pt, {
+        slots: s,
+        slotProps: u,
+        itemsToRender: p.getItemsToRender()
+      })
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (St.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: d.shape({
+    current: d.shape({
+      focusItem: d.func.isRequired,
+      getItem: d.func.isRequired,
+      getItemDOMElement: d.func.isRequired,
+      getItemOrderedChildrenIds: d.func.isRequired,
+      getItemTree: d.func.isRequired,
+      selectItem: d.func.isRequired,
+      setItemExpansion: d.func.isRequired,
+      updateItemLabel: d.func.isRequired
+    })
+  }),
+  /**
+   * If `true`, the Tree View renders a checkbox at the left of its label that allows selecting it.
+   * @default false
+   */
+  checkboxSelection: d.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: d.object,
+  className: d.string,
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is not controlled.
+   * @default []
+   */
+  defaultExpandedItems: d.arrayOf(d.string),
+  /**
+   * Selected item ids. (Uncontrolled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   * @default []
+   */
+  defaultSelectedItems: d.any,
+  /**
+   * If `true`, will allow focus on disabled items.
+   * @default false
+   */
+  disabledItemsFocusable: d.bool,
+  /**
+   * If `true` selection is disabled.
+   * @default false
+   */
+  disableSelection: d.bool,
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is controlled.
+   */
+  expandedItems: d.arrayOf(d.string),
+  /**
+   * The slot that triggers the item's expansion when clicked.
+   * @default 'content'
+   */
+  expansionTrigger: d.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: d.shape({
+    indentationAtItemLevel: d.bool,
+    labelEditing: d.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: d.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: d.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: d.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: d.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: d.oneOfType([d.func, d.bool]),
+  /**
+   * Horizontal indentation between an item and its children.
+   * Examples: 24, "24px", "2rem", "2em".
+   * @default 12px
+   */
+  itemChildrenIndentation: d.oneOfType([d.number, d.string]),
+  items: d.array.isRequired,
+  /**
+   * If `true`, `ctrl` and `shift` will trigger multiselect.
+   * @default false
+   */
+  multiSelect: d.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: d.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: d.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: d.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: d.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: d.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: d.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: d.func,
+  /**
+   * Selected item ids. (Controlled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   */
+  selectedItems: d.any,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: d.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: d.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: d.oneOfType([d.arrayOf(d.oneOfType([d.func, d.object, d.bool])), d.func, d.object])
+});
+const Mt = (e) => Array.isArray(e) ? e.length > 0 && e.some(Mt) : !!e, Hn = ({
+  itemId: e,
+  children: t
+}) => {
+  const {
+    instance: n,
+    selection: {
+      multiSelect: o
+    },
+    publicAPI: r
+  } = ie(), I = {
+    expandable: Mt(t),
+    expanded: n.isItemExpanded(e),
+    focused: n.isItemFocused(e),
+    selected: n.isItemSelected(e),
+    disabled: n.isItemDisabled(e),
+    editing: n != null && n.isItemBeingEdited ? n == null ? void 0 : n.isItemBeingEdited(e) : !1,
+    editable: n.isItemEditable ? n.isItemEditable(e) : !1
+  }, p = (a) => {
+    if (I.disabled)
+      return;
+    I.focused || n.focusItem(a, e);
+    const h = o && (a.shiftKey || a.ctrlKey || a.metaKey);
+    I.expandable && !(h && n.isItemExpanded(e)) && n.toggleItemExpansion(a, e);
+  }, s = (a) => {
+    if (I.disabled)
+      return;
+    I.focused || n.focusItem(a, e), o && (a.shiftKey || a.ctrlKey || a.metaKey) ? a.shiftKey ? n.expandSelectionRange(a, e) : n.selectItem({
+      event: a,
+      itemId: e,
+      keepExistingSelection: !0
+    }) : n.selectItem({
+      event: a,
+      itemId: e,
+      shouldBeSelected: !0
+    });
+  }, u = (a) => {
+    const h = a.nativeEvent.shiftKey;
+    o && h ? n.expandSelectionRange(a, e) : n.selectItem({
+      event: a,
+      itemId: e,
+      keepExistingSelection: o,
+      shouldBeSelected: a.target.checked
+    });
+  }, c = () => {
+    re(n, K) && n.isItemEditable(e) && (n.isItemBeingEdited(e) ? n.setEditedItemId(null) : n.setEditedItemId(e));
+  };
+  return {
+    interactions: {
+      handleExpansion: p,
+      handleSelection: s,
+      handleCheckboxSelection: u,
+      toggleItemEditing: c,
+      handleSaveItemLabel: (a, h) => {
+        re(n, K) && n.isItemBeingEditedRef(e) && (n.updateItemLabel(e, h), c(), n.focusItem(a, e));
+      },
+      handleCancelItemLabelEditing: (a) => {
+        re(n, K) && n.isItemBeingEditedRef(e) && (c(), n.focusItem(a, e));
+      }
+    },
+    status: I,
+    publicAPI: r
+  };
+}, eo = (e) => {
+  const {
+    runItemPlugins: t,
+    items: {
+      onItemClick: n,
+      disabledItemsFocusable: o,
+      indentationAtItemLevel: r
+    },
+    selection: {
+      disableSelection: I,
+      checkboxSelection: p
+    },
+    expansion: {
+      expansionTrigger: s
+    },
+    treeId: u,
+    instance: c,
+    publicAPI: i
+  } = ie(), l = E.useContext(Pe), {
+    id: m,
+    itemId: a,
+    label: h,
+    children: g,
+    rootRef: f
+  } = e, {
+    rootRef: b,
+    contentRef: x,
+    propsEnhancers: R
+  } = t(e), {
+    interactions: M,
+    status: w
+  } = Hn({
+    itemId: a,
+    children: g
+  }), P = E.useRef(null), D = E.useRef(null), N = Ie(f, b, P), z = Ie(x, D), $ = E.useRef(null), j = Ke({
+    itemId: a,
+    treeId: u,
+    id: m
+  }), Q = c.canItemBeTabbed(a) ? 0 : -1, B = {
+    rootRefObject: P,
+    contentRefObject: D,
+    interactions: M
+  }, q = (T) => (y) => {
+    var O;
+    if ((O = T.onFocus) == null || O.call(T, y), y.defaultMuiPrevented)
+      return;
+    const S = !w.disabled || o;
+    !w.focused && S && y.currentTarget === y.target && c.focusItem(y, a);
+  }, X = (T) => (y) => {
+    var O, F, oe, ye, Te;
+    if ((O = T.onBlur) == null || O.call(T, y), y.defaultMuiPrevented)
+      return;
+    const S = c.getItemDOMElement(a);
+    w.editing || // 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
+    y.relatedTarget && be(y.relatedTarget, S) && (y.target && ((oe = (F = y.target) == null ? void 0 : F.dataset) == null ? void 0 : oe.element) === "labelInput" && be(y.target, S) || ((Te = (ye = y.relatedTarget) == null ? void 0 : ye.dataset) == null ? void 0 : Te.element) === "labelInput") || c.removeFocusedItem();
+  }, ee = (T) => (y) => {
+    var S, O, F;
+    (S = T.onKeyDown) == null || S.call(T, y), !(y.defaultMuiPrevented || ((F = (O = y.target) == null ? void 0 : O.dataset) == null ? void 0 : F.element) === "labelInput") && c.handleItemKeyDown(y, a);
+  }, Y = (T) => (y) => {
+    var S;
+    (S = T.onDoubleClick) == null || S.call(T, y), !y.defaultMuiPrevented && M.toggleItemEditing();
+  }, te = (T) => (y) => {
+    var S, O;
+    (S = T.onClick) == null || S.call(T, y), n == null || n(y, a), !(y.defaultMuiPrevented || (O = $.current) != null && O.contains(y.target)) && (s === "content" && M.handleExpansion(y), p || M.handleSelection(y));
+  }, A = (T) => (y) => {
+    var S;
+    (S = T.onMouseDown) == null || S.call(T, y), !y.defaultMuiPrevented && (y.shiftKey || y.ctrlKey || y.metaKey || w.disabled) && y.preventDefault();
+  }, Z = (T) => (y) => {
+    var S;
+    (S = T.onChange) == null || S.call(T, y), !y.defaultMuiPrevented && (I || w.disabled || M.handleCheckboxSelection(y));
+  }, L = (T) => (y) => {
+    var S;
+    (S = T.onClick) == null || S.call(T, y), !y.defaultMuiPrevented && s === "iconContainer" && M.handleExpansion(y);
+  };
+  return {
+    getRootProps: (T = {}) => {
+      var oe;
+      const y = C({}, U(e), U(T));
+      let S;
+      w.selected ? S = !0 : I || w.disabled ? S = void 0 : S = !1;
+      const O = C({}, y, {
+        ref: N,
+        role: "treeitem",
+        tabIndex: Q,
+        id: j,
+        "aria-expanded": w.expandable ? w.expanded : void 0,
+        "aria-selected": S,
+        "aria-disabled": w.disabled || void 0
+      }, T, {
+        onFocus: q(y),
+        onBlur: X(y),
+        onKeyDown: ee(y)
+      });
+      r && (O.style = {
+        "--TreeView-itemDepth": typeof l == "function" ? l(a) : l
+      });
+      const F = ((oe = R.root) == null ? void 0 : oe.call(R, C({}, B, {
+        externalEventHandlers: y
+      }))) ?? {};
+      return C({}, O, F);
+    },
+    getContentProps: (T = {}) => {
+      var F;
+      const y = U(T), S = C({}, y, T, {
+        ref: z,
+        onClick: te(y),
+        onMouseDown: A(y),
+        status: w
+      });
+      r && (S.indentationAtItemLevel = !0);
+      const O = ((F = R.content) == null ? void 0 : F.call(R, C({}, B, {
+        externalEventHandlers: y
+      }))) ?? {};
+      return C({}, S, O);
+    },
+    getGroupTransitionProps: (T = {}) => {
+      const y = U(T), S = C({}, y, {
+        unmountOnExit: !0,
+        component: "ul",
+        role: "group",
+        in: w.expanded,
+        children: g
+      }, T);
+      return r && (S.indentationAtItemLevel = !0), S;
+    },
+    getIconContainerProps: (T = {}) => {
+      const y = U(T);
+      return C({}, y, T, {
+        onClick: L(y)
+      });
+    },
+    getCheckboxProps: (T = {}) => {
+      const y = U(T);
+      return C({}, y, {
+        visible: p,
+        ref: $,
+        checked: w.selected,
+        disabled: I || w.disabled,
+        tabIndex: -1
+      }, T, {
+        onChange: Z(y)
+      });
+    },
+    getLabelProps: (T = {}) => {
+      const y = C({}, U(T)), S = C({}, y, {
+        children: h
+      }, T, {
+        onDoubleClick: Y(y)
+      });
+      return c.isTreeViewEditable && (S.editable = w.editable), S;
+    },
+    getLabelInputProps: (T = {}) => {
+      var O;
+      const y = U(T), S = ((O = R.labelInput) == null ? void 0 : O.call(R, {
+        rootRefObject: P,
+        contentRefObject: D,
+        externalEventHandlers: y,
+        interactions: M
+      })) ?? {};
+      return C({}, T, S);
+    },
+    getDragAndDropOverlayProps: (T = {}) => {
+      var O;
+      const y = U(T), S = ((O = R.dragAndDropOverlay) == null ? void 0 : O.call(R, C({}, B, {
+        externalEventHandlers: y
+      }))) ?? {};
+      return C({}, T, S);
+    },
+    rootRef: N,
+    status: w,
+    publicAPI: i
+  };
+}, kt = eo;
+function Dt(e) {
+  const {
+    slots: t,
+    slotProps: n,
+    status: o
+  } = e, r = ie(), I = C({}, r.icons.slots, {
+    expandIcon: r.icons.slots.expandIcon ?? wt,
+    collapseIcon: r.icons.slots.collapseIcon ?? Rt
+  }), p = r.icons.slotProps;
+  let s;
+  t != null && t.icon ? s = "icon" : o.expandable ? o.expanded ? s = "collapseIcon" : s = "expandIcon" : s = "endIcon";
+  const u = (t == null ? void 0 : t[s]) ?? I[s], c = V({
+    elementType: u,
+    externalSlotProps: (i) => C({}, H(p[s], i), H(n == null ? void 0 : n[s], i)),
+    // TODO: Add proper ownerState
+    ownerState: {}
+  });
+  return u ? /* @__PURE__ */ v(u, C({}, c)) : null;
+}
+process.env.NODE_ENV !== "production" && (Dt.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: d.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: d.object,
+  status: d.shape({
+    disabled: d.bool.isRequired,
+    editable: d.bool.isRequired,
+    editing: d.bool.isRequired,
+    expandable: d.bool.isRequired,
+    expanded: d.bool.isRequired,
+    focused: d.bool.isRequired,
+    selected: d.bool.isRequired
+  }).isRequired
+});
+const to = ["visible"], no = ["id", "itemId", "label", "disabled", "children", "slots", "slotProps"], oo = je(), Ot = _("li", {
+  name: "MuiTreeItem2",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), At = _("div", {
+  name: "MuiTreeItem2",
+  slot: "Content",
+  overridesResolver: (e, t) => t.content,
+  shouldForwardProp: (e) => pe(e) && e !== "status" && 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"
+    }
+  },
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: `calc(${e.spacing(1)} + var(--TreeView-itemChildrenIndentation) * var(--TreeView-itemDepth))`
+    }
+  }, {
+    props: ({
+      status: t
+    }) => t.disabled,
+    style: {
+      opacity: (e.vars || e).palette.action.disabledOpacity,
+      backgroundColor: "transparent"
+    }
+  }, {
+    props: ({
+      status: t
+    }) => t.focused,
+    style: {
+      backgroundColor: (e.vars || e).palette.action.focus
+    }
+  }, {
+    props: ({
+      status: t
+    }) => t.selected,
+    style: {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / ${e.vars.palette.action.selectedOpacity})` : J(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}))` : J(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})` : J(e.palette.primary.main, e.palette.action.selectedOpacity)
+        }
+      }
+    }
+  }, {
+    props: ({
+      status: t
+    }) => t.selected && t.focused,
+    style: {
+      backgroundColor: e.vars ? `rgba(${e.vars.palette.primary.mainChannel} / calc(${e.vars.palette.action.selectedOpacity} + ${e.vars.palette.action.focusOpacity}))` : J(e.palette.primary.main, e.palette.action.selectedOpacity + e.palette.action.focusOpacity)
+    }
+  }]
+})), Lt = _("div", {
+  name: "MuiTreeItem2",
+  slot: "Label",
+  overridesResolver: (e, t) => t.label,
+  shouldForwardProp: (e) => pe(e) && e !== "editable"
+})(({
+  theme: e
+}) => 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",
+  overflow: "hidden"
+}, e.typography.body1, {
+  variants: [{
+    props: ({
+      editable: t
+    }) => t,
+    style: {
+      paddingLeft: "2px"
+    }
+  }]
+})), Vt = _("div", {
+  name: "MuiTreeItem2",
+  slot: "IconContainer",
+  overridesResolver: (e, t) => t.iconContainer
+})({
+  width: 16,
+  display: "flex",
+  flexShrink: 0,
+  justifyContent: "center",
+  "& svg": {
+    fontSize: 18
+  }
+}), Ft = _(at, {
+  name: "MuiTreeItem2",
+  slot: "GroupTransition",
+  overridesResolver: (e, t) => t.groupTransition,
+  shouldForwardProp: (e) => pe(e) && e !== "indentationAtItemLevel"
+})({
+  margin: 0,
+  padding: 0,
+  paddingLeft: "var(--TreeView-itemChildrenIndentation)",
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: 0
+    }
+  }]
+}), ro = _(/* @__PURE__ */ E.forwardRef((e, t) => {
+  const {
+    visible: n
+  } = e, o = G(e, to);
+  return n ? /* @__PURE__ */ v(ct, C({}, o, {
+    ref: t
+  })) : null;
+}), {
+  name: "MuiTreeItem2",
+  slot: "Checkbox",
+  overridesResolver: (e, t) => t.checkbox
+})({
+  padding: 0
+}), io = (e) => {
+  const {
+    classes: t
+  } = e;
+  return Ne({
+    root: ["root"],
+    content: ["content"],
+    expanded: ["expanded"],
+    editing: ["editing"],
+    editable: ["editable"],
+    selected: ["selected"],
+    focused: ["focused"],
+    disabled: ["disabled"],
+    iconContainer: ["iconContainer"],
+    checkbox: ["checkbox"],
+    label: ["label"],
+    groupTransition: ["groupTransition"],
+    labelInput: ["labelInput"],
+    dragAndDropOverlay: ["dragAndDropOverlay"]
+  }, Et, t);
+}, so = /* @__PURE__ */ E.forwardRef(function(t, n) {
+  const o = oo({
+    props: t,
+    name: "MuiTreeItem2"
+  }), {
+    id: r,
+    itemId: I,
+    label: p,
+    disabled: s,
+    children: u,
+    slots: c = {},
+    slotProps: i = {}
+  } = o, l = G(o, no), {
+    getRootProps: m,
+    getContentProps: a,
+    getIconContainerProps: h,
+    getCheckboxProps: g,
+    getLabelProps: f,
+    getGroupTransitionProps: b,
+    getLabelInputProps: x,
+    getDragAndDropOverlayProps: R,
+    status: M
+  } = kt({
+    id: r,
+    itemId: I,
+    children: u,
+    label: p,
+    disabled: s
+  }), w = C({}, o, M), P = io(w), D = c.root ?? Ot, N = V({
+    elementType: D,
+    getSlotProps: m,
+    externalForwardedProps: l,
+    externalSlotProps: i.root,
+    additionalProps: {
+      ref: n
+    },
+    ownerState: {},
+    className: P.root
+  }), z = c.content ?? At, $ = V({
+    elementType: z,
+    getSlotProps: a,
+    externalSlotProps: i.content,
+    ownerState: {},
+    className: $e(P.content, M.expanded && P.expanded, M.selected && P.selected, M.focused && P.focused, M.disabled && P.disabled, M.editing && P.editing, M.editable && P.editable)
+  }), j = c.iconContainer ?? Vt, Q = V({
+    elementType: j,
+    getSlotProps: h,
+    externalSlotProps: i.iconContainer,
+    ownerState: {},
+    className: P.iconContainer
+  }), B = c.label ?? Lt, q = V({
+    elementType: B,
+    getSlotProps: f,
+    externalSlotProps: i.label,
+    ownerState: {},
+    className: P.label
+  }), X = c.checkbox ?? ro, ee = V({
+    elementType: X,
+    getSlotProps: g,
+    externalSlotProps: i.checkbox,
+    ownerState: {},
+    className: P.checkbox
+  }), Y = c.groupTransition ?? void 0, te = V({
+    elementType: Y,
+    getSlotProps: b,
+    externalSlotProps: i.groupTransition,
+    ownerState: {},
+    className: P.groupTransition
+  }), A = c.labelInput ?? Ct, Z = V({
+    elementType: A,
+    getSlotProps: x,
+    externalSlotProps: i.labelInput,
+    ownerState: {},
+    className: P.labelInput
+  }), L = c.dragAndDropOverlay ?? ze, ne = V({
+    elementType: L,
+    getSlotProps: R,
+    externalSlotProps: i.dragAndDropOverlay,
+    ownerState: {},
+    className: P.dragAndDropOverlay
+  });
+  return /* @__PURE__ */ v(ke, {
+    itemId: I,
+    children: /* @__PURE__ */ de(D, C({}, N, {
+      children: [/* @__PURE__ */ de(z, C({}, $, {
+        children: [/* @__PURE__ */ v(j, C({}, Q, {
+          children: /* @__PURE__ */ v(Dt, {
+            status: M,
+            slots: c,
+            slotProps: i
+          })
+        })), /* @__PURE__ */ v(X, C({}, ee)), M.editing ? /* @__PURE__ */ v(A, C({}, Z)) : /* @__PURE__ */ v(B, C({}, q)), /* @__PURE__ */ v(L, C({}, ne))]
+      })), u && /* @__PURE__ */ v(Ft, C({
+        as: Y
+      }, te))]
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (so.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: d.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: d.object,
+  className: d.string,
+  /**
+   * If `true`, the item is disabled.
+   * @default false
+   */
+  disabled: d.bool,
+  /**
+   * The id attribute of the item. If not provided, it will be generated.
+   */
+  id: d.string,
+  /**
+   * The id of the item.
+   * Must be unique.
+   */
+  itemId: d.string.isRequired,
+  /**
+   * The label of the item.
+   */
+  label: d.node,
+  /**
+   * Callback fired when the item root is blurred.
+   */
+  onBlur: d.func,
+  /**
+   * This prop isn't supported.
+   * Use the `onItemFocus` callback on the tree if you need to monitor an item's focus.
+   */
+  onFocus: dt,
+  /**
+   * Callback fired when a key is pressed on the keyboard and the tree is in focus.
+   */
+  onKeyDown: d.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: d.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: d.object
+});
+const lo = () => E.useRef(void 0);
+var ao = /* @__PURE__ */ ((e) => (e.FOLDER = "FOLDER", e.SHARE = "SHARE", e.TRASH = "TRASH", e.CUSTOM = "CUSTOM", e))(ao || {});
+const co = (e, t) => {
+  if (!e) return Ve;
+  if (typeof e != "string") return e;
+  switch (e) {
+    case "SHARE":
+      return ln;
+    case "TRASH":
+      return Yt;
+    case "CUSTOM":
+      return t || Ve;
+    case "FOLDER":
+    default:
+      return Ve;
+  }
+}, uo = Zt(function(t, n) {
+  const {
+    id: o,
+    itemId: r,
+    label: I,
+    disabled: p,
+    children: s,
+    itemData: u,
+    iconColor: c = "primary"
+  } = t, i = co(
+    u == null ? void 0 : u.iconType,
+    u == null ? void 0 : u.customIcon
+  ), {
+    getRootProps: l,
+    getContentProps: m,
+    getLabelProps: a,
+    getGroupTransitionProps: h,
+    getIconContainerProps: g,
+    status: f
+  } = kt({ id: o, itemId: r, label: I, disabled: p, children: s, rootRef: n });
+  return /* @__PURE__ */ v(ke, { itemId: r, children: /* @__PURE__ */ de(Ot, { ...l(), children: [
+    /* @__PURE__ */ de(
+      At,
+      {
+        ...m(),
+        style: { display: "flex", alignItems: "center", width: "100%" },
+        children: [
+          /* @__PURE__ */ v(Vt, { ...g(), children: /* @__PURE__ */ v(i, { fontSize: "small", color: c }) }),
+          /* @__PURE__ */ v(Lt, { ...a() }),
+          /* @__PURE__ */ v(it, { sx: { display: "flex", marginLeft: "auto" }, children: f.expandable && (f.expanded ? /* @__PURE__ */ v(rn, { fontSize: "small" }) : /* @__PURE__ */ v(sn, { fontSize: "small" })) })
+        ]
+      }
+    ),
+    s && /* @__PURE__ */ v(
+      Ft,
+      {
+        ...h(),
+        style: f.expanded ? {
+          borderLeft: "1px solid #bdbdbd",
+          paddingLeft: "12px",
+          marginLeft: "15px",
+          marginTop: "4px",
+          marginBottom: "4px"
+        } : void 0
+      }
+    )
+  ] }) });
+}), po = (e) => {
+  const t = {}, n = (o) => {
+    var r;
+    t[o.id] = o, (r = o.children) != null && r.length && o.children.forEach(n);
+  };
+  return e.forEach(n), t;
+}, $t = (e, t, n = []) => {
+  var o;
+  for (const r of t) {
+    if (r.id === e)
+      return n;
+    if ((o = r.children) != null && o.length) {
+      const I = $t(e, r.children, [
+        ...n,
+        r.id
+      ]);
+      if (I.length > 0)
+        return I;
+    }
+  }
+  return [];
+}, Ao = ({
+  items: e,
+  onItemSelect: t,
+  iconColor: n = "primary",
+  expandedItemId: o
+}) => {
+  const r = nt(() => po(e), [e]), I = lo(), p = nt(() => o ? r[o] ? [...$t(o, e), o] : [] : [], [o, r, e]);
+  return Ht(() => {
+    I.current && p.length > 0 && p.forEach((s) => {
+      I.current.setItemExpansion(s, !0);
+    });
+  }, [I, p]), console.log(p), /* @__PURE__ */ v(it, { sx: { minHeight: 200, minWidth: 200 }, children: /* @__PURE__ */ v(
+    St,
+    {
+      apiRef: I,
+      items: e,
+      itemChildrenIndentation: "50px",
+      defaultExpandedItems: p,
+      onSelect: (s, u) => {
+        t && typeof u == "string" && t(s, u);
+      },
+      slots: {
+        item: (s) => {
+          const u = s.itemId ? r[s.itemId] : void 0;
+          return /* @__PURE__ */ v(
+            uo,
+            {
+              ...s,
+              itemData: u,
+              iconColor: n
+            }
+          );
+        }
+      }
+    }
+  ) });
+};
+export {
+  ao as ICON_TYPE,
+  Ao as default
+};