@kaizen/components 1.4.13 → 1.4.15

package/dist/iife/KaizenProvider/ThemeProvider/ThemeManager.js

@@ -0,0 +1,854 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // ../../node_modules/color-name/index.js
+  var require_color_name = __commonJS({
+    "../../node_modules/color-name/index.js"(exports, module) {
+      "use strict";
+      module.exports = {
+        "aliceblue": [240, 248, 255],
+        "antiquewhite": [250, 235, 215],
+        "aqua": [0, 255, 255],
+        "aquamarine": [127, 255, 212],
+        "azure": [240, 255, 255],
+        "beige": [245, 245, 220],
+        "bisque": [255, 228, 196],
+        "black": [0, 0, 0],
+        "blanchedalmond": [255, 235, 205],
+        "blue": [0, 0, 255],
+        "blueviolet": [138, 43, 226],
+        "brown": [165, 42, 42],
+        "burlywood": [222, 184, 135],
+        "cadetblue": [95, 158, 160],
+        "chartreuse": [127, 255, 0],
+        "chocolate": [210, 105, 30],
+        "coral": [255, 127, 80],
+        "cornflowerblue": [100, 149, 237],
+        "cornsilk": [255, 248, 220],
+        "crimson": [220, 20, 60],
+        "cyan": [0, 255, 255],
+        "darkblue": [0, 0, 139],
+        "darkcyan": [0, 139, 139],
+        "darkgoldenrod": [184, 134, 11],
+        "darkgray": [169, 169, 169],
+        "darkgreen": [0, 100, 0],
+        "darkgrey": [169, 169, 169],
+        "darkkhaki": [189, 183, 107],
+        "darkmagenta": [139, 0, 139],
+        "darkolivegreen": [85, 107, 47],
+        "darkorange": [255, 140, 0],
+        "darkorchid": [153, 50, 204],
+        "darkred": [139, 0, 0],
+        "darksalmon": [233, 150, 122],
+        "darkseagreen": [143, 188, 143],
+        "darkslateblue": [72, 61, 139],
+        "darkslategray": [47, 79, 79],
+        "darkslategrey": [47, 79, 79],
+        "darkturquoise": [0, 206, 209],
+        "darkviolet": [148, 0, 211],
+        "deeppink": [255, 20, 147],
+        "deepskyblue": [0, 191, 255],
+        "dimgray": [105, 105, 105],
+        "dimgrey": [105, 105, 105],
+        "dodgerblue": [30, 144, 255],
+        "firebrick": [178, 34, 34],
+        "floralwhite": [255, 250, 240],
+        "forestgreen": [34, 139, 34],
+        "fuchsia": [255, 0, 255],
+        "gainsboro": [220, 220, 220],
+        "ghostwhite": [248, 248, 255],
+        "gold": [255, 215, 0],
+        "goldenrod": [218, 165, 32],
+        "gray": [128, 128, 128],
+        "green": [0, 128, 0],
+        "greenyellow": [173, 255, 47],
+        "grey": [128, 128, 128],
+        "honeydew": [240, 255, 240],
+        "hotpink": [255, 105, 180],
+        "indianred": [205, 92, 92],
+        "indigo": [75, 0, 130],
+        "ivory": [255, 255, 240],
+        "khaki": [240, 230, 140],
+        "lavender": [230, 230, 250],
+        "lavenderblush": [255, 240, 245],
+        "lawngreen": [124, 252, 0],
+        "lemonchiffon": [255, 250, 205],
+        "lightblue": [173, 216, 230],
+        "lightcoral": [240, 128, 128],
+        "lightcyan": [224, 255, 255],
+        "lightgoldenrodyellow": [250, 250, 210],
+        "lightgray": [211, 211, 211],
+        "lightgreen": [144, 238, 144],
+        "lightgrey": [211, 211, 211],
+        "lightpink": [255, 182, 193],
+        "lightsalmon": [255, 160, 122],
+        "lightseagreen": [32, 178, 170],
+        "lightskyblue": [135, 206, 250],
+        "lightslategray": [119, 136, 153],
+        "lightslategrey": [119, 136, 153],
+        "lightsteelblue": [176, 196, 222],
+        "lightyellow": [255, 255, 224],
+        "lime": [0, 255, 0],
+        "limegreen": [50, 205, 50],
+        "linen": [250, 240, 230],
+        "magenta": [255, 0, 255],
+        "maroon": [128, 0, 0],
+        "mediumaquamarine": [102, 205, 170],
+        "mediumblue": [0, 0, 205],
+        "mediumorchid": [186, 85, 211],
+        "mediumpurple": [147, 112, 219],
+        "mediumseagreen": [60, 179, 113],
+        "mediumslateblue": [123, 104, 238],
+        "mediumspringgreen": [0, 250, 154],
+        "mediumturquoise": [72, 209, 204],
+        "mediumvioletred": [199, 21, 133],
+        "midnightblue": [25, 25, 112],
+        "mintcream": [245, 255, 250],
+        "mistyrose": [255, 228, 225],
+        "moccasin": [255, 228, 181],
+        "navajowhite": [255, 222, 173],
+        "navy": [0, 0, 128],
+        "oldlace": [253, 245, 230],
+        "olive": [128, 128, 0],
+        "olivedrab": [107, 142, 35],
+        "orange": [255, 165, 0],
+        "orangered": [255, 69, 0],
+        "orchid": [218, 112, 214],
+        "palegoldenrod": [238, 232, 170],
+        "palegreen": [152, 251, 152],
+        "paleturquoise": [175, 238, 238],
+        "palevioletred": [219, 112, 147],
+        "papayawhip": [255, 239, 213],
+        "peachpuff": [255, 218, 185],
+        "peru": [205, 133, 63],
+        "pink": [255, 192, 203],
+        "plum": [221, 160, 221],
+        "powderblue": [176, 224, 230],
+        "purple": [128, 0, 128],
+        "rebeccapurple": [102, 51, 153],
+        "red": [255, 0, 0],
+        "rosybrown": [188, 143, 143],
+        "royalblue": [65, 105, 225],
+        "saddlebrown": [139, 69, 19],
+        "salmon": [250, 128, 114],
+        "sandybrown": [244, 164, 96],
+        "seagreen": [46, 139, 87],
+        "seashell": [255, 245, 238],
+        "sienna": [160, 82, 45],
+        "silver": [192, 192, 192],
+        "skyblue": [135, 206, 235],
+        "slateblue": [106, 90, 205],
+        "slategray": [112, 128, 144],
+        "slategrey": [112, 128, 144],
+        "snow": [255, 250, 250],
+        "springgreen": [0, 255, 127],
+        "steelblue": [70, 130, 180],
+        "tan": [210, 180, 140],
+        "teal": [0, 128, 128],
+        "thistle": [216, 191, 216],
+        "tomato": [255, 99, 71],
+        "turquoise": [64, 224, 208],
+        "violet": [238, 130, 238],
+        "wheat": [245, 222, 179],
+        "white": [255, 255, 255],
+        "whitesmoke": [245, 245, 245],
+        "yellow": [255, 255, 0],
+        "yellowgreen": [154, 205, 50]
+      };
+    }
+  });
+
+  // ../../node_modules/simple-swizzle/node_modules/is-arrayish/index.js
+  var require_is_arrayish = __commonJS({
+    "../../node_modules/simple-swizzle/node_modules/is-arrayish/index.js"(exports, module) {
+      module.exports = function isArrayish(obj) {
+        if (!obj || typeof obj === "string") {
+          return false;
+        }
+        return obj instanceof Array || Array.isArray(obj) || obj.length >= 0 && (obj.splice instanceof Function || Object.getOwnPropertyDescriptor(obj, obj.length - 1) && obj.constructor.name !== "String");
+      };
+    }
+  });
+
+  // ../../node_modules/simple-swizzle/index.js
+  var require_simple_swizzle = __commonJS({
+    "../../node_modules/simple-swizzle/index.js"(exports, module) {
+      "use strict";
+      var isArrayish = require_is_arrayish();
+      var concat = Array.prototype.concat;
+      var slice = Array.prototype.slice;
+      var swizzle = module.exports = function swizzle2(args) {
+        var results = [];
+        for (var i = 0, len = args.length; i < len; i++) {
+          var arg = args[i];
+          if (isArrayish(arg)) {
+            results = concat.call(results, slice.call(arg));
+          } else {
+            results.push(arg);
+          }
+        }
+        return results;
+      };
+      swizzle.wrap = function(fn) {
+        return function() {
+          return fn(swizzle(arguments));
+        };
+      };
+    }
+  });
+
+  // ../../node_modules/color-string/index.js
+  var require_color_string = __commonJS({
+    "../../node_modules/color-string/index.js"(exports, module) {
+      var colorNames = require_color_name();
+      var swizzle = require_simple_swizzle();
+      var hasOwnProperty = Object.hasOwnProperty;
+      var reverseNames = /* @__PURE__ */ Object.create(null);
+      for (name in colorNames) {
+        if (hasOwnProperty.call(colorNames, name)) {
+          reverseNames[colorNames[name]] = name;
+        }
+      }
+      var name;
+      var cs = module.exports = {
+        to: {},
+        get: {}
+      };
+      cs.get = function(string) {
+        var prefix = string.substring(0, 3).toLowerCase();
+        var val;
+        var model;
+        switch (prefix) {
+          case "hsl":
+            val = cs.get.hsl(string);
+            model = "hsl";
+            break;
+          case "hwb":
+            val = cs.get.hwb(string);
+            model = "hwb";
+            break;
+          default:
+            val = cs.get.rgb(string);
+            model = "rgb";
+            break;
+        }
+        if (!val) {
+          return null;
+        }
+        return { model, value: val };
+      };
+      cs.get.rgb = function(string) {
+        if (!string) {
+          return null;
+        }
+        var abbr = /^#([a-f0-9]{3,4})$/i;
+        var hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i;
+        var rgba = /^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/;
+        var per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/;
+        var keyword = /^(\w+)$/;
+        var rgb = [0, 0, 0, 1];
+        var match;
+        var i;
+        var hexAlpha;
+        if (match = string.match(hex)) {
+          hexAlpha = match[2];
+          match = match[1];
+          for (i = 0; i < 3; i++) {
+            var i2 = i * 2;
+            rgb[i] = parseInt(match.slice(i2, i2 + 2), 16);
+          }
+          if (hexAlpha) {
+            rgb[3] = parseInt(hexAlpha, 16) / 255;
+          }
+        } else if (match = string.match(abbr)) {
+          match = match[1];
+          hexAlpha = match[3];
+          for (i = 0; i < 3; i++) {
+            rgb[i] = parseInt(match[i] + match[i], 16);
+          }
+          if (hexAlpha) {
+            rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255;
+          }
+        } else if (match = string.match(rgba)) {
+          for (i = 0; i < 3; i++) {
+            rgb[i] = parseInt(match[i + 1], 0);
+          }
+          if (match[4]) {
+            if (match[5]) {
+              rgb[3] = parseFloat(match[4]) * 0.01;
+            } else {
+              rgb[3] = parseFloat(match[4]);
+            }
+          }
+        } else if (match = string.match(per)) {
+          for (i = 0; i < 3; i++) {
+            rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
+          }
+          if (match[4]) {
+            if (match[5]) {
+              rgb[3] = parseFloat(match[4]) * 0.01;
+            } else {
+              rgb[3] = parseFloat(match[4]);
+            }
+          }
+        } else if (match = string.match(keyword)) {
+          if (match[1] === "transparent") {
+            return [0, 0, 0, 0];
+          }
+          if (!hasOwnProperty.call(colorNames, match[1])) {
+            return null;
+          }
+          rgb = colorNames[match[1]];
+          rgb[3] = 1;
+          return rgb;
+        } else {
+          return null;
+        }
+        for (i = 0; i < 3; i++) {
+          rgb[i] = clamp(rgb[i], 0, 255);
+        }
+        rgb[3] = clamp(rgb[3], 0, 1);
+        return rgb;
+      };
+      cs.get.hsl = function(string) {
+        if (!string) {
+          return null;
+        }
+        var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/;
+        var match = string.match(hsl);
+        if (match) {
+          var alpha = parseFloat(match[4]);
+          var h = (parseFloat(match[1]) % 360 + 360) % 360;
+          var s = clamp(parseFloat(match[2]), 0, 100);
+          var l = clamp(parseFloat(match[3]), 0, 100);
+          var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);
+          return [h, s, l, a];
+        }
+        return null;
+      };
+      cs.get.hwb = function(string) {
+        if (!string) {
+          return null;
+        }
+        var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/;
+        var match = string.match(hwb);
+        if (match) {
+          var alpha = parseFloat(match[4]);
+          var h = (parseFloat(match[1]) % 360 + 360) % 360;
+          var w = clamp(parseFloat(match[2]), 0, 100);
+          var b = clamp(parseFloat(match[3]), 0, 100);
+          var a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);
+          return [h, w, b, a];
+        }
+        return null;
+      };
+      cs.to.hex = function() {
+        var rgba = swizzle(arguments);
+        return "#" + hexDouble(rgba[0]) + hexDouble(rgba[1]) + hexDouble(rgba[2]) + (rgba[3] < 1 ? hexDouble(Math.round(rgba[3] * 255)) : "");
+      };
+      cs.to.rgb = function() {
+        var rgba = swizzle(arguments);
+        return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ")" : "rgba(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ", " + rgba[3] + ")";
+      };
+      cs.to.rgb.percent = function() {
+        var rgba = swizzle(arguments);
+        var r = Math.round(rgba[0] / 255 * 100);
+        var g = Math.round(rgba[1] / 255 * 100);
+        var b = Math.round(rgba[2] / 255 * 100);
+        return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + r + "%, " + g + "%, " + b + "%)" : "rgba(" + r + "%, " + g + "%, " + b + "%, " + rgba[3] + ")";
+      };
+      cs.to.hsl = function() {
+        var hsla = swizzle(arguments);
+        return hsla.length < 4 || hsla[3] === 1 ? "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)" : "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, " + hsla[3] + ")";
+      };
+      cs.to.hwb = function() {
+        var hwba = swizzle(arguments);
+        var a = "";
+        if (hwba.length >= 4 && hwba[3] !== 1) {
+          a = ", " + hwba[3];
+        }
+        return "hwb(" + hwba[0] + ", " + hwba[1] + "%, " + hwba[2] + "%" + a + ")";
+      };
+      cs.to.keyword = function(rgb) {
+        return reverseNames[rgb.slice(0, 3)];
+      };
+      function clamp(num, min, max) {
+        return Math.min(Math.max(min, num), max);
+      }
+      function hexDouble(num) {
+        var str = Math.round(num).toString(16).toUpperCase();
+        return str.length < 2 ? "0" + str : str;
+      }
+    }
+  });
+
+  // ../../node_modules/lodash.kebabcase/index.js
+  var require_lodash = __commonJS({
+    "../../node_modules/lodash.kebabcase/index.js"(exports, module) {
+      var INFINITY = 1 / 0;
+      var symbolTag = "[object Symbol]";
+      var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+      var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+      var rsAstralRange = "\\ud800-\\udfff";
+      var rsComboMarksRange = "\\u0300-\\u036f\\ufe20-\\ufe23";
+      var rsComboSymbolsRange = "\\u20d0-\\u20f0";
+      var rsDingbatRange = "\\u2700-\\u27bf";
+      var rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff";
+      var rsMathOpRange = "\\xac\\xb1\\xd7\\xf7";
+      var rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf";
+      var rsPunctuationRange = "\\u2000-\\u206f";
+      var rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
+      var rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde";
+      var rsVarRange = "\\ufe0e\\ufe0f";
+      var rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+      var rsApos = "['\u2019]";
+      var rsBreak = "[" + rsBreakRange + "]";
+      var rsCombo = "[" + rsComboMarksRange + rsComboSymbolsRange + "]";
+      var rsDigits = "\\d+";
+      var rsDingbat = "[" + rsDingbatRange + "]";
+      var rsLower = "[" + rsLowerRange + "]";
+      var rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]";
+      var rsFitz = "\\ud83c[\\udffb-\\udfff]";
+      var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
+      var rsNonAstral = "[^" + rsAstralRange + "]";
+      var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
+      var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
+      var rsUpper = "[" + rsUpperRange + "]";
+      var rsZWJ = "\\u200d";
+      var rsLowerMisc = "(?:" + rsLower + "|" + rsMisc + ")";
+      var rsUpperMisc = "(?:" + rsUpper + "|" + rsMisc + ")";
+      var rsOptLowerContr = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?";
+      var rsOptUpperContr = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?";
+      var reOptMod = rsModifier + "?";
+      var rsOptVar = "[" + rsVarRange + "]?";
+      var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
+      var rsSeq = rsOptVar + reOptMod + rsOptJoin;
+      var rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq;
+      var reApos = RegExp(rsApos, "g");
+      var reComboMark = RegExp(rsCombo, "g");
+      var reUnicodeWord = RegExp([
+        rsUpper + "?" + rsLower + "+" + rsOptLowerContr + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
+        rsUpperMisc + "+" + rsOptUpperContr + "(?=" + [rsBreak, rsUpper + rsLowerMisc, "$"].join("|") + ")",
+        rsUpper + "?" + rsLowerMisc + "+" + rsOptLowerContr,
+        rsUpper + "+" + rsOptUpperContr,
+        rsDigits,
+        rsEmoji
+      ].join("|"), "g");
+      var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+      var deburredLetters = {
+        // Latin-1 Supplement block.
+        "\xC0": "A",
+        "\xC1": "A",
+        "\xC2": "A",
+        "\xC3": "A",
+        "\xC4": "A",
+        "\xC5": "A",
+        "\xE0": "a",
+        "\xE1": "a",
+        "\xE2": "a",
+        "\xE3": "a",
+        "\xE4": "a",
+        "\xE5": "a",
+        "\xC7": "C",
+        "\xE7": "c",
+        "\xD0": "D",
+        "\xF0": "d",
+        "\xC8": "E",
+        "\xC9": "E",
+        "\xCA": "E",
+        "\xCB": "E",
+        "\xE8": "e",
+        "\xE9": "e",
+        "\xEA": "e",
+        "\xEB": "e",
+        "\xCC": "I",
+        "\xCD": "I",
+        "\xCE": "I",
+        "\xCF": "I",
+        "\xEC": "i",
+        "\xED": "i",
+        "\xEE": "i",
+        "\xEF": "i",
+        "\xD1": "N",
+        "\xF1": "n",
+        "\xD2": "O",
+        "\xD3": "O",
+        "\xD4": "O",
+        "\xD5": "O",
+        "\xD6": "O",
+        "\xD8": "O",
+        "\xF2": "o",
+        "\xF3": "o",
+        "\xF4": "o",
+        "\xF5": "o",
+        "\xF6": "o",
+        "\xF8": "o",
+        "\xD9": "U",
+        "\xDA": "U",
+        "\xDB": "U",
+        "\xDC": "U",
+        "\xF9": "u",
+        "\xFA": "u",
+        "\xFB": "u",
+        "\xFC": "u",
+        "\xDD": "Y",
+        "\xFD": "y",
+        "\xFF": "y",
+        "\xC6": "Ae",
+        "\xE6": "ae",
+        "\xDE": "Th",
+        "\xFE": "th",
+        "\xDF": "ss",
+        // Latin Extended-A block.
+        "\u0100": "A",
+        "\u0102": "A",
+        "\u0104": "A",
+        "\u0101": "a",
+        "\u0103": "a",
+        "\u0105": "a",
+        "\u0106": "C",
+        "\u0108": "C",
+        "\u010A": "C",
+        "\u010C": "C",
+        "\u0107": "c",
+        "\u0109": "c",
+        "\u010B": "c",
+        "\u010D": "c",
+        "\u010E": "D",
+        "\u0110": "D",
+        "\u010F": "d",
+        "\u0111": "d",
+        "\u0112": "E",
+        "\u0114": "E",
+        "\u0116": "E",
+        "\u0118": "E",
+        "\u011A": "E",
+        "\u0113": "e",
+        "\u0115": "e",
+        "\u0117": "e",
+        "\u0119": "e",
+        "\u011B": "e",
+        "\u011C": "G",
+        "\u011E": "G",
+        "\u0120": "G",
+        "\u0122": "G",
+        "\u011D": "g",
+        "\u011F": "g",
+        "\u0121": "g",
+        "\u0123": "g",
+        "\u0124": "H",
+        "\u0126": "H",
+        "\u0125": "h",
+        "\u0127": "h",
+        "\u0128": "I",
+        "\u012A": "I",
+        "\u012C": "I",
+        "\u012E": "I",
+        "\u0130": "I",
+        "\u0129": "i",
+        "\u012B": "i",
+        "\u012D": "i",
+        "\u012F": "i",
+        "\u0131": "i",
+        "\u0134": "J",
+        "\u0135": "j",
+        "\u0136": "K",
+        "\u0137": "k",
+        "\u0138": "k",
+        "\u0139": "L",
+        "\u013B": "L",
+        "\u013D": "L",
+        "\u013F": "L",
+        "\u0141": "L",
+        "\u013A": "l",
+        "\u013C": "l",
+        "\u013E": "l",
+        "\u0140": "l",
+        "\u0142": "l",
+        "\u0143": "N",
+        "\u0145": "N",
+        "\u0147": "N",
+        "\u014A": "N",
+        "\u0144": "n",
+        "\u0146": "n",
+        "\u0148": "n",
+        "\u014B": "n",
+        "\u014C": "O",
+        "\u014E": "O",
+        "\u0150": "O",
+        "\u014D": "o",
+        "\u014F": "o",
+        "\u0151": "o",
+        "\u0154": "R",
+        "\u0156": "R",
+        "\u0158": "R",
+        "\u0155": "r",
+        "\u0157": "r",
+        "\u0159": "r",
+        "\u015A": "S",
+        "\u015C": "S",
+        "\u015E": "S",
+        "\u0160": "S",
+        "\u015B": "s",
+        "\u015D": "s",
+        "\u015F": "s",
+        "\u0161": "s",
+        "\u0162": "T",
+        "\u0164": "T",
+        "\u0166": "T",
+        "\u0163": "t",
+        "\u0165": "t",
+        "\u0167": "t",
+        "\u0168": "U",
+        "\u016A": "U",
+        "\u016C": "U",
+        "\u016E": "U",
+        "\u0170": "U",
+        "\u0172": "U",
+        "\u0169": "u",
+        "\u016B": "u",
+        "\u016D": "u",
+        "\u016F": "u",
+        "\u0171": "u",
+        "\u0173": "u",
+        "\u0174": "W",
+        "\u0175": "w",
+        "\u0176": "Y",
+        "\u0177": "y",
+        "\u0178": "Y",
+        "\u0179": "Z",
+        "\u017B": "Z",
+        "\u017D": "Z",
+        "\u017A": "z",
+        "\u017C": "z",
+        "\u017E": "z",
+        "\u0132": "IJ",
+        "\u0133": "ij",
+        "\u0152": "Oe",
+        "\u0153": "oe",
+        "\u0149": "'n",
+        "\u017F": "ss"
+      };
+      var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+      var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+      var root = freeGlobal || freeSelf || Function("return this")();
+      function arrayReduce(array, iteratee, accumulator, initAccum) {
+        var index = -1, length = array ? array.length : 0;
+        if (initAccum && length) {
+          accumulator = array[++index];
+        }
+        while (++index < length) {
+          accumulator = iteratee(accumulator, array[index], index, array);
+        }
+        return accumulator;
+      }
+      function asciiWords(string) {
+        return string.match(reAsciiWord) || [];
+      }
+      function basePropertyOf(object) {
+        return function(key) {
+          return object == null ? void 0 : object[key];
+        };
+      }
+      var deburrLetter = basePropertyOf(deburredLetters);
+      function hasUnicodeWord(string) {
+        return reHasUnicodeWord.test(string);
+      }
+      function unicodeWords(string) {
+        return string.match(reUnicodeWord) || [];
+      }
+      var objectProto = Object.prototype;
+      var objectToString = objectProto.toString;
+      var Symbol2 = root.Symbol;
+      var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+      var symbolToString = symbolProto ? symbolProto.toString : void 0;
+      function baseToString(value) {
+        if (typeof value == "string") {
+          return value;
+        }
+        if (isSymbol(value)) {
+          return symbolToString ? symbolToString.call(value) : "";
+        }
+        var result = value + "";
+        return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+      }
+      function createCompounder(callback) {
+        return function(string) {
+          return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
+        };
+      }
+      function isObjectLike(value) {
+        return !!value && typeof value == "object";
+      }
+      function isSymbol(value) {
+        return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+      }
+      function toString(value) {
+        return value == null ? "" : baseToString(value);
+      }
+      function deburr(string) {
+        string = toString(string);
+        return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
+      }
+      var kebabCase = createCompounder(function(result, word, index) {
+        return result + (index ? "-" : "") + word.toLowerCase();
+      });
+      function words(string, pattern, guard) {
+        string = toString(string);
+        pattern = guard ? void 0 : pattern;
+        if (pattern === void 0) {
+          return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
+        }
+        return string.match(pattern) || [];
+      }
+      module.exports = kebabCase;
+    }
+  });
+
+  // ../design-tokens/src/lib/addExtraThemeEntries.ts
+  var import_color_string = __toESM(require_color_string());
+
+  // ../design-tokens/src/lib/cssVariables.ts
+  var import_lodash = __toESM(require_lodash());
+  var objectPathToCssVarIdentifier = (path) => `--${path.map(import_lodash.default).join("-")}`;
+
+  // ../design-tokens/src/lib/addExtraThemeEntries.ts
+  var addExtraThemeEntries = (path, key, value, printValue, {
+    augmentWithId
+  }) => {
+    const colorRgb = typeof value === "string" ? import_color_string.default.get.rgb(value) : null;
+    const result = {
+      [key]: printValue(path, value)
+    };
+    if (colorRgb) {
+      result[key] = printValue(path, value).toLowerCase();
+      const rgbPath = [...path, "rgb"];
+      const rgbTriple = printValue(rgbPath, colorRgb.slice(0, 3).join(", "));
+      result[`${key}-rgb`] = rgbTriple;
+      if (augmentWithId) {
+        result[`${key}-rgb-id`] = objectPathToCssVarIdentifier(rgbPath);
+      }
+    }
+    if (augmentWithId) {
+      result[`${key}-id`] = objectPathToCssVarIdentifier(path);
+    }
+    return result;
+  };
+
+  // ../design-tokens/src/lib/mapLeafsOfObject.ts
+  function mapLeafsOfObject(object, mapper) {
+    const recurser = (currentPath, obj) => {
+      const handleEntry = (key, value) => {
+        const pathToKey = [...currentPath, key];
+        if (typeof value === "object" && value !== null && value !== void 0) {
+          return recurser(pathToKey, value);
+        }
+        return mapper(pathToKey, value);
+      };
+      return Object.entries(obj).reduce(
+        (acc, [nextKey, nextValue]) => ({
+          ...acc,
+          [nextKey]: handleEntry(nextKey, nextValue)
+        }),
+        {}
+      );
+    };
+    return recurser([], object);
+  }
+
+  // ../design-tokens/src/lib/makeCssVariableDefinitionsMap.ts
+  function makeCssVariableDefinitionsMap(theme) {
+    let accumulatedCssVariables = {};
+    mapLeafsOfObject(theme, (path, value) => {
+      const key = objectPathToCssVarIdentifier(path);
+      const nextCssVariables = addExtraThemeEntries(
+        path,
+        key,
+        value,
+        (_, v) => `${v}`,
+        { augmentWithId: false }
+      );
+      accumulatedCssVariables = {
+        ...accumulatedCssVariables,
+        ...nextCssVariables
+      };
+    });
+    return accumulatedCssVariables;
+  }
+
+  // src/KaizenProvider/ThemeProvider/ThemeManager.ts
+  var ThemeManager = class {
+    constructor(theme, rootElementId = "", apply = true) {
+      this.themeChangeListeners = [];
+      this.rootElement = null;
+      this.getRootElement = () => this.rootElement;
+      this.getRootElementId = () => this.rootElementId;
+      this.getCurrentTheme = () => this.theme;
+      this.setRootElement = (element) => {
+        this.rootElement = element;
+      };
+      this.setRootElementId = (rootElementId) => this.rootElementId = rootElementId;
+      this.setAndApplyTheme = (theme, force) => {
+        if (!force) {
+          if (this.theme === theme)
+            return;
+        }
+        this.theme = theme;
+        this.applyCurrentTheme();
+        this.notifyThemeChangeListeners(theme);
+      };
+      this.addThemeChangeListener = (listener) => {
+        this.themeChangeListeners.push(listener);
+      };
+      this.removeThemeChangeListener = (listener) => {
+        this.themeChangeListeners = this.themeChangeListeners.filter(
+          (l) => l !== listener
+        );
+      };
+      this.applyCurrentTheme = () => {
+        if (typeof window !== "undefined") {
+          this.setRootElement(
+            document.getElementById(this.rootElementId) ?? document.documentElement
+          );
+          const cssVariableDefinitions = makeCssVariableDefinitionsMap(this.theme);
+          Object.entries(cssVariableDefinitions).forEach(([key, value]) => {
+            var _a;
+            (_a = this.rootElement) == null ? void 0 : _a.style.setProperty(key, value);
+          });
+        }
+      };
+      this.notifyThemeChangeListeners = (theme) => {
+        this.themeChangeListeners.forEach((listener) => listener(theme));
+      };
+      this.theme = theme;
+      this.rootElementId = rootElementId;
+      if (apply)
+        this.applyCurrentTheme();
+    }
+  };
+})();