@telicent-oss/ds 0.25.0 → 0.25.1

package/dist/ds.js

@@ -11119,9 +11119,9 @@ var newStyled = createStyled$3.bind(null);
 tags.forEach(function(tagName) {
   newStyled[tagName] = newStyled(tagName);
 });
-let cache;
+let cache$1;
 if (typeof document === "object") {
-  cache = createCache({
+  cache$1 = createCache({
     key: "css",
     prepend: true
   });
@@ -11131,8 +11131,8 @@ function StyledEngineProvider(props) {
     injectFirst,
     children: children2
   } = props;
-  return injectFirst && cache ? /* @__PURE__ */ jsxRuntimeExports.jsx(CacheProvider, {
-    value: cache,
+  return injectFirst && cache$1 ? /* @__PURE__ */ jsxRuntimeExports.jsx(CacheProvider, {
+    value: cache$1,
     children: children2
   }) : children2;
 }
@@ -11321,7 +11321,7 @@ const shape = {
   borderRadius: 4
 };
 const responsivePropType = process.env.NODE_ENV !== "production" ? PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.object, PropTypes.array]) : {};
-function merge(acc, item) {
+function merge$1(acc, item) {
   if (!item) {
     return acc;
   }
@@ -11633,7 +11633,7 @@ function resolveCssProperty(props, keys, prop, transformer) {
 }
 function style$1(props, keys) {
   const transformer = createUnarySpacing(props.theme);
-  return Object.keys(props).map((prop) => resolveCssProperty(props, keys, prop, transformer)).reduce(merge, {});
+  return Object.keys(props).map((prop) => resolveCssProperty(props, keys, prop, transformer)).reduce(merge$1, {});
 }
 function margin(props) {
   return style$1(props, marginKeys);
@@ -11687,7 +11687,7 @@ function compose(...styles2) {
   const fn2 = (props) => {
     return Object.keys(props).reduce((acc, prop) => {
       if (handlers[prop]) {
-        return merge(acc, handlers[prop](props));
+        return merge$1(acc, handlers[prop](props));
       }
       return acc;
     }, {});
@@ -12255,7 +12255,7 @@ function unstable_createStyleFunctionSx() {
         if (value2 !== null && value2 !== void 0) {
           if (typeof value2 === "object") {
             if (config2[styleKey]) {
-              css2 = merge(css2, getThemeValue(styleKey, value2, theme, config2));
+              css2 = merge$1(css2, getThemeValue(styleKey, value2, theme, config2));
             } else {
               const breakpointsValues = handleBreakpoints({
                 theme
@@ -12268,11 +12268,11 @@ function unstable_createStyleFunctionSx() {
                   theme
                 });
               } else {
-                css2 = merge(css2, breakpointsValues);
+                css2 = merge$1(css2, breakpointsValues);
               }
             }
           } else {
-            css2 = merge(css2, getThemeValue(styleKey, value2, theme, config2));
+            css2 = merge$1(css2, getThemeValue(styleKey, value2, theme, config2));
           }
         }
       });
@@ -60815,8 +60815,7 @@ const ADMIN_BLUE = {
   500: main,
   600: alpha$1(main, 0.7)
 };
-const UIThemeSchema = z.enum(["light", "dark", "DataNavy", "DocumentPink", "GraphOrange", "AdminBlue"]);
-const lightMain = common.white;
+const UIThemeSchema = z.enum(["DataNavy", "DocumentPink", "GraphOrange", "AdminBlue", "Blank"]);
 const THEME_COLORS = {
   DataNavy: {
     ...DATA_NAVY,
@@ -60825,19 +60824,6 @@ const THEME_COLORS = {
     dark: DATA_NAVY[600],
     contrastText: common.white
   },
-  light: {
-    main: lightMain,
-    light: alpha$1(lightMain, 0.5),
-    dark: alpha$1(lightMain, 0.9),
-    contrastText: common.black
-  },
-  dark: {
-    main: lightMain,
-    // TODO fix dark theme
-    light: alpha$1(lightMain, 0.5),
-    dark: alpha$1(lightMain, 0.9),
-    contrastText: common.white
-  },
   DocumentPink: {
     ...DOCUMENT_PINK,
     main: DOCUMENT_PINK[500],
@@ -60858,6 +60844,12 @@ const THEME_COLORS = {
     light: ADMIN_BLUE[400],
     dark: ADMIN_BLUE[600],
     contrastText: common.black
+  },
+  Blank: {
+    main: common.white,
+    light: alpha$1(common.white, 0.5),
+    dark: alpha$1(common.white, 0.9),
+    contrastText: common.black
   }
 };
 const AVATAR_OVERRIDES = {
@@ -60899,7 +60891,7 @@ const generateButtonOverrides = (uiTheme) => ({
         border: `1px solid ${theme.palette.primary.main}`,
         backgroundColor: theme.palette.secondary.main,
         ":hover": {
-          backgroundColor: uiTheme === "light" || uiTheme === "dark" ? "inherit" : `${THEME_COLORS[uiTheme][100]}`
+          backgroundColor: uiTheme === "Blank" ? "inherit" : `${THEME_COLORS[uiTheme][100]}`
         }
       }),
       startIcon: {
@@ -60931,7 +60923,7 @@ const generateCardOverrides = (uiTheme) => ({
       style: {
         borderWidth: 1,
         borderStyle: "solid",
-        borderColor: uiTheme === "light" || uiTheme === "dark" ? "inherit" : alpha$1(THEME_COLORS[uiTheme][200], 0.4)
+        borderColor: uiTheme === "Blank" ? "inherit" : alpha$1(THEME_COLORS[uiTheme][200], 0.4)
       }
     }],
     styleOverrides: {
@@ -61072,13 +61064,13 @@ const generateComponentOverrides = (uiTheme) => ({
     ...TYPOGRAPHY_FONT_FACES.MuiCssBaseline
   }
 });
-const createLightPalette = (themeColor) => ({
+const createLightPalette = (uiTheme) => ({
   mode: "light",
   primary: {
-    main: THEME_COLORS[themeColor].main,
-    light: THEME_COLORS[themeColor].light,
-    dark: THEME_COLORS[themeColor].dark,
-    contrastText: THEME_COLORS[themeColor].contrastText
+    main: THEME_COLORS[uiTheme].main,
+    light: THEME_COLORS[uiTheme].light,
+    dark: THEME_COLORS[uiTheme].dark,
+    contrastText: THEME_COLORS[uiTheme].contrastText
   },
   secondary: {
     main: "#F9F9F9"
@@ -61090,20 +61082,697 @@ const createLightPalette = (themeColor) => ({
     default: "#F8F9F9"
   }
 });
-const createDarkPalette = (themeColor) => ({
+var lodash_merge = { exports: {} };
+lodash_merge.exports;
+(function(module, exports) {
+  var LARGE_ARRAY_SIZE = 200;
+  var HASH_UNDEFINED = "__lodash_hash_undefined__";
+  var HOT_COUNT = 800, HOT_SPAN = 16;
+  var MAX_SAFE_INTEGER = 9007199254740991;
+  var argsTag = "[object Arguments]", arrayTag = "[object Array]", asyncTag = "[object AsyncFunction]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", nullTag = "[object Null]", objectTag = "[object Object]", proxyTag = "[object Proxy]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", undefinedTag = "[object Undefined]", weakMapTag = "[object WeakMap]";
+  var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+  var reIsHostCtor = /^\[object .+?Constructor\]$/;
+  var reIsUint = /^(?:0|[1-9]\d*)$/;
+  var typedArrayTags = {};
+  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+  typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+  var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+  var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+  var root2 = freeGlobal || freeSelf || Function("return this")();
+  var freeExports = exports && !exports.nodeType && exports;
+  var freeModule = freeExports && true && module && !module.nodeType && module;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var freeProcess = moduleExports && freeGlobal.process;
+  var nodeUtil = function() {
+    try {
+      var types = freeModule && freeModule.require && freeModule.require("util").types;
+      if (types) {
+        return types;
+      }
+      return freeProcess && freeProcess.binding && freeProcess.binding("util");
+    } catch (e) {
+    }
+  }();
+  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+  function apply(func, thisArg, args) {
+    switch (args.length) {
+      case 0:
+        return func.call(thisArg);
+      case 1:
+        return func.call(thisArg, args[0]);
+      case 2:
+        return func.call(thisArg, args[0], args[1]);
+      case 3:
+        return func.call(thisArg, args[0], args[1], args[2]);
+    }
+    return func.apply(thisArg, args);
+  }
+  function baseTimes(n, iteratee) {
+    var index = -1, result = Array(n);
+    while (++index < n) {
+      result[index] = iteratee(index);
+    }
+    return result;
+  }
+  function baseUnary(func) {
+    return function(value2) {
+      return func(value2);
+    };
+  }
+  function getValue2(object, key) {
+    return object == null ? void 0 : object[key];
+  }
+  function overArg(func, transform) {
+    return function(arg) {
+      return func(transform(arg));
+    };
+  }
+  var arrayProto = Array.prototype, funcProto = Function.prototype, objectProto = Object.prototype;
+  var coreJsData = root2["__core-js_shared__"];
+  var funcToString = funcProto.toString;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  var maskSrcKey = function() {
+    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+    return uid ? "Symbol(src)_1." + uid : "";
+  }();
+  var nativeObjectToString = objectProto.toString;
+  var objectCtorString = funcToString.call(Object);
+  var reIsNative = RegExp(
+    "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+  );
+  var Buffer2 = moduleExports ? root2.Buffer : void 0, Symbol2 = root2.Symbol, Uint8Array2 = root2.Uint8Array;
+  Buffer2 ? Buffer2.allocUnsafe : void 0;
+  var getPrototype = overArg(Object.getPrototypeOf, Object), objectCreate = Object.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+  var defineProperty = function() {
+    try {
+      var func = getNative(Object, "defineProperty");
+      func({}, "", {});
+      return func;
+    } catch (e) {
+    }
+  }();
+  var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0, nativeMax = Math.max, nativeNow = Date.now;
+  var Map2 = getNative(root2, "Map"), nativeCreate = getNative(Object, "create");
+  var baseCreate = /* @__PURE__ */ function() {
+    function object() {
+    }
+    return function(proto) {
+      if (!isObject(proto)) {
+        return {};
+      }
+      if (objectCreate) {
+        return objectCreate(proto);
+      }
+      object.prototype = proto;
+      var result = new object();
+      object.prototype = void 0;
+      return result;
+    };
+  }();
+  function Hash(entries) {
+    var index = -1, length2 = entries == null ? 0 : entries.length;
+    this.clear();
+    while (++index < length2) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+  function hashClear() {
+    this.__data__ = nativeCreate ? nativeCreate(null) : {};
+    this.size = 0;
+  }
+  function hashDelete(key) {
+    var result = this.has(key) && delete this.__data__[key];
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+  function hashGet(key) {
+    var data = this.__data__;
+    if (nativeCreate) {
+      var result = data[key];
+      return result === HASH_UNDEFINED ? void 0 : result;
+    }
+    return hasOwnProperty.call(data, key) ? data[key] : void 0;
+  }
+  function hashHas(key) {
+    var data = this.__data__;
+    return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+  }
+  function hashSet(key, value2) {
+    var data = this.__data__;
+    this.size += this.has(key) ? 0 : 1;
+    data[key] = nativeCreate && value2 === void 0 ? HASH_UNDEFINED : value2;
+    return this;
+  }
+  Hash.prototype.clear = hashClear;
+  Hash.prototype["delete"] = hashDelete;
+  Hash.prototype.get = hashGet;
+  Hash.prototype.has = hashHas;
+  Hash.prototype.set = hashSet;
+  function ListCache(entries) {
+    var index = -1, length2 = entries == null ? 0 : entries.length;
+    this.clear();
+    while (++index < length2) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+  function listCacheClear() {
+    this.__data__ = [];
+    this.size = 0;
+  }
+  function listCacheDelete(key) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    if (index < 0) {
+      return false;
+    }
+    var lastIndex = data.length - 1;
+    if (index == lastIndex) {
+      data.pop();
+    } else {
+      splice.call(data, index, 1);
+    }
+    --this.size;
+    return true;
+  }
+  function listCacheGet(key) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    return index < 0 ? void 0 : data[index][1];
+  }
+  function listCacheHas(key) {
+    return assocIndexOf(this.__data__, key) > -1;
+  }
+  function listCacheSet(key, value2) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    if (index < 0) {
+      ++this.size;
+      data.push([key, value2]);
+    } else {
+      data[index][1] = value2;
+    }
+    return this;
+  }
+  ListCache.prototype.clear = listCacheClear;
+  ListCache.prototype["delete"] = listCacheDelete;
+  ListCache.prototype.get = listCacheGet;
+  ListCache.prototype.has = listCacheHas;
+  ListCache.prototype.set = listCacheSet;
+  function MapCache(entries) {
+    var index = -1, length2 = entries == null ? 0 : entries.length;
+    this.clear();
+    while (++index < length2) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+  function mapCacheClear() {
+    this.size = 0;
+    this.__data__ = {
+      "hash": new Hash(),
+      "map": new (Map2 || ListCache)(),
+      "string": new Hash()
+    };
+  }
+  function mapCacheDelete(key) {
+    var result = getMapData(this, key)["delete"](key);
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+  function mapCacheGet(key) {
+    return getMapData(this, key).get(key);
+  }
+  function mapCacheHas(key) {
+    return getMapData(this, key).has(key);
+  }
+  function mapCacheSet(key, value2) {
+    var data = getMapData(this, key), size = data.size;
+    data.set(key, value2);
+    this.size += data.size == size ? 0 : 1;
+    return this;
+  }
+  MapCache.prototype.clear = mapCacheClear;
+  MapCache.prototype["delete"] = mapCacheDelete;
+  MapCache.prototype.get = mapCacheGet;
+  MapCache.prototype.has = mapCacheHas;
+  MapCache.prototype.set = mapCacheSet;
+  function Stack2(entries) {
+    var data = this.__data__ = new ListCache(entries);
+    this.size = data.size;
+  }
+  function stackClear() {
+    this.__data__ = new ListCache();
+    this.size = 0;
+  }
+  function stackDelete(key) {
+    var data = this.__data__, result = data["delete"](key);
+    this.size = data.size;
+    return result;
+  }
+  function stackGet(key) {
+    return this.__data__.get(key);
+  }
+  function stackHas(key) {
+    return this.__data__.has(key);
+  }
+  function stackSet(key, value2) {
+    var data = this.__data__;
+    if (data instanceof ListCache) {
+      var pairs = data.__data__;
+      if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+        pairs.push([key, value2]);
+        this.size = ++data.size;
+        return this;
+      }
+      data = this.__data__ = new MapCache(pairs);
+    }
+    data.set(key, value2);
+    this.size = data.size;
+    return this;
+  }
+  Stack2.prototype.clear = stackClear;
+  Stack2.prototype["delete"] = stackDelete;
+  Stack2.prototype.get = stackGet;
+  Stack2.prototype.has = stackHas;
+  Stack2.prototype.set = stackSet;
+  function arrayLikeKeys(value2, inherited) {
+    var isArr = isArray(value2), isArg = !isArr && isArguments(value2), isBuff = !isArr && !isArg && isBuffer(value2), isType = !isArr && !isArg && !isBuff && isTypedArray(value2), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value2.length, String) : [], length2 = result.length;
+    for (var key in value2) {
+      if (!(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+      (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+      isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+      isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+      isIndex(key, length2)))) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  function assignMergeValue(object, key, value2) {
+    if (value2 !== void 0 && !eq(object[key], value2) || value2 === void 0 && !(key in object)) {
+      baseAssignValue(object, key, value2);
+    }
+  }
+  function assignValue(object, key, value2) {
+    var objValue = object[key];
+    if (!(hasOwnProperty.call(object, key) && eq(objValue, value2)) || value2 === void 0 && !(key in object)) {
+      baseAssignValue(object, key, value2);
+    }
+  }
+  function assocIndexOf(array2, key) {
+    var length2 = array2.length;
+    while (length2--) {
+      if (eq(array2[length2][0], key)) {
+        return length2;
+      }
+    }
+    return -1;
+  }
+  function baseAssignValue(object, key, value2) {
+    if (key == "__proto__" && defineProperty) {
+      defineProperty(object, key, {
+        "configurable": true,
+        "enumerable": true,
+        "value": value2,
+        "writable": true
+      });
+    } else {
+      object[key] = value2;
+    }
+  }
+  var baseFor = createBaseFor();
+  function baseGetTag(value2) {
+    if (value2 == null) {
+      return value2 === void 0 ? undefinedTag : nullTag;
+    }
+    return symToStringTag && symToStringTag in Object(value2) ? getRawTag(value2) : objectToString(value2);
+  }
+  function baseIsArguments(value2) {
+    return isObjectLike(value2) && baseGetTag(value2) == argsTag;
+  }
+  function baseIsNative(value2) {
+    if (!isObject(value2) || isMasked(value2)) {
+      return false;
+    }
+    var pattern = isFunction2(value2) ? reIsNative : reIsHostCtor;
+    return pattern.test(toSource(value2));
+  }
+  function baseIsTypedArray(value2) {
+    return isObjectLike(value2) && isLength(value2.length) && !!typedArrayTags[baseGetTag(value2)];
+  }
+  function baseKeysIn(object) {
+    if (!isObject(object)) {
+      return nativeKeysIn(object);
+    }
+    var isProto = isPrototype(object), result = [];
+    for (var key in object) {
+      if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  function baseMerge(object, source, srcIndex, customizer, stack) {
+    if (object === source) {
+      return;
+    }
+    baseFor(source, function(srcValue, key) {
+      stack || (stack = new Stack2());
+      if (isObject(srcValue)) {
+        baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+      } else {
+        var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
+        if (newValue === void 0) {
+          newValue = srcValue;
+        }
+        assignMergeValue(object, key, newValue);
+      }
+    }, keysIn);
+  }
+  function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+    var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
+    if (stacked) {
+      assignMergeValue(object, key, stacked);
+      return;
+    }
+    var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
+    var isCommon = newValue === void 0;
+    if (isCommon) {
+      var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+      newValue = srcValue;
+      if (isArr || isBuff || isTyped) {
+        if (isArray(objValue)) {
+          newValue = objValue;
+        } else if (isArrayLikeObject(objValue)) {
+          newValue = copyArray(objValue);
+        } else if (isBuff) {
+          isCommon = false;
+          newValue = cloneBuffer(srcValue);
+        } else if (isTyped) {
+          isCommon = false;
+          newValue = cloneTypedArray(srcValue);
+        } else {
+          newValue = [];
+        }
+      } else if (isPlainObject2(srcValue) || isArguments(srcValue)) {
+        newValue = objValue;
+        if (isArguments(objValue)) {
+          newValue = toPlainObject(objValue);
+        } else if (!isObject(objValue) || isFunction2(objValue)) {
+          newValue = initCloneObject(srcValue);
+        }
+      } else {
+        isCommon = false;
+      }
+    }
+    if (isCommon) {
+      stack.set(srcValue, newValue);
+      mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+      stack["delete"](srcValue);
+    }
+    assignMergeValue(object, key, newValue);
+  }
+  function baseRest(func, start2) {
+    return setToString(overRest(func, start2, identity2), func + "");
+  }
+  var baseSetToString = !defineProperty ? identity2 : function(func, string) {
+    return defineProperty(func, "toString", {
+      "configurable": true,
+      "enumerable": false,
+      "value": constant2(string),
+      "writable": true
+    });
+  };
+  function cloneBuffer(buffer, isDeep) {
+    {
+      return buffer.slice();
+    }
+  }
+  function cloneArrayBuffer(arrayBuffer) {
+    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+    new Uint8Array2(result).set(new Uint8Array2(arrayBuffer));
+    return result;
+  }
+  function cloneTypedArray(typedArray, isDeep) {
+    var buffer = cloneArrayBuffer(typedArray.buffer);
+    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+  }
+  function copyArray(source, array2) {
+    var index = -1, length2 = source.length;
+    array2 || (array2 = Array(length2));
+    while (++index < length2) {
+      array2[index] = source[index];
+    }
+    return array2;
+  }
+  function copyObject(source, props, object, customizer) {
+    var isNew = !object;
+    object || (object = {});
+    var index = -1, length2 = props.length;
+    while (++index < length2) {
+      var key = props[index];
+      var newValue = void 0;
+      if (newValue === void 0) {
+        newValue = source[key];
+      }
+      if (isNew) {
+        baseAssignValue(object, key, newValue);
+      } else {
+        assignValue(object, key, newValue);
+      }
+    }
+    return object;
+  }
+  function createAssigner(assigner) {
+    return baseRest(function(object, sources) {
+      var index = -1, length2 = sources.length, customizer = length2 > 1 ? sources[length2 - 1] : void 0, guard = length2 > 2 ? sources[2] : void 0;
+      customizer = assigner.length > 3 && typeof customizer == "function" ? (length2--, customizer) : void 0;
+      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+        customizer = length2 < 3 ? void 0 : customizer;
+        length2 = 1;
+      }
+      object = Object(object);
+      while (++index < length2) {
+        var source = sources[index];
+        if (source) {
+          assigner(object, source, index, customizer);
+        }
+      }
+      return object;
+    });
+  }
+  function createBaseFor(fromRight) {
+    return function(object, iteratee, keysFunc) {
+      var index = -1, iterable = Object(object), props = keysFunc(object), length2 = props.length;
+      while (length2--) {
+        var key = props[++index];
+        if (iteratee(iterable[key], key, iterable) === false) {
+          break;
+        }
+      }
+      return object;
+    };
+  }
+  function getMapData(map, key) {
+    var data = map.__data__;
+    return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+  }
+  function getNative(object, key) {
+    var value2 = getValue2(object, key);
+    return baseIsNative(value2) ? value2 : void 0;
+  }
+  function getRawTag(value2) {
+    var isOwn = hasOwnProperty.call(value2, symToStringTag), tag = value2[symToStringTag];
+    try {
+      value2[symToStringTag] = void 0;
+      var unmasked = true;
+    } catch (e) {
+    }
+    var result = nativeObjectToString.call(value2);
+    if (unmasked) {
+      if (isOwn) {
+        value2[symToStringTag] = tag;
+      } else {
+        delete value2[symToStringTag];
+      }
+    }
+    return result;
+  }
+  function initCloneObject(object) {
+    return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+  }
+  function isIndex(value2, length2) {
+    var type = typeof value2;
+    length2 = length2 == null ? MAX_SAFE_INTEGER : length2;
+    return !!length2 && (type == "number" || type != "symbol" && reIsUint.test(value2)) && (value2 > -1 && value2 % 1 == 0 && value2 < length2);
+  }
+  function isIterateeCall(value2, index, object) {
+    if (!isObject(object)) {
+      return false;
+    }
+    var type = typeof index;
+    if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
+      return eq(object[index], value2);
+    }
+    return false;
+  }
+  function isKeyable(value2) {
+    var type = typeof value2;
+    return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value2 !== "__proto__" : value2 === null;
+  }
+  function isMasked(func) {
+    return !!maskSrcKey && maskSrcKey in func;
+  }
+  function isPrototype(value2) {
+    var Ctor = value2 && value2.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+    return value2 === proto;
+  }
+  function nativeKeysIn(object) {
+    var result = [];
+    if (object != null) {
+      for (var key in Object(object)) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  function objectToString(value2) {
+    return nativeObjectToString.call(value2);
+  }
+  function overRest(func, start2, transform) {
+    start2 = nativeMax(start2 === void 0 ? func.length - 1 : start2, 0);
+    return function() {
+      var args = arguments, index = -1, length2 = nativeMax(args.length - start2, 0), array2 = Array(length2);
+      while (++index < length2) {
+        array2[index] = args[start2 + index];
+      }
+      index = -1;
+      var otherArgs = Array(start2 + 1);
+      while (++index < start2) {
+        otherArgs[index] = args[index];
+      }
+      otherArgs[start2] = transform(array2);
+      return apply(func, this, otherArgs);
+    };
+  }
+  function safeGet(object, key) {
+    if (key === "constructor" && typeof object[key] === "function") {
+      return;
+    }
+    if (key == "__proto__") {
+      return;
+    }
+    return object[key];
+  }
+  var setToString = shortOut(baseSetToString);
+  function shortOut(func) {
+    var count2 = 0, lastCalled = 0;
+    return function() {
+      var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+      lastCalled = stamp;
+      if (remaining > 0) {
+        if (++count2 >= HOT_COUNT) {
+          return arguments[0];
+        }
+      } else {
+        count2 = 0;
+      }
+      return func.apply(void 0, arguments);
+    };
+  }
+  function toSource(func) {
+    if (func != null) {
+      try {
+        return funcToString.call(func);
+      } catch (e) {
+      }
+      try {
+        return func + "";
+      } catch (e) {
+      }
+    }
+    return "";
+  }
+  function eq(value2, other) {
+    return value2 === other || value2 !== value2 && other !== other;
+  }
+  var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+    return arguments;
+  }()) ? baseIsArguments : function(value2) {
+    return isObjectLike(value2) && hasOwnProperty.call(value2, "callee") && !propertyIsEnumerable.call(value2, "callee");
+  };
+  var isArray = Array.isArray;
+  function isArrayLike(value2) {
+    return value2 != null && isLength(value2.length) && !isFunction2(value2);
+  }
+  function isArrayLikeObject(value2) {
+    return isObjectLike(value2) && isArrayLike(value2);
+  }
+  var isBuffer = nativeIsBuffer || stubFalse;
+  function isFunction2(value2) {
+    if (!isObject(value2)) {
+      return false;
+    }
+    var tag = baseGetTag(value2);
+    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+  }
+  function isLength(value2) {
+    return typeof value2 == "number" && value2 > -1 && value2 % 1 == 0 && value2 <= MAX_SAFE_INTEGER;
+  }
+  function isObject(value2) {
+    var type = typeof value2;
+    return value2 != null && (type == "object" || type == "function");
+  }
+  function isObjectLike(value2) {
+    return value2 != null && typeof value2 == "object";
+  }
+  function isPlainObject2(value2) {
+    if (!isObjectLike(value2) || baseGetTag(value2) != objectTag) {
+      return false;
+    }
+    var proto = getPrototype(value2);
+    if (proto === null) {
+      return true;
+    }
+    var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+    return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+  }
+  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+  function toPlainObject(value2) {
+    return copyObject(value2, keysIn(value2));
+  }
+  function keysIn(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeysIn(object);
+  }
+  var merge2 = createAssigner(function(object, source, srcIndex) {
+    baseMerge(object, source, srcIndex);
+  });
+  function constant2(value2) {
+    return function() {
+      return value2;
+    };
+  }
+  function identity2(value2) {
+    return value2;
+  }
+  function stubFalse() {
+    return false;
+  }
+  module.exports = merge2;
+})(lodash_merge, lodash_merge.exports);
+var lodash_mergeExports = lodash_merge.exports;
+const merge = /* @__PURE__ */ getDefaultExportFromCjs(lodash_mergeExports);
+const createDarkPalette = (uiTheme) => merge(createLightPalette(uiTheme), {
   mode: "dark",
   primary: {
-    main: THEME_COLORS[themeColor].main,
-    light: THEME_COLORS[themeColor].light,
-    dark: THEME_COLORS[themeColor].dark,
-    contrastText: THEME_COLORS[themeColor].contrastText
+    main: THEME_COLORS[uiTheme].main,
+    light: THEME_COLORS[uiTheme].light,
+    dark: THEME_COLORS[uiTheme].dark,
+    contrastText: THEME_COLORS[uiTheme].contrastText
   },
   secondary: {
     main: "#222222"
   },
-  warning: void 0,
-  info: void 0,
-  success: void 0,
   background: {
     default: "#1D1D1D"
   },
@@ -61112,14 +61781,24 @@ const createDarkPalette = (themeColor) => ({
     900: "#2E2E2E"
   }
 });
-const createTheme = (themeColor, dark2) => createTheme$1({
-  components: generateComponentOverrides(themeColor),
-  palette: dark2 ? createDarkPalette(themeColor) : createLightPalette(themeColor),
-  typography: TYPOGRAPHY_STYLE_OVERRIDES
-});
+const createThemePure = (uiTheme, palette) => {
+  return createTheme$1({
+    components: generateComponentOverrides(uiTheme),
+    palette,
+    typography: TYPOGRAPHY_STYLE_OVERRIDES
+  });
+};
+const cache = Object.fromEntries(UIThemeSchema.options.map((uiTheme) => [uiTheme, {
+  light: createThemePure(uiTheme, createLightPalette(uiTheme)),
+  dark: createThemePure(uiTheme, createDarkPalette(uiTheme))
+}]));
+const createTheme = (uiTheme, dark2, skipCache = false) => {
+  var _a2;
+  return !skipCache && ((_a2 = cache == null ? void 0 : cache[uiTheme]) == null ? void 0 : _a2[dark2 ? "dark" : "light"]) || createThemePure(uiTheme, dark2 ? createDarkPalette(uiTheme) : createLightPalette(uiTheme));
+};
 const UIThemeProvider = ({
-  dark: dark2 = false,
   theme,
+  dark: dark2 = false,
   children: children2
 }) => /* @__PURE__ */ jsxs(ThemeProvider, { theme: createTheme(theme, dark2), children: [
   /* @__PURE__ */ jsx$1(CssBaseline, {}),