@cgi-learning-hub/ui 1.4.0-dev.1741950408 → 1.4.0-dev.1741961819

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

@@ -0,0 +1,2802 @@
+import { jsx as v, jsxs as de } from "react/jsx-runtime";
+import { c as be } from "../../createSvgIcon-K1Hd8ryN.js";
+import { B as ot } from "../../Box-DgqaLb7j.js";
+import { _ as C } from "../../ButtonBase-IZ_QjbpE.js";
+import * as w from "react";
+import { forwardRef as Jt } from "react";
+import { w as ve } from "../../warning-C8W811fV.js";
+import { u as me } from "../../useForkRef-C_4o__cU.js";
+import { r as H, e as z } from "../../resolveComponentProps-CPmhKPdH.js";
+import { I as rt, H as it, n as J, P as d, G as Fe } from "../../generateUtilityClasses-DotvgSDH.js";
+import { a as G } from "../../TransitionGroupContext-DbLioz_6.js";
+import { u as Yt } from "../../useThemeProps-BTfGtNci.js";
+import { s as K, f as ue, c as Ne } from "../../DefaultPropsProvider-Cqcb4sws.js";
+import { C as st } from "../../Collapse-CLl0D4CI.js";
+import { C as lt } from "../../Checkbox-DgU-0k3O.js";
+import { u as at } from "../../unsupportedProp-BuVD30Gh.js";
+import { u as Qt, a as L } from "../../useSlotProps-C9tsxDNg.js";
+import { u as ce } from "../../useEventCallback-BAQJJ3ye.js";
+import { o as Zt } from "../../ownerDocument-CUrv0DIK.js";
+import { e as Ht } from "../../elementTypeAcceptingRef-5ESWTE79.js";
+const ct = be(/* @__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"), en = be(/* @__PURE__ */ v("path", {
+  d: "M7.41 8.59 12 13.17l4.59-4.58L18 10l-6 6-6-6z"
+}), "KeyboardArrowDown"), tn = be(/* @__PURE__ */ v("path", {
+  d: "M8.59 16.59 13.17 12 8.59 7.41 10 6l6 6-6 6z"
+}), "KeyboardArrowRight");
+function nn(e) {
+  return rt("MuiRichTreeView", e);
+}
+it("MuiRichTreeView", ["root"]);
+function $e(e) {
+  return Yt;
+}
+const on = (e, t) => {
+  const n = w.useRef({}), [o, i] = w.useState(() => {
+    const f = {};
+    return e.forEach((s) => {
+      s.models && Object.entries(s.models).forEach(([m, c]) => {
+        n.current[m] = {
+          isControlled: t[m] !== void 0,
+          getDefaultValue: c.getDefaultValue
+        }, f[m] = c.getDefaultValue(t);
+      });
+    }), f;
+  }), g = Object.fromEntries(Object.entries(n.current).map(([f, s]) => {
+    const m = t[f] ?? o[f];
+    return [f, {
+      value: m,
+      setControlledValue: (c) => {
+        s.isControlled || i((r) => C({}, r, {
+          [f]: c
+        }));
+      }
+    }];
+  }));
+  return process.env.NODE_ENV !== "production" && Object.entries(n.current).forEach(([f, s]) => {
+    const m = t[f], c = s.getDefaultValue(t);
+    w.useEffect(() => {
+      s.isControlled !== (m !== void 0) && console.error([`MUI X: A component is changing the ${s.isControlled ? "" : "un"}controlled ${f} 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 ${f} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [m]);
+    const {
+      current: r
+    } = w.useRef(c);
+    w.useEffect(() => {
+      !s.isControlled && r !== c && console.error([`MUI X: A component is changing the default ${f} state of an uncontrolled TreeView after being initialized. To suppress this warning opt to use a controlled TreeView.`].join(`
+`));
+    }, [JSON.stringify(c)]);
+  }), g;
+};
+class rn {
+  constructor() {
+    this.maxListeners = 20, this.warnOnce = !1, this.events = {};
+  }
+  on(t, n, o = {}) {
+    let i = this.events[t];
+    if (i || (i = {
+      highPriority: /* @__PURE__ */ new Map(),
+      regular: /* @__PURE__ */ new Map()
+    }, this.events[t] = i), o.isFirst ? i.highPriority.set(n, !0) : i.regular.set(n, !0), process.env.NODE_ENV !== "production") {
+      const g = i.highPriority.size + i.regular.size;
+      g > this.maxListeners && !this.warnOnce && (this.warnOnce = !0, console.warn([`Possible EventEmitter memory leak detected. ${g} ${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 i = Array.from(o.highPriority.keys()), g = Array.from(o.regular.keys());
+    for (let f = i.length - 1; f >= 0; f -= 1) {
+      const s = i[f];
+      o.highPriority.has(s) && s.apply(this, n);
+    }
+    for (let f = 0; f < g.length; f += 1) {
+      const s = g[f];
+      o.regular.has(s) && s.apply(this, n);
+    }
+  }
+  once(t, n) {
+    const o = this;
+    this.on(t, function i(...g) {
+      o.removeListener(t, i), n.apply(o, g);
+    });
+  }
+}
+const sn = (e) => e.isPropagationStopped !== void 0, dt = () => {
+  const [e] = w.useState(() => new rn()), t = w.useCallback((...o) => {
+    const [i, g, f = {}] = o;
+    f.defaultMuiPrevented = !1, !(sn(f) && f.isPropagationStopped()) && e.emit(i, g, f);
+  }, [e]), n = w.useCallback((o, i) => (e.on(o, i), () => {
+    e.removeListener(o, i);
+  }), [e]);
+  return {
+    instance: {
+      $$publishEvent: t,
+      $$subscribeEvent: n
+    }
+  };
+};
+dt.params = {};
+const ut = ({
+  plugins: e
+}) => {
+  const t = new Set(e);
+  return {
+    instance: {
+      getAvailablePlugins: () => t
+    }
+  };
+};
+ut.params = {};
+let tt = 0;
+const ln = () => (tt += 1, `mui-tree-view-${tt}`), je = ({
+  id: e,
+  treeId: t = "",
+  itemId: n
+}) => e ?? `${t}-${n}`, _e = ({
+  params: e,
+  state: t,
+  setState: n
+}) => {
+  w.useEffect(() => {
+    n((i) => i.id.treeId === e.id && i.id.treeId !== void 0 ? i : C({}, i, {
+      id: C({}, i.id, {
+        treeId: e.id ?? ln()
+      })
+    }));
+  }, [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 an = [dt, ut, _e], cn = ["slots", "slotProps", "apiRef", "experimentalFeatures"], dn = (e) => {
+  let {
+    props: {
+      slots: t,
+      slotProps: n,
+      apiRef: o,
+      experimentalFeatures: i
+    },
+    plugins: g
+  } = e, f = G(e.props, cn);
+  const s = {};
+  g.forEach((u) => {
+    Object.assign(s, u.params);
+  });
+  const m = {}, c = {};
+  Object.keys(f).forEach((u) => {
+    const a = f[u];
+    s[u] ? m[u] = a : c[u] = a;
+  });
+  const r = i ?? {}, l = g.reduce((u, a) => a.getDefaultizedParams ? a.getDefaultizedParams({
+    params: u,
+    experimentalFeatures: r
+  }) : u, m);
+  return {
+    apiRef: o,
+    forwardedProps: c,
+    pluginParams: l,
+    slots: t ?? {},
+    slotProps: n ?? {},
+    experimentalFeatures: r
+  };
+}, un = ({
+  plugins: e,
+  instance: t,
+  publicAPI: n,
+  rootRef: o
+}) => ({
+  runItemPlugins: (s) => {
+    let m = null, c = null;
+    const r = [], l = {};
+    e.forEach((h) => {
+      if (!h.itemPlugin)
+        return;
+      const I = h.itemPlugin({
+        props: s,
+        rootRef: m,
+        contentRef: c
+      });
+      I != null && I.rootRef && (m = I.rootRef), I != null && I.contentRef && (c = I.contentRef), I != null && I.propsEnhancers && (r.push(I.propsEnhancers), Object.keys(I.propsEnhancers).forEach((p) => {
+        l[p] = !0;
+      }));
+    });
+    const u = (h) => (I) => {
+      const p = {};
+      return r.forEach((b) => {
+        const x = b[h];
+        x != null && Object.assign(p, x(I));
+      }), p;
+    }, a = Object.fromEntries(Object.keys(l).map((h) => [h, u(h)]));
+    return {
+      contentRef: c,
+      rootRef: m,
+      propsEnhancers: a
+    };
+  },
+  wrapItem: ({
+    itemId: s,
+    children: m
+  }) => {
+    let c = m;
+    for (let r = e.length - 1; r >= 0; r -= 1) {
+      const l = e[r];
+      l.wrapItem && (c = l.wrapItem({
+        itemId: s,
+        children: c,
+        instance: t
+      }));
+    }
+    return c;
+  },
+  wrapRoot: ({
+    children: s
+  }) => {
+    let m = s;
+    for (let c = e.length - 1; c >= 0; c -= 1) {
+      const r = e[c];
+      r.wrapRoot && (m = r.wrapRoot({
+        children: m,
+        instance: t
+      }));
+    }
+    return m;
+  },
+  instance: t,
+  rootRef: o,
+  publicAPI: n
+});
+function pn(e) {
+  const t = w.useRef({});
+  return e ? (e.current == null && (e.current = {}), e.current) : t.current;
+}
+const fn = ({
+  plugins: e,
+  rootRef: t,
+  props: n
+}) => {
+  const o = [...an, ...e], {
+    pluginParams: i,
+    forwardedProps: g,
+    apiRef: f,
+    experimentalFeatures: s,
+    slots: m,
+    slotProps: c
+  } = dn({
+    plugins: o,
+    props: n
+  }), r = on(o, i), u = w.useRef({}).current, a = pn(f), h = w.useRef(null), I = me(h, t), p = un({
+    plugins: o,
+    instance: u,
+    publicAPI: a,
+    rootRef: h
+  }), [b, x] = w.useState(() => {
+    const R = {};
+    return o.forEach((O) => {
+      O.getInitialState && Object.assign(R, O.getInitialState(i));
+    }), R;
+  }), P = [], k = (R) => {
+    const O = R({
+      instance: u,
+      params: i,
+      slots: m,
+      slotProps: c,
+      experimentalFeatures: s,
+      state: b,
+      setState: x,
+      rootRef: h,
+      models: r,
+      plugins: o
+    });
+    O.getRootProps && P.push(O.getRootProps), O.publicAPI && Object.assign(a, O.publicAPI), O.instance && Object.assign(u, O.instance), O.contextValue && Object.assign(p, O.contextValue);
+  };
+  return o.forEach(k), {
+    getRootProps: (R = {}) => {
+      const O = C({
+        role: "tree"
+      }, g, R, {
+        ref: I
+      });
+      return P.forEach(($) => {
+        Object.assign(O, $(R));
+      }), O;
+    },
+    rootRef: I,
+    contextValue: p,
+    instance: u
+  };
+}, Ke = /* @__PURE__ */ w.createContext(null);
+process.env.NODE_ENV !== "production" && (Ke.displayName = "TreeViewContext");
+function mn(e) {
+  const {
+    value: t,
+    children: n
+  } = e;
+  return /* @__PURE__ */ v(Ke.Provider, {
+    value: t,
+    children: t.wrapRoot({
+      children: n,
+      instance: t.instance
+    })
+  });
+}
+const ie = () => {
+  const e = w.useContext(Ke);
+  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;
+}, In = (e, t, n) => {
+  e.$$publishEvent(t, n);
+}, ae = "__TREE_VIEW_ROOT_PARENT_ID__", gn = (e) => {
+  const t = {};
+  return e.forEach((n, o) => {
+    t[n] = o;
+  }), t;
+}, Re = /* @__PURE__ */ w.createContext(() => -1);
+process.env.NODE_ENV !== "production" && (Re.displayName = "TreeViewItemDepthContext");
+const bn = ["children"], pt = ({
+  items: e,
+  isItemDisabled: t,
+  getItemLabel: n,
+  getItemId: o
+}) => {
+  const i = {}, g = {}, f = {
+    [ae]: []
+  }, s = (c, r, l) => {
+    var I, p;
+    const u = o ? o(c) : c.id;
+    if (u == null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", "An item was provided without id in the `items` prop:", JSON.stringify(c)].join(`
+`));
+    if (i[u] != null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", `Two items were provided with the same id in the \`items\` prop: "${u}"`].join(`
+`));
+    const 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(`
+`));
+    i[u] = {
+      id: u,
+      label: a,
+      parentId: l,
+      idAttribute: void 0,
+      expandable: !!((I = c.children) != null && I.length),
+      disabled: t ? t(c) : !1,
+      depth: r
+    }, g[u] = c;
+    const h = l ?? ae;
+    f[h] || (f[h] = []), f[h].push(u), (p = c.children) == null || p.forEach((b) => s(b, r + 1, u));
+  };
+  e.forEach((c) => s(c, 0, null));
+  const m = {};
+  return Object.keys(f).forEach((c) => {
+    m[c] = gn(f[c]);
+  }), {
+    itemMetaMap: i,
+    itemMap: g,
+    itemOrderedChildrenIds: f,
+    itemChildrenIndexes: m
+  };
+}, he = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: o,
+  experimentalFeatures: i
+}) => {
+  const g = w.useCallback((b) => n.items.itemMetaMap[b], [n.items.itemMetaMap]), f = w.useCallback((b) => n.items.itemMap[b], [n.items.itemMap]), s = w.useCallback(() => {
+    const b = (x) => {
+      const P = n.items.itemMap[x], k = G(P, bn), E = n.items.itemOrderedChildrenIds[x];
+      return E && (k.children = E.map(b)), k;
+    };
+    return n.items.itemOrderedChildrenIds[ae].map(b);
+  }, [n.items.itemMap, n.items.itemOrderedChildrenIds]), m = w.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 = w.useCallback((b) => {
+    const x = e.getItemMeta(b).parentId ?? ae;
+    return n.items.itemChildrenIndexes[x][b];
+  }, [e, n.items.itemChildrenIndexes]), r = w.useCallback((b) => n.items.itemOrderedChildrenIds[b ?? ae] ?? [], [n.items.itemOrderedChildrenIds]), l = (b) => {
+    const x = e.getItemMeta(b);
+    return x == null ? null : document.getElementById(je({
+      treeId: n.id.treeId,
+      itemId: b,
+      id: x.idAttribute
+    }));
+  }, u = (b) => t.disabledItemsFocusable ? !0 : !e.isItemDisabled(b), a = w.useRef(!1), h = w.useCallback(() => {
+    a.current = !0;
+  }, []), I = w.useCallback(() => a.current, []);
+  return w.useEffect(() => {
+    e.areItemUpdatesPrevented() || o((b) => {
+      const x = pt({
+        items: t.items,
+        isItemDisabled: t.isItemDisabled,
+        getItemId: t.getItemId,
+        getItemLabel: t.getItemLabel
+      });
+      return Object.values(b.items.itemMetaMap).forEach((P) => {
+        x.itemMetaMap[P.id] || In(e, "removeItem", {
+          id: P.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: f,
+      getItemDOMElement: l,
+      getItemTree: s,
+      getItemOrderedChildrenIds: r
+    },
+    instance: {
+      getItemMeta: g,
+      getItem: f,
+      getItemTree: s,
+      getItemsToRender: () => {
+        const b = (x) => {
+          var k;
+          const P = n.items.itemMetaMap[x];
+          return {
+            label: P.label,
+            itemId: P.id,
+            id: P.idAttribute,
+            children: (k = n.items.itemOrderedChildrenIds[x]) == null ? void 0 : k.map(b)
+          };
+        };
+        return n.items.itemOrderedChildrenIds[ae].map(b);
+      },
+      getItemIndex: c,
+      getItemDOMElement: l,
+      getItemOrderedChildrenIds: r,
+      isItemDisabled: m,
+      isItemNavigable: u,
+      preventItemUpdates: h,
+      areItemUpdatesPrevented: I
+    },
+    contextValue: {
+      items: {
+        onItemClick: t.onItemClick,
+        disabledItemsFocusable: t.disabledItemsFocusable,
+        indentationAtItemLevel: i.indentationAtItemLevel ?? !1
+      }
+    }
+  };
+};
+he.getInitialState = (e) => ({
+  items: pt({
+    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(Re.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 = w.useMemo(() => {
+    const l = /* @__PURE__ */ new Map();
+    return n.expandedItems.value.forEach((u) => {
+      l.set(u, !0);
+    }), l;
+  }, [n.expandedItems.value]), i = (l, u) => {
+    var a;
+    (a = t.onExpandedItemsChange) == null || a.call(t, l, u), n.expandedItems.setControlledValue(u);
+  }, g = w.useCallback((l) => o.has(l), [o]), f = w.useCallback((l) => {
+    var u;
+    return !!((u = e.getItemMeta(l)) != null && u.expandable);
+  }, [e]), s = ce((l, u) => {
+    const a = e.isItemExpanded(u);
+    e.setItemExpansion(l, u, !a);
+  }), m = ce((l, u, a) => {
+    if (e.isItemExpanded(u) === a)
+      return;
+    let I;
+    a ? I = [u].concat(n.expandedItems.value) : I = n.expandedItems.value.filter((p) => p !== u), t.onItemExpansionToggle && t.onItemExpansionToggle(l, u, a), i(l, I);
+  }), c = (l, u) => {
+    const a = e.getItemMeta(u), I = e.getItemOrderedChildrenIds(a.parentId).filter((b) => e.isItemExpandable(b) && !e.isItemExpanded(b)), p = n.expandedItems.value.concat(I);
+    I.length > 0 && (t.onItemExpansionToggle && I.forEach((b) => {
+      t.onItemExpansionToggle(l, b, !0);
+    }), i(l, p));
+  }, r = w.useMemo(() => t.expansionTrigger ? t.expansionTrigger : e.isTreeViewEditable ? "iconContainer" : "content", [t.expansionTrigger, e.isTreeViewEditable]);
+  return {
+    publicAPI: {
+      setItemExpansion: m
+    },
+    instance: {
+      isItemExpanded: g,
+      isItemExpandable: f,
+      setItemExpansion: m,
+      toggleItemExpansion: s,
+      expandAllSiblings: c
+    },
+    contextValue: {
+      expansion: {
+        expansionTrigger: r
+      }
+    }
+  };
+};
+Se.models = {
+  expandedItems: {
+    getDefaultValue: (e) => e.defaultExpandedItems
+  }
+};
+const hn = [];
+Se.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  defaultExpandedItems: e.defaultExpandedItems ?? hn
+});
+Se.params = {
+  expandedItems: !0,
+  defaultExpandedItems: !0,
+  onExpandedItemsChange: !0,
+  onItemExpansionToggle: !0,
+  expansionTrigger: !0
+};
+const ft = (e, t) => {
+  let n = t.length - 1;
+  for (; n >= 0 && !e.isItemNavigable(t[n]); )
+    n -= 1;
+  if (n !== -1)
+    return t[n];
+}, mt = (e, t) => {
+  const n = e.getItemMeta(t), o = e.getItemOrderedChildrenIds(n.parentId), i = e.getItemIndex(t);
+  if (i === 0)
+    return n.parentId;
+  let g = i - 1;
+  for (; !e.isItemNavigable(o[g]) && g >= 0; )
+    g -= 1;
+  if (g === -1)
+    return n.parentId == null ? null : mt(e, n.parentId);
+  let f = o[g], s = ft(e, e.getItemOrderedChildrenIds(f));
+  for (; e.isItemExpanded(f) && s != null; )
+    f = s, s = e.getItemOrderedChildrenIds(f).find(e.isItemNavigable);
+  return f;
+}, 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), i = e.getItemIndex(n.id);
+    if (i < o.length - 1) {
+      let g = i + 1;
+      for (; !e.isItemNavigable(o[g]) && g < o.length - 1; )
+        g += 1;
+      if (e.isItemNavigable(o[g]))
+        return o[g];
+    }
+    n = e.getItemMeta(n.parentId);
+  }
+  return null;
+}, It = (e) => {
+  let t = null;
+  for (; t == null || e.isItemExpanded(t); ) {
+    const n = e.getItemOrderedChildrenIds(t), o = ft(e, n);
+    if (o == null)
+      return t;
+    t = o;
+  }
+  return t;
+}, Ie = (e) => e.getItemOrderedChildrenIds(null).find(e.isItemNavigable), gt = (e, t, n) => {
+  if (t === n)
+    return [t, n];
+  const o = e.getItemMeta(t), i = e.getItemMeta(n);
+  if (o.parentId === i.id || i.parentId === o.id)
+    return i.parentId === o.id ? [o.id, i.id] : [i.id, o.id];
+  const g = [o.id], f = [i.id];
+  let s = o.parentId, m = i.parentId, c = f.indexOf(s) !== -1, r = g.indexOf(m) !== -1, l = !0, u = !0;
+  for (; !r && !c; )
+    l && (g.push(s), c = f.indexOf(s) !== -1, l = s !== null, !c && l && (s = e.getItemMeta(s).parentId)), u && !c && (f.push(m), r = g.indexOf(m) !== -1, u = m !== null, !r && u && (m = e.getItemMeta(m).parentId));
+  const a = c ? s : m, h = e.getItemOrderedChildrenIds(a), I = g[g.indexOf(a) - 1], p = f[f.indexOf(a) - 1];
+  return h.indexOf(I) < h.indexOf(p) ? [t, n] : [n, t];
+}, xn = (e, t, n) => {
+  const o = (m) => {
+    if (e.isItemExpandable(m) && e.isItemExpanded(m))
+      return e.getItemOrderedChildrenIds(m)[0];
+    let c = e.getItemMeta(m);
+    for (; c != null; ) {
+      const r = e.getItemOrderedChildrenIds(c.parentId), l = e.getItemIndex(c.id);
+      if (l < r.length - 1)
+        return r[l + 1];
+      c = e.getItemMeta(c.parentId);
+    }
+    throw new Error("Invalid range");
+  }, [i, g] = gt(e, t, n), f = [i];
+  let s = i;
+  for (; s !== g; )
+    s = o(s), e.isItemDisabled(s) || f.push(s);
+  return f;
+}, yn = (e) => {
+  let t = Ie(e);
+  const n = [];
+  for (; t != null; )
+    n.push(t), t = we(e, t);
+  return n;
+}, ge = (e, t) => t !== e.closest('*[role="treeitem"]'), Pe = (e) => Array.isArray(e) ? e : e != null ? [e] : [], Le = (e) => {
+  const t = {};
+  return e.forEach((n) => {
+    t[n] = !0;
+  }), t;
+}, ke = ({
+  instance: e,
+  params: t,
+  models: n
+}) => {
+  const o = w.useRef(null), i = w.useRef({}), g = w.useMemo(() => {
+    const I = /* @__PURE__ */ new Map();
+    return Array.isArray(n.selectedItems.value) ? n.selectedItems.value.forEach((p) => {
+      I.set(p, !0);
+    }) : n.selectedItems.value != null && I.set(n.selectedItems.value, !0), I;
+  }, [n.selectedItems.value]), f = (I, p) => {
+    if (t.onItemSelectionToggle)
+      if (t.multiSelect) {
+        const b = p.filter((P) => !e.isItemSelected(P)), x = n.selectedItems.value.filter((P) => !p.includes(P));
+        b.forEach((P) => {
+          t.onItemSelectionToggle(I, P, !0);
+        }), x.forEach((P) => {
+          t.onItemSelectionToggle(I, P, !1);
+        });
+      } else p !== n.selectedItems.value && (n.selectedItems.value != null && t.onItemSelectionToggle(I, n.selectedItems.value, !1), p != null && t.onItemSelectionToggle(I, p, !0));
+    t.onSelectedItemsChange && t.onSelectedItemsChange(I, p), n.selectedItems.setControlledValue(p);
+  }, s = (I) => g.has(I), m = ({
+    event: I,
+    itemId: p,
+    keepExistingSelection: b = !1,
+    shouldBeSelected: x
+  }) => {
+    if (t.disableSelection)
+      return;
+    let P;
+    if (b) {
+      const k = Pe(n.selectedItems.value), E = e.isItemSelected(p);
+      E && (x === !1 || x == null) ? P = k.filter((R) => R !== p) : !E && (x === !0 || x == null) ? P = [p].concat(k) : P = k;
+    } else
+      x === !1 || x == null && e.isItemSelected(p) ? P = t.multiSelect ? [] : null : P = t.multiSelect ? [p] : p;
+    f(I, P), o.current = p, i.current = {};
+  }, c = (I, [p, b]) => {
+    if (t.disableSelection || !t.multiSelect)
+      return;
+    let x = Pe(n.selectedItems.value).slice();
+    Object.keys(i.current).length > 0 && (x = x.filter((R) => !i.current[R]));
+    const P = Le(x), k = xn(e, p, b), E = k.filter((R) => !P[R]);
+    x = x.concat(E), f(I, x), i.current = Le(k);
+  };
+  return {
+    getRootProps: () => ({
+      "aria-multiselectable": t.multiSelect
+    }),
+    publicAPI: {
+      selectItem: m
+    },
+    instance: {
+      isItemSelected: s,
+      selectItem: m,
+      selectAllNavigableItems: (I) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        const p = yn(e);
+        f(I, p), i.current = Le(p);
+      },
+      expandSelectionRange: (I, p) => {
+        if (o.current != null) {
+          const [b, x] = gt(e, p, o.current);
+          c(I, [b, x]);
+        }
+      },
+      selectRangeFromStartToItem: (I, p) => {
+        c(I, [Ie(e), p]);
+      },
+      selectRangeFromItemToEnd: (I, p) => {
+        c(I, [p, It(e)]);
+      },
+      selectItemFromArrowNavigation: (I, p, b) => {
+        if (t.disableSelection || !t.multiSelect)
+          return;
+        let x = Pe(n.selectedItems.value).slice();
+        Object.keys(i.current).length === 0 ? (x.push(b), i.current = {
+          [p]: !0,
+          [b]: !0
+        }) : (i.current[p] || (i.current = {}), i.current[b] ? (x = x.filter((P) => P !== p), delete i.current[p]) : (x.push(b), i.current[b] = !0)), f(I, x);
+      }
+    },
+    contextValue: {
+      selection: {
+        multiSelect: t.multiSelect,
+        checkboxSelection: t.checkboxSelection,
+        disableSelection: t.disableSelection
+      }
+    }
+  };
+};
+ke.models = {
+  selectedItems: {
+    getDefaultValue: (e) => e.defaultSelectedItems
+  }
+};
+const Tn = [];
+ke.getDefaultizedParams = ({
+  params: e
+}) => C({}, e, {
+  disableSelection: e.disableSelection ?? !1,
+  multiSelect: e.multiSelect ?? !1,
+  checkboxSelection: e.checkboxSelection ?? !1,
+  defaultSelectedItems: e.defaultSelectedItems ?? (e.multiSelect ? Tn : null)
+});
+ke.params = {
+  disableSelection: !0,
+  multiSelect: !0,
+  checkboxSelection: !0,
+  defaultSelectedItems: !0,
+  selectedItems: !0,
+  onSelectedItemsChange: !0,
+  onItemSelectionToggle: !0
+};
+const nt = 1e3;
+class Cn {
+  constructor(t = nt) {
+    this.timeouts = /* @__PURE__ */ new Map(), this.cleanupTimeout = nt, this.cleanupTimeout = t;
+  }
+  register(t, n, o) {
+    this.timeouts || (this.timeouts = /* @__PURE__ */ new Map());
+    const i = setTimeout(() => {
+      typeof n == "function" && n(), this.timeouts.delete(o.cleanupToken);
+    }, this.cleanupTimeout);
+    this.timeouts.set(o.cleanupToken, i);
+  }
+  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 En {
+  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 wn {
+}
+function Pn(e) {
+  let t = 0;
+  return function(o, i, g) {
+    e.registry === null && (e.registry = typeof FinalizationRegistry < "u" ? new En() : new Cn());
+    const [f] = w.useState(new wn()), s = w.useRef(null), m = w.useRef(void 0);
+    m.current = g;
+    const c = w.useRef(null);
+    if (!s.current && m.current) {
+      const r = (l, u) => {
+        var a;
+        u.defaultMuiPrevented || (a = m.current) == null || a.call(m, l, u);
+      };
+      s.current = o.$$subscribeEvent(i, r), t += 1, c.current = {
+        cleanupToken: t
+      }, e.registry.register(
+        f,
+        // 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 !m.current && s.current && (s.current(), s.current = null, c.current && (e.registry.unregister(c.current), c.current = null));
+    w.useEffect(() => {
+      if (!s.current && m.current) {
+        const r = (l, u) => {
+          var a;
+          u.defaultMuiPrevented || (a = m.current) == null || a.call(m, l, u);
+        };
+        s.current = o.$$subscribeEvent(i, r);
+      }
+      return c.current && e.registry && (e.registry.unregister(c.current), c.current = null), () => {
+        var r;
+        (r = s.current) == null || r.call(s), s.current = null;
+      };
+    }, [o, i]);
+  };
+}
+const vn = {
+  registry: null
+}, Rn = Pn(vn), bt = (e = document) => {
+  const t = e.activeElement;
+  return t ? t.shadowRoot ? bt(t.shadowRoot) : t : null;
+}, Sn = (e, t) => {
+  let n = Pe(t).find((o) => {
+    if (!e.isItemNavigable(o))
+      return !1;
+    const i = e.getItemMeta(o);
+    return i && (i.parentId == null || e.isItemExpanded(i.parentId));
+  });
+  return n == null && (n = Ie(e)), n;
+}, Be = ({
+  instance: e,
+  params: t,
+  state: n,
+  setState: o,
+  models: i,
+  rootRef: g
+}) => {
+  const f = Sn(e, i.selectedItems.value), s = ce((p) => {
+    const b = typeof p == "function" ? p(n.focusedItemId) : p;
+    n.focusedItemId !== b && o((x) => C({}, x, {
+      focusedItemId: b
+    }));
+  }), m = w.useCallback(() => !!g.current && g.current.contains(bt(Zt(g.current))), [g]), c = w.useCallback((p) => n.focusedItemId === p && m(), [n.focusedItemId, m]), r = (p) => {
+    const b = e.getItemMeta(p);
+    return b && (b.parentId == null || e.isItemExpanded(b.parentId));
+  }, l = (p, b) => {
+    const x = e.getItemDOMElement(b);
+    x && x.focus(), s(b), t.onItemFocus && t.onItemFocus(p, b);
+  }, u = ce((p, b) => {
+    r(b) && l(p, 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 = (p) => p === f;
+  Rn(e, "removeItem", ({
+    id: p
+  }) => {
+    n.focusedItemId === p && l(null, f);
+  });
+  const I = (p) => (b) => {
+    var x;
+    (x = p.onFocus) == null || x.call(p, b), !b.defaultMuiPrevented && b.target === b.currentTarget && l(b, f);
+  };
+  return {
+    getRootProps: (p) => ({
+      onFocus: I(p)
+    }),
+    publicAPI: {
+      focusItem: u
+    },
+    instance: {
+      isItemFocused: c,
+      canItemBeTabbed: h,
+      focusItem: u,
+      removeFocusedItem: a
+    }
+  };
+};
+Be.getInitialState = () => ({
+  focusedItemId: null
+});
+Be.params = {
+  onItemFocus: !0
+};
+const re = (e, t) => e.getAvailablePlugins().has(t), kn = ({
+  props: e
+}) => {
+  const {
+    instance: t
+  } = ie(), {
+    label: n,
+    itemId: o
+  } = e, [i, g] = w.useState(n), f = t.isItemBeingEdited(o);
+  return w.useEffect(() => {
+    f || g(n);
+  }, [f, n]), {
+    propsEnhancers: {
+      labelInput: ({
+        externalEventHandlers: s,
+        interactions: m
+      }) => t.isItemEditable(o) ? {
+        value: i ?? "",
+        "data-element": "labelInput",
+        onChange: (a) => {
+          var h;
+          (h = s.onChange) == null || h.call(s, a), g(a.target.value);
+        },
+        onKeyDown: (a) => {
+          var I;
+          if ((I = s.onKeyDown) == null || I.call(s, a), a.defaultMuiPrevented)
+            return;
+          const h = a.target;
+          a.key === "Enter" && h.value ? m.handleSaveItemLabel(a, h.value) : a.key === "Escape" && m.handleCancelItemLabelEditing(a);
+        },
+        onBlur: (a) => {
+          var h;
+          (h = s.onBlur) == null || h.call(s, a), !a.defaultMuiPrevented && a.target.value && m.handleSaveItemLabel(a, a.target.value);
+        },
+        autoFocus: !0,
+        type: "text"
+      } : {}
+    }
+  };
+}, _ = ({
+  instance: e,
+  state: t,
+  setState: n,
+  params: o
+}) => {
+  const i = w.useRef(t.editedItemId), g = (l) => i.current === l, f = (l) => {
+    n((u) => C({}, u, {
+      editedItemId: l
+    })), i.current = l;
+  }, s = (l) => l === t.editedItemId, m = !!o.isItemEditable, c = (l) => {
+    if (l == null || !m)
+      return !1;
+    const u = e.getItem(l);
+    return u ? typeof o.isItemEditable == "function" ? o.isItemEditable(u) : !!o.isItemEditable : !1;
+  }, r = (l, u) => {
+    if (!u)
+      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 !== u ? C({}, a, {
+        items: C({}, a.items, {
+          itemMetaMap: C({}, a.items.itemMetaMap, {
+            [l]: C({}, h, {
+              label: u
+            })
+          })
+        })
+      }) : a;
+    }), o.onItemLabelChange && o.onItemLabelChange(l, u);
+  };
+  return {
+    instance: {
+      setEditedItemId: f,
+      isItemBeingEdited: s,
+      updateItemLabel: r,
+      isItemEditable: c,
+      isTreeViewEditable: m,
+      isItemBeingEditedRef: g
+    },
+    publicAPI: {
+      updateItemLabel: r
+    }
+  };
+};
+_.itemPlugin = kn;
+_.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
+  });
+};
+_.getInitialState = () => ({
+  editedItemId: null
+});
+_.params = {
+  onItemLabelChange: !0,
+  isItemEditable: !0
+};
+function Mn(e) {
+  return !!e && e.length === 1 && !!e.match(/\S/);
+}
+const ht = ({
+  instance: e,
+  params: t,
+  state: n
+}) => {
+  const o = Qt(), i = w.useRef({}), g = ce((r) => {
+    i.current = r(i.current);
+  });
+  w.useEffect(() => {
+    if (e.areItemUpdatesPrevented())
+      return;
+    const r = {}, l = (u) => {
+      r[u.id] = u.label.substring(0, 1).toLowerCase();
+    };
+    Object.values(n.items.itemMetaMap).forEach(l), i.current = r;
+  }, [n.items.itemMetaMap, t.getItemId, e]);
+  const f = (r, l) => {
+    const u = l.toLowerCase(), a = (b) => {
+      const x = we(e, b);
+      return x === null ? Ie(e) : x;
+    };
+    let h = null, I = a(r);
+    const p = {};
+    for (; h == null && !p[I]; )
+      i.current[I] === u ? h = I : (p[I] = !0, I = a(I));
+    return h;
+  }, s = (r) => !t.disableSelection && !e.isItemDisabled(r), m = (r) => !e.isItemDisabled(r) && e.isItemExpandable(r);
+  return {
+    instance: {
+      updateFirstCharMap: g,
+      handleItemKeyDown: (r, l) => {
+        if (r.defaultMuiPrevented || r.altKey || ge(r.target, r.currentTarget))
+          return;
+        const u = r.ctrlKey || r.metaKey, a = r.key;
+        switch (!0) {
+          // Select the item when pressing "Space"
+          case (a === " " && s(l)): {
+            r.preventDefault(), t.multiSelect && r.shiftKey ? e.expandSelectionRange(r, l) : e.selectItem({
+              event: r,
+              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, _) && e.isItemEditable(l) && !e.isItemBeingEdited(l) ? e.setEditedItemId(l) : m(l) ? (e.toggleItemExpansion(r, l), r.preventDefault()) : s(l) && (t.multiSelect ? (r.preventDefault(), e.selectItem({
+              event: r,
+              itemId: l,
+              keepExistingSelection: !0
+            })) : e.isItemSelected(l) || (e.selectItem({
+              event: r,
+              itemId: l
+            }), r.preventDefault()));
+            break;
+          }
+          // Focus the next focusable item
+          case a === "ArrowDown": {
+            const h = we(e, l);
+            h && (r.preventDefault(), e.focusItem(r, h), t.multiSelect && r.shiftKey && s(h) && e.selectItemFromArrowNavigation(r, l, h));
+            break;
+          }
+          // Focuses the previous focusable item
+          case a === "ArrowUp": {
+            const h = mt(e, l);
+            h && (r.preventDefault(), e.focusItem(r, h), t.multiSelect && r.shiftKey && s(h) && e.selectItemFromArrowNavigation(r, 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 (u)
+              return;
+            if (e.isItemExpanded(l)) {
+              const h = we(e, l);
+              h && (e.focusItem(r, h), r.preventDefault());
+            } else m(l) && (e.toggleItemExpansion(r, l), r.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 (u)
+              return;
+            if (m(l) && e.isItemExpanded(l))
+              e.toggleItemExpansion(r, l), r.preventDefault();
+            else {
+              const h = e.getItemMeta(l).parentId;
+              h && (e.focusItem(r, h), r.preventDefault());
+            }
+            break;
+          }
+          // Focuses the first item in the tree
+          case a === "Home": {
+            s(l) && t.multiSelect && u && r.shiftKey ? e.selectRangeFromStartToItem(r, l) : e.focusItem(r, Ie(e)), r.preventDefault();
+            break;
+          }
+          // Focuses the last item in the tree
+          case a === "End": {
+            s(l) && t.multiSelect && u && r.shiftKey ? e.selectRangeFromItemToEnd(r, l) : e.focusItem(r, It(e)), r.preventDefault();
+            break;
+          }
+          // Expand all siblings that are at the same level as the focused item
+          case a === "*": {
+            e.expandAllSiblings(r, l), r.preventDefault();
+            break;
+          }
+          // Multi select behavior when pressing Ctrl + a
+          // Selects all the items
+          case (String.fromCharCode(r.keyCode) === "A" && u && t.multiSelect && !t.disableSelection): {
+            e.selectAllNavigableItems(r), r.preventDefault();
+            break;
+          }
+          // Type-ahead
+          // TODO: Support typing multiple characters
+          case (!u && !r.shiftKey && Mn(a)): {
+            const h = f(l, a);
+            h != null && (e.focusItem(r, h), r.preventDefault());
+            break;
+          }
+        }
+      }
+    }
+  };
+};
+ht.params = {};
+const xt = ({
+  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
+      }
+    }
+  }
+});
+xt.params = {};
+const On = [he, Se, ke, Be, ht, xt, _];
+function yt(e) {
+  const {
+    instance: t,
+    items: {
+      onItemClick: n
+    },
+    selection: {
+      multiSelect: o,
+      checkboxSelection: i,
+      disableSelection: g
+    },
+    expansion: {
+      expansionTrigger: f
+    }
+  } = ie(), s = t.isItemExpandable(e), m = t.isItemExpanded(e), c = t.isItemFocused(e), r = t.isItemSelected(e), l = t.isItemDisabled(e), u = t != null && t.isItemBeingEdited ? t == null ? void 0 : t.isItemBeingEdited(e) : !1, a = t.isItemEditable ? t.isItemEditable(e) : !1, h = (E) => {
+    if (!l) {
+      c || t.focusItem(E, e);
+      const R = o && (E.shiftKey || E.ctrlKey || E.metaKey);
+      s && !(R && t.isItemExpanded(e)) && t.toggleItemExpansion(E, e);
+    }
+  }, I = (E) => {
+    l || (c || t.focusItem(E, e), o && (E.shiftKey || E.ctrlKey || E.metaKey) ? E.shiftKey ? t.expandSelectionRange(E, e) : t.selectItem({
+      event: E,
+      itemId: e,
+      keepExistingSelection: !0
+    }) : t.selectItem({
+      event: E,
+      itemId: e,
+      shouldBeSelected: !0
+    }));
+  }, p = (E) => {
+    if (g || l)
+      return;
+    const R = E.nativeEvent.shiftKey;
+    o && R ? t.expandSelectionRange(E, e) : t.selectItem({
+      event: E,
+      itemId: e,
+      keepExistingSelection: o,
+      shouldBeSelected: E.target.checked
+    });
+  }, b = (E) => {
+    (E.shiftKey || E.ctrlKey || E.metaKey || l) && E.preventDefault();
+  }, x = () => {
+    re(t, _) && t.isItemEditable(e) && (t.isItemBeingEdited(e) ? t.setEditedItemId(null) : t.setEditedItemId(e));
+  };
+  return {
+    disabled: l,
+    expanded: m,
+    selected: r,
+    focused: c,
+    editable: a,
+    editing: u,
+    disableSelection: g,
+    checkboxSelection: i,
+    handleExpansion: h,
+    handleSelection: I,
+    handleCheckboxSelection: p,
+    handleContentClick: n,
+    preventSelection: b,
+    expansionTrigger: f,
+    toggleItemEditing: x,
+    handleSaveItemLabel: (E, R) => {
+      re(t, _) && t.isItemBeingEditedRef(e) && (t.updateItemLabel(e, R), x(), t.focusItem(E, e));
+    },
+    handleCancelItemLabelEditing: (E) => {
+      re(t, _) && t.isItemBeingEditedRef(e) && (x(), t.focusItem(E, e));
+    }
+  };
+}
+const Dn = K("div", {
+  name: "MuiTreeItem2DragAndDropOverlay",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root,
+  shouldForwardProp: (e) => ue(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(Dn, 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 Tt = K("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}`
+  }
+})), Vn = ["classes", "className", "displayIcon", "expansionIcon", "icon", "label", "itemId", "onClick", "onMouseDown", "dragAndDropOverlayProps", "labelInputProps"], Ue = /* @__PURE__ */ w.forwardRef(function(t, n) {
+  const {
+    classes: o,
+    className: i,
+    displayIcon: g,
+    expansionIcon: f,
+    icon: s,
+    label: m,
+    itemId: c,
+    onClick: r,
+    onMouseDown: l,
+    dragAndDropOverlayProps: u,
+    labelInputProps: a
+  } = t, h = G(t, Vn), {
+    disabled: I,
+    expanded: p,
+    selected: b,
+    focused: x,
+    editing: P,
+    editable: k,
+    disableSelection: E,
+    checkboxSelection: R,
+    handleExpansion: O,
+    handleSelection: $,
+    handleCheckboxSelection: U,
+    handleContentClick: N,
+    preventSelection: j,
+    expansionTrigger: Y,
+    toggleItemEditing: B
+  } = yt(c), q = s || f || g, X = w.useRef(null), ee = (V) => {
+    j(V), l && l(V);
+  }, Q = (V) => {
+    var Z;
+    N == null || N(V, c), !((Z = X.current) != null && Z.contains(V.target)) && (Y === "content" && O(V), R || $(V), r && r(V));
+  }, te = (V) => {
+    V.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: Fe(o.root, i, p && o.expanded, b && o.selected, x && o.focused, I && o.disabled, P && o.editing, k && o.editable),
+      onClick: Q,
+      onMouseDown: ee,
+      ref: n,
+      children: [/* @__PURE__ */ v("div", {
+        className: o.iconContainer,
+        children: q
+      }), R && /* @__PURE__ */ v(lt, {
+        className: o.checkbox,
+        checked: b,
+        onChange: U,
+        disabled: I || E,
+        ref: X,
+        tabIndex: -1
+      }), P ? /* @__PURE__ */ v(Tt, C({}, a, {
+        className: o.labelInput
+      })) : /* @__PURE__ */ v("div", C({
+        className: o.label
+      }, k && {
+        onDoubleClick: te
+      }, {
+        children: m
+      })), u && /* @__PURE__ */ v(ze, C({}, u))]
+    }))
+  );
+});
+process.env.NODE_ENV !== "production" && (Ue.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 Ct(e) {
+  return rt("MuiTreeItem", e);
+}
+const W = it("MuiTreeItem", ["root", "groupTransition", "content", "expanded", "selected", "focused", "disabled", "iconContainer", "label", "checkbox", "labelInput", "editable", "editing", "dragAndDropOverlay"]), Et = be(/* @__PURE__ */ v("path", {
+  d: "M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
+}), "TreeViewExpandIcon"), wt = be(/* @__PURE__ */ v("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), "TreeViewCollapseIcon");
+function Me(e) {
+  const {
+    children: t,
+    itemId: n
+  } = e, {
+    wrapItem: o,
+    instance: i
+  } = ie();
+  return o({
+    children: t,
+    itemId: n,
+    instance: i
+  });
+}
+Me.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 An = ["children", "className", "slots", "slotProps", "ContentComponent", "ContentProps", "itemId", "id", "label", "onClick", "onMouseDown", "onFocus", "onBlur", "onKeyDown"], Ln = ["ownerState"], Fn = ["ownerState"], Nn = ["ownerState"], $n = $e(), jn = (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"]
+  }, Ct, t);
+}, _n = K("li", {
+  name: "MuiTreeItem",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), Kn = K(Ue, {
+  name: "MuiTreeItem",
+  slot: "Content",
+  overridesResolver: (e, t) => [t.content, t.iconContainer && {
+    [`& .${W.iconContainer}`]: t.iconContainer
+  }, t.label && {
+    [`& .${W.label}`]: t.label
+  }],
+  shouldForwardProp: (e) => ue(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))`
+    }
+  }]
+})), Bn = K(st, {
+  name: "MuiTreeItem",
+  slot: "GroupTransition",
+  overridesResolver: (e, t) => t.groupTransition,
+  shouldForwardProp: (e) => ue(e) && e !== "indentationAtItemLevel"
+})({
+  margin: 0,
+  padding: 0,
+  paddingLeft: "var(--TreeView-itemChildrenIndentation)",
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: 0
+    }
+  }]
+}), Pt = /* @__PURE__ */ w.forwardRef(function(t, n) {
+  var Je, Ye, Qe, Ze;
+  const {
+    icons: o,
+    runItemPlugins: i,
+    items: {
+      disabledItemsFocusable: g,
+      indentationAtItemLevel: f
+    },
+    selection: {
+      disableSelection: s
+    },
+    expansion: {
+      expansionTrigger: m
+    },
+    treeId: c,
+    instance: r
+  } = ie(), l = w.useContext(Re), u = $n({
+    props: t,
+    name: "MuiTreeItem"
+  }), {
+    children: a,
+    className: h,
+    slots: I,
+    slotProps: p,
+    ContentComponent: b = Ue,
+    ContentProps: x,
+    itemId: P,
+    id: k,
+    label: E,
+    onClick: R,
+    onMouseDown: O,
+    onBlur: $,
+    onKeyDown: U
+  } = u, N = G(u, An), {
+    expanded: j,
+    focused: Y,
+    selected: B,
+    disabled: q,
+    editing: X,
+    handleExpansion: ee,
+    handleCancelItemLabelEditing: Q,
+    handleSaveItemLabel: te
+  } = yt(P);
+  process.env.NODE_ENV !== "production" && (u.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/."]), u.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: V,
+    rootRef: Z,
+    propsEnhancers: A
+  } = i(u), ne = w.useRef(null), Oe = w.useRef(null), qe = me(n, Z, ne), Ge = me(x == null ? void 0 : x.ref, V, Oe), se = {
+    expandIcon: (I == null ? void 0 : I.expandIcon) ?? o.slots.expandIcon ?? Et,
+    collapseIcon: (I == null ? void 0 : I.collapseIcon) ?? o.slots.collapseIcon ?? wt,
+    endIcon: (I == null ? void 0 : I.endIcon) ?? o.slots.endIcon,
+    icon: I == null ? void 0 : I.icon,
+    groupTransition: I == null ? void 0 : I.groupTransition
+  }, De = (M) => Array.isArray(M) ? M.length > 0 && M.some(De) : !!M, pe = De(a), xe = C({}, u, {
+    expanded: j,
+    focused: Y,
+    selected: B,
+    disabled: q,
+    indentationAtItemLevel: f
+  }), T = jn(xe), y = se.groupTransition ?? void 0, S = L({
+    elementType: y,
+    ownerState: {},
+    externalSlotProps: p == null ? void 0 : p.groupTransition,
+    additionalProps: C({
+      unmountOnExit: !0,
+      in: j,
+      component: "ul",
+      role: "group"
+    }, f ? {
+      indentationAtItemLevel: !0
+    } : {}),
+    className: T.groupTransition
+  }), D = (M) => {
+    m === "iconContainer" && ee(M);
+  }, F = j ? se.collapseIcon : se.expandIcon, oe = L({
+    elementType: F,
+    ownerState: {},
+    externalSlotProps: (M) => j ? C({}, H(o.slotProps.collapseIcon, M), H(p == null ? void 0 : p.collapseIcon, M)) : C({}, H(o.slotProps.expandIcon, M), H(p == null ? void 0 : p.expandIcon, M)),
+    additionalProps: {
+      onClick: D
+    }
+  }), ye = G(oe, Ln), Te = pe && F ? /* @__PURE__ */ v(F, C({}, ye)) : null, Ve = pe ? void 0 : se.endIcon, Ft = L({
+    elementType: Ve,
+    ownerState: {},
+    externalSlotProps: (M) => pe ? {} : C({}, H(o.slotProps.endIcon, M), H(p == null ? void 0 : p.endIcon, M))
+  }), Nt = G(Ft, Fn), $t = Ve ? /* @__PURE__ */ v(Ve, C({}, Nt)) : null, Ae = se.icon, jt = L({
+    elementType: Ae,
+    ownerState: {},
+    externalSlotProps: p == null ? void 0 : p.icon
+  }), _t = G(jt, Nn), Kt = Ae ? /* @__PURE__ */ v(Ae, C({}, _t)) : null;
+  let Ce;
+  B ? Ce = !0 : s || q ? Ce = void 0 : Ce = !1;
+  function Bt(M) {
+    !Y && (!q || g) && M.currentTarget === M.target && r.focusItem(M, P);
+  }
+  function zt(M) {
+    var le, fe, He, et;
+    $ == null || $(M), !(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
+    M.relatedTarget && ge(M.relatedTarget, ne.current) && (M.target && ((fe = (le = M.target) == null ? void 0 : le.dataset) == null ? void 0 : fe.element) === "labelInput" && ge(M.target, ne.current) || ((et = (He = M.relatedTarget) == null ? void 0 : He.dataset) == null ? void 0 : et.element) === "labelInput")) && r.removeFocusedItem();
+  }
+  const Ut = (M) => {
+    var le, fe;
+    U == null || U(M), ((fe = (le = M.target) == null ? void 0 : le.dataset) == null ? void 0 : fe.element) !== "labelInput" && r.handleItemKeyDown(M, P);
+  }, qt = je({
+    itemId: P,
+    treeId: c,
+    id: k
+  }), Gt = r.canItemBeTabbed(P) ? 0 : -1, Ee = {
+    rootRefObject: ne,
+    contentRefObject: Oe,
+    interactions: {
+      handleSaveItemLabel: te,
+      handleCancelItemLabelEditing: Q
+    }
+  }, Xt = ((Je = A.root) == null ? void 0 : Je.call(A, C({}, Ee, {
+    externalEventHandlers: z(N)
+  }))) ?? {}, Wt = ((Ye = A.content) == null ? void 0 : Ye.call(A, C({}, Ee, {
+    externalEventHandlers: z(x)
+  }))) ?? {}, Xe = ((Qe = A.dragAndDropOverlay) == null ? void 0 : Qe.call(A, C({}, Ee, {
+    externalEventHandlers: {}
+  }))) ?? {}, We = ((Ze = A.labelInput) == null ? void 0 : Ze.call(A, C({}, Ee, {
+    externalEventHandlers: {}
+  }))) ?? {};
+  return /* @__PURE__ */ v(Me, {
+    itemId: P,
+    children: /* @__PURE__ */ de(_n, C({
+      className: Fe(T.root, h),
+      role: "treeitem",
+      "aria-expanded": pe ? j : void 0,
+      "aria-selected": Ce,
+      "aria-disabled": q || void 0,
+      id: qt,
+      tabIndex: Gt
+    }, N, {
+      ownerState: xe,
+      onFocus: Bt,
+      onBlur: zt,
+      onKeyDown: Ut,
+      ref: qe,
+      style: f ? C({}, N.style, {
+        "--TreeView-itemDepth": typeof l == "function" ? l(P) : l
+      }) : N.style
+    }, Xt, {
+      children: [/* @__PURE__ */ v(Kn, 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: E,
+        itemId: P,
+        onClick: R,
+        onMouseDown: O,
+        icon: Kt,
+        expansionIcon: Te,
+        displayIcon: $t,
+        ownerState: xe
+      }, x, Wt, Xe.action == null ? {} : {
+        dragAndDropOverlayProps: Xe
+      }, We.value == null ? {} : {
+        labelInputProps: We
+      }, {
+        ref: Ge
+      })), a && /* @__PURE__ */ v(Bn, C({
+        as: y
+      }, S, {
+        children: a
+      }))]
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (Pt.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: Ht,
+  /**
+   * 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: at,
+  /**
+   * 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 zn = ["ownerState"];
+function Un({
+  slots: e,
+  slotProps: t,
+  label: n,
+  id: o,
+  itemId: i,
+  itemsToRender: g
+}) {
+  const f = (e == null ? void 0 : e.item) ?? Pt, s = L({
+    elementType: f,
+    externalSlotProps: t == null ? void 0 : t.item,
+    additionalProps: {
+      itemId: i,
+      id: o,
+      label: n
+    },
+    ownerState: {
+      itemId: i,
+      label: n
+    }
+  }), m = G(s, zn), c = w.useMemo(() => g ? /* @__PURE__ */ v(vt, {
+    itemsToRender: g,
+    slots: e,
+    slotProps: t
+  }) : null, [g, e, t]);
+  return /* @__PURE__ */ v(f, C({}, m, {
+    children: c
+  }));
+}
+function vt(e) {
+  const {
+    itemsToRender: t,
+    slots: n,
+    slotProps: o
+  } = e;
+  return /* @__PURE__ */ v(w.Fragment, {
+    children: t.map((i) => /* @__PURE__ */ v(Un, {
+      slots: n,
+      slotProps: o,
+      label: i.label,
+      id: i.id,
+      itemId: i.itemId,
+      itemsToRender: i.children
+    }, i.itemId))
+  });
+}
+const qn = $e(), Gn = (e) => {
+  const {
+    classes: t
+  } = e;
+  return Ne({
+    root: ["root"]
+  }, nn, t);
+}, Xn = K("ul", {
+  name: "MuiRichTreeView",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  padding: 0,
+  margin: 0,
+  listStyle: "none",
+  outline: 0,
+  position: "relative"
+}), Rt = /* @__PURE__ */ w.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: i,
+    contextValue: g,
+    instance: f
+  } = fn({
+    plugins: On,
+    rootRef: n,
+    props: o
+  }), {
+    slots: s,
+    slotProps: m
+  } = o, c = Gn(o), r = (s == null ? void 0 : s.root) ?? Xn, l = L({
+    elementType: r,
+    externalSlotProps: m == null ? void 0 : m.root,
+    className: c.root,
+    getSlotProps: i,
+    ownerState: o
+  });
+  return /* @__PURE__ */ v(mn, {
+    value: g,
+    children: /* @__PURE__ */ v(r, C({}, l, {
+      children: /* @__PURE__ */ v(vt, {
+        slots: s,
+        slotProps: m,
+        itemsToRender: f.getItemsToRender()
+      })
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (Rt.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 St = (e) => Array.isArray(e) ? e.length > 0 && e.some(St) : !!e, Wn = ({
+  itemId: e,
+  children: t
+}) => {
+  const {
+    instance: n,
+    selection: {
+      multiSelect: o
+    },
+    publicAPI: i
+  } = ie(), g = {
+    expandable: St(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
+  }, f = (a) => {
+    if (g.disabled)
+      return;
+    g.focused || n.focusItem(a, e);
+    const h = o && (a.shiftKey || a.ctrlKey || a.metaKey);
+    g.expandable && !(h && n.isItemExpanded(e)) && n.toggleItemExpansion(a, e);
+  }, s = (a) => {
+    if (g.disabled)
+      return;
+    g.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
+    });
+  }, m = (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, _) && n.isItemEditable(e) && (n.isItemBeingEdited(e) ? n.setEditedItemId(null) : n.setEditedItemId(e));
+  };
+  return {
+    interactions: {
+      handleExpansion: f,
+      handleSelection: s,
+      handleCheckboxSelection: m,
+      toggleItemEditing: c,
+      handleSaveItemLabel: (a, h) => {
+        re(n, _) && n.isItemBeingEditedRef(e) && (n.updateItemLabel(e, h), c(), n.focusItem(a, e));
+      },
+      handleCancelItemLabelEditing: (a) => {
+        re(n, _) && n.isItemBeingEditedRef(e) && (c(), n.focusItem(a, e));
+      }
+    },
+    status: g,
+    publicAPI: i
+  };
+}, Jn = (e) => {
+  const {
+    runItemPlugins: t,
+    items: {
+      onItemClick: n,
+      disabledItemsFocusable: o,
+      indentationAtItemLevel: i
+    },
+    selection: {
+      disableSelection: g,
+      checkboxSelection: f
+    },
+    expansion: {
+      expansionTrigger: s
+    },
+    treeId: m,
+    instance: c,
+    publicAPI: r
+  } = ie(), l = w.useContext(Re), {
+    id: u,
+    itemId: a,
+    label: h,
+    children: I,
+    rootRef: p
+  } = e, {
+    rootRef: b,
+    contentRef: x,
+    propsEnhancers: P
+  } = t(e), {
+    interactions: k,
+    status: E
+  } = Wn({
+    itemId: a,
+    children: I
+  }), R = w.useRef(null), O = w.useRef(null), $ = me(p, b, R), U = me(x, O), N = w.useRef(null), j = je({
+    itemId: a,
+    treeId: m,
+    id: u
+  }), Y = c.canItemBeTabbed(a) ? 0 : -1, B = {
+    rootRefObject: R,
+    contentRefObject: O,
+    interactions: k
+  }, q = (T) => (y) => {
+    var D;
+    if ((D = T.onFocus) == null || D.call(T, y), y.defaultMuiPrevented)
+      return;
+    const S = !E.disabled || o;
+    !E.focused && S && y.currentTarget === y.target && c.focusItem(y, a);
+  }, X = (T) => (y) => {
+    var D, F, oe, ye, Te;
+    if ((D = T.onBlur) == null || D.call(T, y), y.defaultMuiPrevented)
+      return;
+    const S = c.getItemDOMElement(a);
+    E.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 && ge(y.relatedTarget, S) && (y.target && ((oe = (F = y.target) == null ? void 0 : F.dataset) == null ? void 0 : oe.element) === "labelInput" && ge(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, D, F;
+    (S = T.onKeyDown) == null || S.call(T, y), !(y.defaultMuiPrevented || ((F = (D = y.target) == null ? void 0 : D.dataset) == null ? void 0 : F.element) === "labelInput") && c.handleItemKeyDown(y, a);
+  }, Q = (T) => (y) => {
+    var S;
+    (S = T.onDoubleClick) == null || S.call(T, y), !y.defaultMuiPrevented && k.toggleItemEditing();
+  }, te = (T) => (y) => {
+    var S, D;
+    (S = T.onClick) == null || S.call(T, y), n == null || n(y, a), !(y.defaultMuiPrevented || (D = N.current) != null && D.contains(y.target)) && (s === "content" && k.handleExpansion(y), f || k.handleSelection(y));
+  }, V = (T) => (y) => {
+    var S;
+    (S = T.onMouseDown) == null || S.call(T, y), !y.defaultMuiPrevented && (y.shiftKey || y.ctrlKey || y.metaKey || E.disabled) && y.preventDefault();
+  }, Z = (T) => (y) => {
+    var S;
+    (S = T.onChange) == null || S.call(T, y), !y.defaultMuiPrevented && (g || E.disabled || k.handleCheckboxSelection(y));
+  }, A = (T) => (y) => {
+    var S;
+    (S = T.onClick) == null || S.call(T, y), !y.defaultMuiPrevented && s === "iconContainer" && k.handleExpansion(y);
+  };
+  return {
+    getRootProps: (T = {}) => {
+      var oe;
+      const y = C({}, z(e), z(T));
+      let S;
+      E.selected ? S = !0 : g || E.disabled ? S = void 0 : S = !1;
+      const D = C({}, y, {
+        ref: $,
+        role: "treeitem",
+        tabIndex: Y,
+        id: j,
+        "aria-expanded": E.expandable ? E.expanded : void 0,
+        "aria-selected": S,
+        "aria-disabled": E.disabled || void 0
+      }, T, {
+        onFocus: q(y),
+        onBlur: X(y),
+        onKeyDown: ee(y)
+      });
+      i && (D.style = {
+        "--TreeView-itemDepth": typeof l == "function" ? l(a) : l
+      });
+      const F = ((oe = P.root) == null ? void 0 : oe.call(P, C({}, B, {
+        externalEventHandlers: y
+      }))) ?? {};
+      return C({}, D, F);
+    },
+    getContentProps: (T = {}) => {
+      var F;
+      const y = z(T), S = C({}, y, T, {
+        ref: U,
+        onClick: te(y),
+        onMouseDown: V(y),
+        status: E
+      });
+      i && (S.indentationAtItemLevel = !0);
+      const D = ((F = P.content) == null ? void 0 : F.call(P, C({}, B, {
+        externalEventHandlers: y
+      }))) ?? {};
+      return C({}, S, D);
+    },
+    getGroupTransitionProps: (T = {}) => {
+      const y = z(T), S = C({}, y, {
+        unmountOnExit: !0,
+        component: "ul",
+        role: "group",
+        in: E.expanded,
+        children: I
+      }, T);
+      return i && (S.indentationAtItemLevel = !0), S;
+    },
+    getIconContainerProps: (T = {}) => {
+      const y = z(T);
+      return C({}, y, T, {
+        onClick: A(y)
+      });
+    },
+    getCheckboxProps: (T = {}) => {
+      const y = z(T);
+      return C({}, y, {
+        visible: f,
+        ref: N,
+        checked: E.selected,
+        disabled: g || E.disabled,
+        tabIndex: -1
+      }, T, {
+        onChange: Z(y)
+      });
+    },
+    getLabelProps: (T = {}) => {
+      const y = C({}, z(T)), S = C({}, y, {
+        children: h
+      }, T, {
+        onDoubleClick: Q(y)
+      });
+      return c.isTreeViewEditable && (S.editable = E.editable), S;
+    },
+    getLabelInputProps: (T = {}) => {
+      var D;
+      const y = z(T), S = ((D = P.labelInput) == null ? void 0 : D.call(P, {
+        rootRefObject: R,
+        contentRefObject: O,
+        externalEventHandlers: y,
+        interactions: k
+      })) ?? {};
+      return C({}, T, S);
+    },
+    getDragAndDropOverlayProps: (T = {}) => {
+      var D;
+      const y = z(T), S = ((D = P.dragAndDropOverlay) == null ? void 0 : D.call(P, C({}, B, {
+        externalEventHandlers: y
+      }))) ?? {};
+      return C({}, T, S);
+    },
+    rootRef: $,
+    status: E,
+    publicAPI: r
+  };
+}, kt = Jn;
+function Mt(e) {
+  const {
+    slots: t,
+    slotProps: n,
+    status: o
+  } = e, i = ie(), g = C({}, i.icons.slots, {
+    expandIcon: i.icons.slots.expandIcon ?? Et,
+    collapseIcon: i.icons.slots.collapseIcon ?? wt
+  }), f = i.icons.slotProps;
+  let s;
+  t != null && t.icon ? s = "icon" : o.expandable ? o.expanded ? s = "collapseIcon" : s = "expandIcon" : s = "endIcon";
+  const m = (t == null ? void 0 : t[s]) ?? g[s], c = L({
+    elementType: m,
+    externalSlotProps: (r) => C({}, H(f[s], r), H(n == null ? void 0 : n[s], r)),
+    // TODO: Add proper ownerState
+    ownerState: {}
+  });
+  return m ? /* @__PURE__ */ v(m, C({}, c)) : null;
+}
+process.env.NODE_ENV !== "production" && (Mt.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 Yn = ["visible"], Qn = ["id", "itemId", "label", "disabled", "children", "slots", "slotProps"], Zn = $e(), Ot = K("li", {
+  name: "MuiTreeItem2",
+  slot: "Root",
+  overridesResolver: (e, t) => t.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), Dt = K("div", {
+  name: "MuiTreeItem2",
+  slot: "Content",
+  overridesResolver: (e, t) => t.content,
+  shouldForwardProp: (e) => ue(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)
+    }
+  }]
+})), Vt = K("div", {
+  name: "MuiTreeItem2",
+  slot: "Label",
+  overridesResolver: (e, t) => t.label,
+  shouldForwardProp: (e) => ue(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"
+    }
+  }]
+})), At = K("div", {
+  name: "MuiTreeItem2",
+  slot: "IconContainer",
+  overridesResolver: (e, t) => t.iconContainer
+})({
+  width: 16,
+  display: "flex",
+  flexShrink: 0,
+  justifyContent: "center",
+  "& svg": {
+    fontSize: 18
+  }
+}), Lt = K(st, {
+  name: "MuiTreeItem2",
+  slot: "GroupTransition",
+  overridesResolver: (e, t) => t.groupTransition,
+  shouldForwardProp: (e) => ue(e) && e !== "indentationAtItemLevel"
+})({
+  margin: 0,
+  padding: 0,
+  paddingLeft: "var(--TreeView-itemChildrenIndentation)",
+  variants: [{
+    props: {
+      indentationAtItemLevel: !0
+    },
+    style: {
+      paddingLeft: 0
+    }
+  }]
+}), Hn = K(/* @__PURE__ */ w.forwardRef((e, t) => {
+  const {
+    visible: n
+  } = e, o = G(e, Yn);
+  return n ? /* @__PURE__ */ v(lt, C({}, o, {
+    ref: t
+  })) : null;
+}), {
+  name: "MuiTreeItem2",
+  slot: "Checkbox",
+  overridesResolver: (e, t) => t.checkbox
+})({
+  padding: 0
+}), eo = (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"]
+  }, Ct, t);
+}, to = /* @__PURE__ */ w.forwardRef(function(t, n) {
+  const o = Zn({
+    props: t,
+    name: "MuiTreeItem2"
+  }), {
+    id: i,
+    itemId: g,
+    label: f,
+    disabled: s,
+    children: m,
+    slots: c = {},
+    slotProps: r = {}
+  } = o, l = G(o, Qn), {
+    getRootProps: u,
+    getContentProps: a,
+    getIconContainerProps: h,
+    getCheckboxProps: I,
+    getLabelProps: p,
+    getGroupTransitionProps: b,
+    getLabelInputProps: x,
+    getDragAndDropOverlayProps: P,
+    status: k
+  } = kt({
+    id: i,
+    itemId: g,
+    children: m,
+    label: f,
+    disabled: s
+  }), E = C({}, o, k), R = eo(E), O = c.root ?? Ot, $ = L({
+    elementType: O,
+    getSlotProps: u,
+    externalForwardedProps: l,
+    externalSlotProps: r.root,
+    additionalProps: {
+      ref: n
+    },
+    ownerState: {},
+    className: R.root
+  }), U = c.content ?? Dt, N = L({
+    elementType: U,
+    getSlotProps: a,
+    externalSlotProps: r.content,
+    ownerState: {},
+    className: Fe(R.content, k.expanded && R.expanded, k.selected && R.selected, k.focused && R.focused, k.disabled && R.disabled, k.editing && R.editing, k.editable && R.editable)
+  }), j = c.iconContainer ?? At, Y = L({
+    elementType: j,
+    getSlotProps: h,
+    externalSlotProps: r.iconContainer,
+    ownerState: {},
+    className: R.iconContainer
+  }), B = c.label ?? Vt, q = L({
+    elementType: B,
+    getSlotProps: p,
+    externalSlotProps: r.label,
+    ownerState: {},
+    className: R.label
+  }), X = c.checkbox ?? Hn, ee = L({
+    elementType: X,
+    getSlotProps: I,
+    externalSlotProps: r.checkbox,
+    ownerState: {},
+    className: R.checkbox
+  }), Q = c.groupTransition ?? void 0, te = L({
+    elementType: Q,
+    getSlotProps: b,
+    externalSlotProps: r.groupTransition,
+    ownerState: {},
+    className: R.groupTransition
+  }), V = c.labelInput ?? Tt, Z = L({
+    elementType: V,
+    getSlotProps: x,
+    externalSlotProps: r.labelInput,
+    ownerState: {},
+    className: R.labelInput
+  }), A = c.dragAndDropOverlay ?? ze, ne = L({
+    elementType: A,
+    getSlotProps: P,
+    externalSlotProps: r.dragAndDropOverlay,
+    ownerState: {},
+    className: R.dragAndDropOverlay
+  });
+  return /* @__PURE__ */ v(Me, {
+    itemId: g,
+    children: /* @__PURE__ */ de(O, C({}, $, {
+      children: [/* @__PURE__ */ de(U, C({}, N, {
+        children: [/* @__PURE__ */ v(j, C({}, Y, {
+          children: /* @__PURE__ */ v(Mt, {
+            status: k,
+            slots: c,
+            slotProps: r
+          })
+        })), /* @__PURE__ */ v(X, C({}, ee)), k.editing ? /* @__PURE__ */ v(V, C({}, Z)) : /* @__PURE__ */ v(B, C({}, q)), /* @__PURE__ */ v(A, C({}, ne))]
+      })), m && /* @__PURE__ */ v(Lt, C({
+        as: Q
+      }, te))]
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (to.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: at,
+  /**
+   * 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 no = Jt(function(t, n) {
+  const { id: o, itemId: i, label: g, disabled: f, children: s } = t, m = t.folderIcon || ct, {
+    getRootProps: c,
+    getContentProps: r,
+    getLabelProps: l,
+    getGroupTransitionProps: u,
+    getIconContainerProps: a,
+    status: h
+  } = kt({ id: o, itemId: i, label: g, disabled: f, children: s, rootRef: n });
+  return /* @__PURE__ */ v(Me, { itemId: i, children: /* @__PURE__ */ de(Ot, { ...c(), children: [
+    /* @__PURE__ */ de(
+      Dt,
+      {
+        ...r(),
+        style: { display: "flex", alignItems: "center", width: "100%" },
+        children: [
+          /* @__PURE__ */ v(At, { ...a(), children: /* @__PURE__ */ v(
+            m,
+            {
+              fontSize: "small",
+              color: "action",
+              style: { color: "#ff9800" }
+            }
+          ) }),
+          /* @__PURE__ */ v(Vt, { ...l() }),
+          /* @__PURE__ */ v(ot, { sx: { display: "flex", marginLeft: "auto" }, children: h.expandable && (h.expanded ? /* @__PURE__ */ v(en, { fontSize: "small" }) : /* @__PURE__ */ v(tn, { fontSize: "small" })) })
+        ]
+      }
+    ),
+    s && /* @__PURE__ */ v(Lt, { ...u() })
+  ] }) });
+}), Eo = ({
+  items: e,
+  onItemSelect: t,
+  folderIcon: n = ct
+}) => /* @__PURE__ */ v(ot, { sx: { minHeight: 200, minWidth: 200 }, children: /* @__PURE__ */ v(
+  Rt,
+  {
+    items: e,
+    onSelect: (o) => t && t(o, o.target.id),
+    slots: {
+      item: (o) => /* @__PURE__ */ v(no, { ...o, folderIcon: n })
+    }
+  }
+) });
+export {
+  Eo as default
+};