@xyo-network/react-typedoc 2.62.3 → 2.64.0-rc.1

package/dist/index.js

@@ -5,6 +5,12 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +33,1056 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../../../node_modules/prop-types/node_modules/react-is/cjs/react-is.production.min.js
+var require_react_is_production_min = __commonJS({
+  "../../../../node_modules/prop-types/node_modules/react-is/cjs/react-is.production.min.js"(exports) {
+    "use strict";
+    var b = "function" === typeof Symbol && Symbol.for;
+    var c = b ? Symbol.for("react.element") : 60103;
+    var d = b ? Symbol.for("react.portal") : 60106;
+    var e = b ? Symbol.for("react.fragment") : 60107;
+    var f = b ? Symbol.for("react.strict_mode") : 60108;
+    var g = b ? Symbol.for("react.profiler") : 60114;
+    var h = b ? Symbol.for("react.provider") : 60109;
+    var k = b ? Symbol.for("react.context") : 60110;
+    var l = b ? Symbol.for("react.async_mode") : 60111;
+    var m = b ? Symbol.for("react.concurrent_mode") : 60111;
+    var n = b ? Symbol.for("react.forward_ref") : 60112;
+    var p = b ? Symbol.for("react.suspense") : 60113;
+    var q = b ? Symbol.for("react.suspense_list") : 60120;
+    var r2 = b ? Symbol.for("react.memo") : 60115;
+    var t = b ? Symbol.for("react.lazy") : 60116;
+    var v = b ? Symbol.for("react.block") : 60121;
+    var w = b ? Symbol.for("react.fundamental") : 60117;
+    var x = b ? Symbol.for("react.responder") : 60118;
+    var y = b ? Symbol.for("react.scope") : 60119;
+    function z(a) {
+      if ("object" === typeof a && null !== a) {
+        var u = a.$$typeof;
+        switch (u) {
+          case c:
+            switch (a = a.type, a) {
+              case l:
+              case m:
+              case e:
+              case g:
+              case f:
+              case p:
+                return a;
+              default:
+                switch (a = a && a.$$typeof, a) {
+                  case k:
+                  case n:
+                  case t:
+                  case r2:
+                  case h:
+                    return a;
+                  default:
+                    return u;
+                }
+            }
+          case d:
+            return u;
+        }
+      }
+    }
+    function A(a) {
+      return z(a) === m;
+    }
+    exports.AsyncMode = l;
+    exports.ConcurrentMode = m;
+    exports.ContextConsumer = k;
+    exports.ContextProvider = h;
+    exports.Element = c;
+    exports.ForwardRef = n;
+    exports.Fragment = e;
+    exports.Lazy = t;
+    exports.Memo = r2;
+    exports.Portal = d;
+    exports.Profiler = g;
+    exports.StrictMode = f;
+    exports.Suspense = p;
+    exports.isAsyncMode = function(a) {
+      return A(a) || z(a) === l;
+    };
+    exports.isConcurrentMode = A;
+    exports.isContextConsumer = function(a) {
+      return z(a) === k;
+    };
+    exports.isContextProvider = function(a) {
+      return z(a) === h;
+    };
+    exports.isElement = function(a) {
+      return "object" === typeof a && null !== a && a.$$typeof === c;
+    };
+    exports.isForwardRef = function(a) {
+      return z(a) === n;
+    };
+    exports.isFragment = function(a) {
+      return z(a) === e;
+    };
+    exports.isLazy = function(a) {
+      return z(a) === t;
+    };
+    exports.isMemo = function(a) {
+      return z(a) === r2;
+    };
+    exports.isPortal = function(a) {
+      return z(a) === d;
+    };
+    exports.isProfiler = function(a) {
+      return z(a) === g;
+    };
+    exports.isStrictMode = function(a) {
+      return z(a) === f;
+    };
+    exports.isSuspense = function(a) {
+      return z(a) === p;
+    };
+    exports.isValidElementType = function(a) {
+      return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r2 || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+    };
+    exports.typeOf = z;
+  }
+});
+
+// ../../../../node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js
+var require_react_is_development = __commonJS({
+  "../../../../node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js"(exports) {
+    "use strict";
+    if (process.env.NODE_ENV !== "production") {
+      (function() {
+        "use strict";
+        var hasSymbol = typeof Symbol === "function" && Symbol.for;
+        var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103;
+        var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106;
+        var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107;
+        var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108;
+        var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114;
+        var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109;
+        var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110;
+        var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111;
+        var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111;
+        var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112;
+        var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113;
+        var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120;
+        var REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115;
+        var REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116;
+        var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121;
+        var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117;
+        var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118;
+        var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119;
+        function isValidElementType(type) {
+          return typeof type === "string" || typeof type === "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+          type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+        }
+        function typeOf(object) {
+          if (typeof object === "object" && object !== null) {
+            var $$typeof = object.$$typeof;
+            switch ($$typeof) {
+              case REACT_ELEMENT_TYPE:
+                var type = object.type;
+                switch (type) {
+                  case REACT_ASYNC_MODE_TYPE:
+                  case REACT_CONCURRENT_MODE_TYPE:
+                  case REACT_FRAGMENT_TYPE:
+                  case REACT_PROFILER_TYPE:
+                  case REACT_STRICT_MODE_TYPE:
+                  case REACT_SUSPENSE_TYPE:
+                    return type;
+                  default:
+                    var $$typeofType = type && type.$$typeof;
+                    switch ($$typeofType) {
+                      case REACT_CONTEXT_TYPE:
+                      case REACT_FORWARD_REF_TYPE:
+                      case REACT_LAZY_TYPE:
+                      case REACT_MEMO_TYPE:
+                      case REACT_PROVIDER_TYPE:
+                        return $$typeofType;
+                      default:
+                        return $$typeof;
+                    }
+                }
+              case REACT_PORTAL_TYPE:
+                return $$typeof;
+            }
+          }
+          return void 0;
+        }
+        var AsyncMode = REACT_ASYNC_MODE_TYPE;
+        var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+        var ContextConsumer = REACT_CONTEXT_TYPE;
+        var ContextProvider = REACT_PROVIDER_TYPE;
+        var Element = REACT_ELEMENT_TYPE;
+        var ForwardRef = REACT_FORWARD_REF_TYPE;
+        var Fragment5 = REACT_FRAGMENT_TYPE;
+        var Lazy = REACT_LAZY_TYPE;
+        var Memo = REACT_MEMO_TYPE;
+        var Portal = REACT_PORTAL_TYPE;
+        var Profiler = REACT_PROFILER_TYPE;
+        var StrictMode = REACT_STRICT_MODE_TYPE;
+        var Suspense2 = REACT_SUSPENSE_TYPE;
+        var hasWarnedAboutDeprecatedIsAsyncMode = false;
+        function isAsyncMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+              hasWarnedAboutDeprecatedIsAsyncMode = true;
+              console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
+            }
+          }
+          return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+        }
+        function isConcurrentMode(object) {
+          return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+        }
+        function isContextConsumer(object) {
+          return typeOf(object) === REACT_CONTEXT_TYPE;
+        }
+        function isContextProvider(object) {
+          return typeOf(object) === REACT_PROVIDER_TYPE;
+        }
+        function isElement(object) {
+          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
+        function isForwardRef(object) {
+          return typeOf(object) === REACT_FORWARD_REF_TYPE;
+        }
+        function isFragment(object) {
+          return typeOf(object) === REACT_FRAGMENT_TYPE;
+        }
+        function isLazy(object) {
+          return typeOf(object) === REACT_LAZY_TYPE;
+        }
+        function isMemo(object) {
+          return typeOf(object) === REACT_MEMO_TYPE;
+        }
+        function isPortal(object) {
+          return typeOf(object) === REACT_PORTAL_TYPE;
+        }
+        function isProfiler(object) {
+          return typeOf(object) === REACT_PROFILER_TYPE;
+        }
+        function isStrictMode(object) {
+          return typeOf(object) === REACT_STRICT_MODE_TYPE;
+        }
+        function isSuspense(object) {
+          return typeOf(object) === REACT_SUSPENSE_TYPE;
+        }
+        exports.AsyncMode = AsyncMode;
+        exports.ConcurrentMode = ConcurrentMode;
+        exports.ContextConsumer = ContextConsumer;
+        exports.ContextProvider = ContextProvider;
+        exports.Element = Element;
+        exports.ForwardRef = ForwardRef;
+        exports.Fragment = Fragment5;
+        exports.Lazy = Lazy;
+        exports.Memo = Memo;
+        exports.Portal = Portal;
+        exports.Profiler = Profiler;
+        exports.StrictMode = StrictMode;
+        exports.Suspense = Suspense2;
+        exports.isAsyncMode = isAsyncMode;
+        exports.isConcurrentMode = isConcurrentMode;
+        exports.isContextConsumer = isContextConsumer;
+        exports.isContextProvider = isContextProvider;
+        exports.isElement = isElement;
+        exports.isForwardRef = isForwardRef;
+        exports.isFragment = isFragment;
+        exports.isLazy = isLazy;
+        exports.isMemo = isMemo;
+        exports.isPortal = isPortal;
+        exports.isProfiler = isProfiler;
+        exports.isStrictMode = isStrictMode;
+        exports.isSuspense = isSuspense;
+        exports.isValidElementType = isValidElementType;
+        exports.typeOf = typeOf;
+      })();
+    }
+  }
+});
+
+// ../../../../node_modules/prop-types/node_modules/react-is/index.js
+var require_react_is = __commonJS({
+  "../../../../node_modules/prop-types/node_modules/react-is/index.js"(exports, module2) {
+    "use strict";
+    if (process.env.NODE_ENV === "production") {
+      module2.exports = require_react_is_production_min();
+    } else {
+      module2.exports = require_react_is_development();
+    }
+  }
+});
+
+// ../../../../node_modules/object-assign/index.js
+var require_object_assign = __commonJS({
+  "../../../../node_modules/object-assign/index.js"(exports, module2) {
+    "use strict";
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+    function toObject(val) {
+      if (val === null || val === void 0) {
+        throw new TypeError("Object.assign cannot be called with null or undefined");
+      }
+      return Object(val);
+    }
+    function shouldUseNative() {
+      try {
+        if (!Object.assign) {
+          return false;
+        }
+        var test1 = new String("abc");
+        test1[5] = "de";
+        if (Object.getOwnPropertyNames(test1)[0] === "5") {
+          return false;
+        }
+        var test2 = {};
+        for (var i = 0; i < 10; i++) {
+          test2["_" + String.fromCharCode(i)] = i;
+        }
+        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+          return test2[n];
+        });
+        if (order2.join("") !== "0123456789") {
+          return false;
+        }
+        var test3 = {};
+        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+          test3[letter] = letter;
+        });
+        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+          return false;
+        }
+        return true;
+      } catch (err) {
+        return false;
+      }
+    }
+    module2.exports = shouldUseNative() ? Object.assign : function(target, source) {
+      var from;
+      var to = toObject(target);
+      var symbols;
+      for (var s = 1; s < arguments.length; s++) {
+        from = Object(arguments[s]);
+        for (var key in from) {
+          if (hasOwnProperty.call(from, key)) {
+            to[key] = from[key];
+          }
+        }
+        if (getOwnPropertySymbols) {
+          symbols = getOwnPropertySymbols(from);
+          for (var i = 0; i < symbols.length; i++) {
+            if (propIsEnumerable.call(from, symbols[i])) {
+              to[symbols[i]] = from[symbols[i]];
+            }
+          }
+        }
+      }
+      return to;
+    };
+  }
+});
+
+// ../../../../node_modules/prop-types/lib/ReactPropTypesSecret.js
+var require_ReactPropTypesSecret = __commonJS({
+  "../../../../node_modules/prop-types/lib/ReactPropTypesSecret.js"(exports, module2) {
+    "use strict";
+    var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+    module2.exports = ReactPropTypesSecret;
+  }
+});
+
+// ../../../../node_modules/prop-types/lib/has.js
+var require_has = __commonJS({
+  "../../../../node_modules/prop-types/lib/has.js"(exports, module2) {
+    "use strict";
+    module2.exports = Function.call.bind(Object.prototype.hasOwnProperty);
+  }
+});
+
+// ../../../../node_modules/prop-types/checkPropTypes.js
+var require_checkPropTypes = __commonJS({
+  "../../../../node_modules/prop-types/checkPropTypes.js"(exports, module2) {
+    "use strict";
+    var printWarning = function() {
+    };
+    if (process.env.NODE_ENV !== "production") {
+      ReactPropTypesSecret = require_ReactPropTypesSecret();
+      loggedTypeFailures = {};
+      has = require_has();
+      printWarning = function(text) {
+        var message = "Warning: " + text;
+        if (typeof console !== "undefined") {
+          console.error(message);
+        }
+        try {
+          throw new Error(message);
+        } catch (x) {
+        }
+      };
+    }
+    var ReactPropTypesSecret;
+    var loggedTypeFailures;
+    var has;
+    function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+      if (process.env.NODE_ENV !== "production") {
+        for (var typeSpecName in typeSpecs) {
+          if (has(typeSpecs, typeSpecName)) {
+            var error;
+            try {
+              if (typeof typeSpecs[typeSpecName] !== "function") {
+                var err = Error(
+                  (componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+                );
+                err.name = "Invariant Violation";
+                throw err;
+              }
+              error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+            } catch (ex) {
+              error = ex;
+            }
+            if (error && !(error instanceof Error)) {
+              printWarning(
+                (componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof error + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+              );
+            }
+            if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+              loggedTypeFailures[error.message] = true;
+              var stack = getStack ? getStack() : "";
+              printWarning(
+                "Failed " + location + " type: " + error.message + (stack != null ? stack : "")
+              );
+            }
+          }
+        }
+      }
+    }
+    checkPropTypes.resetWarningCache = function() {
+      if (process.env.NODE_ENV !== "production") {
+        loggedTypeFailures = {};
+      }
+    };
+    module2.exports = checkPropTypes;
+  }
+});
+
+// ../../../../node_modules/prop-types/factoryWithTypeCheckers.js
+var require_factoryWithTypeCheckers = __commonJS({
+  "../../../../node_modules/prop-types/factoryWithTypeCheckers.js"(exports, module2) {
+    "use strict";
+    var ReactIs = require_react_is();
+    var assign = require_object_assign();
+    var ReactPropTypesSecret = require_ReactPropTypesSecret();
+    var has = require_has();
+    var checkPropTypes = require_checkPropTypes();
+    var printWarning = function() {
+    };
+    if (process.env.NODE_ENV !== "production") {
+      printWarning = function(text) {
+        var message = "Warning: " + text;
+        if (typeof console !== "undefined") {
+          console.error(message);
+        }
+        try {
+          throw new Error(message);
+        } catch (x) {
+        }
+      };
+    }
+    function emptyFunctionThatReturnsNull() {
+      return null;
+    }
+    module2.exports = function(isValidElement, throwOnDirectAccess) {
+      var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+      var FAUX_ITERATOR_SYMBOL = "@@iterator";
+      function getIteratorFn(maybeIterable) {
+        var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+        if (typeof iteratorFn === "function") {
+          return iteratorFn;
+        }
+      }
+      var ANONYMOUS = "<<anonymous>>";
+      var ReactPropTypes = {
+        array: createPrimitiveTypeChecker("array"),
+        bigint: createPrimitiveTypeChecker("bigint"),
+        bool: createPrimitiveTypeChecker("boolean"),
+        func: createPrimitiveTypeChecker("function"),
+        number: createPrimitiveTypeChecker("number"),
+        object: createPrimitiveTypeChecker("object"),
+        string: createPrimitiveTypeChecker("string"),
+        symbol: createPrimitiveTypeChecker("symbol"),
+        any: createAnyTypeChecker(),
+        arrayOf: createArrayOfTypeChecker,
+        element: createElementTypeChecker(),
+        elementType: createElementTypeTypeChecker(),
+        instanceOf: createInstanceTypeChecker,
+        node: createNodeChecker(),
+        objectOf: createObjectOfTypeChecker,
+        oneOf: createEnumTypeChecker,
+        oneOfType: createUnionTypeChecker,
+        shape: createShapeTypeChecker,
+        exact: createStrictShapeTypeChecker
+      };
+      function is(x, y) {
+        if (x === y) {
+          return x !== 0 || 1 / x === 1 / y;
+        } else {
+          return x !== x && y !== y;
+        }
+      }
+      function PropTypeError(message, data) {
+        this.message = message;
+        this.data = data && typeof data === "object" ? data : {};
+        this.stack = "";
+      }
+      PropTypeError.prototype = Error.prototype;
+      function createChainableTypeChecker(validate) {
+        if (process.env.NODE_ENV !== "production") {
+          var manualPropTypeCallCache = {};
+          var manualPropTypeWarningCount = 0;
+        }
+        function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+          componentName = componentName || ANONYMOUS;
+          propFullName = propFullName || propName;
+          if (secret !== ReactPropTypesSecret) {
+            if (throwOnDirectAccess) {
+              var err = new Error(
+                "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+              );
+              err.name = "Invariant Violation";
+              throw err;
+            } else if (process.env.NODE_ENV !== "production" && typeof console !== "undefined") {
+              var cacheKey = componentName + ":" + propName;
+              if (!manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors
+              manualPropTypeWarningCount < 3) {
+                printWarning(
+                  "You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+                );
+                manualPropTypeCallCache[cacheKey] = true;
+                manualPropTypeWarningCount++;
+              }
+            }
+          }
+          if (props[propName] == null) {
+            if (isRequired) {
+              if (props[propName] === null) {
+                return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`."));
+              }
+              return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`."));
+            }
+            return null;
+          } else {
+            return validate(props, propName, componentName, location, propFullName);
+          }
+        }
+        var chainedCheckType = checkType.bind(null, false);
+        chainedCheckType.isRequired = checkType.bind(null, true);
+        return chainedCheckType;
+      }
+      function createPrimitiveTypeChecker(expectedType) {
+        function validate(props, propName, componentName, location, propFullName, secret) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== expectedType) {
+            var preciseType = getPreciseType(propValue);
+            return new PropTypeError(
+              "Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`."),
+              { expectedType }
+            );
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createAnyTypeChecker() {
+        return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+      }
+      function createArrayOfTypeChecker(typeChecker) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (typeof typeChecker !== "function") {
+            return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf.");
+          }
+          var propValue = props[propName];
+          if (!Array.isArray(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array."));
+          }
+          for (var i = 0; i < propValue.length; i++) {
+            var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret);
+            if (error instanceof Error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createElementTypeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          if (!isValidElement(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createElementTypeTypeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          if (!ReactIs.isValidElementType(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createInstanceTypeChecker(expectedClass) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (!(props[propName] instanceof expectedClass)) {
+            var expectedClassName = expectedClass.name || ANONYMOUS;
+            var actualClassName = getClassName(props[propName]);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createEnumTypeChecker(expectedValues) {
+        if (!Array.isArray(expectedValues)) {
+          if (process.env.NODE_ENV !== "production") {
+            if (arguments.length > 1) {
+              printWarning(
+                "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+              );
+            } else {
+              printWarning("Invalid argument supplied to oneOf, expected an array.");
+            }
+          }
+          return emptyFunctionThatReturnsNull;
+        }
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          for (var i = 0; i < expectedValues.length; i++) {
+            if (is(propValue, expectedValues[i])) {
+              return null;
+            }
+          }
+          var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+            var type = getPreciseType(value);
+            if (type === "symbol") {
+              return String(value);
+            }
+            return value;
+          });
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + "."));
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createObjectOfTypeChecker(typeChecker) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (typeof typeChecker !== "function") {
+            return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf.");
+          }
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object."));
+          }
+          for (var key in propValue) {
+            if (has(propValue, key)) {
+              var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+              if (error instanceof Error) {
+                return error;
+              }
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createUnionTypeChecker(arrayOfTypeCheckers) {
+        if (!Array.isArray(arrayOfTypeCheckers)) {
+          process.env.NODE_ENV !== "production" ? printWarning("Invalid argument supplied to oneOfType, expected an instance of array.") : void 0;
+          return emptyFunctionThatReturnsNull;
+        }
+        for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+          var checker = arrayOfTypeCheckers[i];
+          if (typeof checker !== "function") {
+            printWarning(
+              "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + "."
+            );
+            return emptyFunctionThatReturnsNull;
+          }
+        }
+        function validate(props, propName, componentName, location, propFullName) {
+          var expectedTypes = [];
+          for (var i2 = 0; i2 < arrayOfTypeCheckers.length; i2++) {
+            var checker2 = arrayOfTypeCheckers[i2];
+            var checkerResult = checker2(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+            if (checkerResult == null) {
+              return null;
+            }
+            if (checkerResult.data && has(checkerResult.data, "expectedType")) {
+              expectedTypes.push(checkerResult.data.expectedType);
+            }
+          }
+          var expectedTypesMessage = expectedTypes.length > 0 ? ", expected one of type [" + expectedTypes.join(", ") + "]" : "";
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`" + expectedTypesMessage + "."));
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createNodeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (!isNode(props[propName])) {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function invalidValidatorError(componentName, location, propFullName, key, type) {
+        return new PropTypeError(
+          (componentName || "React class") + ": " + location + " type `" + propFullName + "." + key + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + type + "`."
+        );
+      }
+      function createShapeTypeChecker(shapeTypes) {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+          }
+          for (var key in shapeTypes) {
+            var checker = shapeTypes[key];
+            if (typeof checker !== "function") {
+              return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+            }
+            var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+            if (error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createStrictShapeTypeChecker(shapeTypes) {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+          }
+          var allKeys = assign({}, props[propName], shapeTypes);
+          for (var key in allKeys) {
+            var checker = shapeTypes[key];
+            if (has(shapeTypes, key) && typeof checker !== "function") {
+              return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+            }
+            if (!checker) {
+              return new PropTypeError(
+                "Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, "  ") + "\nValid keys: " + JSON.stringify(Object.keys(shapeTypes), null, "  ")
+              );
+            }
+            var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+            if (error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function isNode(propValue) {
+        switch (typeof propValue) {
+          case "number":
+          case "string":
+          case "undefined":
+            return true;
+          case "boolean":
+            return !propValue;
+          case "object":
+            if (Array.isArray(propValue)) {
+              return propValue.every(isNode);
+            }
+            if (propValue === null || isValidElement(propValue)) {
+              return true;
+            }
+            var iteratorFn = getIteratorFn(propValue);
+            if (iteratorFn) {
+              var iterator = iteratorFn.call(propValue);
+              var step;
+              if (iteratorFn !== propValue.entries) {
+                while (!(step = iterator.next()).done) {
+                  if (!isNode(step.value)) {
+                    return false;
+                  }
+                }
+              } else {
+                while (!(step = iterator.next()).done) {
+                  var entry = step.value;
+                  if (entry) {
+                    if (!isNode(entry[1])) {
+                      return false;
+                    }
+                  }
+                }
+              }
+            } else {
+              return false;
+            }
+            return true;
+          default:
+            return false;
+        }
+      }
+      function isSymbol(propType, propValue) {
+        if (propType === "symbol") {
+          return true;
+        }
+        if (!propValue) {
+          return false;
+        }
+        if (propValue["@@toStringTag"] === "Symbol") {
+          return true;
+        }
+        if (typeof Symbol === "function" && propValue instanceof Symbol) {
+          return true;
+        }
+        return false;
+      }
+      function getPropType(propValue) {
+        var propType = typeof propValue;
+        if (Array.isArray(propValue)) {
+          return "array";
+        }
+        if (propValue instanceof RegExp) {
+          return "object";
+        }
+        if (isSymbol(propType, propValue)) {
+          return "symbol";
+        }
+        return propType;
+      }
+      function getPreciseType(propValue) {
+        if (typeof propValue === "undefined" || propValue === null) {
+          return "" + propValue;
+        }
+        var propType = getPropType(propValue);
+        if (propType === "object") {
+          if (propValue instanceof Date) {
+            return "date";
+          } else if (propValue instanceof RegExp) {
+            return "regexp";
+          }
+        }
+        return propType;
+      }
+      function getPostfixForTypeWarning(value) {
+        var type = getPreciseType(value);
+        switch (type) {
+          case "array":
+          case "object":
+            return "an " + type;
+          case "boolean":
+          case "date":
+          case "regexp":
+            return "a " + type;
+          default:
+            return type;
+        }
+      }
+      function getClassName(propValue) {
+        if (!propValue.constructor || !propValue.constructor.name) {
+          return ANONYMOUS;
+        }
+        return propValue.constructor.name;
+      }
+      ReactPropTypes.checkPropTypes = checkPropTypes;
+      ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+      ReactPropTypes.PropTypes = ReactPropTypes;
+      return ReactPropTypes;
+    };
+  }
+});
+
+// ../../../../node_modules/prop-types/factoryWithThrowingShims.js
+var require_factoryWithThrowingShims = __commonJS({
+  "../../../../node_modules/prop-types/factoryWithThrowingShims.js"(exports, module2) {
+    "use strict";
+    var ReactPropTypesSecret = require_ReactPropTypesSecret();
+    function emptyFunction() {
+    }
+    function emptyFunctionWithReset() {
+    }
+    emptyFunctionWithReset.resetWarningCache = emptyFunction;
+    module2.exports = function() {
+      function shim(props, propName, componentName, location, propFullName, secret) {
+        if (secret === ReactPropTypesSecret) {
+          return;
+        }
+        var err = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        err.name = "Invariant Violation";
+        throw err;
+      }
+      ;
+      shim.isRequired = shim;
+      function getShim() {
+        return shim;
+      }
+      ;
+      var ReactPropTypes = {
+        array: shim,
+        bigint: shim,
+        bool: shim,
+        func: shim,
+        number: shim,
+        object: shim,
+        string: shim,
+        symbol: shim,
+        any: shim,
+        arrayOf: getShim,
+        element: shim,
+        elementType: shim,
+        instanceOf: getShim,
+        node: shim,
+        objectOf: getShim,
+        oneOf: getShim,
+        oneOfType: getShim,
+        shape: getShim,
+        exact: getShim,
+        checkPropTypes: emptyFunctionWithReset,
+        resetWarningCache: emptyFunction
+      };
+      ReactPropTypes.PropTypes = ReactPropTypes;
+      return ReactPropTypes;
+    };
+  }
+});
+
+// ../../../../node_modules/prop-types/index.js
+var require_prop_types = __commonJS({
+  "../../../../node_modules/prop-types/index.js"(exports, module2) {
+    "use strict";
+    if (process.env.NODE_ENV !== "production") {
+      ReactIs = require_react_is();
+      throwOnDirectAccess = true;
+      module2.exports = require_factoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
+    } else {
+      module2.exports = require_factoryWithThrowingShims()();
+    }
+    var ReactIs;
+    var throwOnDirectAccess;
+  }
+});
+
+// ../../../../node_modules/@mui/utils/unsupportedProp.js
+var require_unsupportedProp = __commonJS({
+  "../../../../node_modules/@mui/utils/unsupportedProp.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = unsupportedProp2;
+    function unsupportedProp2(props, propName, componentName, location, propFullName) {
+      if (process.env.NODE_ENV === "production") {
+        return null;
+      }
+      const propFullNameSafe = propFullName || propName;
+      if (typeof props[propName] !== "undefined") {
+        return new Error(`The prop \`${propFullNameSafe}\` is not supported. Please remove it.`);
+      }
+      return null;
+    }
+  }
+});
+
+// ../../../../node_modules/@babel/runtime/helpers/interopRequireDefault.js
+var require_interopRequireDefault = __commonJS({
+  "../../../../node_modules/@babel/runtime/helpers/interopRequireDefault.js"(exports, module2) {
+    "use strict";
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : {
+        "default": obj
+      };
+    }
+    module2.exports = _interopRequireDefault, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../../../node_modules/@mui/utils/esm/chainPropTypes/chainPropTypes.js
+function chainPropTypes(propType1, propType2) {
+  if (process.env.NODE_ENV === "production") {
+    return () => null;
+  }
+  return function validate(...args) {
+    return propType1(...args) || propType2(...args);
+  };
+}
+var init_chainPropTypes = __esm({
+  "../../../../node_modules/@mui/utils/esm/chainPropTypes/chainPropTypes.js"() {
+    "use strict";
+  }
+});
+
+// ../../../../node_modules/@mui/utils/esm/chainPropTypes/index.js
+var chainPropTypes_exports = {};
+__export(chainPropTypes_exports, {
+  default: () => chainPropTypes
+});
+var init_chainPropTypes2 = __esm({
+  "../../../../node_modules/@mui/utils/esm/chainPropTypes/index.js"() {
+    "use strict";
+    init_chainPropTypes();
+  }
+});
+
+// ../../../../node_modules/@mui/utils/elementTypeAcceptingRef.js
+var require_elementTypeAcceptingRef = __commonJS({
+  "../../../../node_modules/@mui/utils/elementTypeAcceptingRef.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _propTypes = _interopRequireDefault(require_prop_types());
+    var _chainPropTypes = _interopRequireDefault((init_chainPropTypes2(), __toCommonJS(chainPropTypes_exports)));
+    function isClassComponent(elementType) {
+      const {
+        prototype = {}
+      } = elementType;
+      return Boolean(prototype.isReactComponent);
+    }
+    function elementTypeAcceptingRef2(props, propName, componentName, location, propFullName) {
+      const propValue = props[propName];
+      const safePropName = propFullName || propName;
+      if (propValue == null || // When server-side rendering React doesn't warn either.
+      // This is not an accurate check for SSR.
+      // This is only in place for emotion compat.
+      // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
+      typeof window === "undefined") {
+        return null;
+      }
+      let warningHint;
+      if (typeof propValue === "function" && !isClassComponent(propValue)) {
+        warningHint = "Did you accidentally provide a plain function component instead?";
+      }
+      if (warningHint !== void 0) {
+        return new Error(`Invalid ${location} \`${safePropName}\` supplied to \`${componentName}\`. Expected an element type that can hold a ref. ${warningHint} For more information see https://mui.com/r/caveat-with-refs-guide`);
+      }
+      return null;
+    }
+    var _default = (0, _chainPropTypes.default)(_propTypes.default.elementType, elementTypeAcceptingRef2);
+    exports.default = _default;
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -462,25 +1518,1718 @@ var import_react4 = require("react");
 
 // src/TreeViewer/Reflection.tsx
 var import_icons_material = require("@mui/icons-material");
-var import_lab = require("@mui/lab");
 var import_material7 = require("@mui/material");
+
+// ../../../../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0)
+      continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+// ../../../../node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+// ../../../../node_modules/@mui/x-tree-view/TreeItem/TreeItem.js
+var React9 = __toESM(require("react"));
+var import_prop_types3 = __toESM(require_prop_types());
+
+// ../../../../node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e)
+    n += e;
+  else if ("object" == typeof e)
+    if (Array.isArray(e))
+      for (t = 0; t < e.length; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    else
+      for (t in e)
+        e[t] && (n && (n += " "), n += t);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = ""; f < arguments.length; )
+    (e = arguments[f++]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+var clsx_default = clsx;
+
+// ../../../../node_modules/@mui/x-tree-view/TreeItem/TreeItem.js
+var import_Collapse = __toESM(require("@mui/material/Collapse"));
+var import_styles = require("@mui/material/styles");
+
+// ../../../../node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js
+function ownerDocument(node) {
+  return node && node.ownerDocument || document;
+}
+
+// ../../../../node_modules/@mui/utils/esm/useForkRef/useForkRef.js
+var React = __toESM(require("react"));
+
+// ../../../../node_modules/@mui/utils/esm/setRef.js
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+}
+
+// ../../../../node_modules/@mui/utils/esm/useForkRef/useForkRef.js
+function useForkRef(...refs) {
+  return React.useMemo(() => {
+    if (refs.every((ref) => ref == null)) {
+      return null;
+    }
+    return (instance) => {
+      refs.forEach((ref) => {
+        setRef(ref, instance);
+      });
+    };
+  }, refs);
+}
+
+// ../../../../node_modules/@mui/x-tree-view/TreeItem/TreeItem.js
+var import_unsupportedProp = __toESM(require_unsupportedProp());
+var import_elementTypeAcceptingRef = __toESM(require_elementTypeAcceptingRef());
+
+// ../../../../node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js
+var React2 = __toESM(require("react"));
+var useEnhancedEffect = typeof window !== "undefined" ? React2.useLayoutEffect : React2.useEffect;
+var useEnhancedEffect_default = useEnhancedEffect;
+
+// ../../../../node_modules/@mui/utils/esm/useId/useId.js
+var React3 = __toESM(require("react"));
+var globalId = 0;
+function useGlobalId(idOverride) {
+  const [defaultId, setDefaultId] = React3.useState(idOverride);
+  const id = idOverride || defaultId;
+  React3.useEffect(() => {
+    if (defaultId == null) {
+      globalId += 1;
+      setDefaultId(`mui-${globalId}`);
+    }
+  }, [defaultId]);
+  return id;
+}
+var maybeReactUseId = React3["useId".toString()];
+function useId(idOverride) {
+  if (maybeReactUseId !== void 0) {
+    const reactId = maybeReactUseId();
+    return idOverride != null ? idOverride : reactId;
+  }
+  return useGlobalId(idOverride);
+}
+
+// ../../../../node_modules/@mui/utils/esm/useControlled/useControlled.js
+var React4 = __toESM(require("react"));
+function useControlled({
+  controlled,
+  default: defaultProp,
+  name,
+  state = "value"
+}) {
+  const {
+    current: isControlled
+  } = React4.useRef(controlled !== void 0);
+  const [valueState, setValue] = React4.useState(defaultProp);
+  const value = isControlled ? controlled : valueState;
+  if (process.env.NODE_ENV !== "production") {
+    React4.useEffect(() => {
+      if (isControlled !== (controlled !== void 0)) {
+        console.error([`MUI: A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join("\n"));
+      }
+    }, [state, name, controlled]);
+    const {
+      current: defaultValue
+    } = React4.useRef(defaultProp);
+    React4.useEffect(() => {
+      if (!isControlled && defaultValue !== defaultProp) {
+        console.error([`MUI: A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join("\n"));
+      }
+    }, [JSON.stringify(defaultProp)]);
+  }
+  const setValueIfUncontrolled = React4.useCallback((newValue) => {
+    if (!isControlled) {
+      setValue(newValue);
+    }
+  }, []);
+  return [value, setValueIfUncontrolled];
+}
+
+// ../../../../node_modules/@mui/utils/esm/composeClasses/composeClasses.js
+function composeClasses(slots, getUtilityClass, classes = void 0) {
+  const output = {};
+  Object.keys(slots).forEach(
+    // `Object.keys(slots)` can't be wider than `T` because we infer `T` from `slots`.
+    // @ts-expect-error https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208
+    (slot) => {
+      output[slot] = slots[slot].reduce((acc, key) => {
+        if (key) {
+          const utilityClass = getUtilityClass(key);
+          if (utilityClass !== "") {
+            acc.push(utilityClass);
+          }
+          if (classes && classes[key]) {
+            acc.push(classes[key]);
+          }
+        }
+        return acc;
+      }, []).join(" ");
+    }
+  );
+  return output;
+}
+
+// ../../../../node_modules/@mui/utils/esm/ClassNameGenerator/ClassNameGenerator.js
+var defaultGenerator = (componentName) => componentName;
+var createClassNameGenerator = () => {
+  let generate = defaultGenerator;
+  return {
+    configure(generator) {
+      generate = generator;
+    },
+    generate(componentName) {
+      return generate(componentName);
+    },
+    reset() {
+      generate = defaultGenerator;
+    }
+  };
+};
+var ClassNameGenerator = createClassNameGenerator();
+var ClassNameGenerator_default = ClassNameGenerator;
+
+// ../../../../node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js
+var globalStateClassesMapping = {
+  active: "active",
+  checked: "checked",
+  completed: "completed",
+  disabled: "disabled",
+  error: "error",
+  expanded: "expanded",
+  focused: "focused",
+  focusVisible: "focusVisible",
+  open: "open",
+  readOnly: "readOnly",
+  required: "required",
+  selected: "selected"
+};
+function generateUtilityClass(componentName, slot, globalStatePrefix = "Mui") {
+  const globalStateClass = globalStateClassesMapping[slot];
+  return globalStateClass ? `${globalStatePrefix}-${globalStateClass}` : `${ClassNameGenerator_default.generate(componentName)}-${slot}`;
+}
+
+// ../../../../node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js
+function generateUtilityClasses(componentName, slots, globalStatePrefix = "Mui") {
+  const result = {};
+  slots.forEach((slot) => {
+    result[slot] = generateUtilityClass(componentName, slot, globalStatePrefix);
+  });
+  return result;
+}
+
+// ../../../../node_modules/@mui/x-tree-view/TreeView/TreeViewContext.js
+var React5 = __toESM(require("react"));
+var TreeViewContext = /* @__PURE__ */ React5.createContext({
+  registerNode: () => {
+  },
+  unregisterNode: () => {
+  },
+  isFocused: () => false,
+  isSelected: () => false,
+  isExpanded: () => false,
+  isExpandable: () => false,
+  isDisabled: () => false,
+  mapFirstChar: () => {
+  },
+  unMapFirstChar: () => {
+  },
+  focus: () => {
+  },
+  toggleExpansion: () => {
+  },
+  selectNode: () => {
+  },
+  selectRange: () => {
+  },
+  multiSelect: false,
+  disabledItemsFocusable: false,
+  treeId: void 0,
+  icons: {
+    defaultCollapseIcon: null,
+    defaultExpandIcon: null,
+    defaultParentIcon: null,
+    defaultEndIcon: null
+  }
+});
+if (process.env.NODE_ENV !== "production") {
+  TreeViewContext.displayName = "TreeViewContext";
+}
+
+// ../../../../node_modules/@mui/x-tree-view/TreeView/descendants.js
+var React6 = __toESM(require("react"));
+var import_prop_types = __toESM(require_prop_types());
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var _excluded = ["element"];
+function findIndex(array, comp) {
+  for (let i = 0; i < array.length; i += 1) {
+    if (comp(array[i])) {
+      return i;
+    }
+  }
+  return -1;
+}
+function binaryFindElement(array, element) {
+  let start = 0;
+  let end = array.length - 1;
+  while (start <= end) {
+    const middle = Math.floor((start + end) / 2);
+    if (array[middle].element === element) {
+      return middle;
+    }
+    if (array[middle].element.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_PRECEDING) {
+      end = middle - 1;
+    } else {
+      start = middle + 1;
+    }
+  }
+  return start;
+}
+var DescendantContext = /* @__PURE__ */ React6.createContext({});
+if (process.env.NODE_ENV !== "production") {
+  DescendantContext.displayName = "DescendantContext";
+}
+function usePrevious(value) {
+  const ref = React6.useRef(null);
+  React6.useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+var noop = () => {
+};
+function useDescendant(descendant) {
+  const [, forceUpdate] = React6.useState();
+  const {
+    registerDescendant = noop,
+    unregisterDescendant = noop,
+    descendants = [],
+    parentId = null
+  } = React6.useContext(DescendantContext);
+  const index = findIndex(descendants, (item) => item.element === descendant.element);
+  const previousDescendants = usePrevious(descendants);
+  const someDescendantsHaveChanged = descendants.some((newDescendant, position) => {
+    return previousDescendants && previousDescendants[position] && previousDescendants[position].element !== newDescendant.element;
+  });
+  useEnhancedEffect_default(() => {
+    if (descendant.element) {
+      registerDescendant(_extends({}, descendant, {
+        index
+      }));
+      return () => {
+        unregisterDescendant(descendant.element);
+      };
+    }
+    forceUpdate({});
+    return void 0;
+  }, [registerDescendant, unregisterDescendant, index, someDescendantsHaveChanged, descendant]);
+  return {
+    parentId,
+    index
+  };
+}
+function DescendantProvider(props) {
+  const {
+    children,
+    id
+  } = props;
+  const [items, set] = React6.useState([]);
+  const registerDescendant = React6.useCallback((_ref) => {
+    let {
+      element
+    } = _ref, other = _objectWithoutPropertiesLoose(_ref, _excluded);
+    set((oldItems) => {
+      if (oldItems.length === 0) {
+        return [_extends({}, other, {
+          element,
+          index: 0
+        })];
+      }
+      const index = binaryFindElement(oldItems, element);
+      let newItems;
+      if (oldItems[index] && oldItems[index].element === element) {
+        newItems = oldItems;
+      } else {
+        const newItem = _extends({}, other, {
+          element,
+          index
+        });
+        newItems = oldItems.slice();
+        newItems.splice(index, 0, newItem);
+      }
+      newItems.forEach((item, position) => {
+        item.index = position;
+      });
+      return newItems;
+    });
+  }, []);
+  const unregisterDescendant = React6.useCallback((element) => {
+    set((oldItems) => oldItems.filter((item) => element !== item.element));
+  }, []);
+  const value = React6.useMemo(() => ({
+    descendants: items,
+    registerDescendant,
+    unregisterDescendant,
+    parentId: id
+  }), [items, registerDescendant, unregisterDescendant, id]);
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(DescendantContext.Provider, {
+    value,
+    children
+  });
+}
+process.env.NODE_ENV !== "production" ? DescendantProvider.propTypes = {
+  children: import_prop_types.default.node,
+  id: import_prop_types.default.string
+} : void 0;
+
+// ../../../../node_modules/@mui/x-tree-view/TreeItem/TreeItemContent.js
+var React8 = __toESM(require("react"));
+var import_prop_types2 = __toESM(require_prop_types());
+
+// ../../../../node_modules/@mui/x-tree-view/TreeItem/useTreeItem.js
+var React7 = __toESM(require("react"));
+function useTreeItem(nodeId) {
+  const {
+    focus,
+    isExpanded,
+    isExpandable,
+    isFocused,
+    isDisabled,
+    isSelected,
+    multiSelect,
+    selectNode,
+    selectRange,
+    toggleExpansion
+  } = React7.useContext(TreeViewContext);
+  const expandable = isExpandable ? isExpandable(nodeId) : false;
+  const expanded = isExpanded ? isExpanded(nodeId) : false;
+  const focused = isFocused ? isFocused(nodeId) : false;
+  const disabled = isDisabled ? isDisabled(nodeId) : false;
+  const selected = isSelected ? isSelected(nodeId) : false;
+  const handleExpansion = (event) => {
+    if (!disabled) {
+      if (!focused) {
+        focus(event, nodeId);
+      }
+      const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
+      if (expandable && !(multiple && isExpanded(nodeId))) {
+        toggleExpansion(event, nodeId);
+      }
+    }
+  };
+  const handleSelection = (event) => {
+    if (!disabled) {
+      if (!focused) {
+        focus(event, nodeId);
+      }
+      const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);
+      if (multiple) {
+        if (event.shiftKey) {
+          selectRange(event, {
+            end: nodeId
+          });
+        } else {
+          selectNode(event, nodeId, true);
+        }
+      } else {
+        selectNode(event, nodeId);
+      }
+    }
+  };
+  const preventSelection = (event) => {
+    if (event.shiftKey || event.ctrlKey || event.metaKey || disabled) {
+      event.preventDefault();
+    }
+  };
+  return {
+    disabled,
+    expanded,
+    selected,
+    focused,
+    handleExpansion,
+    handleSelection,
+    preventSelection
+  };
+}
+
+// ../../../../node_modules/@mui/x-tree-view/TreeItem/TreeItemContent.js
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var _excluded2 = ["classes", "className", "displayIcon", "expansionIcon", "icon", "label", "nodeId", "onClick", "onMouseDown"];
+var TreeItemContent = /* @__PURE__ */ React8.forwardRef(function TreeItemContent2(props, ref) {
+  const {
+    classes,
+    className,
+    displayIcon,
+    expansionIcon,
+    icon: iconProp,
+    label,
+    nodeId,
+    onClick,
+    onMouseDown
+  } = props, other = _objectWithoutPropertiesLoose(props, _excluded2);
+  const {
+    disabled,
+    expanded,
+    selected,
+    focused,
+    handleExpansion,
+    handleSelection,
+    preventSelection
+  } = useTreeItem(nodeId);
+  const icon = iconProp || expansionIcon || displayIcon;
+  const handleMouseDown = (event) => {
+    preventSelection(event);
+    if (onMouseDown) {
+      onMouseDown(event);
+    }
+  };
+  const handleClick = (event) => {
+    handleExpansion(event);
+    handleSelection(event);
+    if (onClick) {
+      onClick(event);
+    }
+  };
+  return (
+    /* eslint-disable-next-line jsx-a11y/click-events-have-key-events,jsx-a11y/no-static-element-interactions -- Key event is handled by the TreeView */
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)("div", _extends({}, other, {
+      className: clsx_default(className, classes.root, expanded && classes.expanded, selected && classes.selected, focused && classes.focused, disabled && classes.disabled),
+      onClick: handleClick,
+      onMouseDown: handleMouseDown,
+      ref,
+      children: [/* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", {
+        className: classes.iconContainer,
+        children: icon
+      }), /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", {
+        className: classes.label,
+        children: label
+      })]
+    }))
+  );
+});
+process.env.NODE_ENV !== "production" ? TreeItemContent.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: import_prop_types2.default.object.isRequired,
+  /**
+   * className applied to the root element.
+   */
+  className: import_prop_types2.default.string,
+  /**
+   * The icon to display next to the tree node's label. Either a parent or end icon.
+   */
+  displayIcon: import_prop_types2.default.node,
+  /**
+   * The icon to display next to the tree node's label. Either an expansion or collapse icon.
+   */
+  expansionIcon: import_prop_types2.default.node,
+  /**
+   * The icon to display next to the tree node's label.
+   */
+  icon: import_prop_types2.default.node,
+  /**
+   * The tree node label.
+   */
+  label: import_prop_types2.default.node,
+  /**
+   * The id of the node.
+   */
+  nodeId: import_prop_types2.default.string.isRequired
+} : void 0;
+
+// ../../../../node_modules/@mui/x-tree-view/TreeItem/treeItemClasses.js
+function getTreeItemUtilityClass(slot) {
+  return generateUtilityClass("MuiTreeItem", slot);
+}
+var treeItemClasses = generateUtilityClasses("MuiTreeItem", ["root", "group", "content", "expanded", "selected", "focused", "disabled", "iconContainer", "label"]);
+
+// ../../../../node_modules/@mui/x-tree-view/TreeItem/TreeItem.js
+var import_jsx_runtime15 = require("react/jsx-runtime");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+var _excluded3 = ["children", "className", "collapseIcon", "ContentComponent", "ContentProps", "endIcon", "expandIcon", "disabled", "icon", "id", "label", "nodeId", "onClick", "onMouseDown", "TransitionComponent", "TransitionProps"];
+var useUtilityClasses = (ownerState) => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ["root"],
+    content: ["content"],
+    expanded: ["expanded"],
+    selected: ["selected"],
+    focused: ["focused"],
+    disabled: ["disabled"],
+    iconContainer: ["iconContainer"],
+    label: ["label"],
+    group: ["group"]
+  };
+  return composeClasses(slots, getTreeItemUtilityClass, classes);
+};
+var TreeItemRoot = (0, import_styles.styled)("li", {
+  name: "MuiTreeItem",
+  slot: "Root",
+  overridesResolver: (props, styles) => styles.root
+})({
+  listStyle: "none",
+  margin: 0,
+  padding: 0,
+  outline: 0
+});
+var StyledTreeItemContent = (0, import_styles.styled)(TreeItemContent, {
+  name: "MuiTreeItem",
+  slot: "Content",
+  overridesResolver: (props, styles) => {
+    return [styles.content, styles.iconContainer && {
+      [`& .${treeItemClasses.iconContainer}`]: styles.iconContainer
+    }, styles.label && {
+      [`& .${treeItemClasses.label}`]: styles.label
+    }];
+  }
+})(({
+  theme
+}) => ({
+  padding: "0 8px",
+  width: "100%",
+  boxSizing: "border-box",
+  // prevent width + padding to overflow
+  display: "flex",
+  alignItems: "center",
+  cursor: "pointer",
+  WebkitTapHighlightColor: "transparent",
+  "&:hover": {
+    backgroundColor: (theme.vars || theme).palette.action.hover,
+    // Reset on touch devices, it doesn't add specificity
+    "@media (hover: none)": {
+      backgroundColor: "transparent"
+    }
+  },
+  [`&.${treeItemClasses.disabled}`]: {
+    opacity: (theme.vars || theme).palette.action.disabledOpacity,
+    backgroundColor: "transparent"
+  },
+  [`&.${treeItemClasses.focused}`]: {
+    backgroundColor: (theme.vars || theme).palette.action.focus
+  },
+  [`&.${treeItemClasses.selected}`]: {
+    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / ${theme.vars.palette.action.selectedOpacity})` : (0, import_styles.alpha)(theme.palette.primary.main, theme.palette.action.selectedOpacity),
+    "&:hover": {
+      backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.hoverOpacity}))` : (0, import_styles.alpha)(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / ${theme.vars.palette.action.selectedOpacity})` : (0, import_styles.alpha)(theme.palette.primary.main, theme.palette.action.selectedOpacity)
+      }
+    },
+    [`&.${treeItemClasses.focused}`]: {
+      backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.focusOpacity}))` : (0, import_styles.alpha)(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
+    }
+  },
+  [`& .${treeItemClasses.iconContainer}`]: {
+    marginRight: 4,
+    width: 15,
+    display: "flex",
+    flexShrink: 0,
+    justifyContent: "center",
+    "& svg": {
+      fontSize: 18
+    }
+  },
+  [`& .${treeItemClasses.label}`]: _extends({
+    paddingLeft: 4,
+    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"
+  }, theme.typography.body1)
+}));
+var TreeItemGroup = (0, import_styles.styled)(import_Collapse.default, {
+  name: "MuiTreeItem",
+  slot: "Group",
+  overridesResolver: (props, styles) => styles.group
+})({
+  margin: 0,
+  padding: 0,
+  marginLeft: 17
+});
+var TreeItem = /* @__PURE__ */ React9.forwardRef(function TreeItem2(inProps, ref) {
+  const props = (0, import_styles.useThemeProps)({
+    props: inProps,
+    name: "MuiTreeItem"
+  });
+  const {
+    children,
+    className,
+    collapseIcon,
+    ContentComponent = TreeItemContent,
+    ContentProps,
+    endIcon,
+    expandIcon,
+    disabled: disabledProp,
+    icon,
+    id: idProp,
+    label,
+    nodeId,
+    onClick,
+    onMouseDown,
+    TransitionComponent = import_Collapse.default,
+    TransitionProps
+  } = props, other = _objectWithoutPropertiesLoose(props, _excluded3);
+  const {
+    icons: contextIcons,
+    focus,
+    isExpanded,
+    isFocused,
+    isSelected,
+    isDisabled,
+    multiSelect,
+    disabledItemsFocusable,
+    mapFirstChar,
+    unMapFirstChar,
+    registerNode,
+    unregisterNode,
+    treeId
+  } = React9.useContext(TreeViewContext);
+  let id;
+  if (idProp != null) {
+    id = idProp;
+  } else if (treeId && nodeId) {
+    id = `${treeId}-${nodeId}`;
+  }
+  const [treeItemElement, setTreeItemElement] = React9.useState(null);
+  const contentRef = React9.useRef(null);
+  const handleRef = useForkRef(setTreeItemElement, ref);
+  const descendant = React9.useMemo(() => ({
+    element: treeItemElement,
+    id: nodeId
+  }), [nodeId, treeItemElement]);
+  const {
+    index,
+    parentId
+  } = useDescendant(descendant);
+  const expandable = Boolean(Array.isArray(children) ? children.length : children);
+  const expanded = isExpanded ? isExpanded(nodeId) : false;
+  const focused = isFocused ? isFocused(nodeId) : false;
+  const selected = isSelected ? isSelected(nodeId) : false;
+  const disabled = isDisabled ? isDisabled(nodeId) : false;
+  const ownerState = _extends({}, props, {
+    expanded,
+    focused,
+    selected,
+    disabled
+  });
+  const classes = useUtilityClasses(ownerState);
+  let displayIcon;
+  let expansionIcon;
+  if (expandable) {
+    if (!expanded) {
+      expansionIcon = expandIcon || contextIcons.defaultExpandIcon;
+    } else {
+      expansionIcon = collapseIcon || contextIcons.defaultCollapseIcon;
+    }
+  }
+  if (expandable) {
+    displayIcon = contextIcons.defaultParentIcon;
+  } else {
+    displayIcon = endIcon || contextIcons.defaultEndIcon;
+  }
+  React9.useEffect(() => {
+    if (registerNode && unregisterNode && index !== -1) {
+      registerNode({
+        id: nodeId,
+        idAttribute: id,
+        index,
+        parentId,
+        expandable,
+        disabled: disabledProp
+      });
+      return () => {
+        unregisterNode(nodeId);
+      };
+    }
+    return void 0;
+  }, [registerNode, unregisterNode, parentId, index, nodeId, expandable, disabledProp, id]);
+  React9.useEffect(() => {
+    if (mapFirstChar && unMapFirstChar && label) {
+      var _contentRef$current$t, _contentRef$current;
+      mapFirstChar(nodeId, ((_contentRef$current$t = (_contentRef$current = contentRef.current) == null ? void 0 : _contentRef$current.textContent) != null ? _contentRef$current$t : "").substring(0, 1).toLowerCase());
+      return () => {
+        unMapFirstChar(nodeId);
+      };
+    }
+    return void 0;
+  }, [mapFirstChar, unMapFirstChar, nodeId, label]);
+  let ariaSelected;
+  if (multiSelect) {
+    ariaSelected = selected;
+  } else if (selected) {
+    ariaSelected = true;
+  }
+  function handleFocus(event) {
+    if (event.target === event.currentTarget) {
+      let rootElement;
+      if (typeof event.target.getRootNode === "function") {
+        rootElement = event.target.getRootNode();
+      } else {
+        rootElement = ownerDocument(event.target);
+      }
+      rootElement.getElementById(treeId).focus({
+        preventScroll: true
+      });
+    }
+    const unfocusable = !disabledItemsFocusable && disabled;
+    if (!focused && event.currentTarget === event.target && !unfocusable) {
+      focus(event, nodeId);
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(TreeItemRoot, _extends({
+    className: clsx_default(classes.root, className),
+    role: "treeitem",
+    "aria-expanded": expandable ? expanded : void 0,
+    "aria-selected": ariaSelected,
+    "aria-disabled": disabled || void 0,
+    id,
+    tabIndex: -1
+  }, other, {
+    ownerState,
+    onFocus: handleFocus,
+    ref: handleRef,
+    children: [/* @__PURE__ */ (0, import_jsx_runtime15.jsx)(StyledTreeItemContent, _extends({
+      as: ContentComponent,
+      ref: contentRef,
+      classes: {
+        root: classes.content,
+        expanded: classes.expanded,
+        selected: classes.selected,
+        focused: classes.focused,
+        disabled: classes.disabled,
+        iconContainer: classes.iconContainer,
+        label: classes.label
+      },
+      label,
+      nodeId,
+      onClick,
+      onMouseDown,
+      icon,
+      expansionIcon,
+      displayIcon,
+      ownerState
+    }, ContentProps)), children && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(DescendantProvider, {
+      id: nodeId,
+      children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(TreeItemGroup, _extends({
+        as: TransitionComponent,
+        unmountOnExit: true,
+        className: classes.group,
+        in: expanded,
+        component: "ul",
+        role: "group"
+      }, TransitionProps, {
+        children
+      }))
+    })]
+  }));
+});
+process.env.NODE_ENV !== "production" ? TreeItem.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The content of the component.
+   */
+  children: import_prop_types3.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: import_prop_types3.default.object,
+  /**
+   * className applied to the root element.
+   */
+  className: import_prop_types3.default.string,
+  /**
+   * The icon used to collapse the node.
+   */
+  collapseIcon: import_prop_types3.default.node,
+  /**
+   * The component used for the content node.
+   * @default TreeItemContent
+   */
+  ContentComponent: import_elementTypeAcceptingRef.default,
+  /**
+   * Props applied to ContentComponent.
+   */
+  ContentProps: import_prop_types3.default.object,
+  /**
+   * If `true`, the node is disabled.
+   * @default false
+   */
+  disabled: import_prop_types3.default.bool,
+  /**
+   * The icon displayed next to an end node.
+   */
+  endIcon: import_prop_types3.default.node,
+  /**
+   * The icon used to expand the node.
+   */
+  expandIcon: import_prop_types3.default.node,
+  /**
+   * The icon to display next to the tree node's label.
+   */
+  icon: import_prop_types3.default.node,
+  /**
+   * The tree node label.
+   */
+  label: import_prop_types3.default.node,
+  /**
+   * The id of the node.
+   */
+  nodeId: import_prop_types3.default.string.isRequired,
+  /**
+   * This prop isn't supported.
+   * Use the `onNodeFocus` callback on the tree if you need to monitor a node's focus.
+   */
+  onFocus: import_unsupportedProp.default,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: import_prop_types3.default.oneOfType([import_prop_types3.default.arrayOf(import_prop_types3.default.oneOfType([import_prop_types3.default.func, import_prop_types3.default.object, import_prop_types3.default.bool])), import_prop_types3.default.func, import_prop_types3.default.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Collapse
+   */
+  TransitionComponent: import_prop_types3.default.elementType,
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](http://reactcommunity.org/react-transition-group/transition/) component.
+   */
+  TransitionProps: import_prop_types3.default.object
+} : void 0;
+
+// ../../../../node_modules/@mui/x-tree-view/TreeView/TreeView.js
+var React10 = __toESM(require("react"));
+var import_prop_types4 = __toESM(require_prop_types());
+var import_styles2 = require("@mui/material/styles");
+
+// ../../../../node_modules/@mui/x-tree-view/TreeView/treeViewClasses.js
+function getTreeViewUtilityClass(slot) {
+  return generateUtilityClass("MuiTreeView", slot);
+}
+var treeViewClasses = generateUtilityClasses("MuiTreeView", ["root"]);
+
+// ../../../../node_modules/@mui/x-tree-view/TreeView/TreeView.js
+var import_jsx_runtime17 = require("react/jsx-runtime");
+var _excluded4 = ["children", "className", "defaultCollapseIcon", "defaultEndIcon", "defaultExpanded", "defaultExpandIcon", "defaultParentIcon", "defaultSelected", "disabledItemsFocusable", "disableSelection", "expanded", "id", "multiSelect", "onBlur", "onFocus", "onKeyDown", "onNodeFocus", "onNodeSelect", "onNodeToggle", "selected"];
+var useUtilityClasses2 = (ownerState) => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ["root"]
+  };
+  return composeClasses(slots, getTreeViewUtilityClass, classes);
+};
+var TreeViewRoot = (0, import_styles2.styled)("ul", {
+  name: "MuiTreeView",
+  slot: "Root",
+  overridesResolver: (props, styles) => styles.root
+})({
+  padding: 0,
+  margin: 0,
+  listStyle: "none",
+  outline: 0
+});
+function isPrintableCharacter(string) {
+  return string && string.length === 1 && string.match(/\S/);
+}
+function findNextFirstChar(firstChars, startIndex, char) {
+  for (let i = startIndex; i < firstChars.length; i += 1) {
+    if (char === firstChars[i]) {
+      return i;
+    }
+  }
+  return -1;
+}
+function noopSelection() {
+  return false;
+}
+var defaultDefaultExpanded = [];
+var defaultDefaultSelected = [];
+var TreeView = /* @__PURE__ */ React10.forwardRef(function TreeView2(inProps, ref) {
+  var _themeProps$disabledI, _themeProps$disableSe, _themeProps$multiSele, _themeProps$defaultEx, _themeProps$defaultSe;
+  const themeProps = (0, import_styles2.useThemeProps)({
+    props: inProps,
+    name: "MuiTreeView"
+  });
+  const props = _extends({}, themeProps, {
+    disabledItemsFocusable: (_themeProps$disabledI = themeProps.disabledItemsFocusable) != null ? _themeProps$disabledI : false,
+    disableSelection: (_themeProps$disableSe = themeProps.disableSelection) != null ? _themeProps$disableSe : false,
+    multiSelect: (_themeProps$multiSele = themeProps.multiSelect) != null ? _themeProps$multiSele : false,
+    defaultExpanded: (_themeProps$defaultEx = themeProps.defaultExpanded) != null ? _themeProps$defaultEx : defaultDefaultExpanded,
+    defaultSelected: (_themeProps$defaultSe = themeProps.defaultSelected) != null ? _themeProps$defaultSe : defaultDefaultSelected
+  });
+  const {
+    children,
+    className,
+    defaultCollapseIcon,
+    defaultEndIcon,
+    defaultExpanded,
+    defaultExpandIcon,
+    defaultParentIcon,
+    defaultSelected,
+    disabledItemsFocusable,
+    disableSelection,
+    expanded: expandedProp,
+    id: idProp,
+    multiSelect,
+    onBlur,
+    onFocus,
+    onKeyDown,
+    onNodeFocus,
+    onNodeSelect,
+    onNodeToggle,
+    selected: selectedProp
+  } = props, other = _objectWithoutPropertiesLoose(props, _excluded4);
+  const theme = (0, import_styles2.useTheme)();
+  const isRtl = theme.direction === "rtl";
+  const classes = useUtilityClasses2(props);
+  const treeId = useId(idProp);
+  const treeRef = React10.useRef(null);
+  const handleRef = useForkRef(treeRef, ref);
+  const [focusedNodeId, setFocusedNodeId] = React10.useState(null);
+  const nodeMap = React10.useRef({});
+  const firstCharMap = React10.useRef({});
+  const [expanded, setExpandedState] = useControlled({
+    controlled: expandedProp,
+    default: defaultExpanded,
+    name: "TreeView",
+    state: "expanded"
+  });
+  const [selected, setSelectedState] = useControlled({
+    controlled: selectedProp,
+    default: defaultSelected,
+    name: "TreeView",
+    state: "selected"
+  });
+  const isExpanded = React10.useCallback((nodeId) => Array.isArray(expanded) ? expanded.indexOf(nodeId) !== -1 : false, [expanded]);
+  const isExpandable = React10.useCallback((nodeId) => nodeMap.current[nodeId] && nodeMap.current[nodeId].expandable, []);
+  const isSelected = React10.useCallback((nodeId) => Array.isArray(selected) ? selected.indexOf(nodeId) !== -1 : selected === nodeId, [selected]);
+  const isDisabled = React10.useCallback((nodeId) => {
+    if (nodeId == null) {
+      return false;
+    }
+    let node = nodeMap.current[nodeId];
+    if (!node) {
+      return false;
+    }
+    if (node.disabled) {
+      return true;
+    }
+    while (node.parentId != null) {
+      node = nodeMap.current[node.parentId];
+      if (node.disabled) {
+        return true;
+      }
+    }
+    return false;
+  }, []);
+  const isFocused = (nodeId) => focusedNodeId === nodeId;
+  const getChildrenIds = (nodeId) => Object.keys(nodeMap.current).map((key) => {
+    return nodeMap.current[key];
+  }).filter((node) => node.parentId === nodeId).sort((a, b) => a.index - b.index).map((child) => child.id);
+  const getNavigableChildrenIds = (nodeId) => {
+    let childrenIds = getChildrenIds(nodeId);
+    if (!disabledItemsFocusable) {
+      childrenIds = childrenIds.filter((node) => !isDisabled(node));
+    }
+    return childrenIds;
+  };
+  const getNextNode = (nodeId) => {
+    if (isExpanded(nodeId) && getNavigableChildrenIds(nodeId).length > 0) {
+      return getNavigableChildrenIds(nodeId)[0];
+    }
+    let node = nodeMap.current[nodeId];
+    while (node != null) {
+      const siblings = getNavigableChildrenIds(node.parentId);
+      const nextSibling = siblings[siblings.indexOf(node.id) + 1];
+      if (nextSibling) {
+        return nextSibling;
+      }
+      node = nodeMap.current[node.parentId];
+    }
+    return null;
+  };
+  const getPreviousNode = (nodeId) => {
+    const node = nodeMap.current[nodeId];
+    const siblings = getNavigableChildrenIds(node.parentId);
+    const nodeIndex = siblings.indexOf(nodeId);
+    if (nodeIndex === 0) {
+      return node.parentId;
+    }
+    let currentNode = siblings[nodeIndex - 1];
+    while (isExpanded(currentNode) && getNavigableChildrenIds(currentNode).length > 0) {
+      currentNode = getNavigableChildrenIds(currentNode).pop();
+    }
+    return currentNode;
+  };
+  const getLastNode = () => {
+    let lastNode = getNavigableChildrenIds(null).pop();
+    while (isExpanded(lastNode)) {
+      lastNode = getNavigableChildrenIds(lastNode).pop();
+    }
+    return lastNode;
+  };
+  const getFirstNode = () => getNavigableChildrenIds(null)[0];
+  const getParent = (nodeId) => nodeMap.current[nodeId].parentId;
+  const findOrderInTremauxTree = (nodeAId, nodeBId) => {
+    if (nodeAId === nodeBId) {
+      return [nodeAId, nodeBId];
+    }
+    const nodeA = nodeMap.current[nodeAId];
+    const nodeB = nodeMap.current[nodeBId];
+    if (nodeA.parentId === nodeB.id || nodeB.parentId === nodeA.id) {
+      return nodeB.parentId === nodeA.id ? [nodeA.id, nodeB.id] : [nodeB.id, nodeA.id];
+    }
+    const aFamily = [nodeA.id];
+    const bFamily = [nodeB.id];
+    let aAncestor = nodeA.parentId;
+    let bAncestor = nodeB.parentId;
+    let aAncestorIsCommon = bFamily.indexOf(aAncestor) !== -1;
+    let bAncestorIsCommon = aFamily.indexOf(bAncestor) !== -1;
+    let continueA = true;
+    let continueB = true;
+    while (!bAncestorIsCommon && !aAncestorIsCommon) {
+      if (continueA) {
+        aFamily.push(aAncestor);
+        aAncestorIsCommon = bFamily.indexOf(aAncestor) !== -1;
+        continueA = aAncestor !== null;
+        if (!aAncestorIsCommon && continueA) {
+          aAncestor = nodeMap.current[aAncestor].parentId;
+        }
+      }
+      if (continueB && !aAncestorIsCommon) {
+        bFamily.push(bAncestor);
+        bAncestorIsCommon = aFamily.indexOf(bAncestor) !== -1;
+        continueB = bAncestor !== null;
+        if (!bAncestorIsCommon && continueB) {
+          bAncestor = nodeMap.current[bAncestor].parentId;
+        }
+      }
+    }
+    const commonAncestor = aAncestorIsCommon ? aAncestor : bAncestor;
+    const ancestorFamily = getChildrenIds(commonAncestor);
+    const aSide = aFamily[aFamily.indexOf(commonAncestor) - 1];
+    const bSide = bFamily[bFamily.indexOf(commonAncestor) - 1];
+    return ancestorFamily.indexOf(aSide) < ancestorFamily.indexOf(bSide) ? [nodeAId, nodeBId] : [nodeBId, nodeAId];
+  };
+  const getNodesInRange = (nodeAId, nodeBId) => {
+    const [first, last] = findOrderInTremauxTree(nodeAId, nodeBId);
+    const nodes = [first];
+    let current = first;
+    while (current !== last) {
+      current = getNextNode(current);
+      nodes.push(current);
+    }
+    return nodes;
+  };
+  const focus = (event, nodeId) => {
+    if (nodeId) {
+      setFocusedNodeId(nodeId);
+      if (onNodeFocus) {
+        onNodeFocus(event, nodeId);
+      }
+    }
+  };
+  const focusNextNode = (event, nodeId) => focus(event, getNextNode(nodeId));
+  const focusPreviousNode = (event, nodeId) => focus(event, getPreviousNode(nodeId));
+  const focusFirstNode = (event) => focus(event, getFirstNode());
+  const focusLastNode = (event) => focus(event, getLastNode());
+  const focusByFirstCharacter = (event, nodeId, firstChar) => {
+    let start;
+    let index;
+    const lowercaseChar = firstChar.toLowerCase();
+    const firstCharIds = [];
+    const firstChars = [];
+    Object.keys(firstCharMap.current).forEach((mapNodeId) => {
+      const map = nodeMap.current[mapNodeId];
+      const visible = map.parentId ? isExpanded(map.parentId) : true;
+      const shouldBeSkipped = disabledItemsFocusable ? false : isDisabled(mapNodeId);
+      if (visible && !shouldBeSkipped) {
+        firstCharIds.push(mapNodeId);
+        firstChars.push(firstCharMap.current[mapNodeId]);
+      }
+    });
+    start = firstCharIds.indexOf(nodeId) + 1;
+    if (start >= firstCharIds.length) {
+      start = 0;
+    }
+    index = findNextFirstChar(firstChars, start, lowercaseChar);
+    if (index === -1) {
+      index = findNextFirstChar(firstChars, 0, lowercaseChar);
+    }
+    if (index > -1) {
+      focus(event, firstCharIds[index]);
+    }
+  };
+  const toggleExpansion = (event, value = focusedNodeId) => {
+    if (value == null) {
+      return;
+    }
+    let newExpanded;
+    if (expanded.indexOf(value) !== -1) {
+      newExpanded = expanded.filter((id) => id !== value);
+    } else {
+      newExpanded = [value].concat(expanded);
+    }
+    if (onNodeToggle) {
+      onNodeToggle(event, newExpanded);
+    }
+    setExpandedState(newExpanded);
+  };
+  const expandAllSiblings = (event, nodeId) => {
+    const map = nodeMap.current[nodeId];
+    const siblings = getChildrenIds(map.parentId);
+    const diff = siblings.filter((child) => isExpandable(child) && !isExpanded(child));
+    const newExpanded = expanded.concat(diff);
+    if (diff.length > 0) {
+      setExpandedState(newExpanded);
+      if (onNodeToggle) {
+        onNodeToggle(event, newExpanded);
+      }
+    }
+  };
+  const lastSelectedNode = React10.useRef(null);
+  const lastSelectionWasRange = React10.useRef(false);
+  const currentRangeSelection = React10.useRef([]);
+  const handleRangeArrowSelect = (event, nodes) => {
+    let base = selected.slice();
+    const {
+      start,
+      next,
+      current
+    } = nodes;
+    if (!next || !current) {
+      return;
+    }
+    if (currentRangeSelection.current.indexOf(current) === -1) {
+      currentRangeSelection.current = [];
+    }
+    if (lastSelectionWasRange.current) {
+      if (currentRangeSelection.current.indexOf(next) !== -1) {
+        base = base.filter((id) => id === start || id !== current);
+        currentRangeSelection.current = currentRangeSelection.current.filter((id) => id === start || id !== current);
+      } else {
+        base.push(next);
+        currentRangeSelection.current.push(next);
+      }
+    } else {
+      base.push(next);
+      currentRangeSelection.current.push(current, next);
+    }
+    if (onNodeSelect) {
+      onNodeSelect(event, base);
+    }
+    setSelectedState(base);
+  };
+  const handleRangeSelect = (event, nodes) => {
+    let base = selected.slice();
+    const {
+      start,
+      end
+    } = nodes;
+    if (lastSelectionWasRange.current) {
+      base = base.filter((id) => currentRangeSelection.current.indexOf(id) === -1);
+    }
+    let range = getNodesInRange(start, end);
+    range = range.filter((node) => !isDisabled(node));
+    currentRangeSelection.current = range;
+    let newSelected = base.concat(range);
+    newSelected = newSelected.filter((id, i) => newSelected.indexOf(id) === i);
+    if (onNodeSelect) {
+      onNodeSelect(event, newSelected);
+    }
+    setSelectedState(newSelected);
+  };
+  const handleMultipleSelect = (event, nodeId) => {
+    if (!Array.isArray(selected)) {
+      return;
+    }
+    let newSelected;
+    if (selected.indexOf(nodeId) !== -1) {
+      newSelected = selected.filter((id) => id !== nodeId);
+    } else {
+      newSelected = [nodeId].concat(selected);
+    }
+    if (onNodeSelect) {
+      onNodeSelect(event, newSelected);
+    }
+    setSelectedState(newSelected);
+  };
+  const handleSingleSelect = (event, nodeId) => {
+    const newSelected = multiSelect ? [nodeId] : nodeId;
+    if (onNodeSelect) {
+      onNodeSelect(event, newSelected);
+    }
+    setSelectedState(newSelected);
+  };
+  const selectNode = (event, nodeId, multiple = false) => {
+    if (nodeId) {
+      if (multiple) {
+        handleMultipleSelect(event, nodeId);
+      } else {
+        handleSingleSelect(event, nodeId);
+      }
+      lastSelectedNode.current = nodeId;
+      lastSelectionWasRange.current = false;
+      currentRangeSelection.current = [];
+      return true;
+    }
+    return false;
+  };
+  const selectRange = (event, nodes, stacked = false) => {
+    const {
+      start = lastSelectedNode.current,
+      end,
+      current
+    } = nodes;
+    if (stacked) {
+      handleRangeArrowSelect(event, {
+        start,
+        next: end,
+        current
+      });
+    } else if (start != null && end != null) {
+      handleRangeSelect(event, {
+        start,
+        end
+      });
+    }
+    lastSelectionWasRange.current = true;
+  };
+  const rangeSelectToFirst = (event, id) => {
+    if (!lastSelectedNode.current) {
+      lastSelectedNode.current = id;
+    }
+    const start = lastSelectionWasRange.current ? lastSelectedNode.current : id;
+    selectRange(event, {
+      start,
+      end: getFirstNode()
+    });
+  };
+  const rangeSelectToLast = (event, id) => {
+    if (!lastSelectedNode.current) {
+      lastSelectedNode.current = id;
+    }
+    const start = lastSelectionWasRange.current ? lastSelectedNode.current : id;
+    selectRange(event, {
+      start,
+      end: getLastNode()
+    });
+  };
+  const selectNextNode = (event, id) => {
+    if (!isDisabled(getNextNode(id))) {
+      selectRange(event, {
+        end: getNextNode(id),
+        current: id
+      }, true);
+    }
+  };
+  const selectPreviousNode = (event, id) => {
+    if (!isDisabled(getPreviousNode(id))) {
+      selectRange(event, {
+        end: getPreviousNode(id),
+        current: id
+      }, true);
+    }
+  };
+  const selectAllNodes = (event) => {
+    selectRange(event, {
+      start: getFirstNode(),
+      end: getLastNode()
+    });
+  };
+  const registerNode = React10.useCallback((node) => {
+    const {
+      id,
+      index,
+      parentId,
+      expandable,
+      idAttribute,
+      disabled
+    } = node;
+    nodeMap.current[id] = {
+      id,
+      index,
+      parentId,
+      expandable,
+      idAttribute,
+      disabled
+    };
+  }, []);
+  const unregisterNode = React10.useCallback((nodeId) => {
+    const newMap = _extends({}, nodeMap.current);
+    delete newMap[nodeId];
+    nodeMap.current = newMap;
+    setFocusedNodeId((oldFocusedNodeId) => {
+      if (oldFocusedNodeId === nodeId && treeRef.current === ownerDocument(treeRef.current).activeElement) {
+        return getChildrenIds(null)[0];
+      }
+      return oldFocusedNodeId;
+    });
+  }, []);
+  const mapFirstChar = React10.useCallback((nodeId, firstChar) => {
+    firstCharMap.current[nodeId] = firstChar;
+  }, []);
+  const unMapFirstChar = React10.useCallback((nodeId) => {
+    const newMap = _extends({}, firstCharMap.current);
+    delete newMap[nodeId];
+    firstCharMap.current = newMap;
+  }, []);
+  const handleNextArrow = (event) => {
+    if (focusedNodeId != null && isExpandable(focusedNodeId)) {
+      if (isExpanded(focusedNodeId)) {
+        focusNextNode(event, focusedNodeId);
+      } else if (!isDisabled(focusedNodeId)) {
+        toggleExpansion(event);
+      }
+    }
+    return true;
+  };
+  const handlePreviousArrow = (event) => {
+    if (focusedNodeId == null) {
+      return false;
+    }
+    if (isExpanded(focusedNodeId) && !isDisabled(focusedNodeId)) {
+      toggleExpansion(event, focusedNodeId);
+      return true;
+    }
+    const parent = getParent(focusedNodeId);
+    if (parent) {
+      focus(event, parent);
+      return true;
+    }
+    return false;
+  };
+  const handleKeyDown = (event) => {
+    let flag = false;
+    const key = event.key;
+    if (event.altKey || event.currentTarget !== event.target || !focusedNodeId) {
+      return;
+    }
+    const ctrlPressed = event.ctrlKey || event.metaKey;
+    switch (key) {
+      case " ":
+        if (!disableSelection && focusedNodeId != null && !isDisabled(focusedNodeId)) {
+          if (multiSelect && event.shiftKey) {
+            selectRange(event, {
+              end: focusedNodeId
+            });
+            flag = true;
+          } else if (multiSelect) {
+            flag = selectNode(event, focusedNodeId, true);
+          } else {
+            flag = selectNode(event, focusedNodeId);
+          }
+        }
+        event.stopPropagation();
+        break;
+      case "Enter":
+        if (!isDisabled(focusedNodeId)) {
+          if (isExpandable(focusedNodeId)) {
+            toggleExpansion(event);
+            flag = true;
+          } else if (multiSelect) {
+            flag = selectNode(event, focusedNodeId, true);
+          } else {
+            flag = selectNode(event, focusedNodeId);
+          }
+        }
+        event.stopPropagation();
+        break;
+      case "ArrowDown":
+        if (multiSelect && event.shiftKey && !disableSelection) {
+          selectNextNode(event, focusedNodeId);
+        }
+        focusNextNode(event, focusedNodeId);
+        flag = true;
+        break;
+      case "ArrowUp":
+        if (multiSelect && event.shiftKey && !disableSelection) {
+          selectPreviousNode(event, focusedNodeId);
+        }
+        focusPreviousNode(event, focusedNodeId);
+        flag = true;
+        break;
+      case "ArrowRight":
+        if (isRtl) {
+          flag = handlePreviousArrow(event);
+        } else {
+          flag = handleNextArrow(event);
+        }
+        break;
+      case "ArrowLeft":
+        if (isRtl) {
+          flag = handleNextArrow(event);
+        } else {
+          flag = handlePreviousArrow(event);
+        }
+        break;
+      case "Home":
+        if (multiSelect && ctrlPressed && event.shiftKey && !disableSelection && !isDisabled(focusedNodeId)) {
+          rangeSelectToFirst(event, focusedNodeId);
+        }
+        focusFirstNode(event);
+        flag = true;
+        break;
+      case "End":
+        if (multiSelect && ctrlPressed && event.shiftKey && !disableSelection && !isDisabled(focusedNodeId)) {
+          rangeSelectToLast(event, focusedNodeId);
+        }
+        focusLastNode(event);
+        flag = true;
+        break;
+      default:
+        if (key === "*") {
+          expandAllSiblings(event, focusedNodeId);
+          flag = true;
+        } else if (multiSelect && ctrlPressed && key.toLowerCase() === "a" && !disableSelection) {
+          selectAllNodes(event);
+          flag = true;
+        } else if (!ctrlPressed && !event.shiftKey && isPrintableCharacter(key)) {
+          focusByFirstCharacter(event, focusedNodeId, key);
+          flag = true;
+        }
+    }
+    if (flag) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    if (onKeyDown) {
+      onKeyDown(event);
+    }
+  };
+  const handleFocus = (event) => {
+    if (event.target === event.currentTarget) {
+      const firstSelected = Array.isArray(selected) ? selected[0] : selected;
+      focus(event, firstSelected || getNavigableChildrenIds(null)[0]);
+    }
+    if (onFocus) {
+      onFocus(event);
+    }
+  };
+  const handleBlur = (event) => {
+    setFocusedNodeId(null);
+    if (onBlur) {
+      onBlur(event);
+    }
+  };
+  const activeDescendant = nodeMap.current[focusedNodeId] ? nodeMap.current[focusedNodeId].idAttribute : null;
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(TreeViewContext.Provider, {
+    // TODO: fix this lint error
+    // eslint-disable-next-line react/jsx-no-constructed-context-values
+    value: {
+      icons: {
+        defaultCollapseIcon,
+        defaultExpandIcon,
+        defaultParentIcon,
+        defaultEndIcon
+      },
+      focus,
+      toggleExpansion,
+      isExpanded,
+      isExpandable,
+      isFocused,
+      isSelected,
+      isDisabled,
+      selectNode: disableSelection ? noopSelection : selectNode,
+      selectRange: disableSelection ? noopSelection : selectRange,
+      multiSelect,
+      disabledItemsFocusable,
+      mapFirstChar,
+      unMapFirstChar,
+      registerNode,
+      unregisterNode,
+      treeId
+    },
+    children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DescendantProvider, {
+      children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(TreeViewRoot, _extends({
+        role: "tree",
+        id: treeId,
+        "aria-activedescendant": activeDescendant != null ? activeDescendant : void 0,
+        "aria-multiselectable": multiSelect,
+        className: clsx_default(classes.root, className),
+        tabIndex: 0,
+        onKeyDown: handleKeyDown,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        ownerState: props
+      }, other, {
+        ref: handleRef,
+        children
+      }))
+    })
+  });
+});
+process.env.NODE_ENV !== "production" ? TreeView.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The content of the component.
+   */
+  children: import_prop_types4.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: import_prop_types4.default.object,
+  /**
+   * className applied to the root element.
+   */
+  className: import_prop_types4.default.string,
+  /**
+   * The default icon used to collapse the node.
+   */
+  defaultCollapseIcon: import_prop_types4.default.node,
+  /**
+   * The default icon displayed next to a end node. This is applied to all
+   * tree nodes and can be overridden by the TreeItem `icon` prop.
+   */
+  defaultEndIcon: import_prop_types4.default.node,
+  /**
+   * Expanded node ids.
+   * Used when the item's expansion are not controlled.
+   * @default []
+   */
+  defaultExpanded: import_prop_types4.default.arrayOf(import_prop_types4.default.string),
+  /**
+   * The default icon used to expand the node.
+   */
+  defaultExpandIcon: import_prop_types4.default.node,
+  /**
+   * The default icon displayed next to a parent node. This is applied to all
+   * parent nodes and can be overridden by the TreeItem `icon` prop.
+   */
+  defaultParentIcon: import_prop_types4.default.node,
+  /**
+   * Selected node ids. (Uncontrolled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   * @default []
+   */
+  defaultSelected: import_prop_types4.default.oneOfType([import_prop_types4.default.arrayOf(import_prop_types4.default.string), import_prop_types4.default.string]),
+  /**
+   * If `true`, will allow focus on disabled items.
+   * @default false
+   */
+  disabledItemsFocusable: import_prop_types4.default.bool,
+  /**
+   * If `true` selection is disabled.
+   * @default false
+   */
+  disableSelection: import_prop_types4.default.bool,
+  /**
+   * Expanded node ids.
+   * Used when the item's expansion are controlled.
+   */
+  expanded: import_prop_types4.default.arrayOf(import_prop_types4.default.string),
+  /**
+   * 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: import_prop_types4.default.string,
+  /**
+   * If true `ctrl` and `shift` will trigger multiselect.
+   * @default false
+   */
+  multiSelect: import_prop_types4.default.bool,
+  /**
+   * Callback fired when tree items are focused.
+   * @param {React.SyntheticEvent} event The event source of the callback **Warning**: This is a generic event not a focus event.
+   * @param {string} nodeId The id of the node focused.
+   * @param {string} value of the focused node.
+   */
+  onNodeFocus: import_prop_types4.default.func,
+  /**
+   * Callback fired when tree items are selected/unselected.
+   * @param {React.SyntheticEvent} event The event source of the callback
+   * @param {string[] | string} nodeIds Ids of the selected nodes. When `multiSelect` is true
+   * this is an array of strings; when false (default) a string.
+   */
+  onNodeSelect: import_prop_types4.default.func,
+  /**
+   * Callback fired when tree items are expanded/collapsed.
+   * @param {React.SyntheticEvent} event The event source of the callback.
+   * @param {array} nodeIds The ids of the expanded nodes.
+   */
+  onNodeToggle: import_prop_types4.default.func,
+  /**
+   * Selected node ids. (Controlled)
+   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
+   */
+  selected: import_prop_types4.default.oneOfType([import_prop_types4.default.arrayOf(import_prop_types4.default.string), import_prop_types4.default.string]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: import_prop_types4.default.oneOfType([import_prop_types4.default.arrayOf(import_prop_types4.default.oneOfType([import_prop_types4.default.func, import_prop_types4.default.object, import_prop_types4.default.bool])), import_prop_types4.default.func, import_prop_types4.default.object])
+} : void 0;
+
+// src/TreeViewer/Reflection.tsx
 var import_react_flexbox5 = require("@xylabs/react-flexbox");
 var import_react_router_dom3 = require("react-router-dom");
-var import_jsx_runtime12 = require("react/jsx-runtime");
+var import_jsx_runtime18 = require("react/jsx-runtime");
 var ReflectionTreeViewer = ({ lookup, reflection, searchTerm, ...props }) => {
   const navigate = (0, import_react_router_dom3.useNavigate)();
-  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_react_flexbox5.FlexCol, { alignItems: "stretch", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
-    import_lab.TreeView,
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_react_flexbox5.FlexCol, { alignItems: "stretch", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    TreeView,
     {
       "aria-label": "XYO SDK Documentation",
-      defaultExpandIcon: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_icons_material.Add, {}),
-      defaultCollapseIcon: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_icons_material.Remove, {}),
+      defaultExpandIcon: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_icons_material.Add, {}),
+      defaultCollapseIcon: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_icons_material.Remove, {}),
       defaultExpanded: reflection.groups ? [reflection.groups[0].title] : [],
-      children: reflection.groups?.map((group, index) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_lab.TreeItem, { nodeId: group.title, label: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_material7.Typography, { variant: "h6", children: group.title }), children: group.children.map((child, jndex) => {
+      children: reflection.groups?.map((group, index) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(TreeItem, { nodeId: group.title, label: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_material7.Typography, { variant: "h6", children: group.title }), children: group.children.map((child, jndex) => {
         const searchTermTrimmed = searchTerm?.trim().toLowerCase();
         const childReflection = typeof child === "number" ? lookup?.[child] : child;
-        return childReflection && (!searchTermTrimmed || childReflection.name.toLowerCase().indexOf(searchTermTrimmed) !== -1) ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
-          import_lab.TreeItem,
+        return childReflection && (!searchTermTrimmed || childReflection.name.toLowerCase().indexOf(searchTermTrimmed) !== -1) ? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+          TreeItem,
           {
             nodeId: `declaration-${childReflection?.id}`,
             label: childReflection.name,
@@ -500,7 +3249,7 @@ var ReflectionTreeViewer = ({ lookup, reflection, searchTerm, ...props }) => {
 // src/TreeViewer/ReflectionGroup.tsx
 var import_material8 = require("@mui/material");
 var import_react_flexbox6 = require("@xylabs/react-flexbox");
-var import_jsx_runtime13 = require("react/jsx-runtime");
+var import_jsx_runtime19 = require("react/jsx-runtime");
 var ReflectionGroupTreeViewer = ({
   variant,
   group,
@@ -509,10 +3258,10 @@ var ReflectionGroupTreeViewer = ({
   renderer = ReflectionViewer,
   ...props
 }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_react_flexbox6.FlexCol, { ...props, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_react_flexbox6.FlexRow, { marginY: 1, justifyContent: "flex-start", children: [
-      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Typography, { variant, children: group.title }),
-      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_react_flexbox6.FlexCol, { ...props, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_react_flexbox6.FlexRow, { marginY: 1, justifyContent: "flex-start", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_material8.Typography, { variant, children: group.title }),
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
         JsonViewerButton,
         {
           jsonViewProps: { collapsed: 1 },
@@ -527,7 +3276,7 @@ var ReflectionGroupTreeViewer = ({
     resolveChildren(group, lookup).map((reflection) => {
       return reflection ? (
         // I wrap this in a div since React does not understand that they have keys using the Renderer
-        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { children: renderer({ lookup, margin: 1, reflection }) }, reflection.id)
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { children: renderer({ lookup, margin: 1, reflection }) }, reflection.id)
       ) : null;
     }),
     children
@@ -535,7 +3284,7 @@ var ReflectionGroupTreeViewer = ({
 };
 
 // src/TwoPanelReflectionViewer.tsx
-var import_jsx_runtime14 = require("react/jsx-runtime");
+var import_jsx_runtime20 = require("react/jsx-runtime");
 var TwoPanelReflectionViewer = ({
   reflection,
   itemRenderer = ReflectionViewer,
@@ -550,7 +3299,7 @@ var TwoPanelReflectionViewer = ({
   };
   const reflectionGroups = (0, import_react4.useMemo)(() => {
     return reflection.groups?.map((group) => {
-      return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+      return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
         ReflectionGroupViewer,
         {
           autoscroll: true,
@@ -567,18 +3316,18 @@ var TwoPanelReflectionViewer = ({
     });
   }, [itemRenderer, lookup, reflection, hiddenFlags]);
   const NavigationCol = (props2) => {
-    return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react_flexbox7.FlexCol, { ...props2, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_react_flexbox7.FlexCol, { ...props2, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
         import_material9.TextField,
         {
           fullWidth: true,
           InputProps: {
-            startAdornment: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_icons_material2.Search, {})
+            startAdornment: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_icons_material2.Search, {})
           },
           onChange: onSearchTermChange
         }
       ),
-      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_flexbox7.FlexGrowCol, { marginTop: 1, alignItems: "stretch", children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_react_flexbox7.FlexGrowCol, { marginTop: 1, alignItems: "stretch", children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
         ReflectionTreeViewer,
         {
           justifyContent: "flex-start",
@@ -600,7 +3349,7 @@ var TwoPanelReflectionViewer = ({
     ] });
   };
   const DetailsCol = (props2) => {
-    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_flexbox7.FlexGrowCol, { ...props2, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_flexbox7.FlexGrowCol, { alignItems: "stretch", children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_react_flexbox7.FlexGrowCol, { ...props2, children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_react_flexbox7.FlexGrowCol, { alignItems: "stretch", children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
       import_react_flexbox7.FlexCol,
       {
         alignItems: "stretch",
@@ -618,29 +3367,29 @@ var TwoPanelReflectionViewer = ({
       }
     ) }) });
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react_flexbox7.FlexRow, { alignItems: "stretch", justifyContent: "start", sx: { overflowY: "scroll" }, ...props, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(NavigationCol, { minWidth: 320, alignItems: "stretch", justifyContent: "flex-start", overflow: "hidden" }),
-    /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DetailsCol, { marginLeft: 1, alignItems: "stretch", justifyContent: "flex-start", overflow: "hidden" })
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_react_flexbox7.FlexRow, { alignItems: "stretch", justifyContent: "start", sx: { overflowY: "scroll" }, ...props, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(NavigationCol, { minWidth: 320, alignItems: "stretch", justifyContent: "flex-start", overflow: "hidden" }),
+    /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(DetailsCol, { marginLeft: 1, alignItems: "stretch", justifyContent: "flex-start", overflow: "hidden" })
   ] });
 };
 
 // src/ProjectTwoPanelReflectionViewer.tsx
-var import_jsx_runtime15 = require("react/jsx-runtime");
+var import_jsx_runtime21 = require("react/jsx-runtime");
 var ProjectTwoPanelReflectionViewer = ({
   reflection,
   itemRenderer = DeclarationContainerReflectionViewer,
   ...props
 }) => {
   (0, import_assert.assertEx)(reflection.isProject, "Project expected to be Project");
-  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(TwoPanelReflectionViewer, { itemRenderer, reflection, ...props });
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(TwoPanelReflectionViewer, { itemRenderer, reflection, ...props });
 };
 
 // src/SourceViewer.tsx
 var import_material10 = require("@mui/material");
 var import_react_flexbox8 = require("@xylabs/react-flexbox");
-var import_jsx_runtime16 = require("react/jsx-runtime");
+var import_jsx_runtime22 = require("react/jsx-runtime");
 var SourceViewer = ({ source, ...props }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_react_flexbox8.FlexCol, { alignItems: "stretch", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_material10.Typography, { style: { opacity: 0.5 }, variant: "body2", children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("i", { children: source.fileName }) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_react_flexbox8.FlexCol, { alignItems: "stretch", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_material10.Typography, { style: { opacity: 0.5 }, variant: "body2", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("i", { children: source.fileName }) }) });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -659,4 +3408,33 @@ var SourceViewer = ({ source, ...props }) => {
   SourceViewer,
   TwoPanelReflectionViewer
 });
+/*! Bundled license information:
+
+react-is/cjs/react-is.production.min.js:
+  (** @license React v16.13.1
+   * react-is.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+react-is/cjs/react-is.development.js:
+  (** @license React v16.13.1
+   * react-is.development.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+object-assign/index.js:
+  (*
+  object-assign
+  (c) Sindre Sorhus
+  @license MIT
+  *)
+*/
 //# sourceMappingURL=index.js.map