css-color-parser-h 1.0.5 → 2.0.0

package/dist/css-color-parser-h.umd.js

@@ -0,0 +1,1674 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["Parser"] = factory();
+	else
+		root["Parser"] = factory();
+})(this, function() {
+return /******/ (function() { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 208:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+/* MIT license */
+/* eslint-disable no-mixed-operators */
+var cssKeywords = __webpack_require__(101);
+
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+//       values that give correct `typeof` results).
+//       do not use box values types (i.e. Number(), String(), etc.)
+
+var reverseKeywords = {};
+for (var _i = 0, _Object$keys = Object.keys(cssKeywords); _i < _Object$keys.length; _i++) {
+  var key = _Object$keys[_i];
+  reverseKeywords[cssKeywords[key]] = key;
+}
+var convert = {
+  rgb: {
+    channels: 3,
+    labels: 'rgb'
+  },
+  hsl: {
+    channels: 3,
+    labels: 'hsl'
+  },
+  hsv: {
+    channels: 3,
+    labels: 'hsv'
+  },
+  hwb: {
+    channels: 3,
+    labels: 'hwb'
+  },
+  cmyk: {
+    channels: 4,
+    labels: 'cmyk'
+  },
+  xyz: {
+    channels: 3,
+    labels: 'xyz'
+  },
+  lab: {
+    channels: 3,
+    labels: 'lab'
+  },
+  lch: {
+    channels: 3,
+    labels: 'lch'
+  },
+  hex: {
+    channels: 1,
+    labels: ['hex']
+  },
+  keyword: {
+    channels: 1,
+    labels: ['keyword']
+  },
+  ansi16: {
+    channels: 1,
+    labels: ['ansi16']
+  },
+  ansi256: {
+    channels: 1,
+    labels: ['ansi256']
+  },
+  hcg: {
+    channels: 3,
+    labels: ['h', 'c', 'g']
+  },
+  apple: {
+    channels: 3,
+    labels: ['r16', 'g16', 'b16']
+  },
+  gray: {
+    channels: 1,
+    labels: ['gray']
+  }
+};
+module.exports = convert;
+
+// Hide .channels and .labels properties
+for (var _i2 = 0, _Object$keys2 = Object.keys(convert); _i2 < _Object$keys2.length; _i2++) {
+  var model = _Object$keys2[_i2];
+  if (!('channels' in convert[model])) {
+    throw new Error('missing channels property: ' + model);
+  }
+  if (!('labels' in convert[model])) {
+    throw new Error('missing channel labels property: ' + model);
+  }
+  if (convert[model].labels.length !== convert[model].channels) {
+    throw new Error('channel and label counts mismatch: ' + model);
+  }
+  var _convert$model = convert[model],
+    channels = _convert$model.channels,
+    labels = _convert$model.labels;
+  delete convert[model].channels;
+  delete convert[model].labels;
+  Object.defineProperty(convert[model], 'channels', {
+    value: channels
+  });
+  Object.defineProperty(convert[model], 'labels', {
+    value: labels
+  });
+}
+convert.rgb.hsl = function (rgb) {
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  var min = Math.min(r, g, b);
+  var max = Math.max(r, g, b);
+  var delta = max - min;
+  var h;
+  var s;
+  if (max === min) {
+    h = 0;
+  } else if (r === max) {
+    h = (g - b) / delta;
+  } else if (g === max) {
+    h = 2 + (b - r) / delta;
+  } else if (b === max) {
+    h = 4 + (r - g) / delta;
+  }
+  h = Math.min(h * 60, 360);
+  if (h < 0) {
+    h += 360;
+  }
+  var l = (min + max) / 2;
+  if (max === min) {
+    s = 0;
+  } else if (l <= 0.5) {
+    s = delta / (max + min);
+  } else {
+    s = delta / (2 - max - min);
+  }
+  return [h, s * 100, l * 100];
+};
+convert.rgb.hsv = function (rgb) {
+  var rdif;
+  var gdif;
+  var bdif;
+  var h;
+  var s;
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  var v = Math.max(r, g, b);
+  var diff = v - Math.min(r, g, b);
+  var diffc = function diffc(c) {
+    return (v - c) / 6 / diff + 1 / 2;
+  };
+  if (diff === 0) {
+    h = 0;
+    s = 0;
+  } else {
+    s = diff / v;
+    rdif = diffc(r);
+    gdif = diffc(g);
+    bdif = diffc(b);
+    if (r === v) {
+      h = bdif - gdif;
+    } else if (g === v) {
+      h = 1 / 3 + rdif - bdif;
+    } else if (b === v) {
+      h = 2 / 3 + gdif - rdif;
+    }
+    if (h < 0) {
+      h += 1;
+    } else if (h > 1) {
+      h -= 1;
+    }
+  }
+  return [h * 360, s * 100, v * 100];
+};
+convert.rgb.hwb = function (rgb) {
+  var r = rgb[0];
+  var g = rgb[1];
+  var b = rgb[2];
+  var h = convert.rgb.hsl(rgb)[0];
+  var w = 1 / 255 * Math.min(r, Math.min(g, b));
+  b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+  return [h, w * 100, b * 100];
+};
+convert.rgb.cmyk = function (rgb) {
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  var k = Math.min(1 - r, 1 - g, 1 - b);
+  var c = (1 - r - k) / (1 - k) || 0;
+  var m = (1 - g - k) / (1 - k) || 0;
+  var y = (1 - b - k) / (1 - k) || 0;
+  return [c * 100, m * 100, y * 100, k * 100];
+};
+function comparativeDistance(x, y) {
+  /*
+  	See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+  */
+  return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2);
+}
+convert.rgb.keyword = function (rgb) {
+  var reversed = reverseKeywords[rgb];
+  if (reversed) {
+    return reversed;
+  }
+  var currentClosestDistance = Infinity;
+  var currentClosestKeyword;
+  for (var _i3 = 0, _Object$keys3 = Object.keys(cssKeywords); _i3 < _Object$keys3.length; _i3++) {
+    var keyword = _Object$keys3[_i3];
+    var value = cssKeywords[keyword];
+
+    // Compute comparative distance
+    var distance = comparativeDistance(rgb, value);
+
+    // Check if its less, if so set as closest
+    if (distance < currentClosestDistance) {
+      currentClosestDistance = distance;
+      currentClosestKeyword = keyword;
+    }
+  }
+  return currentClosestKeyword;
+};
+convert.keyword.rgb = function (keyword) {
+  return cssKeywords[keyword];
+};
+convert.rgb.xyz = function (rgb) {
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+
+  // Assume sRGB
+  r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+  g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+  b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+  var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+  var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+  var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+  return [x * 100, y * 100, z * 100];
+};
+convert.rgb.lab = function (rgb) {
+  var xyz = convert.rgb.xyz(rgb);
+  var x = xyz[0];
+  var y = xyz[1];
+  var z = xyz[2];
+  x /= 95.047;
+  y /= 100;
+  z /= 108.883;
+  x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+  y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+  z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+  var l = 116 * y - 16;
+  var a = 500 * (x - y);
+  var b = 200 * (y - z);
+  return [l, a, b];
+};
+convert.hsl.rgb = function (hsl) {
+  var h = hsl[0] / 360;
+  var s = hsl[1] / 100;
+  var l = hsl[2] / 100;
+  var t2;
+  var t3;
+  var val;
+  if (s === 0) {
+    val = l * 255;
+    return [val, val, val];
+  }
+  if (l < 0.5) {
+    t2 = l * (1 + s);
+  } else {
+    t2 = l + s - l * s;
+  }
+  var t1 = 2 * l - t2;
+  var rgb = [0, 0, 0];
+  for (var i = 0; i < 3; i++) {
+    t3 = h + 1 / 3 * -(i - 1);
+    if (t3 < 0) {
+      t3++;
+    }
+    if (t3 > 1) {
+      t3--;
+    }
+    if (6 * t3 < 1) {
+      val = t1 + (t2 - t1) * 6 * t3;
+    } else if (2 * t3 < 1) {
+      val = t2;
+    } else if (3 * t3 < 2) {
+      val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+    } else {
+      val = t1;
+    }
+    rgb[i] = val * 255;
+  }
+  return rgb;
+};
+convert.hsl.hsv = function (hsl) {
+  var h = hsl[0];
+  var s = hsl[1] / 100;
+  var l = hsl[2] / 100;
+  var smin = s;
+  var lmin = Math.max(l, 0.01);
+  l *= 2;
+  s *= l <= 1 ? l : 2 - l;
+  smin *= lmin <= 1 ? lmin : 2 - lmin;
+  var v = (l + s) / 2;
+  var sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+  return [h, sv * 100, v * 100];
+};
+convert.hsv.rgb = function (hsv) {
+  var h = hsv[0] / 60;
+  var s = hsv[1] / 100;
+  var v = hsv[2] / 100;
+  var hi = Math.floor(h) % 6;
+  var f = h - Math.floor(h);
+  var p = 255 * v * (1 - s);
+  var q = 255 * v * (1 - s * f);
+  var t = 255 * v * (1 - s * (1 - f));
+  v *= 255;
+  switch (hi) {
+    case 0:
+      return [v, t, p];
+    case 1:
+      return [q, v, p];
+    case 2:
+      return [p, v, t];
+    case 3:
+      return [p, q, v];
+    case 4:
+      return [t, p, v];
+    case 5:
+      return [v, p, q];
+  }
+};
+convert.hsv.hsl = function (hsv) {
+  var h = hsv[0];
+  var s = hsv[1] / 100;
+  var v = hsv[2] / 100;
+  var vmin = Math.max(v, 0.01);
+  var sl;
+  var l;
+  l = (2 - s) * v;
+  var lmin = (2 - s) * vmin;
+  sl = s * vmin;
+  sl /= lmin <= 1 ? lmin : 2 - lmin;
+  sl = sl || 0;
+  l /= 2;
+  return [h, sl * 100, l * 100];
+};
+
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert.hwb.rgb = function (hwb) {
+  var h = hwb[0] / 360;
+  var wh = hwb[1] / 100;
+  var bl = hwb[2] / 100;
+  var ratio = wh + bl;
+  var f;
+
+  // Wh + bl cant be > 1
+  if (ratio > 1) {
+    wh /= ratio;
+    bl /= ratio;
+  }
+  var i = Math.floor(6 * h);
+  var v = 1 - bl;
+  f = 6 * h - i;
+  if ((i & 0x01) !== 0) {
+    f = 1 - f;
+  }
+  var n = wh + f * (v - wh); // Linear interpolation
+
+  var r;
+  var g;
+  var b;
+  /* eslint-disable max-statements-per-line,no-multi-spaces */
+  switch (i) {
+    default:
+    case 6:
+    case 0:
+      r = v;
+      g = n;
+      b = wh;
+      break;
+    case 1:
+      r = n;
+      g = v;
+      b = wh;
+      break;
+    case 2:
+      r = wh;
+      g = v;
+      b = n;
+      break;
+    case 3:
+      r = wh;
+      g = n;
+      b = v;
+      break;
+    case 4:
+      r = n;
+      g = wh;
+      b = v;
+      break;
+    case 5:
+      r = v;
+      g = wh;
+      b = n;
+      break;
+  }
+  /* eslint-enable max-statements-per-line,no-multi-spaces */
+
+  return [r * 255, g * 255, b * 255];
+};
+convert.cmyk.rgb = function (cmyk) {
+  var c = cmyk[0] / 100;
+  var m = cmyk[1] / 100;
+  var y = cmyk[2] / 100;
+  var k = cmyk[3] / 100;
+  var r = 1 - Math.min(1, c * (1 - k) + k);
+  var g = 1 - Math.min(1, m * (1 - k) + k);
+  var b = 1 - Math.min(1, y * (1 - k) + k);
+  return [r * 255, g * 255, b * 255];
+};
+convert.xyz.rgb = function (xyz) {
+  var x = xyz[0] / 100;
+  var y = xyz[1] / 100;
+  var z = xyz[2] / 100;
+  var r;
+  var g;
+  var b;
+  r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+  g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+  b = x * 0.0557 + y * -0.2040 + z * 1.0570;
+
+  // Assume sRGB
+  r = r > 0.0031308 ? 1.055 * Math.pow(r, 1.0 / 2.4) - 0.055 : r * 12.92;
+  g = g > 0.0031308 ? 1.055 * Math.pow(g, 1.0 / 2.4) - 0.055 : g * 12.92;
+  b = b > 0.0031308 ? 1.055 * Math.pow(b, 1.0 / 2.4) - 0.055 : b * 12.92;
+  r = Math.min(Math.max(0, r), 1);
+  g = Math.min(Math.max(0, g), 1);
+  b = Math.min(Math.max(0, b), 1);
+  return [r * 255, g * 255, b * 255];
+};
+convert.xyz.lab = function (xyz) {
+  var x = xyz[0];
+  var y = xyz[1];
+  var z = xyz[2];
+  x /= 95.047;
+  y /= 100;
+  z /= 108.883;
+  x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+  y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+  z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+  var l = 116 * y - 16;
+  var a = 500 * (x - y);
+  var b = 200 * (y - z);
+  return [l, a, b];
+};
+convert.lab.xyz = function (lab) {
+  var l = lab[0];
+  var a = lab[1];
+  var b = lab[2];
+  var x;
+  var y;
+  var z;
+  y = (l + 16) / 116;
+  x = a / 500 + y;
+  z = y - b / 200;
+  var y2 = Math.pow(y, 3);
+  var x2 = Math.pow(x, 3);
+  var z2 = Math.pow(z, 3);
+  y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+  x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+  z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+  x *= 95.047;
+  y *= 100;
+  z *= 108.883;
+  return [x, y, z];
+};
+convert.lab.lch = function (lab) {
+  var l = lab[0];
+  var a = lab[1];
+  var b = lab[2];
+  var h;
+  var hr = Math.atan2(b, a);
+  h = hr * 360 / 2 / Math.PI;
+  if (h < 0) {
+    h += 360;
+  }
+  var c = Math.sqrt(a * a + b * b);
+  return [l, c, h];
+};
+convert.lch.lab = function (lch) {
+  var l = lch[0];
+  var c = lch[1];
+  var h = lch[2];
+  var hr = h / 360 * 2 * Math.PI;
+  var a = c * Math.cos(hr);
+  var b = c * Math.sin(hr);
+  return [l, a, b];
+};
+convert.rgb.ansi16 = function (args) {
+  var saturation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var _args = _slicedToArray(args, 3),
+    r = _args[0],
+    g = _args[1],
+    b = _args[2];
+  var value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
+
+  value = Math.round(value / 50);
+  if (value === 0) {
+    return 30;
+  }
+  var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+  if (value === 2) {
+    ansi += 60;
+  }
+  return ansi;
+};
+convert.hsv.ansi16 = function (args) {
+  // Optimization here; we already know the value and don't need to get
+  // it converted for us.
+  return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+};
+convert.rgb.ansi256 = function (args) {
+  var r = args[0];
+  var g = args[1];
+  var b = args[2];
+
+  // We use the extended greyscale palette here, with the exception of
+  // black and white. normal palette only has 4 greyscale shades.
+  if (r === g && g === b) {
+    if (r < 8) {
+      return 16;
+    }
+    if (r > 248) {
+      return 231;
+    }
+    return Math.round((r - 8) / 247 * 24) + 232;
+  }
+  var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+  return ansi;
+};
+convert.ansi16.rgb = function (args) {
+  var color = args % 10;
+
+  // Handle greyscale
+  if (color === 0 || color === 7) {
+    if (args > 50) {
+      color += 3.5;
+    }
+    color = color / 10.5 * 255;
+    return [color, color, color];
+  }
+  var mult = (~~(args > 50) + 1) * 0.5;
+  var r = (color & 1) * mult * 255;
+  var g = (color >> 1 & 1) * mult * 255;
+  var b = (color >> 2 & 1) * mult * 255;
+  return [r, g, b];
+};
+convert.ansi256.rgb = function (args) {
+  // Handle greyscale
+  if (args >= 232) {
+    var c = (args - 232) * 10 + 8;
+    return [c, c, c];
+  }
+  args -= 16;
+  var rem;
+  var r = Math.floor(args / 36) / 5 * 255;
+  var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+  var b = rem % 6 / 5 * 255;
+  return [r, g, b];
+};
+convert.rgb.hex = function (args) {
+  var integer = ((Math.round(args[0]) & 0xFF) << 16) + ((Math.round(args[1]) & 0xFF) << 8) + (Math.round(args[2]) & 0xFF);
+  var string = integer.toString(16).toUpperCase();
+  return '000000'.substring(string.length) + string;
+};
+convert.hex.rgb = function (args) {
+  var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+  if (!match) {
+    return [0, 0, 0];
+  }
+  var colorString = match[0];
+  if (match[0].length === 3) {
+    colorString = colorString.split('').map(function (_char) {
+      return _char + _char;
+    }).join('');
+  }
+  var integer = parseInt(colorString, 16);
+  var r = integer >> 16 & 0xFF;
+  var g = integer >> 8 & 0xFF;
+  var b = integer & 0xFF;
+  return [r, g, b];
+};
+convert.rgb.hcg = function (rgb) {
+  var r = rgb[0] / 255;
+  var g = rgb[1] / 255;
+  var b = rgb[2] / 255;
+  var max = Math.max(Math.max(r, g), b);
+  var min = Math.min(Math.min(r, g), b);
+  var chroma = max - min;
+  var grayscale;
+  var hue;
+  if (chroma < 1) {
+    grayscale = min / (1 - chroma);
+  } else {
+    grayscale = 0;
+  }
+  if (chroma <= 0) {
+    hue = 0;
+  } else if (max === r) {
+    hue = (g - b) / chroma % 6;
+  } else if (max === g) {
+    hue = 2 + (b - r) / chroma;
+  } else {
+    hue = 4 + (r - g) / chroma;
+  }
+  hue /= 6;
+  hue %= 1;
+  return [hue * 360, chroma * 100, grayscale * 100];
+};
+convert.hsl.hcg = function (hsl) {
+  var s = hsl[1] / 100;
+  var l = hsl[2] / 100;
+  var c = l < 0.5 ? 2.0 * s * l : 2.0 * s * (1.0 - l);
+  var f = 0;
+  if (c < 1.0) {
+    f = (l - 0.5 * c) / (1.0 - c);
+  }
+  return [hsl[0], c * 100, f * 100];
+};
+convert.hsv.hcg = function (hsv) {
+  var s = hsv[1] / 100;
+  var v = hsv[2] / 100;
+  var c = s * v;
+  var f = 0;
+  if (c < 1.0) {
+    f = (v - c) / (1 - c);
+  }
+  return [hsv[0], c * 100, f * 100];
+};
+convert.hcg.rgb = function (hcg) {
+  var h = hcg[0] / 360;
+  var c = hcg[1] / 100;
+  var g = hcg[2] / 100;
+  if (c === 0.0) {
+    return [g * 255, g * 255, g * 255];
+  }
+  var pure = [0, 0, 0];
+  var hi = h % 1 * 6;
+  var v = hi % 1;
+  var w = 1 - v;
+  var mg = 0;
+
+  /* eslint-disable max-statements-per-line */
+  switch (Math.floor(hi)) {
+    case 0:
+      pure[0] = 1;
+      pure[1] = v;
+      pure[2] = 0;
+      break;
+    case 1:
+      pure[0] = w;
+      pure[1] = 1;
+      pure[2] = 0;
+      break;
+    case 2:
+      pure[0] = 0;
+      pure[1] = 1;
+      pure[2] = v;
+      break;
+    case 3:
+      pure[0] = 0;
+      pure[1] = w;
+      pure[2] = 1;
+      break;
+    case 4:
+      pure[0] = v;
+      pure[1] = 0;
+      pure[2] = 1;
+      break;
+    default:
+      pure[0] = 1;
+      pure[1] = 0;
+      pure[2] = w;
+  }
+  /* eslint-enable max-statements-per-line */
+
+  mg = (1.0 - c) * g;
+  return [(c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255];
+};
+convert.hcg.hsv = function (hcg) {
+  var c = hcg[1] / 100;
+  var g = hcg[2] / 100;
+  var v = c + g * (1.0 - c);
+  var f = 0;
+  if (v > 0.0) {
+    f = c / v;
+  }
+  return [hcg[0], f * 100, v * 100];
+};
+convert.hcg.hsl = function (hcg) {
+  var c = hcg[1] / 100;
+  var g = hcg[2] / 100;
+  var l = g * (1.0 - c) + 0.5 * c;
+  var s = 0;
+  if (l > 0.0 && l < 0.5) {
+    s = c / (2 * l);
+  } else if (l >= 0.5 && l < 1.0) {
+    s = c / (2 * (1 - l));
+  }
+  return [hcg[0], s * 100, l * 100];
+};
+convert.hcg.hwb = function (hcg) {
+  var c = hcg[1] / 100;
+  var g = hcg[2] / 100;
+  var v = c + g * (1.0 - c);
+  return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
+convert.hwb.hcg = function (hwb) {
+  var w = hwb[1] / 100;
+  var b = hwb[2] / 100;
+  var v = 1 - b;
+  var c = v - w;
+  var g = 0;
+  if (c < 1) {
+    g = (v - c) / (1 - c);
+  }
+  return [hwb[0], c * 100, g * 100];
+};
+convert.apple.rgb = function (apple) {
+  return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+};
+convert.rgb.apple = function (rgb) {
+  return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+};
+convert.gray.rgb = function (args) {
+  return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+};
+convert.gray.hsl = function (args) {
+  return [0, 0, args[0]];
+};
+convert.gray.hsv = convert.gray.hsl;
+convert.gray.hwb = function (gray) {
+  return [0, 100, gray[0]];
+};
+convert.gray.cmyk = function (gray) {
+  return [0, 0, 0, gray[0]];
+};
+convert.gray.lab = function (gray) {
+  return [gray[0], 0, 0];
+};
+convert.gray.hex = function (gray) {
+  var val = Math.round(gray[0] / 100 * 255) & 0xFF;
+  var integer = (val << 16) + (val << 8) + val;
+  var string = integer.toString(16).toUpperCase();
+  return '000000'.substring(string.length) + string;
+};
+convert.rgb.gray = function (rgb) {
+  var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+  return [val / 255 * 100];
+};
+
+/***/ }),
+
+/***/ 907:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var conversions = __webpack_require__(208);
+var route = __webpack_require__(171);
+var convert = {};
+var models = Object.keys(conversions);
+function wrapRaw(fn) {
+  var wrappedFn = function wrappedFn() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var arg0 = args[0];
+    if (arg0 === undefined || arg0 === null) {
+      return arg0;
+    }
+    if (arg0.length > 1) {
+      args = arg0;
+    }
+    return fn(args);
+  };
+
+  // Preserve .conversion property if there is one
+  if ('conversion' in fn) {
+    wrappedFn.conversion = fn.conversion;
+  }
+  return wrappedFn;
+}
+function wrapRounded(fn) {
+  var wrappedFn = function wrappedFn() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    var arg0 = args[0];
+    if (arg0 === undefined || arg0 === null) {
+      return arg0;
+    }
+    if (arg0.length > 1) {
+      args = arg0;
+    }
+    var result = fn(args);
+
+    // We're assuming the result is an array here.
+    // see notice in conversions.js; don't use box types
+    // in conversion functions.
+    if (_typeof(result) === 'object') {
+      for (var len = result.length, i = 0; i < len; i++) {
+        result[i] = Math.round(result[i]);
+      }
+    }
+    return result;
+  };
+
+  // Preserve .conversion property if there is one
+  if ('conversion' in fn) {
+    wrappedFn.conversion = fn.conversion;
+  }
+  return wrappedFn;
+}
+models.forEach(function (fromModel) {
+  convert[fromModel] = {};
+  Object.defineProperty(convert[fromModel], 'channels', {
+    value: conversions[fromModel].channels
+  });
+  Object.defineProperty(convert[fromModel], 'labels', {
+    value: conversions[fromModel].labels
+  });
+  var routes = route(fromModel);
+  var routeModels = Object.keys(routes);
+  routeModels.forEach(function (toModel) {
+    var fn = routes[toModel];
+    convert[fromModel][toModel] = wrapRounded(fn);
+    convert[fromModel][toModel].raw = wrapRaw(fn);
+  });
+});
+module.exports = convert;
+
+/***/ }),
+
+/***/ 171:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var conversions = __webpack_require__(208);
+
+/*
+	This function routes a model to all other models.
+
+	all functions that are routed have a property `.conversion` attached
+	to the returned synthetic function. This property is an array
+	of strings, each with the steps in between the 'from' and 'to'
+	color models (inclusive).
+
+	conversions that are not possible simply are not included.
+*/
+
+function buildGraph() {
+  var graph = {};
+  // https://jsperf.com/object-keys-vs-for-in-with-closure/3
+  var models = Object.keys(conversions);
+  for (var len = models.length, i = 0; i < len; i++) {
+    graph[models[i]] = {
+      // http://jsperf.com/1-vs-infinity
+      // micro-opt, but this is simple.
+      distance: -1,
+      parent: null
+    };
+  }
+  return graph;
+}
+
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS(fromModel) {
+  var graph = buildGraph();
+  var queue = [fromModel]; // Unshift -> queue -> pop
+
+  graph[fromModel].distance = 0;
+  while (queue.length) {
+    var current = queue.pop();
+    var adjacents = Object.keys(conversions[current]);
+    for (var len = adjacents.length, i = 0; i < len; i++) {
+      var adjacent = adjacents[i];
+      var node = graph[adjacent];
+      if (node.distance === -1) {
+        node.distance = graph[current].distance + 1;
+        node.parent = current;
+        queue.unshift(adjacent);
+      }
+    }
+  }
+  return graph;
+}
+function link(from, to) {
+  return function (args) {
+    return to(from(args));
+  };
+}
+function wrapConversion(toModel, graph) {
+  var path = [graph[toModel].parent, toModel];
+  var fn = conversions[graph[toModel].parent][toModel];
+  var cur = graph[toModel].parent;
+  while (graph[cur].parent) {
+    path.unshift(graph[cur].parent);
+    fn = link(conversions[graph[cur].parent][cur], fn);
+    cur = graph[cur].parent;
+  }
+  fn.conversion = path;
+  return fn;
+}
+module.exports = function (fromModel) {
+  var graph = deriveBFS(fromModel);
+  var conversion = {};
+  var models = Object.keys(graph);
+  for (var len = models.length, i = 0; i < len; i++) {
+    var toModel = models[i];
+    var node = graph[toModel];
+    if (node.parent === null) {
+      // No possible conversion, or this node is the source model.
+      continue;
+    }
+    conversion[toModel] = wrapConversion(toModel, graph);
+  }
+  return conversion;
+};
+
+/***/ }),
+
+/***/ 101:
+/***/ (function(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]
+};
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	!function() {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = function(exports) {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+!function() {
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "CssColorParser": function() { return /* reexport */ src_CssColorParser; },
+  "fromArray": function() { return /* reexport */ fromArray; },
+  "fromColorStr": function() { return /* reexport */ fromColorStr; },
+  "fromHSL": function() { return /* reexport */ fromHSL; },
+  "fromHWB": function() { return /* reexport */ fromHWB; },
+  "fromJson": function() { return /* reexport */ fromJson; },
+  "fromRandom": function() { return /* reexport */ fromRandom; },
+  "parseCssColorStr": function() { return /* reexport */ parseCssColorStr; },
+  "parseHEX": function() { return /* reexport */ parseHEX; },
+  "parseHSLA": function() { return /* reexport */ parseHSLA; },
+  "parseHWB": function() { return /* reexport */ parseHWB; },
+  "parseKeyWord": function() { return /* reexport */ parseKeyWord; },
+  "parseRGBA": function() { return /* reexport */ parseRGBA; }
+});
+
+;// CONCATENATED MODULE: ./src/utils/common.ts
+var Check = /** @class */ (function () {
+    function Check() {
+    }
+    Check.type = function (type, paramName, value) {
+        var valueType = typeof value;
+        if (valueType !== type) {
+            throw new Error("Expected ".concat(paramName, " to be typeof ").concat(type, ", actual typeof was ").concat(valueType));
+        }
+    };
+    Check.types = function (types, paramName, value) {
+        var valueType = typeof value;
+        var isContained = types.includes(valueType);
+        if (!isContained) {
+            throw new Error("Expected ".concat(paramName, " to be typeof ").concat(types.join('|'), ", actual typeof was ").concat(valueType));
+        }
+    };
+    return Check;
+}());
+
+var ColorJson = /** @class */ (function () {
+    function ColorJson() {
+    }
+    return ColorJson;
+}());
+
+function defaultValue(v, defaultV) {
+    if (v === undefined || v === null) {
+        return defaultV;
+    }
+    if (isNaN(v) && typeof defaultV === 'number') {
+        return defaultV;
+    }
+    return v;
+}
+function limitNumber(min, max, v) {
+    if (v > max) {
+        v = max;
+    }
+    else if (v < min) {
+        v = min;
+    }
+    return v;
+}
+function setNumberPrecision(number, precision) {
+    return Number(number.toFixed(precision));
+}
+
+;// CONCATENATED MODULE: ./src/CssColorParser.ts
+/*
+ * @Descripttion: 颜色解析器
+ * @version: 1.0.0
+ * @Author: roman_123
+ * @Date: 2021-01-19 09:22:11
+ * @LastEditors: Please set LastEditors
+ * @LastEditTime: 2023-05-26 11:20:17
+ */
+
+var CssColorParser = /** @class */ (function () {
+    function CssColorParser(red, green, blue, alpha) {
+        this.r = 255;
+        this.g = 255;
+        this.b = 255;
+        this.a = 1;
+        this.setColor(red, green, blue, alpha);
+    }
+    /**
+     * 设置颜色
+     * @param red
+     * @param green
+     * @param blue
+     * @param alpha
+     * @example: this.setColor(255,255,255,1)
+     */
+    CssColorParser.prototype.setColor = function (red, green, blue, alpha) {
+        this.r = limitNumber(0, 255, defaultValue(Number(red), 0));
+        this.g = limitNumber(0, 255, defaultValue(Number(green), 0));
+        this.b = limitNumber(0, 255, defaultValue(Number(blue), 0));
+        this.a = limitNumber(0, 1, defaultValue(Number(alpha), 1));
+    };
+    /**
+     * @description: 返回rgba格式的css字符串
+     * @return {*}
+     * @author: roman_123
+     */
+    CssColorParser.prototype.toRGBA = function () {
+        var color = this.toJson();
+        if (color.a === 1) {
+            return "rgb(".concat(color.r, ",").concat(color.g, ",").concat(color.b, ")");
+        }
+        return "rgba(".concat(color.r, ",").concat(color.g, ",").concat(color.b, ",").concat(color.a, ")");
+    };
+    /**
+     * @description: 返回字符串
+     * @return {*}
+     * @author: roman_123
+     */
+    CssColorParser.prototype.toString = function () {
+        return this.toRGBA();
+    };
+    /**
+     * @description: 归一化
+     * @return {*}
+     * @author: roman_123
+     */
+    CssColorParser.prototype.toNormalize = function () {
+        return {
+            r: setNumberPrecision(this.r / 255, 2),
+            g: setNumberPrecision(this.g / 255, 2),
+            b: setNumberPrecision(this.b / 255, 2),
+            a: setNumberPrecision(this.a, 2)
+        };
+    };
+    /**
+     * @description: 返回16进制格式的css字符串
+     * @return {*}
+     * @author: roman_123
+     */
+    CssColorParser.prototype.toHEX = function () {
+        var color = this.toJson();
+        var r = color.r.toString(16);
+        if (r.length < 2) {
+            r = "0".concat(r);
+        }
+        var g = color.g.toString(16);
+        if (g.length < 2) {
+            g = "0".concat(g);
+        }
+        var b = color.b.toString(16);
+        if (b.length < 2) {
+            b = "0".concat(b);
+        }
+        // 由于tojson后a会丢失精度，此处使用this.a
+        if (this.a < 1) {
+            var hexAlpha = parseInt((this.a * 255).toFixed()).toString(16);
+            if (hexAlpha.length < 2) {
+                hexAlpha = "0".concat(hexAlpha);
+            }
+            return "#".concat(r).concat(g).concat(b).concat(hexAlpha);
+        }
+        return "#".concat(r).concat(g).concat(b);
+    };
+    /**
+     * @description: 返回rgba数组
+     * @return {*}
+     * @author: roman_123
+     */
+    CssColorParser.prototype.toArray = function () {
+        var color = this.toJson();
+        return [color.r, color.g, color.b, color.a];
+    };
+    /**
+     * @description: 返回ColorJson
+     * @return {*}
+     * @author: roman_123
+     */
+    CssColorParser.prototype.toJson = function () {
+        return {
+            r: parseInt(this.r.toFixed()),
+            g: parseInt(this.g.toFixed()),
+            b: parseInt(this.b.toFixed()),
+            a: parseFloat(this.a.toFixed(2))
+        };
+    };
+    /**
+     * @description: 拷贝
+     * @return {*}
+     * @author: roman_123
+     */
+    CssColorParser.prototype.clone = function () {
+        return new CssColorParser(this.r, this.g, this.b, this.a);
+    };
+    /**
+     * @description: 比较两个解析对象的数据是否相等
+     * @param {*} color
+     * @return {*}
+     * @author: roman_123
+     */
+    CssColorParser.prototype.equals = function (color) {
+        if (this === color) {
+            return true;
+        }
+        else {
+            return (this.r === color.r &&
+                this.g === color.g &&
+                this.b === color.g &&
+                this.a === color.a);
+        }
+    };
+    return CssColorParser;
+}());
+/* harmony default export */ var src_CssColorParser = (CssColorParser);
+
+;// CONCATENATED MODULE: ./src/utils/color-tools.ts
+
+/*
+ * @Author: roman_123
+ * @Description: 部分核心代码修改自cesium
+ * @Date: 2022-11-28 17:32:57
+ * @LastEditTime: 2022-12-06 00:02:21
+ */
+var CssColorStringParser = /** @class */ (function () {
+    function CssColorStringParser() {
+    }
+    // 去除字符串内所有空格
+    CssColorStringParser.clearStrSpace = function (v) {
+        return v.replace(/\s/g, '');
+    };
+    // 去除字符串两边空格,将中间多个空格合并为一个
+    CssColorStringParser.trimStr = function (v) {
+        v = v.replace(/\s+/g, ' ');
+        return v.trim();
+    };
+    // 解析3位16进制 #fff #fff0 
+    CssColorStringParser.parse3BitsHEX = function (v) {
+        var regx = /^#([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?$/i;
+        var res = regx.exec(v);
+        if (res) {
+            var res4 = defaultValue(res[4], 'f');
+            var r = CssColorStringParser._parseResStrForRgb(parseInt(res[1] + res[1], 16));
+            var g = CssColorStringParser._parseResStrForRgb(parseInt(res[2] + res[2], 16));
+            var b = CssColorStringParser._parseResStrForRgb(parseInt(res[3] + res[3], 16));
+            var a = CssColorStringParser._parsePercent(parseInt(res4 + res4, 16) / 255);
+            return [r, g, b, a];
+        }
+        return null;
+    };
+    // 解析6位16进制 #ffffff #ffffff00
+    CssColorStringParser.parse6BitsHEX = function (v) {
+        var regx = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?$/i;
+        var res = regx.exec(v);
+        if (res) {
+            var res4 = defaultValue(res[4], 'ff');
+            var r = CssColorStringParser._parseResStrForRgb(parseInt(res[1], 16));
+            var g = CssColorStringParser._parseResStrForRgb(parseInt(res[2], 16));
+            var b = CssColorStringParser._parseResStrForRgb(parseInt(res[3], 16));
+            var a = CssColorStringParser._parsePercent(parseInt(res4, 16) / 255.0);
+            return [r, g, b, a];
+        }
+        return null;
+    };
+    // 解析rgb rgba  rgb(255,255,255) rgba(255,255,255,1) rgba(100%,100%,100%, 1)
+    CssColorStringParser.parseRGBA = function (v) {
+        var regx = /^rgba?\(([0-9.]+%?),([0-9.]+%?),([0-9.]+%?)(?:,([0-9.]+%?))?\)$/i;
+        var res = regx.exec(v);
+        if (res) {
+            var r = CssColorStringParser._parseResStrForRgb(res[1]);
+            var g = CssColorStringParser._parseResStrForRgb(res[2]);
+            var b = CssColorStringParser._parseResStrForRgb(res[3]);
+            var a = CssColorStringParser._parsePercent(res[4]);
+            return [r, g, b, a];
+        }
+        return null;
+    };
+    // 解析hsl hsla  hsl(360,100%,100%) hsla(360,100%,100%,1)
+    CssColorStringParser.parseHSLA = function (v) {
+        var regx = /^hsla?\(([0-9.]+)(?:deg)?,([0-9.]+%?),([0-9.]+%?)(?:,([0-9.]+%?))?\)$/i;
+        var res = regx.exec(v);
+        if (res) {
+            var h = CssColorStringParser._parseResStrForHue(res[1]);
+            var s = CssColorStringParser._parsePercent(res[2]);
+            var l = CssColorStringParser._parsePercent(res[3]);
+            var a = CssColorStringParser._parsePercent(res[4]);
+            return [h, s, l, a];
+        }
+        return null;
+    };
+    // 解析hwb
+    CssColorStringParser.parseHWB = function (v) {
+        var regx = /^hwb\s?\(\s?([0-9.]+)(?:deg)?\s([0-9.]+%?)\s([0-9.]+%?)\s?(?:\/\s?([0-9.]+%?))?\s?\)$/i;
+        var res = regx.exec(v);
+        if (res) {
+            var h = CssColorStringParser._parseResStrForHue(res[1]);
+            var w = CssColorStringParser._parsePercent(res[2]);
+            var b = CssColorStringParser._parsePercent(res[3]);
+            var a = CssColorStringParser._parsePercent(res[4]);
+            return [h, w, b, a];
+        }
+        return null;
+    };
+    // 解析rgb rgb(178 57 57 / 44%) 字符串中存在空格，因此使用清除两侧空格的原始字符串
+    CssColorStringParser.parseRGBA2 = function (v) {
+        var regx = /^rgba?\s?\(\s?([0-9.]+%?)\s?([0-9.]+%?)\s?([0-9.]+%?)(?:\s?\/\s?([0-9.]+%?))?\s?\)$/i;
+        var res = regx.exec(v);
+        if (res) {
+            var r = CssColorStringParser._parseResStrForRgb(res[1]);
+            var g = CssColorStringParser._parseResStrForRgb(res[2]);
+            var b = CssColorStringParser._parseResStrForRgb(res[3]);
+            var a = CssColorStringParser._parsePercent(res[4]);
+            return [r, g, b, a];
+        }
+        return null;
+    };
+    // 解析hsl hsl(215 85% 62% / 1)
+    CssColorStringParser.parseHSLA2 = function (v) {
+        var regx = /^hsla?\s?\(\s?([0-9.]+)(?:deg)?\s([0-9.]+%?)\s([0-9.]+%?)\s?(?:\/\s?([0-9.]+%?))?\s?\)$/i;
+        var res = regx.exec(v);
+        if (res) {
+            var h = CssColorStringParser._parseResStrForHue(res[1]);
+            var s = CssColorStringParser._parsePercent(res[2]);
+            var l = CssColorStringParser._parsePercent(res[3]);
+            var a = CssColorStringParser._parsePercent(res[4]);
+            return [h, s, l, a];
+        }
+        return null;
+    };
+    // 将结果解析为数字
+    CssColorStringParser._parseResStrForRgb = function (v) {
+        if (typeof v === 'string') {
+            v = parseFloat(v) / ('%' === v.substr(-1) ? 100.0 / 255 : 1);
+        }
+        if (isNaN(v)) {
+            v = 1;
+        }
+        return limitNumber(0, 255, v);
+    };
+    CssColorStringParser._parseResStrForHue = function (v) {
+        if (typeof v === 'string') {
+            v = parseFloat(v);
+        }
+        if (isNaN(v)) {
+            v = 0;
+        }
+        return limitNumber(0, 360, v);
+    };
+    CssColorStringParser._parsePercent = function (v) {
+        if (typeof v === 'string') {
+            v = parseFloat(v) / ('%' === v.substr(-1) ? 100.0 : 1);
+        }
+        if (isNaN(v)) {
+            v = 1;
+        }
+        return limitNumber(0, 1, v);
+    };
+    return CssColorStringParser;
+}());
+
+
+;// CONCATENATED MODULE: ./src/utils/parsers/parsers.ts
+
+
+
+var convert = __webpack_require__(907);
+function parseKeyWord(v) {
+    var cssStr = CssColorStringParser.clearStrSpace(v);
+    var res = convert.keyword.rgb(cssStr);
+    return res && fromArray(res);
+}
+function parseHEX(v) {
+    var cssStr = CssColorStringParser.clearStrSpace(v);
+    var res = CssColorStringParser.parse3BitsHEX(cssStr);
+    if (!res) {
+        res = CssColorStringParser.parse6BitsHEX(cssStr);
+    }
+    return res && fromArray(res);
+}
+function parseRGBA(v) {
+    var cssStr = CssColorStringParser.clearStrSpace(v);
+    var res = CssColorStringParser.parseRGBA(cssStr);
+    if (!res) {
+        var cssStr2 = CssColorStringParser.trimStr(v);
+        res = CssColorStringParser.parseRGBA2(cssStr2);
+    }
+    return res && fromArray(res);
+}
+function parseHSLA(v) {
+    var cssStr = CssColorStringParser.clearStrSpace(v);
+    var res = CssColorStringParser.parseHSLA(cssStr);
+    if (!res) {
+        var cssStr2 = CssColorStringParser.trimStr(v);
+        res = CssColorStringParser.parseHSLA2(cssStr2);
+    }
+    return res && fromHSL(res[0], res[1], res[2], res[3]);
+}
+function parseHWB(v) {
+    var cssStr2 = CssColorStringParser.trimStr(v);
+    var res = CssColorStringParser.parseHWB(cssStr2);
+    return res && fromHWB(res[0], res[1], res[2], res[3]);
+}
+/**
+ * @description: 将css字符串转换为解析对象
+ * @param {string} v
+ * @return {CssColorParser}
+ * @example: parseCssColorStr('rgba(255,255,255,1)')
+ */
+function parseCssColorStr(v) {
+    Check.type('string', 'color', v);
+    return parseHEX(v) || parseRGBA(v) || parseKeyWord(v) || parseHSLA(v) || parseHWB(v);
+}
+/**
+ * **Deprecated method.** Use `parseCssColorStr()` instead.
+ * @description: since 2.0.1
+ * @deprecated
+ * @param {string} v
+ * @return {CssColorParser}
+ * @example: fromColorStr('rgba(255,255,255,1)')
+ */
+function fromColorStr(v) {
+    Check.type('string', 'color', v);
+    return parseHEX(v) || parseRGBA(v) || parseKeyWord(v) || parseHSLA(v) || parseHWB(v);
+}
+/**
+ * @description: 将HSL色彩模式转换为解析对象
+ * @param {number} hue 色相
+ * @param {number} saturation 饱和度
+ * @param {number} lightness 亮度
+ * @param {number} alpha 不透明度
+ * @return {CssColorParser}
+ * @example: fromHSL(0,1,1,1)
+ */
+function fromHSL(h, s, l, a) {
+    var res = convert.hsl.rgb(limitNumber(0, 360, h), limitNumber(0, 100, s * 100), limitNumber(0, 100, l * 100));
+    return new src_CssColorParser(res[0], res[1], res[2], defaultValue(Number(a), 1));
+}
+/**
+ * @description: 将HWB色彩模式转换为解析对象
+ * @param {number} h 色调
+ * @param {number} w 白度
+ * @param {number} b 黑度
+ * @param {number} a 不透明度
+ * @return {CssColorParser}
+ * @example: fromHSL(0,1,1,1)
+ */
+function fromHWB(h, w, b, a) {
+    var res = convert.hwb.rgb(limitNumber(0, 360, h), limitNumber(0, 100, w * 100), limitNumber(0, 100, b * 100));
+    return new src_CssColorParser(res[0], res[1], res[2], defaultValue(Number(a), 1));
+}
+/**
+   * @description: 从解析器中产生随机颜色
+   * @return {CssColorParser}
+   * @author: roman_123
+   */
+function fromRandom(color1, color2) {
+    if (typeof color1 === 'string') {
+        color1 = parseCssColorStr(color1);
+    }
+    if (typeof color2 === 'string') {
+        color2 = parseCssColorStr(color2);
+    }
+    if (!color1 || !color2) {
+        throw new Error('fail to create object from random');
+    }
+    var r = Math.random() * Math.abs(color2.r - color1.r) +
+        Math.min(color1.r, color2.r);
+    var g = Math.random() * Math.abs(color2.g - color1.g) +
+        Math.min(color1.g, color2.g);
+    var b = Math.random() * Math.abs(color2.b - color1.b) +
+        Math.min(color1.b, color2.b);
+    var a = Math.random() * Math.abs(color2.a - color1.a) +
+        Math.min(color1.a, color2.a);
+    return new src_CssColorParser(r, g, b, a);
+}
+/**
+ * @description: 将ColorJson格式的json数据转换为解析对象
+ * @param {ColorJson} json
+ * @return {CssColorParser}
+ * @author: roman_123
+ */
+function fromJson(json) {
+    return new src_CssColorParser(json.r, json.g, json.b, json.a);
+}
+/**
+ * @description: 将rgba数组转换为解析对象
+ * @param {Array} color
+ * @return {CssColorParser}
+ * @author: roman_123
+ */
+function fromArray(color) {
+    return new src_CssColorParser(color[0], color[1], color[2], color[3]);
+}
+
+;// CONCATENATED MODULE: ./src/main.ts
+/*
+ * @Author: roman_123
+ * @Description:
+ * @Date: 2023-05-25 17:45:22
+ * @LastEditTime: 2023-05-26 11:17:48
+ */
+
+
+
+
+}();
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});