@amateescu/portal-ui-components 0.0.38 → 0.0.40

package/dist/components/PassportTreeSelect/PassportTreeSelect.js

@@ -0,0 +1,4641 @@
+import { jsx as v, jsxs as Y, Fragment as mn } from "react/jsx-runtime";
+import * as M from "react";
+import $e, { useState as We, useRef as gt, useMemo as Ke, useEffect as bt, useCallback as St } from "react";
+import { FormControl as In, InputLabel as gn, OutlinedInput as bn, InputAdornment as yt, IconButton as Sn, Box as fe, Chip as xt, Collapse as yn, Paper as xn, TextField as En, Typography as Ue, Checkbox as Cn } from "@mui/material";
+import { S as vn } from "../../Search-BxOqluZm.js";
+import { c as ge } from "../../createSvgIcon-DQP4Lgl5.js";
+import { C as wn } from "../../Clear-BzF0WMi7.js";
+import { _ as Be, a as S, e as Tn, u as kn, f as On, B as Mn, r as Pn } from "../../ButtonBase-Cj889DO9.js";
+import { g as Ce, a as ve, P as i, s as G, e as we, u as Kt, t as Rn, c as Q, m as Ut, b as xe, l as Ht, p as st, q as Se } from "../../DefaultPropsProvider-8An9vBcT.js";
+import { u as Ln, b as te, T as Dn, c as _n, g as Et, d as An, m as Nn, a as Fn } from "../../useFormControl-DUby-fW8.js";
+import { a as Vn, b as Ie, u as zn, e as re, r as Ct } from "../../useSlot-Bvdicoh5.js";
+import { c as vt } from "../../createSimplePaletteValueFilter-Bz8RuRaa.js";
+import { C as jn } from "../../CircularProgress-BjeN7Xv-.js";
+const $n = ge(/* @__PURE__ */ v("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), "ExpandMore"), wt = {};
+function it(t, e) {
+  const n = M.useRef(wt);
+  return n.current === wt && (n.current = t(e)), n;
+}
+function Ne(t, e, n, o) {
+  const r = it(Bn).current;
+  return Wn(r, t, e, n, o) && Kn(r, [t, e, n, o]), r.callback;
+}
+function Bn() {
+  return {
+    callback: null,
+    cleanup: null,
+    refs: []
+  };
+}
+function Wn(t, e, n, o, r) {
+  return t.refs[0] !== e || t.refs[1] !== n || t.refs[2] !== o || t.refs[3] !== r;
+}
+function Kn(t, e) {
+  if (t.refs = e, e.every((n) => n == null)) {
+    t.callback = null;
+    return;
+  }
+  t.callback = (n) => {
+    if (t.cleanup && (t.cleanup(), t.cleanup = null), n != null) {
+      const o = Array(e.length).fill(null);
+      for (let r = 0; r < e.length; r += 1) {
+        const s = e[r];
+        if (s != null)
+          switch (typeof s) {
+            case "function": {
+              const l = s(n);
+              typeof l == "function" && (o[r] = l);
+              break;
+            }
+            case "object": {
+              s.current = n;
+              break;
+            }
+          }
+      }
+      t.cleanup = () => {
+        for (let r = 0; r < e.length; r += 1) {
+          const s = e[r];
+          if (s != null)
+            switch (typeof s) {
+              case "function": {
+                const l = o[r];
+                typeof l == "function" ? l() : s(null);
+                break;
+              }
+              case "object": {
+                s.current = null;
+                break;
+              }
+            }
+        }
+      };
+    }
+  };
+}
+const Tt = /* @__PURE__ */ new Set();
+function et(t, e = "warning") {
+  if (process.env.NODE_ENV === "production")
+    return;
+  const n = Array.isArray(t) ? t.join(`
+`) : t;
+  Tt.has(n) || (Tt.add(n), e === "error" ? console.error(n) : console.warn(n));
+}
+function qt(t) {
+  return Ln;
+}
+function Un(t) {
+  return Ce("MuiSimpleTreeView", t);
+}
+ve("MuiSimpleTreeView", ["root", "item", "itemContent", "itemGroupTransition", "itemIconContainer", "itemLabel", "itemCheckbox"]);
+const tt = Object.freeze([]), ye = Object.freeze({}), lt = /* @__PURE__ */ M.createContext(null);
+process.env.NODE_ENV !== "production" && (lt.displayName = "TreeViewContext");
+const be = () => {
+  const t = M.useContext(lt);
+  if (t == 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 t;
+}, at = /* @__PURE__ */ M.createContext({
+  classes: {},
+  slots: {},
+  slotProps: {}
+});
+process.env.NODE_ENV !== "production" && (at.displayName = "TreeViewStyleContext");
+const Gt = () => M.useContext(at), Hn = (t) => {
+  const {
+    store: e,
+    apiRef: n,
+    rootRef: o
+  } = t, r = it(() => e.buildPublicAPI()).current;
+  qn(r, n);
+  const s = M.useCallback((a) => {
+    let h = null, d = null;
+    const c = [], p = {};
+    e.itemPluginManager.listPlugins().forEach((m) => {
+      const I = m({
+        props: a,
+        rootRef: h,
+        contentRef: d
+      });
+      I?.rootRef && (h = I.rootRef), I?.contentRef && (d = I.contentRef), I?.propsEnhancers && (c.push(I.propsEnhancers), Object.keys(I.propsEnhancers).forEach((b) => {
+        p[b] = !0;
+      }));
+    });
+    const f = (m) => (I) => {
+      const b = {};
+      return c.forEach((x) => {
+        const w = x[m];
+        w != null && Object.assign(b, w(I));
+      }), b;
+    }, u = Object.fromEntries(Object.keys(p).map((m) => [m, f(m)]));
+    return {
+      contentRef: d,
+      rootRef: h,
+      propsEnhancers: u
+    };
+  }, [e]), l = M.useCallback(({
+    itemId: a,
+    children: h,
+    idAttribute: d
+  }) => {
+    let c = h;
+    const p = e.itemPluginManager.listWrappers();
+    for (let f = p.length - 1; f >= 0; f -= 1) {
+      const u = p[f];
+      c = u({
+        store: e,
+        itemId: a,
+        children: c,
+        idAttribute: d
+      });
+    }
+    return c;
+  }, [e]);
+  return M.useMemo(() => ({
+    runItemPlugins: s,
+    wrapItem: l,
+    publicAPI: r,
+    store: e,
+    rootRef: o
+  }), [s, l, r, e, o]);
+};
+function qn(t, e) {
+  e != null && e.current == null && (e.current = t);
+}
+function Gn(t) {
+  const {
+    store: e,
+    apiRef: n,
+    rootRef: o,
+    classes: r = ye,
+    slots: s = ye,
+    slotProps: l = ye,
+    children: a
+  } = t, h = Hn({
+    store: e,
+    apiRef: n,
+    rootRef: o
+  }), d = M.useMemo(() => ({
+    classes: r,
+    slots: {
+      collapseIcon: s.collapseIcon,
+      expandIcon: s.expandIcon,
+      endIcon: s.endIcon
+    },
+    slotProps: {
+      collapseIcon: l.collapseIcon,
+      expandIcon: l.expandIcon,
+      endIcon: l.endIcon
+    }
+  }), [r, s.collapseIcon, s.expandIcon, s.endIcon, l.collapseIcon, l.expandIcon, l.endIcon]);
+  return /* @__PURE__ */ v(lt.Provider, {
+    value: h,
+    children: /* @__PURE__ */ v(at.Provider, {
+      value: d,
+      children: a
+    })
+  });
+}
+const Xn = ["apiRef", "slots", "slotProps", "disabledItemsFocusable", "onItemClick", "itemChildrenIndentation", "id", "expandedItems", "defaultExpandedItems", "onExpandedItemsChange", "onItemExpansionToggle", "expansionTrigger", "disableSelection", "selectedItems", "defaultSelectedItems", "multiSelect", "checkboxSelection", "selectionPropagation", "onSelectedItemsChange", "onItemSelectionToggle", "onItemFocus"];
+function Jn(t) {
+  const {
+    // Props for Provider
+    apiRef: e,
+    slots: n,
+    slotProps: o,
+    // Shared parameters
+    disabledItemsFocusable: r,
+    onItemClick: s,
+    itemChildrenIndentation: l,
+    id: a,
+    expandedItems: h,
+    defaultExpandedItems: d,
+    onExpandedItemsChange: c,
+    onItemExpansionToggle: p,
+    expansionTrigger: f,
+    disableSelection: u,
+    selectedItems: m,
+    defaultSelectedItems: I,
+    multiSelect: b,
+    checkboxSelection: x,
+    selectionPropagation: w,
+    onSelectedItemsChange: _,
+    onItemSelectionToggle: R,
+    onItemFocus: F
+    // SimpleTreeViewStore parameters
+    // Forwarded props
+  } = t, C = Be(t, Xn), D = M.useMemo(() => ({
+    // Shared parameters
+    disabledItemsFocusable: r,
+    onItemClick: s,
+    itemChildrenIndentation: l,
+    id: a,
+    expandedItems: h,
+    defaultExpandedItems: d,
+    onExpandedItemsChange: c,
+    onItemExpansionToggle: p,
+    expansionTrigger: f,
+    disableSelection: u,
+    selectedItems: m,
+    defaultSelectedItems: I,
+    multiSelect: b,
+    checkboxSelection: x,
+    selectionPropagation: w,
+    onSelectedItemsChange: _,
+    onItemSelectionToggle: R,
+    onItemFocus: F
+    // SimpleTreeViewStore parameters
+  }), [
+    // Shared parameters
+    r,
+    s,
+    l,
+    a,
+    h,
+    d,
+    c,
+    p,
+    f,
+    u,
+    m,
+    I,
+    b,
+    x,
+    w,
+    _,
+    R,
+    F
+    // SimpleTreeViewStore parameters
+  ]);
+  return {
+    apiRef: e,
+    slots: n,
+    slotProps: o,
+    parameters: D,
+    forwardedProps: C
+  };
+}
+var Qn = (t, e, n) => {
+  if (e.length === 1 && e[0] === n) {
+    let o = !1;
+    try {
+      const r = {};
+      t(r) === r && (o = !0);
+    } catch {
+    }
+    if (o) {
+      let r;
+      try {
+        throw new Error();
+      } catch (s) {
+        ({ stack: r } = s);
+      }
+      console.warn(
+        `The result function returned its own inputs without modification. e.g
+\`createSelector([state => state.todos], todos => todos)\`
+This could lead to inefficient memoization and unnecessary re-renders.
+Ensure transformation logic is in the result function, and extraction logic is in the input selectors.`,
+        { stack: r }
+      );
+    }
+  }
+}, Yn = (t, e, n) => {
+  const { memoize: o, memoizeOptions: r } = e, { inputSelectorResults: s, inputSelectorResultsCopy: l } = t, a = o(() => ({}), ...r);
+  if (!(a.apply(null, s) === a.apply(null, l))) {
+    let d;
+    try {
+      throw new Error();
+    } catch (c) {
+      ({ stack: d } = c);
+    }
+    console.warn(
+      `An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+\`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)\``,
+      {
+        arguments: n,
+        firstInputs: s,
+        secondInputs: l,
+        stack: d
+      }
+    );
+  }
+}, Zn = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+}, Fe = /* @__PURE__ */ Symbol("NOT_FOUND");
+function eo(t, e = `expected a function, instead received ${typeof t}`) {
+  if (typeof t != "function")
+    throw new TypeError(e);
+}
+function to(t, e = `expected an object, instead received ${typeof t}`) {
+  if (typeof t != "object")
+    throw new TypeError(e);
+}
+function no(t, e = "expected all items to be functions, instead received the following types: ") {
+  if (!t.every((n) => typeof n == "function")) {
+    const n = t.map(
+      (o) => typeof o == "function" ? `function ${o.name || "unnamed"}()` : typeof o
+    ).join(", ");
+    throw new TypeError(`${e}[${n}]`);
+  }
+}
+var kt = (t) => Array.isArray(t) ? t : [t];
+function oo(t) {
+  const e = Array.isArray(t[0]) ? t[0] : t;
+  return no(
+    e,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), e;
+}
+function Ot(t, e) {
+  const n = [], { length: o } = t;
+  for (let r = 0; r < o; r++)
+    n.push(t[r].apply(null, e));
+  return n;
+}
+var ro = (t, e) => {
+  const { identityFunctionCheck: n, inputStabilityCheck: o } = {
+    ...Zn,
+    ...e
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: n === "always" || n === "once" && t,
+      run: Qn
+    },
+    inputStabilityCheck: {
+      shouldRun: o === "always" || o === "once" && t,
+      run: Yn
+    }
+  };
+};
+function so(t) {
+  let e;
+  return {
+    get(n) {
+      return e && t(e.key, n) ? e.value : Fe;
+    },
+    put(n, o) {
+      e = { key: n, value: o };
+    },
+    getEntries() {
+      return e ? [e] : [];
+    },
+    clear() {
+      e = void 0;
+    }
+  };
+}
+function io(t, e) {
+  let n = [];
+  function o(a) {
+    const h = n.findIndex((d) => e(a, d.key));
+    if (h > -1) {
+      const d = n[h];
+      return h > 0 && (n.splice(h, 1), n.unshift(d)), d.value;
+    }
+    return Fe;
+  }
+  function r(a, h) {
+    o(a) === Fe && (n.unshift({ key: a, value: h }), n.length > t && n.pop());
+  }
+  function s() {
+    return n;
+  }
+  function l() {
+    n = [];
+  }
+  return { get: o, put: r, getEntries: s, clear: l };
+}
+var lo = (t, e) => t === e;
+function ao(t) {
+  return function(n, o) {
+    if (n === null || o === null || n.length !== o.length)
+      return !1;
+    const { length: r } = n;
+    for (let s = 0; s < r; s++)
+      if (!t(n[s], o[s]))
+        return !1;
+    return !0;
+  };
+}
+function co(t, e) {
+  const n = typeof e == "object" ? e : { equalityCheck: e }, {
+    equalityCheck: o = lo,
+    maxSize: r = 1,
+    resultEqualityCheck: s
+  } = n, l = ao(o);
+  let a = 0;
+  const h = r <= 1 ? so(l) : io(r, l);
+  function d() {
+    let c = h.get(arguments);
+    if (c === Fe) {
+      if (c = t.apply(null, arguments), a++, s) {
+        const f = h.getEntries().find(
+          (u) => s(u.value, c)
+        );
+        f && (c = f.value, a !== 0 && a--);
+      }
+      h.put(arguments, c);
+    }
+    return c;
+  }
+  return d.clearCache = () => {
+    h.clear(), d.resetResultsCount();
+  }, d.resultsCount = () => a, d.resetResultsCount = () => {
+    a = 0;
+  }, d;
+}
+var uo = class {
+  constructor(t) {
+    this.value = t;
+  }
+  deref() {
+    return this.value;
+  }
+}, po = typeof WeakRef < "u" ? WeakRef : uo, fo = 0, Mt = 1;
+function Pe() {
+  return {
+    s: fo,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function Xt(t, e = {}) {
+  let n = Pe();
+  const { resultEqualityCheck: o } = e;
+  let r, s = 0;
+  function l() {
+    let a = n;
+    const { length: h } = arguments;
+    for (let p = 0, f = h; p < f; p++) {
+      const u = arguments[p];
+      if (typeof u == "function" || typeof u == "object" && u !== null) {
+        let m = a.o;
+        m === null && (a.o = m = /* @__PURE__ */ new WeakMap());
+        const I = m.get(u);
+        I === void 0 ? (a = Pe(), m.set(u, a)) : a = I;
+      } else {
+        let m = a.p;
+        m === null && (a.p = m = /* @__PURE__ */ new Map());
+        const I = m.get(u);
+        I === void 0 ? (a = Pe(), m.set(u, a)) : a = I;
+      }
+    }
+    const d = a;
+    let c;
+    if (a.s === Mt)
+      c = a.v;
+    else if (c = t.apply(null, arguments), s++, o) {
+      const p = r?.deref?.() ?? r;
+      p != null && o(p, c) && (c = p, s !== 0 && s--), r = typeof c == "object" && c !== null || typeof c == "function" ? new po(c) : c;
+    }
+    return d.s = Mt, d.v = c, c;
+  }
+  return l.clearCache = () => {
+    n = Pe(), l.resetResultsCount();
+  }, l.resultsCount = () => s, l.resetResultsCount = () => {
+    s = 0;
+  }, l;
+}
+function Jt(t, ...e) {
+  const n = typeof t == "function" ? {
+    memoize: t,
+    memoizeOptions: e
+  } : t, o = (...r) => {
+    let s = 0, l = 0, a, h = {}, d = r.pop();
+    typeof d == "object" && (h = d, d = r.pop()), eo(
+      d,
+      `createSelector expects an output function after the inputs, but received: [${typeof d}]`
+    );
+    const c = {
+      ...n,
+      ...h
+    }, {
+      memoize: p,
+      memoizeOptions: f = [],
+      argsMemoize: u = Xt,
+      argsMemoizeOptions: m = [],
+      devModeChecks: I = {}
+    } = c, b = kt(f), x = kt(m), w = oo(r), _ = p(function() {
+      return s++, d.apply(
+        null,
+        arguments
+      );
+    }, ...b);
+    let R = !0;
+    const F = u(function() {
+      l++;
+      const D = Ot(
+        w,
+        arguments
+      );
+      if (a = _.apply(null, D), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: V, inputStabilityCheck: j } = ro(R, I);
+        if (V.shouldRun && V.run(
+          d,
+          D,
+          a
+        ), j.shouldRun) {
+          const E = Ot(
+            w,
+            arguments
+          );
+          j.run(
+            { inputSelectorResults: D, inputSelectorResultsCopy: E },
+            { memoize: p, memoizeOptions: b },
+            arguments
+          );
+        }
+        R && (R = !1);
+      }
+      return a;
+    }, ...x);
+    return Object.assign(F, {
+      resultFunc: d,
+      memoizedResultFunc: _,
+      dependencies: w,
+      dependencyRecomputations: () => l,
+      resetDependencyRecomputations: () => {
+        l = 0;
+      },
+      lastResult: () => a,
+      recomputations: () => s,
+      resetRecomputations: () => {
+        s = 0;
+      },
+      memoize: p,
+      argsMemoize: u
+    });
+  };
+  return Object.assign(o, {
+    withTypes: () => o
+  }), o;
+}
+var ho = /* @__PURE__ */ Jt(Xt), mo = Object.assign(
+  (t, e = ho) => {
+    to(
+      t,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof t}`
+    );
+    const n = Object.keys(t), o = n.map(
+      (s) => t[s]
+    );
+    return e(
+      o,
+      (...s) => s.reduce((l, a, h) => (l[n[h]] = a, l), {})
+    );
+  },
+  { withTypes: () => mo }
+);
+const Io = Jt({
+  memoize: co,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+}), P = (t, e, n, o, r, s, l, a, ...h) => {
+  if (h.length > 0)
+    throw new Error("Unsupported number of selectors");
+  let d;
+  if (t && e && n && o && r && s && l && a)
+    d = (c, p, f, u) => {
+      const m = t(c, p, f, u), I = e(c, p, f, u), b = n(c, p, f, u), x = o(c, p, f, u), w = r(c, p, f, u), _ = s(c, p, f, u), R = l(c, p, f, u);
+      return a(m, I, b, x, w, _, R, p, f, u);
+    };
+  else if (t && e && n && o && r && s && l)
+    d = (c, p, f, u) => {
+      const m = t(c, p, f, u), I = e(c, p, f, u), b = n(c, p, f, u), x = o(c, p, f, u), w = r(c, p, f, u), _ = s(c, p, f, u);
+      return l(m, I, b, x, w, _, p, f, u);
+    };
+  else if (t && e && n && o && r && s)
+    d = (c, p, f, u) => {
+      const m = t(c, p, f, u), I = e(c, p, f, u), b = n(c, p, f, u), x = o(c, p, f, u), w = r(c, p, f, u);
+      return s(m, I, b, x, w, p, f, u);
+    };
+  else if (t && e && n && o && r)
+    d = (c, p, f, u) => {
+      const m = t(c, p, f, u), I = e(c, p, f, u), b = n(c, p, f, u), x = o(c, p, f, u);
+      return r(m, I, b, x, p, f, u);
+    };
+  else if (t && e && n && o)
+    d = (c, p, f, u) => {
+      const m = t(c, p, f, u), I = e(c, p, f, u), b = n(c, p, f, u);
+      return o(m, I, b, p, f, u);
+    };
+  else if (t && e && n)
+    d = (c, p, f, u) => {
+      const m = t(c, p, f, u), I = e(c, p, f, u);
+      return n(m, I, p, f, u);
+    };
+  else if (t && e)
+    d = (c, p, f, u) => {
+      const m = t(c, p, f, u);
+      return e(m, p, f, u);
+    };
+  else if (t)
+    d = t;
+  else
+    throw new Error("Missing arguments");
+  return d;
+}, go = (t) => (...e) => {
+  const n = /* @__PURE__ */ new WeakMap();
+  let o = 1;
+  const r = e[e.length - 1], s = e.length - 1 || 1, l = Math.max(r.length - s, 0);
+  if (l > 3)
+    throw new Error("Unsupported number of arguments");
+  return (h, d, c, p) => {
+    let f = h.__cacheKey__;
+    f || (f = {
+      id: o
+    }, h.__cacheKey__ = f, o += 1);
+    let u = n.get(f);
+    if (!u) {
+      const m = e.length === 1 ? [(x) => x, r] : e;
+      let I = e;
+      const b = [void 0, void 0, void 0];
+      switch (l) {
+        case 0:
+          break;
+        case 1: {
+          I = [...m.slice(0, -1), () => b[0], r];
+          break;
+        }
+        case 2: {
+          I = [...m.slice(0, -1), () => b[0], () => b[1], r];
+          break;
+        }
+        case 3: {
+          I = [...m.slice(0, -1), () => b[0], () => b[1], () => b[2], r];
+          break;
+        }
+        default:
+          throw new Error("Unsupported number of arguments");
+      }
+      u = Io(...I), u.selectorArgs = b, n.set(f, u);
+    }
+    switch (l) {
+      case 3:
+        u.selectorArgs[2] = p;
+      case 2:
+        u.selectorArgs[1] = c;
+      case 1:
+        u.selectorArgs[0] = d;
+    }
+    switch (l) {
+      case 0:
+        return u(h);
+      case 1:
+        return u(h, d);
+      case 2:
+        return u(h, d, c);
+      case 3:
+        return u(h, d, c, p);
+      default:
+        throw new Error("unreachable");
+    }
+  };
+}, Te = go();
+var Re = { exports: {} }, He = {};
+var Pt;
+function bo() {
+  if (Pt) return He;
+  Pt = 1;
+  var t = $e;
+  function e(p, f) {
+    return p === f && (p !== 0 || 1 / p === 1 / f) || p !== p && f !== f;
+  }
+  var n = typeof Object.is == "function" ? Object.is : e, o = t.useState, r = t.useEffect, s = t.useLayoutEffect, l = t.useDebugValue;
+  function a(p, f) {
+    var u = f(), m = o({ inst: { value: u, getSnapshot: f } }), I = m[0].inst, b = m[1];
+    return s(
+      function() {
+        I.value = u, I.getSnapshot = f, h(I) && b({ inst: I });
+      },
+      [p, u, f]
+    ), r(
+      function() {
+        return h(I) && b({ inst: I }), p(function() {
+          h(I) && b({ inst: I });
+        });
+      },
+      [p]
+    ), l(u), u;
+  }
+  function h(p) {
+    var f = p.getSnapshot;
+    p = p.value;
+    try {
+      var u = f();
+      return !n(p, u);
+    } catch {
+      return !0;
+    }
+  }
+  function d(p, f) {
+    return f();
+  }
+  var c = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? d : a;
+  return He.useSyncExternalStore = t.useSyncExternalStore !== void 0 ? t.useSyncExternalStore : c, He;
+}
+var qe = {};
+var Rt;
+function So() {
+  return Rt || (Rt = 1, process.env.NODE_ENV !== "production" && (function() {
+    function t(u, m) {
+      return u === m && (u !== 0 || 1 / u === 1 / m) || u !== u && m !== m;
+    }
+    function e(u, m) {
+      c || r.startTransition === void 0 || (c = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var I = m();
+      if (!p) {
+        var b = m();
+        s(I, b) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), p = !0);
+      }
+      b = l({
+        inst: { value: I, getSnapshot: m }
+      });
+      var x = b[0].inst, w = b[1];
+      return h(
+        function() {
+          x.value = I, x.getSnapshot = m, n(x) && w({ inst: x });
+        },
+        [u, I, m]
+      ), a(
+        function() {
+          return n(x) && w({ inst: x }), u(function() {
+            n(x) && w({ inst: x });
+          });
+        },
+        [u]
+      ), d(I), I;
+    }
+    function n(u) {
+      var m = u.getSnapshot;
+      u = u.value;
+      try {
+        var I = m();
+        return !s(u, I);
+      } catch {
+        return !0;
+      }
+    }
+    function o(u, m) {
+      return m();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var r = $e, s = typeof Object.is == "function" ? Object.is : t, l = r.useState, a = r.useEffect, h = r.useLayoutEffect, d = r.useDebugValue, c = !1, p = !1, f = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? o : e;
+    qe.useSyncExternalStore = r.useSyncExternalStore !== void 0 ? r.useSyncExternalStore : f, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), qe;
+}
+var Lt;
+function ct() {
+  return Lt || (Lt = 1, process.env.NODE_ENV === "production" ? Re.exports = bo() : Re.exports = So()), Re.exports;
+}
+var yo = ct(), Le = { exports: {} }, Ge = {};
+var Dt;
+function xo() {
+  if (Dt) return Ge;
+  Dt = 1;
+  var t = $e, e = ct();
+  function n(d, c) {
+    return d === c && (d !== 0 || 1 / d === 1 / c) || d !== d && c !== c;
+  }
+  var o = typeof Object.is == "function" ? Object.is : n, r = e.useSyncExternalStore, s = t.useRef, l = t.useEffect, a = t.useMemo, h = t.useDebugValue;
+  return Ge.useSyncExternalStoreWithSelector = function(d, c, p, f, u) {
+    var m = s(null);
+    if (m.current === null) {
+      var I = { hasValue: !1, value: null };
+      m.current = I;
+    } else I = m.current;
+    m = a(
+      function() {
+        function x(C) {
+          if (!w) {
+            if (w = !0, _ = C, C = f(C), u !== void 0 && I.hasValue) {
+              var D = I.value;
+              if (u(D, C))
+                return R = D;
+            }
+            return R = C;
+          }
+          if (D = R, o(_, C)) return D;
+          var V = f(C);
+          return u !== void 0 && u(D, V) ? (_ = C, D) : (_ = C, R = V);
+        }
+        var w = !1, _, R, F = p === void 0 ? null : p;
+        return [
+          function() {
+            return x(c());
+          },
+          F === null ? void 0 : function() {
+            return x(F());
+          }
+        ];
+      },
+      [c, p, f, u]
+    );
+    var b = r(d, m[0], m[1]);
+    return l(
+      function() {
+        I.hasValue = !0, I.value = b;
+      },
+      [b]
+    ), h(b), b;
+  }, Ge;
+}
+var Xe = {};
+var _t;
+function Eo() {
+  return _t || (_t = 1, process.env.NODE_ENV !== "production" && (function() {
+    function t(d, c) {
+      return d === c && (d !== 0 || 1 / d === 1 / c) || d !== d && c !== c;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var e = $e, n = ct(), o = typeof Object.is == "function" ? Object.is : t, r = n.useSyncExternalStore, s = e.useRef, l = e.useEffect, a = e.useMemo, h = e.useDebugValue;
+    Xe.useSyncExternalStoreWithSelector = function(d, c, p, f, u) {
+      var m = s(null);
+      if (m.current === null) {
+        var I = { hasValue: !1, value: null };
+        m.current = I;
+      } else I = m.current;
+      m = a(
+        function() {
+          function x(C) {
+            if (!w) {
+              if (w = !0, _ = C, C = f(C), u !== void 0 && I.hasValue) {
+                var D = I.value;
+                if (u(D, C))
+                  return R = D;
+              }
+              return R = C;
+            }
+            if (D = R, o(_, C))
+              return D;
+            var V = f(C);
+            return u !== void 0 && u(D, V) ? (_ = C, D) : (_ = C, R = V);
+          }
+          var w = !1, _, R, F = p === void 0 ? null : p;
+          return [
+            function() {
+              return x(c());
+            },
+            F === null ? void 0 : function() {
+              return x(F());
+            }
+          ];
+        },
+        [c, p, f, u]
+      );
+      var b = r(d, m[0], m[1]);
+      return l(
+        function() {
+          I.hasValue = !0, I.value = b;
+        },
+        [b]
+      ), h(b), b;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), Xe;
+}
+var At;
+function Co() {
+  return At || (At = 1, process.env.NODE_ENV === "production" ? Le.exports = xo() : Le.exports = Eo()), Le.exports;
+}
+var vo = Co();
+const wo = parseInt(M.version, 10), To = wo >= 19, ko = To ? Oo : Mo;
+function W(t, e, n, o, r) {
+  return ko(t, e, n, o, r);
+}
+function Oo(t, e, n, o, r) {
+  const s = M.useCallback(() => e(t.getSnapshot(), n, o, r), [t, e, n, o, r]);
+  return yo.useSyncExternalStore(t.subscribe, s, s);
+}
+function Mo(t, e, n, o, r) {
+  return vo.useSyncExternalStoreWithSelector(t.subscribe, t.getSnapshot, t.getSnapshot, (s) => e(s, n, o, r));
+}
+class dt {
+  // HACK: `any` fixes adding listeners that accept partial state.
+  // Internal state to handle recursive `setState()` calls
+  static create(e) {
+    return new dt(e);
+  }
+  constructor(e) {
+    this.state = e, this.listeners = /* @__PURE__ */ new Set(), this.updateTick = 0;
+  }
+  subscribe = (e) => (this.listeners.add(e), () => {
+    this.listeners.delete(e);
+  });
+  /**
+   * Returns the current state snapshot. Meant for usage with `useSyncExternalStore`.
+   * If you want to access the state, use the `state` property instead.
+   */
+  getSnapshot = () => this.state;
+  setState(e) {
+    this.state = e, this.updateTick += 1;
+    const n = this.updateTick, o = this.listeners.values();
+    let r;
+    for (; r = o.next(), !r.done; ) {
+      if (n !== this.updateTick)
+        return;
+      const s = r.value;
+      s(e);
+    }
+  }
+  update(e) {
+    for (const n in e)
+      if (!Object.is(this.state[n], e[n])) {
+        this.setState(S({}, this.state, e));
+        return;
+      }
+  }
+  set(e, n) {
+    Object.is(this.state[e], n) || this.setState(S({}, this.state, {
+      [e]: n
+    }));
+  }
+  use = (e, n, o, r) => W(this, e, n, o, r);
+}
+const Nt = P((t) => t.providedTreeId ?? t.treeId), ke = {
+  /**
+   * Get the id attribute of the tree view.
+   */
+  treeId: Nt,
+  /**
+   * Generate the id attribute (i.e.: the `id` attribute passed to the DOM element) of a Tree Item.
+   * If the user explicitly defined an id attribute, it will be returned.
+   * Otherwise, the method creates a unique id for the item based on the Tree View id attribute and the item `itemId`
+   */
+  treeItemIdAttribute: P(Nt, (t, e, n) => n ?? `${t ?? ""}-${e}`)
+}, se = "__TREE_VIEW_ROOT_PARENT_ID__", Qt = (t) => {
+  const e = {};
+  return t.forEach((n, o) => {
+    e[n] = o;
+  }), e;
+}, Ve = (t, e) => {
+  if (e == null)
+    return !1;
+  let n = t[e];
+  if (!n)
+    return !1;
+  if (n.disabled)
+    return !0;
+  for (; n.parentId != null; ) {
+    if (n = t[n.parentId], !n)
+      return !1;
+    if (n.disabled)
+      return !0;
+  }
+  return !1;
+};
+function Ft(t) {
+  const {
+    storeParameters: e,
+    items: n,
+    parentId: o,
+    depth: r,
+    isItemExpandable: s,
+    otherItemsMetaLookup: l
+  } = t, a = {}, h = {}, d = [], c = [], p = (f) => {
+    const u = e.getItemId ? e.getItemId(f) : f.id;
+    Po({
+      id: u,
+      parentId: o,
+      item: f,
+      itemMetaLookup: l,
+      siblingsMetaLookup: a
+    });
+    const m = e.getItemLabel ? e.getItemLabel(f) : f.label;
+    if (m == 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(f)].join(`
+`));
+    const I = (e.getItemChildren ? e.getItemChildren(f) : f.children) || [];
+    c.push({
+      id: u,
+      children: I
+    }), h[u] = f, a[u] = {
+      id: u,
+      label: m,
+      parentId: o,
+      idAttribute: void 0,
+      expandable: s(f, I),
+      disabled: e.isItemDisabled ? e.isItemDisabled(f) : !1,
+      selectable: e.isItemSelectionDisabled ? !e.isItemSelectionDisabled(f) : !0,
+      depth: r
+    }, d.push(u);
+  };
+  for (const f of n)
+    p(f);
+  return {
+    metaLookup: a,
+    modelLookup: h,
+    orderedChildrenIds: d,
+    childrenIndexes: Qt(d),
+    itemsChildren: c
+  };
+}
+function Po({
+  id: t,
+  parentId: e,
+  item: n,
+  itemMetaLookup: o,
+  siblingsMetaLookup: r
+}) {
+  if (t == 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(n)].join(`
+`));
+  if (r[t] != null || // Ignore items with the same parent id, because it's the same item from the previous generation.
+  o[t] != null && o[t].parentId !== e)
+    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: "${t}"`].join(`
+`));
+}
+const Ro = [], y = {
+  /**
+   * Gets the DOM structure of the Tree View.
+   */
+  domStructure: P((t) => t.domStructure),
+  /**
+   * Checks whether the disabled items are focusable.
+   */
+  disabledItemFocusable: P((t) => t.disabledItemsFocusable),
+  /**
+   * Gets the meta-information of all items.
+   */
+  itemMetaLookup: P((t) => t.itemMetaLookup),
+  /**
+   * Gets the ordered children ids of all items.
+   */
+  itemOrderedChildrenIdsLookup: P((t) => t.itemOrderedChildrenIdsLookup),
+  /**
+   * Gets the meta-information of an item.
+   */
+  itemMeta: P((t, e) => t.itemMetaLookup[e ?? se] ?? null),
+  /**
+   * Gets the ordered children ids of an item.
+   */
+  itemOrderedChildrenIds: P((t, e) => t.itemOrderedChildrenIdsLookup[e ?? se] ?? Ro),
+  /**
+   * Gets the model of an item.
+   */
+  itemModel: P((t, e) => t.itemModelLookup[e]),
+  /**
+   * Checks whether an item is disabled.
+   */
+  isItemDisabled: P((t, e) => Ve(t.itemMetaLookup, e)),
+  /**
+   * Gets the index of an item in its parent's children.
+   */
+  itemIndex: P((t, e) => {
+    const n = t.itemMetaLookup[e];
+    return n == null ? -1 : t.itemChildrenIndexesLookup[n.parentId ?? se][n.id];
+  }),
+  /**
+   * Gets the id of an item's parent.
+   */
+  itemParentId: P((t, e) => t.itemMetaLookup[e]?.parentId ?? null),
+  /**
+   * Gets the depth of an item (items at the root level have a depth of 0).
+   */
+  itemDepth: P((t, e) => t.itemMetaLookup[e]?.depth ?? 0),
+  /**
+   * Checks whether an item can be focused.
+   */
+  canItemBeFocused: P((t, e) => t.disabledItemsFocusable || !Ve(t.itemMetaLookup, e)),
+  /**
+   * Gets the identation between an item and its children.
+   */
+  itemChildrenIndentation: P((t) => t.itemChildrenIndentation)
+};
+class De {
+  // We can't type `store`, otherwise we get the following TS error:
+  // 'items' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
+  constructor(e) {
+    this.store = e;
+  }
+  /**
+   * Determines if the items state should be rebuilt based on the new and previous parameters.
+   */
+  static shouldRebuildItemsState = (e, n) => ["items", "isItemDisabled", "isItemSelectionDisabled", "getItemId", "getItemLabel", "getItemChildren"].some((o) => {
+    const r = o;
+    return e[r] !== n[r];
+  });
+  /**
+   * Builds the state properties derived from the `items` prop.
+   */
+  static buildItemsStateIfNeeded = (e) => {
+    const n = {}, o = {}, r = {}, s = {};
+    function l(a, h, d) {
+      const c = h ?? se, {
+        metaLookup: p,
+        modelLookup: f,
+        orderedChildrenIds: u,
+        childrenIndexes: m,
+        itemsChildren: I
+      } = Ft({
+        storeParameters: e,
+        items: a,
+        parentId: h,
+        depth: d,
+        isItemExpandable: (b, x) => !!x && x.length > 0,
+        otherItemsMetaLookup: n
+      });
+      Object.assign(n, p), Object.assign(o, f), r[c] = u, s[c] = m;
+      for (const b of I)
+        l(b.children || [], b.id, d + 1);
+    }
+    return l(e.items, null, 0), {
+      itemMetaLookup: n,
+      itemModelLookup: o,
+      itemOrderedChildrenIdsLookup: r,
+      itemChildrenIndexesLookup: s
+    };
+  };
+  /**
+   * Get the item with the given id.
+   * When used in the Simple Tree View, it returns an object with the `id` and `label` properties.
+   * @param {TreeViewItemId} itemId The id of the item to retrieve.
+   * @returns {R} The item with the given id.
+   */
+  getItem = (e) => y.itemModel(this.store.state, e);
+  /**
+   * Get all the items in the same format as provided by `props.items`.
+   * @returns {R[]} The items in the tree.
+   */
+  getItemTree = () => {
+    const e = (n) => {
+      const o = y.itemModel(this.store.state, n), r = S({}, o), s = y.itemOrderedChildrenIds(this.store.state, n);
+      return s.length > 0 ? r.children = s.map(e) : delete r.children, r;
+    };
+    return y.itemOrderedChildrenIds(this.store.state, null).map(e);
+  };
+  /**
+   * Get the ids of a given item's children.
+   * Those ids are returned in the order they should be rendered.
+   * To get the root items, pass `null` as the `itemId`.
+   * @param {TreeViewItemId | null} itemId The id of the item to get the children of.
+   * @returns {TreeViewItemId[]} The ids of the item's children.
+   */
+  getItemOrderedChildrenIds = (e) => y.itemOrderedChildrenIds(this.store.state, e);
+  /** * Get the id of the parent item.
+   * @param {TreeViewItemId} itemId The id of the item to whose parentId we want to retrieve.
+   * @returns {TreeViewItemId | null} The id of the parent item.
+   */
+  getParentId = (e) => y.itemMeta(this.store.state, e)?.parentId || null;
+  /**
+   * Toggle the disabled state of the item with the given id.
+   * @param {object} parameters The params of the method.
+   * @param {TreeViewItemId } parameters.itemId The id of the item to get the children of.
+   * @param {boolean } parameters.shouldBeDisabled true if the item should be disabled.
+   */
+  setIsItemDisabled = ({
+    itemId: e,
+    shouldBeDisabled: n
+  }) => {
+    if (!this.store.state.itemMetaLookup[e])
+      return;
+    const o = S({}, this.store.state.itemMetaLookup);
+    o[e] = S({}, o[e], {
+      disabled: n ?? !o[e].disabled
+    }), this.store.set("itemMetaLookup", o);
+  };
+  buildPublicAPI = () => ({
+    getItem: this.getItem,
+    getItemDOMElement: this.getItemDOMElement,
+    getItemOrderedChildrenIds: this.getItemOrderedChildrenIds,
+    getItemTree: this.getItemTree,
+    getParentId: this.getParentId,
+    setIsItemDisabled: this.setIsItemDisabled
+  });
+  /**
+   * Get the DOM element of the item with the given id.
+   * @param {TreeViewItemId} itemId The id of the item to get the DOM element of.
+   * @returns {HTMLElement | null} The DOM element of the item with the given id.
+   */
+  getItemDOMElement = (e) => {
+    const n = y.itemMeta(this.store.state, e);
+    if (n == null)
+      return null;
+    const o = ke.treeItemIdAttribute(this.store.state, e, n.idAttribute);
+    return document.getElementById(o);
+  };
+  /**
+   * Add an array of items to the tree.
+   * @param {SetItemChildrenParameters<R>} args The items to add to the tree and information about their ancestors.
+   */
+  setItemChildren = ({
+    items: e,
+    parentId: n,
+    getChildrenCount: o
+  }) => {
+    const r = n ?? se, s = n == null ? -1 : y.itemDepth(this.store.state, n), {
+      metaLookup: l,
+      modelLookup: a,
+      orderedChildrenIds: h,
+      childrenIndexes: d
+    } = Ft({
+      storeParameters: this.store.parameters,
+      items: e,
+      parentId: n,
+      depth: s + 1,
+      isItemExpandable: o ? (c) => o(c) !== 0 : () => !1,
+      otherItemsMetaLookup: y.itemMetaLookup(this.store.state)
+    });
+    this.store.update({
+      itemModelLookup: S({}, this.store.state.itemModelLookup, a),
+      itemMetaLookup: S({}, this.store.state.itemMetaLookup, l),
+      itemOrderedChildrenIdsLookup: S({}, this.store.state.itemOrderedChildrenIdsLookup, {
+        [r]: h
+      }),
+      itemChildrenIndexesLookup: S({}, this.store.state.itemChildrenIndexesLookup, {
+        [r]: d
+      })
+    });
+  };
+  /**
+   * Remove the children of an item.
+   * @param {TreeViewItemId | null} parentId The id of the item to remove the children of.
+   */
+  removeChildren = (e) => {
+    const n = this.store.state.itemMetaLookup, o = Object.keys(n).reduce((a, h) => {
+      const d = n[h];
+      return d.parentId === e ? a : S({}, a, {
+        [d.id]: d
+      });
+    }, {}), r = S({}, this.store.state.itemOrderedChildrenIdsLookup), s = S({}, this.store.state.itemChildrenIndexesLookup), l = e ?? se;
+    delete s[l], delete r[l], this.store.update({
+      itemMetaLookup: o,
+      itemOrderedChildrenIdsLookup: r,
+      itemChildrenIndexesLookup: s
+    });
+  };
+  /**
+   * 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 {TreeViewItemId} itemId The id of the item being clicked.
+   */
+  handleItemClick = (e, n) => {
+    this.store.parameters.onItemClick?.(e, n);
+  };
+}
+const Yt = Te((t) => t.selectedItems, (t) => Array.isArray(t) ? t : t != null ? [t] : []), Vt = Te(Yt, (t) => {
+  const e = /* @__PURE__ */ new Map();
+  return t.forEach((n) => {
+    e.set(n, !0);
+  }), e;
+}), Je = P((t, e) => t.itemMetaLookup[e]?.selectable ?? !0), N = {
+  /**
+   * Gets the selected items as provided to the component.
+   */
+  selectedItemsRaw: P((t) => t.selectedItems),
+  /**
+   * Gets the selected items as an array.
+   */
+  selectedItems: Yt,
+  /**
+   * Gets the selected items as a Map.
+   */
+  selectedItemsMap: Vt,
+  /**
+   * Checks whether selection is enabled.
+   */
+  enabled: P((t) => !t.disableSelection),
+  /**
+   * Checks whether multi selection is enabled.
+   */
+  isMultiSelectEnabled: P((t) => t.multiSelect),
+  /**
+   * Checks whether checkbox selection is enabled.
+   */
+  isCheckboxSelectionEnabled: P((t) => t.checkboxSelection),
+  /**
+   * Gets the selection propagation rules.
+   */
+  propagationRules: P((t) => t.selectionPropagation),
+  /**
+   * Checks whether an item is selected.
+   */
+  isItemSelected: P(Vt, (t, e) => t.has(e)),
+  /**
+   * Checks whether the selection feature is enabled for an item.
+   * Returns `true` when selection is enabled on the Tree View and the item is selectable (even if the item is disabled).
+   */
+  isFeatureEnabledForItem: P(Je, (t) => !t.disableSelection, (t, e, n) => e && t),
+  /**
+   * Checks whether an item can be selected (if selection is enabled, if the item is not disabled, and if the item is selectable).
+   */
+  canItemBeSelected: P(y.isItemDisabled, Je, (t) => !t.disableSelection, (t, e, n, o) => n && !t && e),
+  /**
+   * Checks whether an item is selectable based on the `isItemSelectionDisabled` prop.
+   */
+  isItemSelectable: Je
+}, Lo = P((t, e) => {
+  if (N.isItemSelected(t, e))
+    return "checked";
+  let n = !1, o = !1;
+  const r = (l) => {
+    l !== e && (N.isItemSelected(t, l) ? n = !0 : o = !0), y.itemOrderedChildrenIds(t, l).forEach(r);
+  };
+  return r(e), N.propagationRules(t).parents ? n && o ? "indeterminate" : n && !o ? "checked" : "empty" : n ? "indeterminate" : "empty";
+}), Do = ({
+  props: t
+}) => {
+  const {
+    itemId: e
+  } = t, {
+    store: n
+  } = be(), o = W(n, N.isCheckboxSelectionEnabled), r = W(n, N.isFeatureEnabledForItem, e), s = W(n, N.canItemBeSelected, e), l = W(n, Lo, e);
+  return {
+    propsEnhancers: {
+      root: () => {
+        let a;
+        return l === "checked" ? a = !0 : l === "indeterminate" ? a = "mixed" : s ? a = !1 : a = void 0, {
+          "aria-checked": a
+        };
+      },
+      checkbox: ({
+        externalEventHandlers: a,
+        interactions: h
+      }) => ({
+        tabIndex: -1,
+        onChange: (c) => {
+          a.onChange?.(c), !c.defaultMuiPrevented && N.canItemBeSelected(n.state, e) && h.handleCheckboxSelection(c);
+        },
+        visible: o && r,
+        disabled: !s,
+        checked: l === "checked",
+        indeterminate: l === "indeterminate"
+      })
+    }
+  };
+}, Qe = Te((t) => t.expandedItems, (t) => {
+  const e = /* @__PURE__ */ new Map();
+  return t.forEach((n) => {
+    e.set(n, !0);
+  }), e;
+}), H = {
+  /**
+   * Gets the expanded items as provided to the component.
+   */
+  expandedItemsRaw: P((t) => t.expandedItems),
+  /**
+   * Gets the expanded items as a Map.
+   */
+  expandedItemsMap: Qe,
+  /**
+   * Gets the items to render as a flat list (the descendants of an expanded item are listed as siblings of the item).
+   */
+  flatList: Te(y.itemOrderedChildrenIdsLookup, Qe, (t, e) => {
+    function n(o) {
+      if (!e.has(o))
+        return [o];
+      const r = [o], s = t[o] || [];
+      for (const l of s)
+        r.push(...n(l));
+      return r;
+    }
+    return (t[se] ?? []).flatMap(n);
+  }),
+  /**
+   * Gets the slot that triggers the item's expansion when clicked.
+   */
+  triggerSlot: P((t) => t.expansionTrigger),
+  /**
+   * Checks whether an item is expanded.
+   */
+  isItemExpanded: P(Qe, (t, e) => t.has(e)),
+  /**
+   * Checks whether an item is expandable.
+   */
+  isItemExpandable: P(y.itemMeta, (t, e) => t?.expandable ?? !1)
+}, nt = (t, e) => {
+  let n = e.length - 1;
+  for (; n >= 0 && !y.canItemBeFocused(t, e[n]); )
+    n -= 1;
+  if (n !== -1)
+    return e[n];
+}, Zt = (t, e) => {
+  const n = y.itemMeta(t, e);
+  if (!n)
+    return null;
+  const o = y.itemOrderedChildrenIds(t, n.parentId), r = y.itemIndex(t, e);
+  if (r === 0)
+    return n.parentId;
+  let s = r - 1;
+  for (; !y.canItemBeFocused(t, o[s]) && s >= 0; )
+    s -= 1;
+  if (s === -1)
+    return n.parentId == null ? null : Zt(t, n.parentId);
+  let l = o[s], a = nt(t, y.itemOrderedChildrenIds(t, l));
+  for (; H.isItemExpanded(t, l) && a != null; )
+    l = a, a = nt(t, y.itemOrderedChildrenIds(t, l));
+  return l;
+}, _e = (t, e) => {
+  if (H.isItemExpanded(t, e)) {
+    const o = y.itemOrderedChildrenIds(t, e).find((r) => y.canItemBeFocused(t, r));
+    if (o != null)
+      return o;
+  }
+  let n = y.itemMeta(t, e);
+  for (; n != null; ) {
+    const o = y.itemOrderedChildrenIds(t, n.parentId), r = y.itemIndex(t, n.id);
+    if (r < o.length - 1) {
+      let s = r + 1;
+      for (; !y.canItemBeFocused(t, o[s]) && s < o.length - 1; )
+        s += 1;
+      if (y.canItemBeFocused(t, o[s]))
+        return o[s];
+    }
+    n = y.itemMeta(t, n.parentId);
+  }
+  return null;
+}, en = (t) => {
+  let e = null;
+  for (; e == null || H.isItemExpanded(t, e); ) {
+    const n = y.itemOrderedChildrenIds(t, e), o = nt(t, n);
+    if (o == null)
+      return e;
+    e = o;
+  }
+  return e;
+}, ze = (t) => y.itemOrderedChildrenIds(t, null).find((e) => y.canItemBeFocused(t, e)), tn = (t, e, n) => {
+  if (e === n)
+    return [e, n];
+  const o = y.itemMeta(t, e), r = y.itemMeta(t, n);
+  if (!o || !r)
+    return [e, n];
+  if (o.parentId === r.id || r.parentId === o.id)
+    return r.parentId === o.id ? [o.id, r.id] : [r.id, o.id];
+  const s = [o.id], l = [r.id];
+  let a = o.parentId, h = r.parentId, d = l.indexOf(a) !== -1, c = s.indexOf(h) !== -1, p = !0, f = !0;
+  for (; !c && !d; )
+    p && (s.push(a), d = l.indexOf(a) !== -1, p = a !== null, !d && p && (a = y.itemParentId(t, a))), f && !d && (l.push(h), c = s.indexOf(h) !== -1, f = h !== null, !c && f && (h = y.itemParentId(t, h)));
+  const u = d ? a : h, m = y.itemOrderedChildrenIds(t, u), I = s[s.indexOf(u) - 1], b = l[l.indexOf(u) - 1];
+  return m.indexOf(I) < m.indexOf(b) ? [e, n] : [n, e];
+}, _o = (t, e, n) => {
+  const o = (h) => {
+    if (H.isItemExpandable(t, h) && H.isItemExpanded(t, h))
+      return y.itemOrderedChildrenIds(t, h)[0];
+    let d = y.itemMeta(t, h);
+    for (; d != null; ) {
+      const c = y.itemOrderedChildrenIds(t, d.parentId), p = y.itemIndex(t, d.id);
+      if (p < c.length - 1)
+        return c[p + 1];
+      d = d.parentId ? y.itemMeta(t, d.parentId) : null;
+    }
+    throw new Error("Invalid range");
+  }, [r, s] = tn(t, e, n), l = [r];
+  let a = r;
+  for (; a !== s; )
+    a = o(a), y.isItemDisabled(t, a) || l.push(a);
+  return l;
+}, Ao = (t) => {
+  let e = ze(t);
+  const n = [];
+  for (; e != null; )
+    n.push(e), e = _e(t, e);
+  return n;
+}, ot = (t, e) => e !== t.closest('*[role="treeitem"]');
+class No {
+  lastSelectedItem = null;
+  lastSelectedRange = {};
+  // We can't type `store`, otherwise we get the following TS error:
+  // 'selection' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
+  constructor(e) {
+    this.store = e, e.itemPluginManager.register(Do, null);
+  }
+  setSelectedItems = (e, n, o) => {
+    const {
+      selectionPropagation: r = ye,
+      selectedItems: s,
+      onItemSelectionToggle: l,
+      onSelectedItemsChange: a
+    } = this.store.parameters, h = N.selectedItemsRaw(this.store.state);
+    let d;
+    const c = N.isMultiSelectEnabled(this.store.state);
+    if (c && (r.descendants || r.parents) ? d = Fo({
+      store: this.store,
+      selectionPropagation: r,
+      newModel: n,
+      oldModel: h,
+      additionalItemsToPropagate: o
+    }) : d = n, l)
+      if (c) {
+        const p = nn({
+          store: this.store,
+          newModel: d,
+          oldModel: h
+        });
+        l && (p.added.forEach((f) => {
+          l(e, f, !0);
+        }), p.removed.forEach((f) => {
+          l(e, f, !1);
+        }));
+      } else d !== h && (h != null && l(e, h, !1), d != null && l(e, d, !0));
+    s === void 0 && this.store.set("selectedItems", d), a?.(e, d);
+  };
+  selectRange = (e, [n, o]) => {
+    if (!N.isMultiSelectEnabled(this.store.state))
+      return;
+    let s = N.selectedItems(this.store.state).slice();
+    Object.keys(this.lastSelectedRange).length > 0 && (s = s.filter((d) => !this.lastSelectedRange[d]));
+    const l = Ae(s), a = _o(this.store.state, n, o).filter((d) => N.isItemSelectable(this.store.state, d)), h = a.filter((d) => !l[d]);
+    s = s.concat(h), this.setSelectedItems(e, s), this.lastSelectedRange = Ae(a);
+  };
+  buildPublicAPI = () => ({
+    setItemSelection: this.setItemSelection
+  });
+  /**
+   * Select or deselect an item.
+   * @param {object} parameters The parameters of the method.
+   * @param {TreeViewItemId} parameters.itemId The id of the item to select or deselect.
+   * @param {React.SyntheticEvent} parameters.event The DOM event that triggered the change.
+   * @param {boolean} parameters.keepExistingSelection If `true`, the other already selected items will remain selected, otherwise, they will be deselected. This parameter is only relevant when `multiSelect` is `true`
+   * @param {boolean | undefined} parameters.shouldBeSelected If `true` the item will be selected. If `false` the item will be deselected. If not defined, the item's selection status will be toggled.
+   */
+  setItemSelection = ({
+    itemId: e,
+    event: n = null,
+    keepExistingSelection: o = !1,
+    shouldBeSelected: r
+  }) => {
+    if (!N.enabled(this.store.state))
+      return;
+    let s;
+    const l = N.isMultiSelectEnabled(this.store.state);
+    if (o) {
+      const a = N.selectedItems(this.store.state), h = N.isItemSelected(this.store.state, e);
+      h && (r === !1 || r == null) ? s = a.filter((d) => d !== e) : !h && (r === !0 || r == null) ? s = [e].concat(a) : s = a;
+    } else
+      r === !1 || r == null && N.isItemSelected(this.store.state, e) ? s = l ? [] : null : s = l ? [e] : e;
+    this.setSelectedItems(
+      n,
+      s,
+      // If shouldBeSelected === selectionSelectors.isItemSelected(store, itemId), we still want to propagate the select.
+      // This is useful when the element is in an indeterminate state.
+      [e]
+    ), this.lastSelectedItem = e, this.lastSelectedRange = {};
+  };
+  /**
+   * Select all the navigable items in the tree.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   */
+  selectAllNavigableItems = (e) => {
+    if (!N.isMultiSelectEnabled(this.store.state))
+      return;
+    const o = Ao(this.store.state);
+    this.setSelectedItems(e, o), this.lastSelectedRange = Ae(o);
+  };
+  /**
+   * Expand the current selection range up to the given item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item to expand the selection to.
+   */
+  expandSelectionRange = (e, n) => {
+    if (this.lastSelectedItem != null) {
+      const [o, r] = tn(this.store.state, n, this.lastSelectedItem);
+      this.selectRange(e, [o, r]);
+    }
+  };
+  /**
+   * Expand the current selection range from the first navigable item to the given item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item up to which the selection range should be expanded.
+   */
+  selectRangeFromStartToItem = (e, n) => {
+    this.selectRange(e, [ze(this.store.state), n]);
+  };
+  /**
+   * Expand the current selection range from the given item to the last navigable item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item from which the selection range should be expanded.
+   */
+  selectRangeFromItemToEnd = (e, n) => {
+    this.selectRange(e, [n, en(this.store.state)]);
+  };
+  /**
+   * Update the selection when navigating with ArrowUp / ArrowDown keys.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} currentItemId The id of the active item before the keyboard navigation.
+   * @param {TreeViewItemId} nextItemId The id of the active item after the keyboard navigation.
+   */
+  selectItemFromArrowNavigation = (e, n, o) => {
+    if (!N.isMultiSelectEnabled(this.store.state))
+      return;
+    let s = N.selectedItems(this.store.state).slice();
+    Object.keys(this.lastSelectedRange).length === 0 ? (s.push(o), this.lastSelectedRange = {
+      [n]: !0,
+      [o]: !0
+    }) : (this.lastSelectedRange[n] || (this.lastSelectedRange = {}), this.lastSelectedRange[o] ? (s = s.filter((l) => l !== n), delete this.lastSelectedRange[n]) : (s.push(o), this.lastSelectedRange[o] = !0)), this.setSelectedItems(e, s);
+  };
+}
+function Fo({
+  store: t,
+  selectionPropagation: e,
+  newModel: n,
+  oldModel: o,
+  additionalItemsToPropagate: r
+}) {
+  if (!e.descendants && !e.parents)
+    return n;
+  let s = !1;
+  const l = Ae(n), a = nn({
+    store: t,
+    newModel: n,
+    oldModel: o
+  });
+  return r?.forEach((h) => {
+    l[h] ? a.added.includes(h) || a.added.push(h) : a.removed.includes(h) || a.removed.push(h);
+  }), a.added.forEach((h) => {
+    if (e.descendants) {
+      const d = (c) => {
+        c !== h && (s = !0, l[c] = !0), y.itemOrderedChildrenIds(t.state, c).forEach(d);
+      };
+      d(h);
+    }
+    if (e.parents) {
+      const d = (p) => l[p] ? y.itemOrderedChildrenIds(t.state, p).every(d) : !1, c = (p) => {
+        const f = y.itemParentId(t.state, p);
+        if (f == null)
+          return;
+        y.itemOrderedChildrenIds(t.state, f).every(d) && (s = !0, l[f] = !0, c(f));
+      };
+      c(h);
+    }
+  }), a.removed.forEach((h) => {
+    if (e.parents) {
+      let d = y.itemParentId(t.state, h);
+      for (; d != null; )
+        l[d] && (s = !0, delete l[d]), d = y.itemParentId(t.state, d);
+    }
+    if (e.descendants) {
+      const d = (c) => {
+        c !== h && (s = !0, delete l[c]), y.itemOrderedChildrenIds(t.state, c).forEach(d);
+      };
+      d(h);
+    }
+  }), s ? Object.keys(l) : n;
+}
+function nn({
+  store: t,
+  oldModel: e,
+  newModel: n
+}) {
+  const o = /* @__PURE__ */ new Map();
+  return n.forEach((r) => {
+    o.set(r, !0);
+  }), {
+    added: n.filter((r) => !N.isItemSelected(t.state, r)),
+    removed: e.filter((r) => !o.has(r))
+  };
+}
+function Ae(t) {
+  const e = {};
+  return t.forEach((n) => {
+    e[n] = !0;
+  }), e;
+}
+function Vo(t, e, n) {
+  const o = W(t, ke.treeId), r = W(t, y.itemChildrenIndentation), s = W(t, N.isMultiSelectEnabled);
+  return (l) => S({
+    ref: n,
+    role: "tree",
+    id: o,
+    "aria-multiselectable": s
+  }, e, l, {
+    style: S({}, e.style, {
+      "--TreeView-itemChildrenIndentation": typeof r == "number" ? `${r}px` : r
+    }),
+    onFocus: (a) => {
+      l.onFocus?.(a), t.focus.handleRootFocus(a);
+    },
+    onBlur: (a) => {
+      l.onBlur?.(a), t.focus.handleRootBlur(a);
+    }
+  });
+}
+function zo(t) {
+  return t.replace(/["\\]/g, "\\$&");
+}
+const ut = /* @__PURE__ */ M.createContext(null);
+process.env.NODE_ENV !== "production" && (ut.displayName = "TreeViewChildrenItemContext");
+function pt(t) {
+  const {
+    children: e,
+    itemId: n = null,
+    idAttribute: o
+  } = t, {
+    store: r,
+    rootRef: s
+  } = be(), l = M.useRef(/* @__PURE__ */ new Map());
+  M.useEffect(() => {
+    if (!s.current)
+      return;
+    const h = y.itemOrderedChildrenIds(r.state, n ?? null) ?? [], d = zo(o ?? s.current.id);
+    if (n != null) {
+      const u = s.current.querySelector(`*[id="${d}"][role="treeitem"]`);
+      if (u && u.getAttribute("aria-expanded") === "false")
+        return;
+    }
+    const c = s.current.querySelectorAll(`${n == null ? "" : `*[id="${d}"] `}[role="treeitem"]:not(*[id="${d}"] [role="treeitem"] [role="treeitem"])`), p = Array.from(c).map((u) => l.current.get(u.id));
+    (p.length !== h.length || p.some((u, m) => u !== h[m])) && r.jsxItems.setJSXItemsOrderedChildrenIds(n ?? null, p);
+  });
+  const a = M.useMemo(() => ({
+    registerChild: (h, d) => l.current.set(h, d),
+    unregisterChild: (h) => l.current.delete(h),
+    parentId: n
+  }), [n]);
+  return /* @__PURE__ */ v(ut.Provider, {
+    value: a,
+    children: e
+  });
+}
+process.env.NODE_ENV !== "production" && (pt.propTypes = {
+  children: i.node,
+  id: i.string
+});
+const Ee = /* @__PURE__ */ M.createContext(() => -1);
+process.env.NODE_ENV !== "production" && (Ee.displayName = "TreeViewItemDepthContext");
+const jo = () => {
+}, rt = typeof document < "u" ? M.useLayoutEffect : jo, $o = [];
+function Bo(t) {
+  M.useEffect(t, $o);
+}
+function Wo(t, e) {
+  const n = Vn(), o = it(() => new t(S({}, e, {
+    isRtl: n
+  }))).current;
+  return rt(() => o.updateStateFromParameters(S({}, e, {
+    isRtl: n
+  })), [o, n, e]), Bo(o.disposeEffect), o;
+}
+class Ko {
+  maxListeners = 20;
+  warnOnce = !1;
+  events = {};
+  on(e, n, o = {}) {
+    let r = this.events[e];
+    if (r || (r = {
+      highPriority: /* @__PURE__ */ new Map(),
+      regular: /* @__PURE__ */ new Map()
+    }, this.events[e] = r), o.isFirst ? r.highPriority.set(n, !0) : r.regular.set(n, !0), process.env.NODE_ENV !== "production") {
+      const s = r.highPriority.size + r.regular.size;
+      s > this.maxListeners && !this.warnOnce && (this.warnOnce = !0, console.warn([`Possible EventEmitter memory leak detected. ${s} ${e} listeners added.`].join(`
+`)));
+    }
+  }
+  removeListener(e, n) {
+    this.events[e] && (this.events[e].regular.delete(n), this.events[e].highPriority.delete(n));
+  }
+  removeAllListeners() {
+    this.events = {};
+  }
+  emit(e, ...n) {
+    const o = this.events[e];
+    if (!o)
+      return;
+    const r = Array.from(o.highPriority.keys()), s = Array.from(o.regular.keys());
+    for (let l = r.length - 1; l >= 0; l -= 1) {
+      const a = r[l];
+      o.highPriority.has(a) && a.apply(this, n);
+    }
+    for (let l = 0; l < s.length; l += 1) {
+      const a = s[l];
+      o.regular.has(a) && a.apply(this, n);
+    }
+  }
+  once(e, n) {
+    const o = this;
+    this.on(e, function r(...s) {
+      o.removeListener(e, r), n.apply(o, s);
+    });
+  }
+}
+const Uo = ({
+  isItemEditable: t,
+  expansionTrigger: e
+}) => e || (t ? "iconContainer" : "content");
+function on(t) {
+  return {
+    disabledItemsFocusable: t.disabledItemsFocusable ?? !1,
+    domStructure: "nested",
+    itemChildrenIndentation: t.itemChildrenIndentation ?? "12px",
+    providedTreeId: t.id,
+    // TODO: Fix
+    expansionTrigger: Uo({
+      isItemEditable: t.isItemEditable,
+      expansionTrigger: t.expansionTrigger
+    }),
+    disableSelection: t.disableSelection ?? !1,
+    multiSelect: t.multiSelect ?? !1,
+    checkboxSelection: t.checkboxSelection ?? !1,
+    selectionPropagation: t.selectionPropagation ?? ye
+  };
+}
+function zt(t, e, n) {
+  return t !== void 0 ? t : e !== void 0 ? e : n;
+}
+function Ho(t) {
+  return S({
+    treeId: void 0,
+    focusedItemId: null
+  }, on(t), De.buildItemsStateIfNeeded(t), {
+    expandedItems: zt(t.expandedItems, t.defaultExpandedItems, []),
+    selectedItems: zt(t.selectedItems, t.defaultSelectedItems, t.multiSelect ? tt : null)
+  });
+}
+let jt = 0;
+const qo = () => (jt += 1, `mui-tree-view-${jt}`);
+class Go {
+  timeoutIds = /* @__PURE__ */ new Map();
+  intervalIds = /* @__PURE__ */ new Map();
+  startTimeout = (e, n, o) => {
+    this.clearTimeout(e);
+    const r = setTimeout(() => {
+      this.timeoutIds.delete(e), o();
+    }, n);
+    this.timeoutIds.set(e, r);
+  };
+  startInterval = (e, n, o) => {
+    this.clearTimeout(e);
+    const r = setInterval(o, n);
+    this.intervalIds.set(e, r);
+  };
+  clearTimeout = (e) => {
+    const n = this.timeoutIds.get(e);
+    n != null && (clearTimeout(n), this.timeoutIds.delete(e));
+  };
+  clearInterval = (e) => {
+    const n = this.intervalIds.get(e);
+    n != null && (clearInterval(n), this.intervalIds.delete(e));
+  };
+  clearAll = () => {
+    this.timeoutIds.forEach(clearTimeout), this.timeoutIds.clear(), this.intervalIds.forEach(clearInterval), this.intervalIds.clear();
+  };
+}
+class Xo {
+  // We can't type `store`, otherwise we get the following TS error:
+  // 'expansion' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
+  constructor(e) {
+    this.store = e;
+  }
+  setExpandedItems = (e, n) => {
+    this.store.parameters.expandedItems === void 0 && this.store.set("expandedItems", n), this.store.parameters.onExpandedItemsChange?.(e, n);
+  };
+  /**
+   * Check if an item is expanded.
+   * @param {TreeViewItemId} itemId The id of the item to check.
+   * @returns {boolean} `true` if the item is expanded, `false` otherwise.
+   */
+  isItemExpanded = (e) => H.isItemExpanded(this.store.state, e);
+  buildPublicAPI = () => ({
+    isItemExpanded: this.isItemExpanded,
+    setItemExpansion: this.setItemExpansion
+  });
+  /**
+   * Change the expansion status of a given item.
+   * @param {object} parameters The parameters of the method.
+   * @param {TreeViewItemId} parameters.itemId The id of the item to expand of collapse.
+   * @param {React.SyntheticEvent} parameters.event The DOM event that triggered the change.
+   * @param {boolean} parameters.shouldBeExpanded If `true` the item will be expanded. If `false` the item will be collapsed. If not defined, the item's expansion status will be the toggled.
+   */
+  setItemExpansion = ({
+    itemId: e,
+    event: n = null,
+    shouldBeExpanded: o
+  }) => {
+    const r = H.isItemExpanded(this.store.state, e), s = o ?? !r;
+    if (r === s)
+      return;
+    const l = {
+      isExpansionPrevented: !1,
+      shouldBeExpanded: s,
+      itemId: e
+    };
+    this.store.publishEvent("beforeItemToggleExpansion", l, n), !l.isExpansionPrevented && this.applyItemExpansion({
+      itemId: e,
+      event: n,
+      shouldBeExpanded: s
+    });
+  };
+  /**
+   * Apply the new expansion status of a given item.
+   * Is used by the `setItemExpansion` method and by the `useTreeViewLazyLoading` plugin.
+   * Unlike `setItemExpansion`, this method does not trigger the lazy loading.
+   * @param {object} parameters The parameters of the method.
+   * @param {TreeViewItemId} parameters.itemId The id of the item to expand of collapse.
+   * @param {React.SyntheticEvent | null} parameters.event The DOM event that triggered the change.
+   * @param {boolean} parameters.shouldBeExpanded If `true` the item will be expanded. If `false` the item will be collapsed.
+   */
+  applyItemExpansion = ({
+    itemId: e,
+    event: n,
+    shouldBeExpanded: o
+  }) => {
+    const r = H.expandedItemsRaw(this.store.state);
+    let s;
+    o ? s = [e].concat(r) : s = r.filter((l) => l !== e), this.store.parameters.onItemExpansionToggle?.(n, e, o), this.setExpandedItems(n, s);
+  };
+  /**
+   * Expand all the siblings (i.e.: the items that have the same parent) of a given item.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item whose siblings will be expanded.
+   */
+  expandAllSiblings = (e, n) => {
+    const o = y.itemMeta(this.store.state, n);
+    if (o == null)
+      return;
+    const s = y.itemOrderedChildrenIds(this.store.state, o.parentId).filter((a) => H.isItemExpandable(this.store.state, a) && !H.isItemExpanded(this.store.state, a)), l = H.expandedItemsRaw(this.store.state).concat(s);
+    s.length > 0 && (this.store.parameters.onItemExpansionToggle && s.forEach((a) => {
+      this.store.parameters.onItemExpansionToggle(e, a, !0);
+    }), this.setExpandedItems(e, l));
+  };
+  /**
+   * Mark a list of items as expandable.
+   * @param {TreeViewItemId[]} items The ids of the items to mark as expandable.
+   */
+  addExpandableItems = (e) => {
+    const n = S({}, this.store.state.itemMetaLookup);
+    for (const o of e)
+      n[o] = S({}, n[o], {
+        expandable: !0
+      });
+    this.store.set("itemMetaLookup", n);
+  };
+}
+const me = {
+  /**
+   * Checks whether an item is editable.
+   */
+  isItemEditable: P((t) => t.isItemEditable, y.itemModel, (t, e, n) => !e || t == null ? !1 : typeof t == "boolean" ? t : t(e)),
+  /**
+   * Checks whether an item is being edited.
+   */
+  isItemBeingEdited: P((t, e) => e == null ? !1 : t.editedItemId === e),
+  /**
+   * Checks whether any item is being edited.
+   */
+  isAnyItemBeingEdited: P((t) => !!t.editedItemId)
+}, Jo = 500;
+class Qo {
+  typeaheadQuery = "";
+  // We can't type `store`, otherwise we get the following TS error:
+  // 'keyboardNavigation' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
+  constructor(e) {
+    this.store = e, this.labelMap = $t(y.itemMetaLookup(this.store.state)), this.store.registerStoreEffect(y.itemMetaLookup, (n, o) => {
+      this.store.shouldIgnoreItemsStateUpdate() || (this.labelMap = $t(o));
+    });
+  }
+  canToggleItemSelection = (e) => N.canItemBeSelected(this.store.state, e);
+  canToggleItemExpansion = (e) => !y.isItemDisabled(this.store.state, e) && H.isItemExpandable(this.store.state, e);
+  getFirstItemMatchingTypeaheadQuery = (e, n) => {
+    const o = (d) => {
+      const c = _e(this.store.state, d);
+      return c === null ? ze(this.store.state) : c;
+    }, r = (d) => {
+      let c = null;
+      const p = {};
+      let f = d.length > 1 ? e : o(e);
+      for (; c == null && !p[f]; )
+        this.labelMap[f]?.startsWith(d) ? c = f : (p[f] = !0, f = o(f));
+      return c;
+    }, s = n.toLowerCase(), l = `${this.typeaheadQuery}${s}`, a = r(l);
+    if (a != null)
+      return this.typeaheadQuery = l, a;
+    const h = r(s);
+    return h != null ? (this.typeaheadQuery = s, h) : (this.typeaheadQuery = "", null);
+  };
+  /**
+   * Updates the `labelMap` to add/remove the first character of some item's labels.
+   * This map is used to navigate the tree using type-ahead search.
+   * This method is only used by the `useTreeViewJSXItems` plugin, otherwise the updates are handled internally.
+   * @param {(map: TreeViewLabelMap) => TreeViewLabelMap} updater The function to update the map.
+   */
+  updateLabelMap = (e) => {
+    this.labelMap = e(this.labelMap);
+  };
+  // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
+  /**
+   * Callback fired when a key is pressed on an item.
+   * Handles all the keyboard navigation logic.
+   * @param {React.KeyboardEvent<HTMLElement> & TreeViewCancellableEvent} event The keyboard event that triggered the callback.
+   * @param {TreeViewItemId} itemId The id of the item that the event was triggered on.
+   */
+  handleItemKeyDown = async (e, n) => {
+    if (e.defaultMuiPrevented || e.altKey || ot(e.target, e.currentTarget))
+      return;
+    const o = e.ctrlKey || e.metaKey, r = e.key, s = N.isMultiSelectEnabled(this.store.state);
+    switch (!0) {
+      // Select the item when pressing "Space"
+      case (r === " " && this.canToggleItemSelection(n)): {
+        e.preventDefault(), s && e.shiftKey ? this.store.selection.expandSelectionRange(e, n) : this.store.selection.setItemSelection({
+          event: e,
+          itemId: n,
+          keepExistingSelection: s,
+          shouldBeSelected: void 0
+        });
+        break;
+      }
+      // If the focused item has children, we expand it.
+      // If the focused item has no children, we select it.
+      case r === "Enter": {
+        this.store.labelEditing?.setEditedItem && me.isItemEditable(this.store.state, n) && !me.isItemBeingEdited(this.store.state, n) ? this.store.labelEditing.setEditedItem(n) : this.canToggleItemExpansion(n) ? (this.store.expansion.setItemExpansion({
+          event: e,
+          itemId: n
+        }), e.preventDefault()) : this.canToggleItemSelection(n) && (s ? (e.preventDefault(), this.store.selection.setItemSelection({
+          event: e,
+          itemId: n,
+          keepExistingSelection: !0
+        })) : N.isItemSelected(this.store.state, n) || (this.store.selection.setItemSelection({
+          event: e,
+          itemId: n
+        }), e.preventDefault()));
+        break;
+      }
+      // Focus the next focusable item
+      case r === "ArrowDown": {
+        const l = _e(this.store.state, n);
+        l && (e.preventDefault(), this.store.focus.focusItem(e, l), s && e.shiftKey && this.canToggleItemSelection(l) && this.store.selection.selectItemFromArrowNavigation(e, n, l));
+        break;
+      }
+      // Focuses the previous focusable item
+      case r === "ArrowUp": {
+        const l = Zt(this.store.state, n);
+        l && (e.preventDefault(), this.store.focus.focusItem(e, l), s && e.shiftKey && this.canToggleItemSelection(l) && this.store.selection.selectItemFromArrowNavigation(e, n, l));
+        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 (r === "ArrowRight" && !this.store.parameters.isRtl || r === "ArrowLeft" && this.store.parameters.isRtl): {
+        if (o)
+          return;
+        if (H.isItemExpanded(this.store.state, n)) {
+          const l = _e(this.store.state, n);
+          l && (this.store.focus.focusItem(e, l), e.preventDefault());
+        } else this.canToggleItemExpansion(n) && (this.store.expansion.setItemExpansion({
+          event: e,
+          itemId: n
+        }), e.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 (r === "ArrowLeft" && !this.store.parameters.isRtl || r === "ArrowRight" && this.store.parameters.isRtl): {
+        if (o)
+          return;
+        if (this.canToggleItemExpansion(n) && H.isItemExpanded(this.store.state, n))
+          this.store.expansion.setItemExpansion({
+            event: e,
+            itemId: n
+          }), e.preventDefault();
+        else {
+          const l = y.itemParentId(this.store.state, n);
+          l && (this.store.focus.focusItem(e, l), e.preventDefault());
+        }
+        break;
+      }
+      // Focuses the first item in the tree
+      case r === "Home": {
+        this.canToggleItemSelection(n) && s && o && e.shiftKey ? this.store.selection.selectRangeFromStartToItem(e, n) : this.store.focus.focusItem(e, ze(this.store.state)), e.preventDefault();
+        break;
+      }
+      // Focuses the last item in the tree
+      case r === "End": {
+        this.canToggleItemSelection(n) && s && o && e.shiftKey ? this.store.selection.selectRangeFromItemToEnd(e, n) : this.store.focus.focusItem(e, en(this.store.state)), e.preventDefault();
+        break;
+      }
+      // Expand all siblings that are at the same level as the focused item
+      case r === "*": {
+        this.store.expansion.expandAllSiblings(e, n), e.preventDefault();
+        break;
+      }
+      // Multi select behavior when pressing Ctrl + a
+      // Selects all the items
+      case (String.fromCharCode(e.keyCode) === "A" && o && s && N.enabled(this.store.state)): {
+        this.store.selection.selectAllNavigableItems(e), e.preventDefault();
+        break;
+      }
+      // Type-ahead
+      case (!o && !e.shiftKey && Yo(r)): {
+        this.store.timeoutManager.clearTimeout("typeahead");
+        const l = this.getFirstItemMatchingTypeaheadQuery(n, r);
+        l != null ? (this.store.focus.focusItem(e, l), e.preventDefault()) : this.typeaheadQuery = "", this.store.timeoutManager.startTimeout("typeahead", Jo, () => {
+          this.typeaheadQuery = "";
+        });
+        break;
+      }
+    }
+  };
+}
+function Yo(t) {
+  return !!t && t.length === 1 && !!t.match(/\S/);
+}
+function $t(t) {
+  const e = {}, n = (o) => {
+    e[o.id] = o.label.toLowerCase();
+  };
+  return Object.values(t).forEach(n), e;
+}
+const Bt = Te(N.selectedItems, H.expandedItemsMap, y.itemMetaLookup, y.disabledItemFocusable, (t) => y.itemOrderedChildrenIds(t, null), (t, e, n, o, r) => {
+  const s = t.find((a) => {
+    if (!o && Ve(n, a))
+      return !1;
+    const h = n[a];
+    return h && (h.parentId == null || e.has(h.parentId));
+  });
+  if (s != null)
+    return s;
+  const l = r.find((a) => o || !Ve(n, a));
+  return l ?? null;
+}), de = {
+  /**
+   * Gets the item that should be sequentially focusable (usually with the Tab key).
+   * At any point in time, there is a single item that can be sequentially focused in the Tree View.
+   * This item is the first selected item (that is both visible and navigable), if any, or the first navigable item if no item is selected.
+   */
+  defaultFocusableItemId: Bt,
+  /**
+   * Checks whether an item is the default focusable item.
+   */
+  isItemTheDefaultFocusableItem: P(Bt, (t, e) => t === e),
+  /**
+   * Gets the id of the item that is currently focused.
+   */
+  focusedItemId: P((t) => t.focusedItemId),
+  /**
+   * Checks whether an item is focused.
+   */
+  isItemFocused: P((t, e) => t.focusedItemId === e)
+};
+class Zo {
+  // We can't type `store`, otherwise we get the following TS error:
+  // 'focus' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
+  constructor(e) {
+    this.store = e, this.store.registerStoreEffect(y.itemMetaLookup, () => {
+      const n = de.focusedItemId(e.state);
+      if (n == null || !!y.itemMeta(e.state, n))
+        return;
+      const r = de.defaultFocusableItemId(e.state);
+      if (r == null) {
+        this.setFocusedItemId(null);
+        return;
+      }
+      this.applyItemFocus(null, r);
+    });
+  }
+  setFocusedItemId = (e) => {
+    de.focusedItemId(this.store.state) !== e && this.store.set("focusedItemId", e);
+  };
+  applyItemFocus = (e, n) => {
+    this.store.items.getItemDOMElement(n)?.focus(), this.setFocusedItemId(n), this.store.parameters.onItemFocus?.(e, n);
+  };
+  buildPublicAPI = () => ({
+    focusItem: this.focusItem
+  });
+  /**
+   * Focus the item with the given id.
+   *
+   * If the item is the child of a collapsed item, then this method will do nothing.
+   * Make sure to expand the ancestors of the item before calling this method if needed.
+   * @param {React.SyntheticEvent | null} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item to focus.
+   */
+  focusItem = (e, n) => {
+    const o = y.itemMeta(this.store.state, n);
+    o && (o.parentId == null || H.isItemExpanded(this.store.state, o.parentId)) && this.applyItemFocus(e, n);
+  };
+  /**
+   * Remove the focus from the currently focused item (both from the internal state and the DOM).
+   */
+  removeFocusedItem = () => {
+    const e = de.focusedItemId(this.store.state);
+    if (e == null)
+      return;
+    if (y.itemMeta(this.store.state, e)) {
+      const o = this.store.items.getItemDOMElement(e);
+      o && o.blur();
+    }
+    this.setFocusedItemId(null);
+  };
+  /**
+   * Event handler to fire when the `root` slot of the Tree View is focused.
+   * @param {React.MouseEvent} event The DOM event that triggered the change.
+   */
+  handleRootFocus = (e) => {
+    if (e.defaultMuiPrevented)
+      return;
+    const n = de.defaultFocusableItemId(this.store.state);
+    e.target === e.currentTarget && n != null && this.applyItemFocus(e, n);
+  };
+  /**
+   * Event handler to fire when the `root` slot of the Tree View is blurred.
+   * @param {React.MouseEvent} event The DOM event that triggered the change.
+   */
+  handleRootBlur = (e) => {
+    e.defaultMuiPrevented || this.setFocusedItemId(null);
+  };
+}
+class er {
+  itemPlugins = [];
+  itemWrappers = [];
+  register = (e, n) => {
+    this.itemPlugins.push(e), n && this.itemWrappers.push(n);
+  };
+  listPlugins = () => this.itemPlugins;
+  listWrappers = () => this.itemWrappers;
+}
+class tr extends dt {
+  initialParameters = null;
+  eventManager = new Ko();
+  timeoutManager = new Go();
+  itemPluginManager = new er();
+  constructor(e, n, o) {
+    const r = Ho(e), s = o.getInitialState(r, e);
+    super(s), this.parameters = e, this.instanceName = n, this.mapper = o, this.items = new De(this), this.focus = new Zo(this), this.expansion = new Xo(this), this.selection = new No(this), this.keyboardNavigation = new Qo(this), process.env.NODE_ENV !== "production" && (this.initialParameters = e);
+  }
+  /**
+   * Builds an object containing the method that should be exposed publicly by the Tree View components.
+   */
+  buildPublicAPI() {
+    return S({}, this.items.buildPublicAPI(), this.focus.buildPublicAPI(), this.expansion.buildPublicAPI(), this.selection.buildPublicAPI());
+  }
+  /**
+   * Updates the state of the Tree View based on the new parameters provided to the root component.
+   */
+  updateStateFromParameters(e) {
+    const n = (s, l, a) => {
+      if (e[l] !== void 0 && (s[l] = e[l]), process.env.NODE_ENV !== "production") {
+        const h = e[a], d = e[l] !== void 0, c = this.initialParameters?.[a], p = this.initialParameters?.[l] !== void 0;
+        p !== d ? et([`MUI X Tree View: A component is changing the ${p ? "" : "un"}controlled ${l} state of ${this.instanceName} to be ${p ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${l} 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"], "error") : JSON.stringify(c) !== JSON.stringify(h) && et([`MUI X Tree View: A component is changing the default ${l} state of an uncontrolled ${this.instanceName} after being initialized. `, `To suppress this warning opt to use a controlled ${this.instanceName}.`], "error");
+      }
+    }, o = on(e);
+    n(o, "expandedItems", "defaultExpandedItems"), n(o, "selectedItems", "defaultSelectedItems"), (this.state.providedTreeId !== e.id || this.state.treeId === void 0) && (o.treeId = qo()), !this.mapper.shouldIgnoreItemsStateUpdate(e) && De.shouldRebuildItemsState(e, this.parameters) && Object.assign(o, De.buildItemsStateIfNeeded(e));
+    const r = this.mapper.updateStateFromParameters(o, e, n);
+    this.update(r), this.parameters = e;
+  }
+  /**
+   * Returns a cleanup function that need to be called when the store is destroyed.
+   */
+  disposeEffect = () => this.timeoutManager.clearAll;
+  /**
+   * Whether updates based on `props.items` change should be ignored.
+   */
+  shouldIgnoreItemsStateUpdate = () => this.mapper.shouldIgnoreItemsStateUpdate(this.parameters);
+  /**
+   * Registers an effect to be run when the value returned by the selector changes.
+   */
+  registerStoreEffect = (e, n) => {
+    let o = e(this.state);
+    this.subscribe((r) => {
+      const s = e(r);
+      s !== o && (n(o, s), o = s);
+    });
+  };
+  /**
+   * Publishes an event to all its subscribers.
+   */
+  publishEvent = (e, n, o) => {
+    nr(o) && o.isPropagationStopped() || this.eventManager.emit(e, n, o);
+  };
+  /**
+   * Subscribe to an event emitted by the store.
+   * For now, the subscription is only removed when the store is destroyed.
+   */
+  subscribeEvent = (e, n) => {
+    this.eventManager.on(e, n);
+  };
+}
+function nr(t) {
+  return t.isPropagationStopped !== void 0;
+}
+const Wt = {
+  /**
+   * Checks if the lazy loaded state is empty.
+   */
+  isEmpty: P((t) => t.lazyLoadedItems == null ? !0 : Object.keys(t.lazyLoadedItems.loading).length === 0 && Object.keys(t.lazyLoadedItems.errors).length === 0),
+  /**
+   * Checks whether an item is loading.
+   */
+  isItemLoading: P((t, e) => t.lazyLoadedItems?.loading[e ?? se] ?? !1),
+  /**
+   * Checks whether an item has errors.
+   */
+  itemHasError: P((t, e) => !!t.lazyLoadedItems?.errors[e ?? se]),
+  /**
+   * Get an item error.
+   */
+  itemError: P((t, e) => t.lazyLoadedItems?.errors[e ?? se])
+}, ft = (t) => Array.isArray(t) ? t.length > 0 && t.some(ft) : !!t, or = ({
+  itemId: t,
+  children: e
+}) => {
+  const {
+    store: n,
+    publicAPI: o
+  } = be(), r = W(n, H.isItemExpandable, t), s = W(n, Wt.isItemLoading, t), l = W(n, Wt.itemHasError, t), a = ft(e) || r, h = W(n, H.isItemExpanded, t), d = W(n, de.isItemFocused, t), c = W(n, N.isItemSelected, t), p = W(n, y.isItemDisabled, t), f = W(n, me.isItemBeingEdited, t), u = W(n, me.isItemEditable, t), m = {
+    expandable: a,
+    expanded: h,
+    focused: d,
+    selected: c,
+    disabled: p,
+    editing: f,
+    editable: u,
+    loading: s,
+    error: l
+  }, I = (C) => {
+    if (m.disabled)
+      return;
+    m.focused || n.focus.focusItem(C, t);
+    const D = N.isMultiSelectEnabled(n.state) && (C.shiftKey || C.ctrlKey || C.metaKey);
+    m.expandable && !(D && H.isItemExpanded(n.state, t)) && n.expansion.setItemExpansion({
+      event: C,
+      itemId: t
+    });
+  }, b = (C) => {
+    if (!N.canItemBeSelected(n.state, t))
+      return;
+    !m.focused && !m.editing && n.focus.focusItem(C, t), N.isMultiSelectEnabled(n.state) && (C.shiftKey || C.ctrlKey || C.metaKey) ? C.shiftKey ? n.selection.expandSelectionRange(C, t) : n.selection.setItemSelection({
+      event: C,
+      itemId: t,
+      keepExistingSelection: !0
+    }) : n.selection.setItemSelection({
+      event: C,
+      itemId: t,
+      shouldBeSelected: !0
+    });
+  }, x = (C) => {
+    const D = C.nativeEvent.shiftKey, V = N.isMultiSelectEnabled(n.state);
+    V && D ? n.selection.expandSelectionRange(C, t) : n.selection.setItemSelection({
+      event: C,
+      itemId: t,
+      keepExistingSelection: V,
+      shouldBeSelected: C.target.checked
+    });
+  }, w = () => {
+    n.labelEditing && (f ? n.labelEditing.setEditedItem(null) : n.labelEditing.setEditedItem(t));
+  };
+  return {
+    interactions: {
+      handleExpansion: I,
+      handleSelection: b,
+      handleCheckboxSelection: x,
+      toggleItemEditing: w,
+      handleSaveItemLabel: (C, D) => {
+        n.labelEditing && me.isItemBeingEdited(n.state, t) && (n.labelEditing.updateItemLabel(t, D), w(), n.focus.focusItem(C, t));
+      },
+      handleCancelItemLabelEditing: (C) => {
+        n.labelEditing && me.isItemBeingEdited(n.state, t) && (w(), n.focus.focusItem(C, t));
+      }
+    },
+    status: m,
+    publicAPI: o
+  };
+}, rr = ({
+  props: t,
+  rootRef: e,
+  contentRef: n
+}) => {
+  const {
+    store: o
+  } = be(), {
+    children: r,
+    disabled: s = !1,
+    disableSelection: l = !1,
+    label: a,
+    itemId: h,
+    id: d
+  } = t, c = M.useContext(ut);
+  if (c == null)
+    throw new Error(["MUI X: Could not find the Tree View Children Item context.", "It looks like you rendered your component outside of a SimpleTreeView parent component.", "This can also happen if you are bundling multiple versions of the Tree View."].join(`
+`));
+  const {
+    registerChild: p,
+    unregisterChild: f,
+    parentId: u
+  } = c, m = ft(r), I = M.useRef(null), b = Ne(I, n), x = W(o, ke.treeItemIdAttribute, h, d);
+  return rt(() => (p(x, h), () => {
+    f(x), f(x);
+  }), [o, p, f, x, h]), rt(() => o.jsxItems.insertJSXItem({
+    id: h,
+    idAttribute: d,
+    parentId: u,
+    expandable: m,
+    disabled: s,
+    selectable: !l
+  }), [o, u, h, m, s, l, d]), M.useEffect(() => {
+    if (a)
+      return o.jsxItems.mapLabelFromJSX(h, (I.current?.textContent ?? "").toLowerCase());
+  }, [o, h, a]), {
+    contentRef: b,
+    rootRef: e
+  };
+}, rn = ({
+  children: t,
+  itemId: e,
+  idAttribute: n
+}) => {
+  const o = M.useContext(Ee);
+  return /* @__PURE__ */ v(pt, {
+    itemId: e,
+    idAttribute: n,
+    children: /* @__PURE__ */ v(Ee.Provider, {
+      value: o + 1,
+      children: t
+    })
+  });
+};
+process.env.NODE_ENV !== "production" && (rn.displayName = "jsxItemsitemWrapper");
+class sr {
+  constructor(e) {
+    this.store = e, e.itemPluginManager.register(rr, rn);
+  }
+  /**
+   * Insert a new item in the state from a Tree Item component.
+   * @param {TreeViewItemMeta} item The meta-information of the item to insert.
+   * @returns {() => void} A function to remove the item from the state.
+   */
+  insertJSXItem = (e) => {
+    if (this.store.state.itemMetaLookup[e.id] != null)
+      throw new Error(["MUI X: The Tree View component requires all items to have a unique `id` property.", "Alternatively, you can use the `getItemId` prop to specify a custom id for each item.", `Two items were provided with the same id in the \`items\` prop: "${e.id}"`].join(`
+`));
+    return this.store.update({
+      itemMetaLookup: S({}, this.store.state.itemMetaLookup, {
+        [e.id]: e
+      }),
+      // For Simple Tree View, we don't have a proper `item` object, so we create a very basic one.
+      itemModelLookup: S({}, this.store.state.itemModelLookup, {
+        [e.id]: {
+          id: e.id,
+          label: e.label ?? ""
+        }
+      })
+    }), () => {
+      const n = S({}, this.store.state.itemMetaLookup), o = S({}, this.store.state.itemModelLookup);
+      delete n[e.id], delete o[e.id], this.store.update({
+        itemMetaLookup: n,
+        itemModelLookup: o
+      });
+    };
+  };
+  /**
+   * Updates the `labelMap` to register the first character of the given item's label.
+   * This map is used to navigate the tree using type-ahead search.
+   * @param {TreeViewItemId} itemId The id of the item to map the label of.
+   * @param {string} label The item's label.
+   * @returns {() => void} A function to remove the item from the `labelMap`.
+   */
+  mapLabelFromJSX = (e, n) => (this.store.keyboardNavigation.updateLabelMap((o) => (o[e] = n, o)), () => {
+    this.store.keyboardNavigation.updateLabelMap((o) => {
+      const r = S({}, o);
+      return delete r[e], r;
+    });
+  });
+  /**
+   * Store the ids of a given item's children in the state.
+   * Those ids must be passed in the order they should be rendered.
+   * @param {TreeViewItemId | null} parentId The id of the item to store the children of.
+   * @param {TreeViewItemId[]} orderedChildrenIds The ids of the item's children.
+   */
+  setJSXItemsOrderedChildrenIds = (e, n) => {
+    const o = e ?? se;
+    this.store.update({
+      itemOrderedChildrenIdsLookup: S({}, this.store.state.itemOrderedChildrenIdsLookup, {
+        [o]: n
+      }),
+      itemChildrenIndexesLookup: S({}, this.store.state.itemChildrenIndexesLookup, {
+        [o]: Qt(n)
+      })
+    });
+  };
+}
+const ir = {
+  getInitialState: (t) => t,
+  updateStateFromParameters: (t) => t,
+  shouldIgnoreItemsStateUpdate: () => !0
+};
+class lr extends tr {
+  jsxItems = new sr(this);
+  constructor(e) {
+    super(S({}, e, {
+      items: tt
+    }), "SimpleTreeView", ir);
+  }
+  updateStateFromParameters(e) {
+    super.updateStateFromParameters(S({}, e, {
+      items: tt
+    }));
+  }
+}
+const ar = qt(), cr = (t) => {
+  const {
+    classes: e
+  } = t;
+  return M.useMemo(() => we({
+    root: ["root"],
+    item: ["item"],
+    itemContent: ["itemContent"],
+    itemGroupTransition: ["itemGroupTransition"],
+    itemIconContainer: ["itemIconContainer"],
+    itemLabel: ["itemLabel"],
+    // itemLabelInput: ['itemLabelInput'], => feature not available on this component
+    itemCheckbox: ["itemCheckbox"]
+    // itemDragAndDropOverlay: ['itemDragAndDropOverlay'], => feature not available on this component
+    // itemErrorIcon: ['itemErrorIcon'], => feature not available on this component
+  }, Un, e), [e]);
+}, dr = G("ul", {
+  name: "MuiSimpleTreeView",
+  slot: "Root"
+})({
+  padding: 0,
+  margin: 0,
+  listStyle: "none",
+  outline: 0,
+  position: "relative"
+}), ht = /* @__PURE__ */ M.forwardRef(function(e, n) {
+  const o = ar({
+    props: e,
+    name: "MuiSimpleTreeView"
+  });
+  process.env.NODE_ENV !== "production" && o.items != null && et(["MUI X: The Simple Tree View component does not support the `items` prop.", "If you want to add items, you need to pass them as JSX children.", "Check the documentation for more details: https://mui.com/x/react-tree-view/simple-tree-view/items/."]);
+  const {
+    slots: r,
+    slotProps: s,
+    apiRef: l,
+    parameters: a,
+    forwardedProps: h
+  } = Jn(o), d = Wo(lr, a), c = M.useRef(null), p = Ne(n, c), f = Vo(d, h, p), u = cr(o), m = r?.root ?? dr, I = te({
+    elementType: m,
+    externalSlotProps: s?.root,
+    className: u.root,
+    getSlotProps: f,
+    ownerState: o
+  });
+  return /* @__PURE__ */ v(Gn, {
+    store: d,
+    classes: u,
+    slots: r,
+    slotProps: s,
+    apiRef: l,
+    rootRef: c,
+    children: /* @__PURE__ */ v(pt, {
+      itemId: null,
+      idAttribute: null,
+      children: /* @__PURE__ */ v(Ee.Provider, {
+        value: 0,
+        children: /* @__PURE__ */ v(m, S({}, I))
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ht.displayName = "SimpleTreeView");
+process.env.NODE_ENV !== "production" && (ht.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 `useSimpleTreeViewApiRef()`.
+   */
+  apiRef: i.shape({
+    current: i.shape({
+      focusItem: i.func,
+      getItem: i.func,
+      getItemDOMElement: i.func,
+      getItemOrderedChildrenIds: i.func,
+      getItemTree: i.func,
+      getParentId: i.func,
+      isItemExpanded: i.func,
+      setIsItemDisabled: i.func,
+      setItemExpansion: i.func,
+      setItemSelection: i.func
+    })
+  }),
+  /**
+   * Whether the Tree View renders a checkbox at the left of its label that allows selecting it.
+   * @default false
+   */
+  checkboxSelection: i.bool,
+  /**
+   * The content of the component.
+   */
+  children: i.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: i.object,
+  className: i.string,
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is not controlled.
+   * @default []
+   */
+  defaultExpandedItems: i.arrayOf(i.string),
+  /**
+   * Selected item ids. (Uncontrolled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   * @default []
+   */
+  defaultSelectedItems: i.any,
+  /**
+   * Whether the items should be focusable when disabled.
+   * @default false
+   */
+  disabledItemsFocusable: i.bool,
+  /**
+   * Whether selection is disabled.
+   * @default false
+   */
+  disableSelection: i.bool,
+  /**
+   * Expanded item ids.
+   * Used when the item's expansion is controlled.
+   */
+  expandedItems: i.arrayOf(i.string),
+  /**
+   * The slot that triggers the item's expansion when clicked.
+   * @default 'content'
+   */
+  expansionTrigger: i.oneOf(["content", "iconContainer"]),
+  /**
+   * 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: i.string,
+  /**
+   * Horizontal indentation between an item and its children.
+   * Examples: 24, "24px", "2rem", "2em".
+   * @default 12px
+   */
+  itemChildrenIndentation: i.oneOfType([i.number, i.string]),
+  /**
+   * Whether multiple items can be selected.
+   * @default false
+   */
+  multiSelect: i.bool,
+  /**
+   * Callback fired when Tree Items are expanded/collapsed.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemExpansion()` method.
+   * @param {TreeViewItemId[]} itemIds The ids of the expanded items.
+   */
+  onExpandedItemsChange: i.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 {TreeViewItemId} itemId The id of the focused item.
+   */
+  onItemClick: i.func,
+  /**
+   * Callback fired when a Tree Item is expanded or collapsed.
+   * @param {React.SyntheticEvent | null} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemExpansion()` method.
+   * @param {TreeViewItemId} itemId The itemId of the modified item.
+   * @param {boolean} isExpanded `true` if the item has just been expanded, `false` if it has just been collapsed.
+   */
+  onItemExpansionToggle: i.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 {TreeViewItemId} itemId The id of the focused item.
+   */
+  onItemFocus: i.func,
+  /**
+   * Callback fired when a Tree Item is selected or deselected.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemSelection()` method.
+   * @param {TreeViewItemId} itemId The itemId of the modified item.
+   * @param {boolean} isSelected `true` if the item has just been selected, `false` if it has just been deselected.
+   */
+  onItemSelectionToggle: i.func,
+  /**
+   * Callback fired when Tree Items are selected/deselected.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemSelection()` method.
+   * @param {TreeViewItemId[] | TreeViewItemId} itemIds The ids of the selected items.
+   * When `multiSelect` is `true`, this is an array of strings; when false (default) a string.
+   */
+  onSelectedItemsChange: i.func,
+  /**
+   * Selected item ids. (Controlled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   */
+  selectedItems: i.any,
+  /**
+   * When `selectionPropagation.descendants` is set to `true`.
+   *
+   * - Selecting a parent selects all its descendants automatically.
+   * - Deselecting a parent deselects all its descendants automatically.
+   *
+   * When `selectionPropagation.parents` is set to `true`.
+   *
+   * - Selecting all the descendants of a parent selects the parent automatically.
+   * - Deselecting a descendant of a selected parent deselects the parent automatically.
+   *
+   * Only works when `multiSelect` is `true`.
+   * On the <SimpleTreeView />, only the expanded items are considered (since the collapsed item are not passed to the Tree View component at all)
+   *
+   * @default { parents: false, descendants: false }
+   */
+  selectionPropagation: i.shape({
+    descendants: i.bool,
+    parents: i.bool
+  }),
+  /**
+   * The props used for each component slot.
+   */
+  slotProps: i.object,
+  /**
+   * Overridable component slots.
+   */
+  slots: i.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: i.oneOfType([i.arrayOf(i.oneOfType([i.func, i.object, i.bool])), i.func, i.object])
+});
+function ur(t) {
+  return Ce("MuiCollapse", t);
+}
+ve("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const pr = (t) => {
+  const {
+    orientation: e,
+    classes: n
+  } = t, o = {
+    root: ["root", `${e}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${e}`],
+    wrapperInner: ["wrapperInner", `${e}`]
+  };
+  return we(o, ur, n);
+}, fr = G("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (t, e) => {
+    const {
+      ownerState: n
+    } = t;
+    return [e.root, e[n.orientation], n.state === "entered" && e.entered, n.state === "exited" && !n.in && n.collapsedSize === "0px" && e.hidden];
+  }
+})(Ut(({
+  theme: t
+}) => ({
+  height: 0,
+  overflow: "hidden",
+  transition: t.transitions.create("height"),
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      height: "auto",
+      width: 0,
+      transition: t.transitions.create("width")
+    }
+  }, {
+    props: {
+      state: "entered"
+    },
+    style: {
+      height: "auto",
+      overflow: "visible"
+    }
+  }, {
+    props: {
+      state: "entered",
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto"
+    }
+  }, {
+    props: ({
+      ownerState: e
+    }) => e.state === "exited" && !e.in && e.collapsedSize === "0px",
+    style: {
+      visibility: "hidden"
+    }
+  }]
+}))), hr = G("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper"
+})({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto",
+      height: "100%"
+    }
+  }]
+}), mr = G("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner"
+})({
+  width: "100%",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto",
+      height: "100%"
+    }
+  }]
+}), je = /* @__PURE__ */ M.forwardRef(function(e, n) {
+  const o = Kt({
+    props: e,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: r,
+    children: s,
+    className: l,
+    collapsedSize: a = "0px",
+    component: h,
+    easing: d,
+    in: c,
+    onEnter: p,
+    onEntered: f,
+    onEntering: u,
+    onExit: m,
+    onExited: I,
+    onExiting: b,
+    orientation: x = "vertical",
+    slots: w = {},
+    slotProps: _ = {},
+    style: R,
+    timeout: F = Rn.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: C = Dn,
+    ...D
+  } = o, V = {
+    ...o,
+    orientation: x,
+    collapsedSize: a
+  }, j = pr(V), E = _n(), k = Tn(), O = M.useRef(null), A = M.useRef(), L = typeof a == "number" ? `${a}px` : a, $ = x === "horizontal", B = $ ? "width" : "height", J = M.useRef(null), Z = kn(n, J), q = (z) => (ne) => {
+    if (z) {
+      const oe = J.current;
+      ne === void 0 ? z(oe) : z(oe, ne);
+    }
+  }, ie = () => O.current ? O.current[$ ? "clientWidth" : "clientHeight"] : 0, ae = q((z, ne) => {
+    O.current && $ && (O.current.style.position = "absolute"), z.style[B] = L, p && p(z, ne);
+  }), ue = q((z, ne) => {
+    const oe = ie();
+    O.current && $ && (O.current.style.position = "");
+    const {
+      duration: le,
+      easing: Me
+    } = Et({
+      style: R,
+      timeout: F,
+      easing: d
+    }, {
+      mode: "enter"
+    });
+    if (F === "auto") {
+      const It = E.transitions.getAutoHeightDuration(oe);
+      z.style.transitionDuration = `${It}ms`, A.current = It;
+    } else
+      z.style.transitionDuration = typeof le == "string" ? le : `${le}ms`;
+    z.style[B] = `${oe}px`, z.style.transitionTimingFunction = Me, u && u(z, ne);
+  }), ce = q((z, ne) => {
+    z.style[B] = "auto", f && f(z, ne);
+  }), pe = q((z) => {
+    z.style[B] = `${ie()}px`, m && m(z);
+  }), K = q(I), X = q((z) => {
+    const ne = ie(), {
+      duration: oe,
+      easing: le
+    } = Et({
+      style: R,
+      timeout: F,
+      easing: d
+    }, {
+      mode: "exit"
+    });
+    if (F === "auto") {
+      const Me = E.transitions.getAutoHeightDuration(ne);
+      z.style.transitionDuration = `${Me}ms`, A.current = Me;
+    } else
+      z.style.transitionDuration = typeof oe == "string" ? oe : `${oe}ms`;
+    z.style[B] = L, z.style.transitionTimingFunction = le, b && b(z);
+  }), T = (z) => {
+    F === "auto" && k.start(A.current || 0, z), r && r(J.current, z);
+  }, g = {
+    slots: w,
+    slotProps: _,
+    component: h
+  }, [U, ee] = Ie("root", {
+    ref: Z,
+    className: Q(j.root, l),
+    elementType: fr,
+    externalForwardedProps: g,
+    ownerState: V,
+    additionalProps: {
+      style: {
+        [$ ? "minWidth" : "minHeight"]: L,
+        ...R
+      }
+    }
+  }), [Oe, pn] = Ie("wrapper", {
+    ref: O,
+    className: j.wrapper,
+    elementType: hr,
+    externalForwardedProps: g,
+    ownerState: V
+  }), [fn, hn] = Ie("wrapperInner", {
+    className: j.wrapperInner,
+    elementType: mr,
+    externalForwardedProps: g,
+    ownerState: V
+  });
+  return /* @__PURE__ */ v(C, {
+    in: c,
+    onEnter: ae,
+    onEntered: ce,
+    onEntering: ue,
+    onExit: pe,
+    onExited: K,
+    onExiting: X,
+    addEndListener: T,
+    nodeRef: J,
+    timeout: F === "auto" ? null : F,
+    ...D,
+    children: (z, {
+      ownerState: ne,
+      ...oe
+    }) => {
+      const le = {
+        ...V,
+        state: z
+      };
+      return /* @__PURE__ */ v(U, {
+        ...ee,
+        className: Q(ee.className, {
+          entered: j.entered,
+          exited: !c && L === "0px" && j.hidden
+        }[z]),
+        ownerState: le,
+        ...oe,
+        children: /* @__PURE__ */ v(Oe, {
+          ...pn,
+          ownerState: le,
+          children: /* @__PURE__ */ v(fn, {
+            ...hn,
+            ownerState: le,
+            children: s
+          })
+        })
+      });
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (je.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: i.func,
+  /**
+   * The content node to be collapsed.
+   */
+  children: i.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: i.object,
+  /**
+   * @ignore
+   */
+  className: i.string,
+  /**
+   * The width (horizontal) or height (vertical) of the container when collapsed.
+   * @default '0px'
+   */
+  collapsedSize: i.oneOfType([i.number, i.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: On,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: i.oneOfType([i.shape({
+    enter: i.string,
+    exit: i.string
+  }), i.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: i.bool,
+  /**
+   * @ignore
+   */
+  onEnter: i.func,
+  /**
+   * @ignore
+   */
+  onEntered: i.func,
+  /**
+   * @ignore
+   */
+  onEntering: i.func,
+  /**
+   * @ignore
+   */
+  onExit: i.func,
+  /**
+   * @ignore
+   */
+  onExited: i.func,
+  /**
+   * @ignore
+   */
+  onExiting: i.func,
+  /**
+   * The transition orientation.
+   * @default 'vertical'
+   */
+  orientation: i.oneOf(["horizontal", "vertical"]),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: i.shape({
+    root: i.oneOfType([i.func, i.object]),
+    wrapper: i.oneOfType([i.func, i.object]),
+    wrapperInner: i.oneOfType([i.func, i.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: i.shape({
+    root: i.elementType,
+    wrapper: i.elementType,
+    wrapperInner: i.elementType
+  }),
+  /**
+   * @ignore
+   */
+  style: i.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: i.oneOfType([i.arrayOf(i.oneOfType([i.func, i.object, i.bool])), i.func, i.object]),
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   *
+   * Set to 'auto' to automatically calculate transition time based on height.
+   * @default duration.standard
+   */
+  timeout: i.oneOfType([i.oneOf(["auto"]), i.number, i.shape({
+    appear: i.number,
+    enter: i.number,
+    exit: i.number
+  })])
+});
+je && (je.muiSupportAuto = !0);
+function Ir(t) {
+  return Ce("PrivateSwitchBase", t);
+}
+ve("PrivateSwitchBase", ["root", "checked", "disabled", "input", "edgeStart", "edgeEnd"]);
+const gr = (t) => {
+  const {
+    classes: e,
+    checked: n,
+    disabled: o,
+    edge: r
+  } = t, s = {
+    root: ["root", n && "checked", o && "disabled", r && `edge${xe(r)}`],
+    input: ["input"]
+  };
+  return we(s, Ir, e);
+}, br = G(Mn, {
+  name: "MuiSwitchBase"
+})({
+  padding: 9,
+  borderRadius: "50%",
+  variants: [{
+    props: {
+      edge: "start",
+      size: "small"
+    },
+    style: {
+      marginLeft: -3
+    }
+  }, {
+    props: ({
+      edge: t,
+      ownerState: e
+    }) => t === "start" && e.size !== "small",
+    style: {
+      marginLeft: -12
+    }
+  }, {
+    props: {
+      edge: "end",
+      size: "small"
+    },
+    style: {
+      marginRight: -3
+    }
+  }, {
+    props: ({
+      edge: t,
+      ownerState: e
+    }) => t === "end" && e.size !== "small",
+    style: {
+      marginRight: -12
+    }
+  }]
+}), Sr = G("input", {
+  name: "MuiSwitchBase",
+  shouldForwardProp: Ht
+})({
+  cursor: "inherit",
+  position: "absolute",
+  opacity: 0,
+  width: "100%",
+  height: "100%",
+  top: 0,
+  left: 0,
+  margin: 0,
+  padding: 0,
+  zIndex: 1
+}), sn = /* @__PURE__ */ M.forwardRef(function(e, n) {
+  const {
+    autoFocus: o,
+    checked: r,
+    checkedIcon: s,
+    defaultChecked: l,
+    disabled: a,
+    disableFocusRipple: h = !1,
+    edge: d = !1,
+    icon: c,
+    id: p,
+    inputProps: f,
+    inputRef: u,
+    name: m,
+    onBlur: I,
+    onChange: b,
+    onFocus: x,
+    readOnly: w,
+    required: _ = !1,
+    tabIndex: R,
+    type: F,
+    value: C,
+    slots: D = {},
+    slotProps: V = {},
+    ...j
+  } = e, [E, k] = zn({
+    controlled: r,
+    default: !!l,
+    name: "SwitchBase",
+    state: "checked"
+  }), O = An(), A = (K) => {
+    x && x(K), O && O.onFocus && O.onFocus(K);
+  }, L = (K) => {
+    I && I(K), O && O.onBlur && O.onBlur(K);
+  }, $ = (K) => {
+    if (K.nativeEvent.defaultPrevented || w)
+      return;
+    const X = K.target.checked;
+    k(X), b && b(K, X);
+  };
+  let B = a;
+  O && typeof B > "u" && (B = O.disabled);
+  const J = F === "checkbox" || F === "radio", Z = {
+    ...e,
+    checked: E,
+    disabled: B,
+    disableFocusRipple: h,
+    edge: d
+  }, q = gr(Z), ie = {
+    slots: D,
+    slotProps: {
+      input: f,
+      ...V
+    }
+  }, [ae, ue] = Ie("root", {
+    ref: n,
+    elementType: br,
+    className: q.root,
+    shouldForwardComponentProp: !0,
+    externalForwardedProps: {
+      ...ie,
+      component: "span",
+      ...j
+    },
+    getSlotProps: (K) => ({
+      ...K,
+      onFocus: (X) => {
+        K.onFocus?.(X), A(X);
+      },
+      onBlur: (X) => {
+        K.onBlur?.(X), L(X);
+      }
+    }),
+    ownerState: Z,
+    additionalProps: {
+      centerRipple: !0,
+      focusRipple: !h,
+      disabled: B,
+      role: void 0,
+      tabIndex: null
+    }
+  }), [ce, pe] = Ie("input", {
+    ref: u,
+    elementType: Sr,
+    className: q.input,
+    externalForwardedProps: ie,
+    getSlotProps: (K) => ({
+      ...K,
+      onChange: (X) => {
+        K.onChange?.(X), $(X);
+      }
+    }),
+    ownerState: Z,
+    additionalProps: {
+      autoFocus: o,
+      checked: r,
+      defaultChecked: l,
+      disabled: B,
+      id: J ? p : void 0,
+      name: m,
+      readOnly: w,
+      required: _,
+      tabIndex: R,
+      type: F,
+      ...F === "checkbox" && C === void 0 ? {} : {
+        value: C
+      }
+    }
+  });
+  return /* @__PURE__ */ Y(ae, {
+    ...ue,
+    children: [/* @__PURE__ */ v(ce, {
+      ...pe
+    }), E ? s : c]
+  });
+});
+process.env.NODE_ENV !== "production" && (sn.propTypes = {
+  /**
+   * If `true`, the `input` element is focused during the first mount.
+   */
+  autoFocus: i.bool,
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: i.bool,
+  /**
+   * The icon to display when the component is checked.
+   */
+  checkedIcon: i.node.isRequired,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: i.object,
+  /**
+   * @ignore
+   */
+  className: i.string,
+  /**
+   * @ignore
+   */
+  defaultChecked: i.bool,
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: i.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: i.bool,
+  /**
+   * If given, uses a negative margin to counteract the padding on one
+   * side (this is often helpful for aligning the left or right
+   * side of the icon with content above or below, without ruining the border
+   * size and shape).
+   * @default false
+   */
+  edge: i.oneOf(["end", "start", !1]),
+  /**
+   * The icon to display when the component is unchecked.
+   */
+  icon: i.node.isRequired,
+  /**
+   * The id of the `input` element.
+   */
+  id: i.string,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#attributes) applied to the `input` element.
+   */
+  inputProps: i.object,
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef: Pn,
+  /*
+   * @ignore
+   */
+  name: i.string,
+  /**
+   * @ignore
+   */
+  onBlur: i.func,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {object} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: i.func,
+  /**
+   * @ignore
+   */
+  onFocus: i.func,
+  /**
+   * It prevents the user from changing the value of the field
+   * (not from interacting with the field).
+   */
+  readOnly: i.bool,
+  /**
+   * If `true`, the `input` element is required.
+   */
+  required: i.bool,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: i.shape({
+    input: i.oneOfType([i.func, i.object]),
+    root: i.oneOfType([i.func, i.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: i.shape({
+    input: i.elementType,
+    root: i.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: i.object,
+  /**
+   * @ignore
+   */
+  tabIndex: i.oneOfType([i.number, i.string]),
+  /**
+   * The input component prop `type`.
+   */
+  type: i.string.isRequired,
+  /**
+   * The value of the component.
+   */
+  value: i.any
+});
+const yr = ge(/* @__PURE__ */ v("path", {
+  d: "M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"
+}), "CheckBoxOutlineBlank"), xr = ge(/* @__PURE__ */ v("path", {
+  d: "M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"
+}), "CheckBox"), Er = ge(/* @__PURE__ */ v("path", {
+  d: "M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"
+}), "IndeterminateCheckBox");
+function Cr(t) {
+  return Ce("MuiCheckbox", t);
+}
+const Ye = ve("MuiCheckbox", ["root", "checked", "disabled", "indeterminate", "colorPrimary", "colorSecondary", "sizeSmall", "sizeMedium"]), vr = (t) => {
+  const {
+    classes: e,
+    indeterminate: n,
+    color: o,
+    size: r
+  } = t, s = {
+    root: ["root", n && "indeterminate", `color${xe(o)}`, `size${xe(r)}`]
+  }, l = we(s, Cr, e);
+  return {
+    ...e,
+    // forward the disabled and checked classes to the SwitchBase
+    ...l
+  };
+}, wr = G(sn, {
+  shouldForwardProp: (t) => Ht(t) || t === "classes",
+  name: "MuiCheckbox",
+  slot: "Root",
+  overridesResolver: (t, e) => {
+    const {
+      ownerState: n
+    } = t;
+    return [e.root, n.indeterminate && e.indeterminate, e[`size${xe(n.size)}`], n.color !== "default" && e[`color${xe(n.color)}`]];
+  }
+})(Ut(({
+  theme: t
+}) => ({
+  color: (t.vars || t).palette.text.secondary,
+  variants: [{
+    props: {
+      color: "default",
+      disableRipple: !1
+    },
+    style: {
+      "&:hover": {
+        backgroundColor: t.alpha((t.vars || t).palette.action.active, (t.vars || t).palette.action.hoverOpacity)
+      }
+    }
+  }, ...Object.entries(t.palette).filter(vt()).map(([e]) => ({
+    props: {
+      color: e,
+      disableRipple: !1
+    },
+    style: {
+      "&:hover": {
+        backgroundColor: t.alpha((t.vars || t).palette[e].main, (t.vars || t).palette.action.hoverOpacity)
+      }
+    }
+  })), ...Object.entries(t.palette).filter(vt()).map(([e]) => ({
+    props: {
+      color: e
+    },
+    style: {
+      [`&.${Ye.checked}, &.${Ye.indeterminate}`]: {
+        color: (t.vars || t).palette[e].main
+      },
+      [`&.${Ye.disabled}`]: {
+        color: (t.vars || t).palette.action.disabled
+      }
+    }
+  })), {
+    // Should be last to override other colors
+    props: {
+      disableRipple: !1
+    },
+    style: {
+      // Reset on touch devices, it doesn't add specificity
+      "&:hover": {
+        "@media (hover: none)": {
+          backgroundColor: "transparent"
+        }
+      }
+    }
+  }]
+}))), Tr = /* @__PURE__ */ v(xr, {}), kr = /* @__PURE__ */ v(yr, {}), Or = /* @__PURE__ */ v(Er, {}), ln = /* @__PURE__ */ M.forwardRef(function(e, n) {
+  const o = Kt({
+    props: e,
+    name: "MuiCheckbox"
+  }), {
+    checkedIcon: r = Tr,
+    color: s = "primary",
+    icon: l = kr,
+    indeterminate: a = !1,
+    indeterminateIcon: h = Or,
+    inputProps: d,
+    size: c = "medium",
+    disableRipple: p = !1,
+    className: f,
+    slots: u = {},
+    slotProps: m = {},
+    ...I
+  } = o, b = a ? h : l, x = a ? h : r, w = {
+    ...o,
+    disableRipple: p,
+    color: s,
+    indeterminate: a,
+    size: c
+  }, _ = vr(w), R = m.input ?? d, [F, C] = Ie("root", {
+    ref: n,
+    elementType: wr,
+    className: Q(_.root, f),
+    shouldForwardComponentProp: !0,
+    externalForwardedProps: {
+      slots: u,
+      slotProps: m,
+      ...I
+    },
+    ownerState: w,
+    additionalProps: {
+      type: "checkbox",
+      icon: /* @__PURE__ */ M.cloneElement(b, {
+        fontSize: b.props.fontSize ?? c
+      }),
+      checkedIcon: /* @__PURE__ */ M.cloneElement(x, {
+        fontSize: x.props.fontSize ?? c
+      }),
+      disableRipple: p,
+      slots: u,
+      slotProps: {
+        input: Nn(typeof R == "function" ? R(w) : R, {
+          "data-indeterminate": a
+        })
+      }
+    }
+  });
+  return /* @__PURE__ */ v(F, {
+    ...C,
+    classes: _
+  });
+});
+process.env.NODE_ENV !== "production" && (ln.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * If `true`, the component is checked.
+   */
+  checked: i.bool,
+  /**
+   * The icon to display when the component is checked.
+   * @default <CheckBoxIcon />
+   */
+  checkedIcon: i.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: i.object,
+  /**
+   * @ignore
+   */
+  className: i.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: i.oneOfType([i.oneOf(["default", "primary", "secondary", "error", "info", "success", "warning"]), i.string]),
+  /**
+   * The default checked state. Use when the component is not controlled.
+   */
+  defaultChecked: i.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: i.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   * @default false
+   */
+  disableRipple: i.bool,
+  /**
+   * The icon to display when the component is unchecked.
+   * @default <CheckBoxOutlineBlankIcon />
+   */
+  icon: i.node,
+  /**
+   * The id of the `input` element.
+   */
+  id: i.string,
+  /**
+   * If `true`, the component appears indeterminate.
+   * This does not set the native input element to indeterminate due
+   * to inconsistent behavior across browsers.
+   * However, we set a `data-indeterminate` attribute on the `input`.
+   * @default false
+   */
+  indeterminate: i.bool,
+  /**
+   * The icon to display when the component is indeterminate.
+   * @default <IndeterminateCheckBoxIcon />
+   */
+  indeterminateIcon: i.node,
+  /**
+   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#attributes) applied to the `input` element.
+   * @deprecated Use `slotProps.input` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  inputProps: i.object,
+  /**
+   * Callback fired when the state is changed.
+   *
+   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
+   * You can pull out the new checked state by accessing `event.target.checked` (boolean).
+   */
+  onChange: i.func,
+  /**
+   * If `true`, the `input` element is required.
+   * @default false
+   */
+  required: i.bool,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense checkbox styling.
+   * @default 'medium'
+   */
+  size: i.oneOfType([i.oneOf(["medium", "small"]), i.string]),
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: i.shape({
+    input: i.oneOfType([i.func, i.object]),
+    root: i.oneOfType([i.func, i.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: i.shape({
+    input: i.elementType,
+    root: i.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: i.oneOfType([i.arrayOf(i.oneOfType([i.func, i.object, i.bool])), i.func, i.object]),
+  /**
+   * The value of the component. The DOM API casts this to a string.
+   * The browser uses "on" as the default value.
+   */
+  value: i.any
+});
+const Mr = (t, e, n) => typeof n == "function" ? n(t, e) : n, Pr = (t) => {
+  const {
+    runItemPlugins: e,
+    publicAPI: n,
+    store: o
+  } = be(), r = M.useContext(Ee), s = W(o, Mr, t.itemId, r), {
+    id: l,
+    itemId: a,
+    label: h,
+    children: d,
+    rootRef: c
+  } = t, {
+    rootRef: p,
+    contentRef: f,
+    propsEnhancers: u
+  } = e(t), {
+    interactions: m,
+    status: I
+  } = or({
+    itemId: a,
+    children: d
+  }), b = M.useRef(null), x = M.useRef(null), w = Ne(c, p, b), _ = Ne(f, x), R = M.useRef(null), F = W(o, N.isCheckboxSelectionEnabled), C = W(o, ke.treeItemIdAttribute, a, l), D = W(o, de.isItemTheDefaultFocusableItem, a), V = {
+    rootRefObject: b,
+    contentRefObject: x,
+    interactions: m
+  }, j = (T) => (g) => {
+    T.onFocus?.(g), !g.defaultMuiPrevented && !I.focused && y.canItemBeFocused(o.state, a) && g.currentTarget === g.target && o.focus.focusItem(g, a);
+  }, E = (T) => (g) => {
+    if (T.onBlur?.(g), g.defaultMuiPrevented)
+      return;
+    const U = o.items.getItemDOMElement(a);
+    I.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
+    g.relatedTarget && ot(g.relatedTarget, U) && (g.target && g.target?.dataset?.element === "labelInput" && ot(g.target, U) || g.relatedTarget?.dataset?.element === "labelInput") || o.focus.removeFocusedItem();
+  }, k = (T) => (g) => {
+    T.onKeyDown?.(g), !(g.defaultMuiPrevented || g.target?.dataset?.element === "labelInput") && o.keyboardNavigation.handleItemKeyDown(g, a);
+  }, O = (T) => (g) => {
+    T.onDoubleClick?.(g), !g.defaultMuiPrevented && m.toggleItemEditing();
+  }, A = (T) => (g) => {
+    T.onClick?.(g), o.items.handleItemClick(g, a), !(g.defaultMuiPrevented || R.current?.contains(g.target)) && (H.triggerSlot(o.state) === "content" && m.handleExpansion(g), F || m.handleSelection(g));
+  }, L = (T) => (g) => {
+    T.onMouseDown?.(g), !g.defaultMuiPrevented && (g.shiftKey || g.ctrlKey || g.metaKey || I.disabled) && g.preventDefault();
+  }, $ = (T) => (g) => {
+    T.onClick?.(g), !g.defaultMuiPrevented && H.triggerSlot(o.state) === "iconContainer" && m.handleExpansion(g);
+  };
+  return {
+    getContextProviderProps: () => ({
+      itemId: a,
+      id: l
+    }),
+    getRootProps: (T = {}) => {
+      const g = S({}, re(t), re(T)), U = S({}, g, {
+        ref: w,
+        role: "treeitem",
+        tabIndex: D ? 0 : -1,
+        id: C,
+        "aria-expanded": I.expandable ? I.expanded : void 0,
+        "aria-disabled": I.disabled || void 0
+      }, T, {
+        style: S({}, T.style ?? {}, {
+          "--TreeView-itemDepth": s
+        }),
+        onFocus: j(g),
+        onBlur: E(g),
+        onKeyDown: k(g)
+      }), ee = u.root?.(S({}, V, {
+        externalEventHandlers: g
+      })) ?? {};
+      return S({}, U, ee);
+    },
+    getContentProps: (T = {}) => {
+      const g = re(T), U = S({}, g, T, {
+        ref: _,
+        onClick: A(g),
+        onMouseDown: L(g),
+        status: I
+      });
+      ["expanded", "selected", "focused", "disabled", "editing", "editable"].forEach((Oe) => {
+        I[Oe] && (U[`data-${Oe}`] = "");
+      });
+      const ee = u.content?.(S({}, V, {
+        externalEventHandlers: g
+      })) ?? {};
+      return S({}, U, ee);
+    },
+    getGroupTransitionProps: (T = {}) => {
+      const g = re(T);
+      return S({}, g, {
+        unmountOnExit: !0,
+        component: "ul",
+        role: "group",
+        in: I.expanded,
+        children: d
+      }, T);
+    },
+    getIconContainerProps: (T = {}) => {
+      const g = re(T);
+      return S({}, g, T, {
+        onClick: $(g)
+      });
+    },
+    getCheckboxProps: (T = {}) => {
+      const g = re(T), U = S({}, g, {
+        ref: R,
+        "aria-hidden": !0
+      }, T), ee = u.checkbox?.(S({}, V, {
+        externalEventHandlers: g
+      })) ?? {};
+      return S({}, U, ee);
+    },
+    getLabelProps: (T = {}) => {
+      const g = S({}, re(T)), U = S({}, g, {
+        children: h
+      }, T, {
+        onDoubleClick: O(g)
+      }), ee = u.label?.(S({}, V, {
+        externalEventHandlers: g
+      })) ?? {};
+      return S({}, ee, U);
+    },
+    getLabelInputProps: (T = {}) => {
+      const g = re(T), U = u.labelInput?.(S({}, V, {
+        externalEventHandlers: g
+      })) ?? {};
+      return S({}, T, U);
+    },
+    getDragAndDropOverlayProps: (T = {}) => {
+      const g = re(T), U = u.dragAndDropOverlay?.(S({}, V, {
+        externalEventHandlers: g
+      })) ?? {};
+      return S({}, T, U);
+    },
+    getErrorContainerProps: (T = {}) => {
+      const g = re(T);
+      return S({}, g, T);
+    },
+    getLoadingContainerProps: (T = {}) => {
+      const g = re(T);
+      return S({
+        size: "12px",
+        thickness: 6
+      }, g, T);
+    },
+    rootRef: w,
+    status: I,
+    publicAPI: n
+  };
+};
+function Rr(t) {
+  return Ce("MuiTreeItem", t);
+}
+ve("MuiTreeItem", [
+  "root",
+  "content",
+  "groupTransition",
+  "iconContainer",
+  "label",
+  "checkbox",
+  "labelInput",
+  "dragAndDropOverlay",
+  "errorIcon",
+  "loadingIcon",
+  // State classes, will be replaced by data-attrs in the next major
+  "expanded",
+  "selected",
+  "focused",
+  "disabled",
+  "editable",
+  "editing"
+]);
+const Lr = ge(/* @__PURE__ */ v("path", {
+  d: "M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
+}), "TreeViewExpandIcon"), Dr = ge(/* @__PURE__ */ v("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), "TreeViewCollapseIcon"), _r = ["ownerState"];
+function Ze(t, e, n) {
+  return t !== void 0 ? t : e !== void 0 ? e : n;
+}
+function an(t) {
+  const {
+    slots: e,
+    slotProps: n,
+    status: o
+  } = t, {
+    slots: r,
+    slotProps: s
+  } = Gt(), l = {
+    collapseIcon: Ze(e?.collapseIcon, r.collapseIcon, Dr),
+    expandIcon: Ze(e?.expandIcon, r.expandIcon, Lr),
+    endIcon: Ze(e?.endIcon, r.endIcon),
+    icon: e?.icon
+  };
+  let a;
+  l?.icon ? a = "icon" : o.expandable ? o.expanded ? a = "collapseIcon" : a = "expandIcon" : a = "endIcon";
+  const h = l[a], d = te({
+    elementType: h,
+    externalSlotProps: (p) => S({}, Ct(s[a], p), Ct(n?.[a], p)),
+    // TODO: Add proper ownerState
+    ownerState: {}
+  }), c = Be(d, _r);
+  return h ? /* @__PURE__ */ v(h, S({}, c)) : null;
+}
+process.env.NODE_ENV !== "production" && (an.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: i.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: i.object,
+  status: i.shape({
+    disabled: i.bool.isRequired,
+    editable: i.bool.isRequired,
+    editing: i.bool.isRequired,
+    error: i.bool.isRequired,
+    expandable: i.bool.isRequired,
+    expanded: i.bool.isRequired,
+    focused: i.bool.isRequired,
+    loading: i.bool.isRequired,
+    selected: i.bool.isRequired
+  }).isRequired
+});
+const Ar = G("div", {
+  name: "MuiTreeItemDragAndDropOverlay",
+  slot: "Root",
+  shouldForwardProp: (t) => st(t) && t !== "action"
+})(({
+  theme: t
+}) => ({
+  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: t.shape.borderRadius,
+      backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.darkChannel} / ${t.vars.palette.action.focusOpacity})` : Se(t.palette.primary.dark, t.palette.action.focusOpacity)
+    }
+  }, {
+    props: {
+      action: "reorder-above"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderTop: `1px solid ${(t.vars || t).palette.action.active}`
+    }
+  }, {
+    props: {
+      action: "reorder-below"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * var(--TreeView-itemDepth))",
+      borderBottom: `1px solid ${(t.vars || t).palette.action.active}`
+    }
+  }, {
+    props: {
+      action: "move-to-parent"
+    },
+    style: {
+      marginLeft: "calc(var(--TreeView-indentMultiplier) * calc(var(--TreeView-itemDepth) - 1))",
+      borderBottom: `1px solid ${(t.vars || t).palette.action.active}`
+    }
+  }]
+}));
+function cn(t) {
+  return t.action == null ? null : /* @__PURE__ */ v(Ar, S({}, t));
+}
+process.env.NODE_ENV !== "production" && (cn.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  action: i.oneOf(["make-child", "move-to-parent", "reorder-above", "reorder-below"]),
+  style: i.object
+});
+function dn(t) {
+  const {
+    children: e,
+    itemId: n,
+    id: o
+  } = t, {
+    wrapItem: r,
+    store: s
+  } = be(), l = W(s, ke.treeItemIdAttribute, n, o);
+  return /* @__PURE__ */ v(M.Fragment, {
+    children: r({
+      children: e,
+      itemId: n,
+      store: s,
+      idAttribute: l
+    })
+  });
+}
+process.env.NODE_ENV !== "production" && (dn.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  children: i.node,
+  id: i.string,
+  itemId: i.string.isRequired
+});
+const Nr = G("input", {
+  name: "MuiTreeItem",
+  slot: "LabelInput"
+})(({
+  theme: t
+}) => S({}, t.typography.body1, {
+  width: "100%",
+  backgroundColor: (t.vars || t).palette.background.paper,
+  borderRadius: t.shape.borderRadius,
+  border: "none",
+  padding: "0 2px",
+  boxSizing: "border-box",
+  "&:focus": {
+    outline: `1px solid ${(t.vars || t).palette.primary.main}`
+  }
+})), Fr = ["visible"], Vr = ["id", "itemId", "label", "disabled", "disableSelection", "children", "slots", "slotProps", "classes"], zr = qt(), jr = G("li", {
+  name: "MuiTreeItem",
+  slot: "Root"
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+}), $r = G("div", {
+  name: "MuiTreeItem",
+  slot: "Content",
+  shouldForwardProp: (t) => st(t) && t !== "status"
+})(({
+  theme: t
+}) => ({
+  padding: t.spacing(0.5, 1),
+  paddingLeft: `calc(${t.spacing(1)} + var(--TreeView-itemChildrenIndentation) * var(--TreeView-itemDepth))`,
+  borderRadius: t.shape.borderRadius,
+  width: "100%",
+  boxSizing: "border-box",
+  // prevent width + padding to overflow
+  position: "relative",
+  display: "flex",
+  alignItems: "center",
+  gap: t.spacing(1),
+  cursor: "pointer",
+  WebkitTapHighlightColor: "transparent",
+  "&:hover": {
+    backgroundColor: (t.vars || t).palette.action.hover,
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  },
+  "&[data-disabled]": {
+    opacity: (t.vars || t).palette.action.disabledOpacity,
+    backgroundColor: "transparent",
+    cursor: "auto"
+  },
+  "&[data-focused]": {
+    backgroundColor: (t.vars || t).palette.action.focus
+  },
+  "&[data-selected]": {
+    backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.mainChannel} / ${t.vars.palette.action.selectedOpacity})` : Se(t.palette.primary.main, t.palette.action.selectedOpacity),
+    "&:hover": {
+      backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.mainChannel} / calc(${t.vars.palette.action.selectedOpacity} + ${t.vars.palette.action.hoverOpacity}))` : Se(t.palette.primary.main, t.palette.action.selectedOpacity + t.palette.action.hoverOpacity),
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.mainChannel} / ${t.vars.palette.action.selectedOpacity})` : Se(t.palette.primary.main, t.palette.action.selectedOpacity)
+      }
+    }
+  },
+  "&[data-selected][data-focused]": {
+    backgroundColor: t.vars ? `rgba(${t.vars.palette.primary.mainChannel} / calc(${t.vars.palette.action.selectedOpacity} + ${t.vars.palette.action.focusOpacity}))` : Se(t.palette.primary.main, t.palette.action.selectedOpacity + t.palette.action.focusOpacity)
+  }
+})), Br = G("div", {
+  name: "MuiTreeItem",
+  slot: "Label",
+  shouldForwardProp: (t) => st(t) && t !== "editable"
+})(({
+  theme: t
+}) => S({
+  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"
+}, t.typography.body1, {
+  variants: [{
+    props: ({
+      editable: e
+    }) => e,
+    style: {
+      paddingLeft: "2px"
+    }
+  }]
+})), Wr = G("div", {
+  name: "MuiTreeItem",
+  slot: "IconContainer"
+})({
+  width: 16,
+  display: "flex",
+  flexShrink: 0,
+  justifyContent: "center",
+  position: "relative",
+  cursor: "inherit",
+  "& svg": {
+    fontSize: 18
+  }
+}), Kr = G(je, {
+  name: "MuiTreeItem",
+  slot: "GroupTransition",
+  overridesResolver: (t, e) => e.groupTransition
+})({
+  margin: 0,
+  padding: 0
+}), Ur = G("div", {
+  name: "MuiTreeItem",
+  slot: "ErrorIcon"
+})({
+  position: "absolute",
+  right: -3,
+  width: 7,
+  height: 7,
+  borderRadius: "50%",
+  backgroundColor: "red"
+}), Hr = G(jn, {
+  name: "MuiTreeItem",
+  slot: "LoadingIcon"
+})({
+  color: "text.primary"
+}), un = G(/* @__PURE__ */ M.forwardRef((t, e) => {
+  const {
+    visible: n
+  } = t, o = Be(t, Fr);
+  return n ? /* @__PURE__ */ v(ln, S({}, o, {
+    ref: e
+  })) : null;
+}), {
+  name: "MuiTreeItem",
+  slot: "Checkbox"
+})({
+  padding: 0
+});
+process.env.NODE_ENV !== "production" && (un.displayName = "TreeItemCheckbox");
+const qr = (t) => {
+  const {
+    classes: e
+  } = Gt(), n = S({}, t, {
+    root: Q(t?.root, e.root),
+    content: Q(t?.content, e.itemContent),
+    iconContainer: Q(t?.iconContainer, e.itemIconContainer),
+    checkbox: Q(t?.checkbox, e.itemCheckbox),
+    label: Q(t?.label, e.itemLabel),
+    groupTransition: Q(t?.groupTransition, e.itemGroupTransition),
+    labelInput: Q(t?.labelInput, e.itemLabelInput),
+    dragAndDropOverlay: Q(t?.dragAndDropOverlay, e.itemDragAndDropOverlay),
+    errorIcon: Q(t?.errorIcon, e.itemErrorIcon),
+    loadingIcon: Q(t?.loadingIcon, e.itemLoadingIcon)
+  });
+  return we({
+    root: ["root"],
+    content: ["content"],
+    iconContainer: ["iconContainer"],
+    checkbox: ["checkbox"],
+    label: ["label"],
+    groupTransition: ["groupTransition"],
+    labelInput: ["labelInput"],
+    dragAndDropOverlay: ["dragAndDropOverlay"],
+    errorIcon: ["errorIcon"],
+    loadingIcon: ["loadingIcon"],
+    expanded: ["expanded"],
+    editing: ["editing"],
+    editable: ["editable"],
+    selected: ["selected"],
+    focused: ["focused"],
+    disabled: ["disabled"]
+  }, Rr, n);
+}, mt = /* @__PURE__ */ M.forwardRef(function(e, n) {
+  const o = zr({
+    props: e,
+    name: "MuiTreeItem"
+  }), {
+    id: r,
+    itemId: s,
+    label: l,
+    disabled: a,
+    disableSelection: h,
+    children: d,
+    slots: c = {},
+    slotProps: p = {},
+    classes: f
+  } = o, u = Be(o, Vr), {
+    getContextProviderProps: m,
+    getRootProps: I,
+    getContentProps: b,
+    getIconContainerProps: x,
+    getCheckboxProps: w,
+    getLabelProps: _,
+    getGroupTransitionProps: R,
+    getLabelInputProps: F,
+    getDragAndDropOverlayProps: C,
+    getErrorContainerProps: D,
+    getLoadingContainerProps: V,
+    status: j
+  } = Pr({
+    id: r,
+    itemId: s,
+    children: d,
+    label: l,
+    disabled: a,
+    disableSelection: h
+  }), E = qr(f), k = c.root ?? jr, O = te({
+    elementType: k,
+    getSlotProps: I,
+    externalForwardedProps: u,
+    externalSlotProps: p.root,
+    additionalProps: {
+      ref: n
+    },
+    ownerState: {},
+    className: E.root
+  }), A = c.content ?? $r, L = te({
+    elementType: A,
+    getSlotProps: b,
+    externalSlotProps: p.content,
+    ownerState: {},
+    className: Q(E.content, j.expanded && E.expanded, j.selected && E.selected, j.focused && E.focused, j.disabled && E.disabled, j.editing && E.editing, j.editable && E.editable)
+  }), $ = c.iconContainer ?? Wr, B = te({
+    elementType: $,
+    getSlotProps: x,
+    externalSlotProps: p.iconContainer,
+    ownerState: {},
+    className: E.iconContainer
+  }), J = c.label ?? Br, Z = te({
+    elementType: J,
+    getSlotProps: _,
+    externalSlotProps: p.label,
+    ownerState: {},
+    className: E.label
+  }), q = c.checkbox ?? un, ie = te({
+    elementType: q,
+    getSlotProps: w,
+    externalSlotProps: p.checkbox,
+    ownerState: {},
+    className: E.checkbox
+  }), ae = c.groupTransition ?? void 0, ue = te({
+    elementType: ae,
+    getSlotProps: R,
+    externalSlotProps: p.groupTransition,
+    ownerState: {},
+    className: E.groupTransition
+  }), ce = c.labelInput ?? Nr, pe = te({
+    elementType: ce,
+    getSlotProps: F,
+    externalSlotProps: p.labelInput,
+    ownerState: {},
+    className: E.labelInput
+  }), K = c.dragAndDropOverlay ?? cn, X = te({
+    elementType: K,
+    getSlotProps: C,
+    externalSlotProps: p.dragAndDropOverlay,
+    ownerState: {},
+    className: E.dragAndDropOverlay
+  }), T = c.errorIcon ?? Ur, g = te({
+    elementType: T,
+    getSlotProps: D,
+    externalSlotProps: p.errorIcon,
+    ownerState: {},
+    className: E.errorIcon
+  }), U = c.loadingIcon ?? Hr, ee = te({
+    elementType: U,
+    getSlotProps: V,
+    externalSlotProps: p.loadingIcon,
+    ownerState: {},
+    className: E.loadingIcon
+  });
+  return /* @__PURE__ */ v(dn, S({}, m(), {
+    children: /* @__PURE__ */ Y(k, S({}, O, {
+      children: [/* @__PURE__ */ Y(A, S({}, L, {
+        children: [/* @__PURE__ */ Y($, S({}, B, {
+          children: [j.error && /* @__PURE__ */ v(T, S({}, g)), j.loading ? /* @__PURE__ */ v(U, S({}, ee)) : /* @__PURE__ */ v(an, {
+            status: j,
+            slots: c,
+            slotProps: p
+          })]
+        })), /* @__PURE__ */ v(q, S({}, ie)), j.editing ? /* @__PURE__ */ v(ce, S({}, pe)) : /* @__PURE__ */ v(J, S({}, Z)), /* @__PURE__ */ v(K, S({}, X))]
+      })), d && /* @__PURE__ */ v(Kr, S({
+        as: ae
+      }, ue))]
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (mt.displayName = "TreeItem");
+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 content of the component.
+   */
+  children: i.any,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: i.object,
+  className: i.string,
+  /**
+   * If `true`, the item is disabled.
+   * @default false
+   */
+  disabled: i.bool,
+  /**
+   * If `true`, the item cannot be selected.
+   * @default false
+   */
+  disableSelection: i.bool,
+  /**
+   * The id attribute of the item. If not provided, it will be generated.
+   */
+  id: i.string,
+  /**
+   * The id of the item.
+   * Must be unique.
+   */
+  itemId: i.string.isRequired,
+  /**
+   * The label of the item.
+   */
+  label: i.node,
+  /**
+   * Callback fired when the item root is blurred.
+   */
+  onBlur: i.func,
+  /**
+   * This prop isn't supported.
+   * Use the `onItemFocus` callback on the tree if you need to monitor an item's focus.
+   */
+  onFocus: Fn,
+  /**
+   * Callback fired when a key is pressed on the keyboard and the tree is in focus.
+   */
+  onKeyDown: i.func,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: i.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: i.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: i.oneOfType([i.arrayOf(i.oneOfType([i.func, i.object, i.bool])), i.func, i.object])
+});
+const he = (t, e) => {
+  for (const n of t) {
+    if (n.value === e) return n;
+    if (n.children) {
+      const o = he(n.children, e);
+      if (o) return o;
+    }
+  }
+};
+function is({
+  label: t,
+  data: e,
+  handleChange: n,
+  fullWidth: o = !1,
+  values: r = [],
+  disabled: s = !1,
+  isRtl: l = !1,
+  width: a = 300,
+  placeholder: h = "Search...",
+  maxHeight: d = 300
+}) {
+  const [c, p] = We(""), [f, u] = We(!1), [m, I] = We(5), b = gt(null), x = gt(null), w = Ke(() => {
+    if (!e || r.length === 0) return [];
+    const E = new Set(r), k = [], O = (A) => {
+      for (const L of A)
+        L.children && L.children.length > 0 ? O(L.children) : E.has(L.value) && k.push(L.label);
+    };
+    return O(e), k;
+  }, [e, r]);
+  bt(() => {
+    const E = (k) => {
+      b.current && !b.current.contains(k.target) && u(!1);
+    };
+    return f && document.addEventListener("mousedown", E), () => {
+      document.removeEventListener("mousedown", E);
+    };
+  }, [f]), bt(() => {
+    const E = () => {
+      if (!x.current || w.length === 0) {
+        I(5);
+        return;
+      }
+      const O = x.current.offsetWidth, A = 60, L = 110, $ = 45, B = 4, J = O - $ - B, Z = (A + L) / 2, q = Math.max(1, Math.floor(J / (Z + B)));
+      I(Math.min(q, w.length));
+    };
+    E();
+    const k = new ResizeObserver(E);
+    return x.current && k.observe(x.current), () => k.disconnect();
+  }, [w.length]);
+  const _ = Ke(() => {
+    if (!e) return [];
+    if (!c.trim()) return e;
+    const E = c.toLowerCase(), k = (O) => {
+      const A = [];
+      for (const L of O) {
+        const $ = L.label.toLowerCase().includes(E) || String(L.id).toLowerCase().includes(E) || L.externalId && String(L.externalId).toLowerCase().includes(E), B = L.children ? k(L.children) : [];
+        ($ || B.length > 0) && A.push({
+          ...L,
+          children: B.length > 0 ? B : L.children
+        });
+      }
+      return A;
+    };
+    return k(e);
+  }, [e, c]), R = St((E) => !E.children || E.children.length === 0 ? [E.value] : E.children.flatMap((k) => {
+    const O = he(e || [], k.value) || k;
+    return R(O);
+  }), [e]), F = St(
+    (E) => {
+      const k = he(e || [], E.value) || E, O = R(k);
+      if (k.children && k.children.length > 0)
+        if (O.every(($) => r.includes($))) {
+          const $ = new Set(O);
+          n(r.filter((B) => !$.has(B)));
+        } else {
+          const $ = /* @__PURE__ */ new Set([...r, ...O]);
+          n(Array.from($));
+        }
+      else {
+        const L = r.includes(E.value);
+        n(L ? r.filter(($) => $ !== E.value) : [...r, E.value]);
+      }
+    },
+    [e, r, n, R]
+  ), C = (E) => {
+    E.stopPropagation(), n([]);
+  }, { areAllChildrenSelected: D, areSomeChildrenSelected: V } = Ke(() => {
+    const E = (O) => {
+      const A = he(e || [], O);
+      return !A || !A.children || A.children.length === 0 ? r.includes(O) : A.children.every((L) => E(L.value));
+    }, k = (O) => {
+      const A = he(e || [], O);
+      return !A || !A.children || A.children.length === 0 ? r.includes(O) : A.children.some((L) => k(L.value));
+    };
+    return {
+      areAllChildrenSelected: E,
+      areSomeChildrenSelected: k
+    };
+  }, [e, r]), j = (E) => E.map((k) => {
+    const O = he(e || [], k.value), A = O?.children && O.children.length > 0, L = !A, $ = L && r.includes(k.value), B = A && D(k.value), J = A && V(k.value), Z = A && J && !B;
+    return /* @__PURE__ */ v(
+      mt,
+      {
+        itemId: k.value,
+        label: /* @__PURE__ */ Y(
+          fe,
+          {
+            sx: {
+              display: "flex",
+              alignItems: "flex-start",
+              py: 0.5
+            },
+            onClick: (q) => {
+              q.stopPropagation(), F(k);
+            },
+            children: [
+              /* @__PURE__ */ v(
+                Cn,
+                {
+                  checked: L ? $ : B,
+                  indeterminate: Z,
+                  size: "small",
+                  sx: { p: 0, mr: 1 }
+                }
+              ),
+              /* @__PURE__ */ Y(fe, { sx: { display: "flex", flexDirection: "column" }, children: [
+                /* @__PURE__ */ v(
+                  Ue,
+                  {
+                    component: "span",
+                    sx: { fontWeight: 600, fontSize: "0.875rem" },
+                    children: k.label
+                  }
+                ),
+                /* @__PURE__ */ Y(
+                  Ue,
+                  {
+                    component: "span",
+                    sx: { fontSize: "0.75rem", color: "text.secondary" },
+                    children: [
+                      "Id: ",
+                      k.id,
+                      k.externalId !== void 0 && k.externalId !== "" && /* @__PURE__ */ Y("span", { style: { marginLeft: 8 }, children: [
+                        "External ID: ",
+                        k.externalId
+                      ] })
+                    ]
+                  }
+                )
+              ] })
+            ]
+          }
+        ),
+        children: k.children && j(k.children)
+      },
+      k.value
+    );
+  });
+  return /* @__PURE__ */ Y(
+    In,
+    {
+      ref: b,
+      size: "small",
+      sx: {
+        width: o ? "100%" : a,
+        marginRight: l ? "10px" : "0px"
+      },
+      disabled: s,
+      children: [
+        /* @__PURE__ */ v(gn, { shrink: f || r.length > 0, children: t }),
+        /* @__PURE__ */ v(
+          bn,
+          {
+            label: t,
+            notched: f || r.length > 0,
+            readOnly: !0,
+            onClick: () => !s && u(!f),
+            sx: {
+              borderRadius: "8px",
+              bgcolor: "var(--color-background)",
+              cursor: s ? "default" : "pointer",
+              minHeight: 40,
+              display: "flex",
+              flexWrap: "nowrap",
+              "& .MuiOutlinedInput-notchedOutline": {
+                border: "1px solid var(--color-gray)"
+              },
+              "& .MuiOutlinedInput-input": {
+                display: "none"
+              }
+            },
+            value: "",
+            startAdornment: /* @__PURE__ */ v(
+              fe,
+              {
+                ref: x,
+                sx: {
+                  display: "flex",
+                  flexWrap: "nowrap",
+                  gap: 0.5,
+                  flex: 1,
+                  overflow: "hidden",
+                  alignItems: "center",
+                  py: 0.5,
+                  pl: 1
+                },
+                children: w.length > 0 ? /* @__PURE__ */ Y(mn, { children: [
+                  w.slice(0, m).map((E) => /* @__PURE__ */ v(
+                    xt,
+                    {
+                      label: E,
+                      size: "small",
+                      sx: {
+                        height: 24,
+                        flexShrink: 0,
+                        "& .MuiChip-label": {
+                          px: 1,
+                          maxWidth: 100,
+                          overflow: "hidden",
+                          textOverflow: "ellipsis",
+                          whiteSpace: "nowrap"
+                        }
+                      }
+                    },
+                    E
+                  )),
+                  w.length > m && /* @__PURE__ */ v(
+                    xt,
+                    {
+                      label: `+${w.length - m}`,
+                      size: "small",
+                      sx: { height: 24, flexShrink: 0 }
+                    }
+                  )
+                ] }) : null
+              }
+            ),
+            endAdornment: /* @__PURE__ */ Y(yt, { position: "end", sx: { flexShrink: 0 }, children: [
+              r.length > 0 && !s && /* @__PURE__ */ v(Sn, { size: "small", onClick: C, children: /* @__PURE__ */ v(wn, { fontSize: "small" }) }),
+              /* @__PURE__ */ v(
+                $n,
+                {
+                  sx: {
+                    transform: f ? "rotate(180deg)" : "rotate(0deg)",
+                    transition: "transform 0.2s"
+                  }
+                }
+              )
+            ] })
+          }
+        ),
+        /* @__PURE__ */ v(yn, { in: f && !s, children: /* @__PURE__ */ Y(
+          xn,
+          {
+            elevation: 3,
+            sx: {
+              position: "absolute",
+              zIndex: 1300,
+              width: "100%",
+              mt: 0.5,
+              borderRadius: "8px",
+              overflow: "hidden"
+            },
+            children: [
+              /* @__PURE__ */ v(fe, { sx: { p: 1 }, children: /* @__PURE__ */ v(
+                En,
+                {
+                  fullWidth: !0,
+                  size: "small",
+                  placeholder: h,
+                  value: c,
+                  onChange: (E) => p(E.target.value),
+                  slotProps: {
+                    input: {
+                      startAdornment: /* @__PURE__ */ v(yt, { position: "start", children: /* @__PURE__ */ v(vn, { fontSize: "small" }) })
+                    }
+                  },
+                  sx: {
+                    "& fieldset": {
+                      borderRadius: "8px"
+                    }
+                  }
+                }
+              ) }),
+              /* @__PURE__ */ Y(fe, { sx: { maxHeight: d, overflow: "auto" }, children: [
+                /* @__PURE__ */ v(ht, { children: j(_) }),
+                _.length === 0 && /* @__PURE__ */ v(fe, { sx: { p: 2, textAlign: "center" }, children: /* @__PURE__ */ v(Ue, { color: "text.secondary", variant: "body2", children: "No options found" }) })
+              ] })
+            ]
+          }
+        ) })
+      ]
+    }
+  );
+}
+export {
+  is as PassportTreeSelect
+};