@difizen/libro-common 0.3.4 → 1.0.0

package/es/core/theme/color/color.js

@@ -0,0 +1,658 @@
+var _Color;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/* eslint-disable no-inner-declarations */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CharCode } from "../../../common/index.js";
+function roundFloat(number, decimalPoints) {
+  var decimal = Math.pow(10, decimalPoints);
+  return Math.round(number * decimal) / decimal;
+}
+export var RGBA = /*#__PURE__*/function () {
+  /**
+   * Red: integer in [0-255]
+   */
+
+  /**
+   * Green: integer in [0-255]
+   */
+
+  /**
+   * Blue: integer in [0-255]
+   */
+
+  /**
+   * Alpha: float in [0-1]
+   */
+
+  function RGBA(r, g, b) {
+    var a = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+    _classCallCheck(this, RGBA);
+    this._rgbaBrand = undefined;
+    this.r = Math.min(255, Math.max(0, r)) | 0;
+    this.g = Math.min(255, Math.max(0, g)) | 0;
+    this.b = Math.min(255, Math.max(0, b)) | 0;
+    this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+  }
+  _createClass(RGBA, null, [{
+    key: "equals",
+    value: function equals(a, b) {
+      return a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;
+    }
+  }]);
+  return RGBA;
+}();
+export var HSLA = /*#__PURE__*/function () {
+  /**
+   * Hue: integer in [0, 360]
+   */
+
+  /**
+   * Saturation: float in [0, 1]
+   */
+
+  /**
+   * Luminosity: float in [0, 1]
+   */
+
+  /**
+   * Alpha: float in [0, 1]
+   */
+
+  function HSLA(h, s, l, a) {
+    _classCallCheck(this, HSLA);
+    this._hslaBrand = undefined;
+    this.h = Math.max(Math.min(360, h), 0) | 0;
+    this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);
+    this.l = roundFloat(Math.max(Math.min(1, l), 0), 3);
+    this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+  }
+  _createClass(HSLA, null, [{
+    key: "equals",
+    value: function equals(a, b) {
+      return a.h === b.h && a.s === b.s && a.l === b.l && a.a === b.a;
+    }
+
+    /**
+     * Converts an RGB color value to HSL. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes r, g, and b are contained in the set [0, 255] and
+     * returns h in the set [0, 360], s, and l in the set [0, 1].
+     */
+  }, {
+    key: "fromRGBA",
+    value: function fromRGBA(rgba) {
+      var r = rgba.r / 255;
+      var g = rgba.g / 255;
+      var b = rgba.b / 255;
+      var a = rgba.a;
+      var max = Math.max(r, g, b);
+      var min = Math.min(r, g, b);
+      var h = 0;
+      var s = 0;
+      var l = (min + max) / 2;
+      var chroma = max - min;
+      if (chroma > 0) {
+        s = Math.min(l <= 0.5 ? chroma / (2 * l) : chroma / (2 - 2 * l), 1);
+        switch (max) {
+          case r:
+            h = (g - b) / chroma + (g < b ? 6 : 0);
+            break;
+          case g:
+            h = (b - r) / chroma + 2;
+            break;
+          case b:
+            h = (r - g) / chroma + 4;
+            break;
+        }
+        h *= 60;
+        h = Math.round(h);
+      }
+      return new HSLA(h, s, l, a);
+    }
+  }, {
+    key: "_hue2rgb",
+    value: function _hue2rgb(p, q, t) {
+      if (t < 0) {
+        t += 1;
+      }
+      if (t > 1) {
+        t -= 1;
+      }
+      if (t < 1 / 6) {
+        return p + (q - p) * 6 * t;
+      }
+      if (t < 1 / 2) {
+        return q;
+      }
+      if (t < 2 / 3) {
+        return p + (q - p) * (2 / 3 - t) * 6;
+      }
+      return p;
+    }
+
+    /**
+     * Converts an HSL color value to RGB. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
+     * returns r, g, and b in the set [0, 255].
+     */
+  }, {
+    key: "toRGBA",
+    value: function toRGBA(hsla) {
+      var h = hsla.h / 360;
+      var s = hsla.s,
+        l = hsla.l,
+        a = hsla.a;
+      var r;
+      var g;
+      var b;
+      if (s === 0) {
+        r = g = b = l; // achromatic
+      } else {
+        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        var p = 2 * l - q;
+        r = HSLA._hue2rgb(p, q, h + 1 / 3);
+        g = HSLA._hue2rgb(p, q, h);
+        b = HSLA._hue2rgb(p, q, h - 1 / 3);
+      }
+      return new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a);
+    }
+  }]);
+  return HSLA;
+}();
+export var HSVA = /*#__PURE__*/function () {
+  /**
+   * Hue: integer in [0, 360]
+   */
+
+  /**
+   * Saturation: float in [0, 1]
+   */
+
+  /**
+   * Value: float in [0, 1]
+   */
+
+  /**
+   * Alpha: float in [0, 1]
+   */
+
+  function HSVA(h, s, v, a) {
+    _classCallCheck(this, HSVA);
+    this._hsvaBrand = undefined;
+    this.h = Math.max(Math.min(360, h), 0) | 0;
+    this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);
+    this.v = roundFloat(Math.max(Math.min(1, v), 0), 3);
+    this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+  }
+  _createClass(HSVA, null, [{
+    key: "equals",
+    value: function equals(a, b) {
+      return a.h === b.h && a.s === b.s && a.v === b.v && a.a === b.a;
+    }
+
+    // from http://www.rapidtables.com/convert/color/rgb-to-hsv.htm
+  }, {
+    key: "fromRGBA",
+    value: function fromRGBA(rgba) {
+      var r = rgba.r / 255;
+      var g = rgba.g / 255;
+      var b = rgba.b / 255;
+      var cmax = Math.max(r, g, b);
+      var cmin = Math.min(r, g, b);
+      var delta = cmax - cmin;
+      var s = cmax === 0 ? 0 : delta / cmax;
+      var m;
+      if (delta === 0) {
+        m = 0;
+      } else if (cmax === r) {
+        m = ((g - b) / delta % 6 + 6) % 6;
+      } else if (cmax === g) {
+        m = (b - r) / delta + 2;
+      } else {
+        m = (r - g) / delta + 4;
+      }
+      return new HSVA(Math.round(m * 60), s, cmax, rgba.a);
+    }
+
+    // from http://www.rapidtables.com/convert/color/hsv-to-rgb.htm
+  }, {
+    key: "toRGBA",
+    value: function toRGBA(hsva) {
+      var h = hsva.h,
+        s = hsva.s,
+        v = hsva.v,
+        a = hsva.a;
+      var c = v * s;
+      var x = c * (1 - Math.abs(h / 60 % 2 - 1));
+      var m = v - c;
+      var r = 0,
+        g = 0,
+        b = 0;
+      if (h < 60) {
+        r = c;
+        g = x;
+      } else if (h < 120) {
+        r = x;
+        g = c;
+      } else if (h < 180) {
+        g = c;
+        b = x;
+      } else if (h < 240) {
+        g = x;
+        b = c;
+      } else if (h < 300) {
+        r = x;
+        b = c;
+      } else if (h <= 360) {
+        r = c;
+        b = x;
+      }
+      r = Math.round((r + m) * 255);
+      g = Math.round((g + m) * 255);
+      b = Math.round((b + m) * 255);
+      return new RGBA(r, g, b, a);
+    }
+  }]);
+  return HSVA;
+}();
+export var Color = /*#__PURE__*/function () {
+  function Color(arg) {
+    _classCallCheck(this, Color);
+    if (!arg) {
+      throw new Error('Color needs a value');
+    } else if (arg instanceof RGBA) {
+      this.rgba = arg;
+    } else if (arg instanceof HSLA) {
+      this._hsla = arg;
+      this.rgba = HSLA.toRGBA(arg);
+    } else if (arg instanceof HSVA) {
+      this._hsva = arg;
+      this.rgba = HSVA.toRGBA(arg);
+    } else {
+      throw new Error('Invalid color ctor argument');
+    }
+  }
+  _createClass(Color, [{
+    key: "hsla",
+    get: function get() {
+      if (this._hsla) {
+        return this._hsla;
+      }
+      return HSLA.fromRGBA(this.rgba);
+    }
+  }, {
+    key: "hsva",
+    get: function get() {
+      if (this._hsva) {
+        return this._hsva;
+      }
+      return HSVA.fromRGBA(this.rgba);
+    }
+  }, {
+    key: "equals",
+    value: function equals(other) {
+      return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva);
+    }
+
+    /**
+     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
+     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
+     */
+  }, {
+    key: "getRelativeLuminance",
+    value: function getRelativeLuminance() {
+      var R = Color._relativeLuminanceForComponent(this.rgba.r);
+      var G = Color._relativeLuminanceForComponent(this.rgba.g);
+      var B = Color._relativeLuminanceForComponent(this.rgba.b);
+      var luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B;
+      return roundFloat(luminance, 4);
+    }
+  }, {
+    key: "getContrastRatio",
+    value:
+    /**
+     * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+     * Returns the contrast ration number in the set [1, 21].
+     */
+    function getContrastRatio(another) {
+      var lum1 = this.getRelativeLuminance();
+      var lum2 = another.getRelativeLuminance();
+      return lum1 > lum2 ? (lum1 + 0.05) / (lum2 + 0.05) : (lum2 + 0.05) / (lum1 + 0.05);
+    }
+
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if darker color otherwise 'false'
+     */
+  }, {
+    key: "isDarker",
+    value: function isDarker() {
+      var yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;
+      return yiq < 128;
+    }
+
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if lighter color otherwise 'false'
+     */
+  }, {
+    key: "isLighter",
+    value: function isLighter() {
+      var yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;
+      return yiq >= 128;
+    }
+  }, {
+    key: "isLighterThan",
+    value: function isLighterThan(another) {
+      var lum1 = this.getRelativeLuminance();
+      var lum2 = another.getRelativeLuminance();
+      return lum1 > lum2;
+    }
+  }, {
+    key: "isDarkerThan",
+    value: function isDarkerThan(another) {
+      var lum1 = this.getRelativeLuminance();
+      var lum2 = another.getRelativeLuminance();
+      return lum1 < lum2;
+    }
+  }, {
+    key: "lighten",
+    value: function lighten(factor) {
+      return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a));
+    }
+  }, {
+    key: "darken",
+    value: function darken(factor) {
+      return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a));
+    }
+  }, {
+    key: "transparent",
+    value: function transparent(factor) {
+      var _this$rgba = this.rgba,
+        r = _this$rgba.r,
+        g = _this$rgba.g,
+        b = _this$rgba.b,
+        a = _this$rgba.a;
+      return new Color(new RGBA(r, g, b, a * factor));
+    }
+  }, {
+    key: "isTransparent",
+    value: function isTransparent() {
+      return this.rgba.a === 0;
+    }
+  }, {
+    key: "isOpaque",
+    value: function isOpaque() {
+      return this.rgba.a === 1;
+    }
+  }, {
+    key: "opposite",
+    value: function opposite() {
+      return new Color(new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a));
+    }
+  }, {
+    key: "blend",
+    value: function blend(c) {
+      var rgba = c.rgba;
+
+      // Convert to 0..1 opacity
+      var thisA = this.rgba.a;
+      var colorA = rgba.a;
+      var a = thisA + colorA * (1 - thisA);
+      if (a < 1e-6) {
+        return Color.transparent;
+      }
+      var r = this.rgba.r * thisA / a + rgba.r * colorA * (1 - thisA) / a;
+      var g = this.rgba.g * thisA / a + rgba.g * colorA * (1 - thisA) / a;
+      var b = this.rgba.b * thisA / a + rgba.b * colorA * (1 - thisA) / a;
+      return new Color(new RGBA(r, g, b, a));
+    }
+  }, {
+    key: "makeOpaque",
+    value: function makeOpaque(opaqueBackground) {
+      if (this.isOpaque() || opaqueBackground.rgba.a !== 1) {
+        // only allow to blend onto a non-opaque color onto a opaque color
+        return this;
+      }
+      var _this$rgba2 = this.rgba,
+        r = _this$rgba2.r,
+        g = _this$rgba2.g,
+        b = _this$rgba2.b,
+        a = _this$rgba2.a;
+
+      // https://stackoverflow.com/questions/12228548/finding-equivalent-color-with-opacity
+      return new Color(new RGBA(opaqueBackground.rgba.r - a * (opaqueBackground.rgba.r - r), opaqueBackground.rgba.g - a * (opaqueBackground.rgba.g - g), opaqueBackground.rgba.b - a * (opaqueBackground.rgba.b - b), 1));
+    }
+  }, {
+    key: "flatten",
+    value: function flatten() {
+      for (var _len = arguments.length, backgrounds = new Array(_len), _key = 0; _key < _len; _key++) {
+        backgrounds[_key] = arguments[_key];
+      }
+      var background = backgrounds.reduceRight(function (accumulator, color) {
+        return Color._flatten(color, accumulator);
+      });
+      return Color._flatten(this, background);
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      if (!this._toString) {
+        this._toString = Color.Format.CSS.format(this);
+      }
+      return this._toString;
+    }
+  }], [{
+    key: "fromHex",
+    value: function fromHex(hex) {
+      return Color.Format.CSS.parseHex(hex) || Color.red;
+    }
+  }, {
+    key: "_relativeLuminanceForComponent",
+    value: function _relativeLuminanceForComponent(color) {
+      var c = color / 255;
+      return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    }
+  }, {
+    key: "_flatten",
+    value: function _flatten(foreground, background) {
+      var backgroundAlpha = 1 - foreground.rgba.a;
+      return new Color(new RGBA(backgroundAlpha * background.rgba.r + foreground.rgba.a * foreground.rgba.r, backgroundAlpha * background.rgba.g + foreground.rgba.a * foreground.rgba.g, backgroundAlpha * background.rgba.b + foreground.rgba.a * foreground.rgba.b));
+    }
+  }, {
+    key: "getLighterColor",
+    value: function getLighterColor(of, relative, factor) {
+      if (of.isLighterThan(relative)) {
+        return of;
+      }
+      factor = factor || 0.5;
+      var lum1 = of.getRelativeLuminance();
+      var lum2 = relative.getRelativeLuminance();
+      factor = factor * (lum2 - lum1) / lum2;
+      return of.lighten(factor);
+    }
+  }, {
+    key: "getDarkerColor",
+    value: function getDarkerColor(of, relative, factor) {
+      if (of.isDarkerThan(relative)) {
+        return of;
+      }
+      factor = factor || 0.5;
+      var lum1 = of.getRelativeLuminance();
+      var lum2 = relative.getRelativeLuminance();
+      factor = factor * (lum1 - lum2) / lum1;
+      return of.darken(factor);
+    }
+  }]);
+  return Color;
+}();
+_Color = Color;
+Color.white = new _Color(new RGBA(255, 255, 255, 1));
+Color.black = new _Color(new RGBA(0, 0, 0, 1));
+Color.red = new _Color(new RGBA(255, 0, 0, 1));
+Color.blue = new _Color(new RGBA(0, 0, 255, 1));
+Color.green = new _Color(new RGBA(0, 255, 0, 1));
+Color.cyan = new _Color(new RGBA(0, 255, 255, 1));
+Color.lightgrey = new _Color(new RGBA(211, 211, 211, 1));
+Color.transparent = new _Color(new RGBA(0, 0, 0, 0));
+(function (_Color2) {
+  var Format;
+  (function (_Format) {
+    var CSS;
+    (function (_CSS) {
+      function formatRGB(color) {
+        if (color.rgba.a === 1) {
+          return "rgb(".concat(color.rgba.r, ", ").concat(color.rgba.g, ", ").concat(color.rgba.b, ")");
+        }
+        return Color.Format.CSS.formatRGBA(color);
+      }
+      _CSS.formatRGB = formatRGB;
+      function formatRGBA(color) {
+        return "rgba(".concat(color.rgba.r, ", ").concat(color.rgba.g, ", ").concat(color.rgba.b, ", ").concat(+color.rgba.a.toFixed(2), ")");
+      }
+      _CSS.formatRGBA = formatRGBA;
+      function formatHSL(color) {
+        if (color.hsla.a === 1) {
+          return "hsl(".concat(color.hsla.h, ", ").concat((color.hsla.s * 100).toFixed(2), "%, ").concat((color.hsla.l * 100).toFixed(2), "%)");
+        }
+        return Color.Format.CSS.formatHSLA(color);
+      }
+      _CSS.formatHSL = formatHSL;
+      function formatHSLA(color) {
+        return "hsla(".concat(color.hsla.h, ", ").concat((color.hsla.s * 100).toFixed(2), "%, ").concat((color.hsla.l * 100).toFixed(2), "%, ").concat(color.hsla.a.toFixed(2), ")");
+      }
+      _CSS.formatHSLA = formatHSLA;
+      function _toTwoDigitHex(n) {
+        var r = n.toString(16);
+        return r.length !== 2 ? "0".concat(r) : r;
+      }
+
+      /**
+       * Formats the color as #RRGGBB
+       */
+      function formatHex(color) {
+        return "#".concat(_toTwoDigitHex(color.rgba.r)).concat(_toTwoDigitHex(color.rgba.g)).concat(_toTwoDigitHex(color.rgba.b));
+      }
+      _CSS.formatHex = formatHex;
+      function formatHexA(color) {
+        var compact = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+        if (compact && color.rgba.a === 1) {
+          return Color.Format.CSS.formatHex(color);
+        }
+        return "#".concat(_toTwoDigitHex(color.rgba.r)).concat(_toTwoDigitHex(color.rgba.g)).concat(_toTwoDigitHex(color.rgba.b)).concat(_toTwoDigitHex(Math.round(color.rgba.a * 255)));
+      }
+      _CSS.formatHexA = formatHexA;
+      function format(color) {
+        if (color.isOpaque()) {
+          return Color.Format.CSS.formatHex(color);
+        }
+        return Color.Format.CSS.formatRGBA(color);
+      }
+      _CSS.format = format;
+      function parseHex(hex) {
+        var length = hex.length;
+        if (length === 0) {
+          // Invalid color
+          return null;
+        }
+        if (hex.charCodeAt(0) !== CharCode.Hash) {
+          // Does not begin with a #
+          return null;
+        }
+        if (length === 7) {
+          // #RRGGBB format
+          var r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
+          var g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
+          var b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
+          return new Color(new RGBA(r, g, b, 1));
+        }
+        if (length === 9) {
+          // #RRGGBBAA format
+          var _r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
+          var _g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
+          var _b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
+          var a = 16 * _parseHexDigit(hex.charCodeAt(7)) + _parseHexDigit(hex.charCodeAt(8));
+          return new Color(new RGBA(_r, _g, _b, a / 255));
+        }
+        if (length === 4) {
+          // #RGB format
+          var _r2 = _parseHexDigit(hex.charCodeAt(1));
+          var _g2 = _parseHexDigit(hex.charCodeAt(2));
+          var _b2 = _parseHexDigit(hex.charCodeAt(3));
+          return new Color(new RGBA(16 * _r2 + _r2, 16 * _g2 + _g2, 16 * _b2 + _b2));
+        }
+        if (length === 5) {
+          // #RGBA format
+          var _r3 = _parseHexDigit(hex.charCodeAt(1));
+          var _g3 = _parseHexDigit(hex.charCodeAt(2));
+          var _b3 = _parseHexDigit(hex.charCodeAt(3));
+          var _a = _parseHexDigit(hex.charCodeAt(4));
+          return new Color(new RGBA(16 * _r3 + _r3, 16 * _g3 + _g3, 16 * _b3 + _b3, (16 * _a + _a) / 255));
+        }
+
+        // Invalid color
+        return null;
+      }
+      _CSS.parseHex = parseHex;
+      function _parseHexDigit(charCode) {
+        switch (charCode) {
+          case CharCode.Digit0:
+            return 0;
+          case CharCode.Digit1:
+            return 1;
+          case CharCode.Digit2:
+            return 2;
+          case CharCode.Digit3:
+            return 3;
+          case CharCode.Digit4:
+            return 4;
+          case CharCode.Digit5:
+            return 5;
+          case CharCode.Digit6:
+            return 6;
+          case CharCode.Digit7:
+            return 7;
+          case CharCode.Digit8:
+            return 8;
+          case CharCode.Digit9:
+            return 9;
+          case CharCode.a:
+            return 10;
+          case CharCode.A:
+            return 10;
+          case CharCode.b:
+            return 11;
+          case CharCode.B:
+            return 11;
+          case CharCode.c:
+            return 12;
+          case CharCode.C:
+            return 12;
+          case CharCode.d:
+            return 13;
+          case CharCode.D:
+            return 13;
+          case CharCode.e:
+            return 14;
+          case CharCode.E:
+            return 14;
+          case CharCode.f:
+            return 15;
+          case CharCode.F:
+            return 15;
+        }
+        return 0;
+      }
+    })(CSS || (CSS = _Format.CSS || (_Format.CSS = {})));
+  })(Format || (Format = _Color2.Format || (_Color2.Format = {})));
+})(Color || (Color = {}));

package/es/core/theme/color/default-color-contribution.d.ts

@@ -0,0 +1,6 @@
+import { ColorContribution } from './color-protocol';
+import type { ColorRegistry } from './color-registry';
+export declare class DefaultColorContribution implements ColorContribution {
+    registerColors(colors: ColorRegistry): void;
+}
+//# sourceMappingURL=default-color-contribution.d.ts.map

package/es/core/theme/color/default-color-contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-color-contribution.d.ts","sourceRoot":"","sources":["../../../../src/core/theme/color/default-color-contribution.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD,qBACa,wBAAyB,YAAW,iBAAiB;IAChE,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;CA6e5C"}