@qsxy/element-plus-react 1.0.0-next.2 → 1.0.0-next.21

package/dist/ColorPicker/color.js

@@ -1,147 +1,180 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/ColorPicker/color.ts
-var color_exports = {};
-__export(color_exports, {
-  default: () => Color
-});
-module.exports = __toCommonJS(color_exports);
-var hsv2hsl = function(hue, sat, val) {
+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 _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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); }
+var hsv2hsl = function hsv2hsl(hue, sat, val) {
   return [hue, sat * val / ((hue = (2 - sat) * val) < 1 ? hue : 2 - hue) || 0, hue / 2];
 };
-var isOnePointZero = function(n) {
-  return typeof n === "string" && n.includes(".") && Number.parseFloat(n) === 1;
+
+// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
+// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
+var isOnePointZero = function isOnePointZero(n) {
+  return typeof n === 'string' && n.includes('.') && Number.parseFloat(n) === 1;
 };
-var isPercentage = function(n) {
-  return typeof n === "string" && n.includes("%");
+var isPercentage = function isPercentage(n) {
+  return typeof n === 'string' && n.includes('%');
 };
-var bound01 = function(value, max) {
+
+// Take input from [0, n] and return it as [0, 1]
+var bound01 = function bound01(value, max) {
   if (isOnePointZero(value)) {
-    value = "100%";
+    value = '100%';
   }
-  const processPercent = isPercentage(value);
-  value = Math.min(max, Math.max(0, Number.parseFloat(`${value}`)));
+  var processPercent = isPercentage(value);
+  value = Math.min(max, Math.max(0, Number.parseFloat("".concat(value))));
+
+  // Automatically convert percentage into number
   if (processPercent) {
-    value = Number.parseInt(`${value * max}`, 10) / 100;
+    value = Number.parseInt("".concat(value * max), 10) / 100;
   }
-  if (Math.abs(value - max) < 1e-6) {
+
+  // Handle floating point rounding errors
+  if (Math.abs(value - max) < 0.000001) {
     return 1;
   }
+
+  // Convert into [0, 1] range if it isn't already
   return value % max / Number.parseFloat(max);
 };
-var INT_HEX_MAP = { 10: "A", 11: "B", 12: "C", 13: "D", 14: "E", 15: "F" };
-var hexOne = function(value) {
+var INT_HEX_MAP = {
+  10: 'A',
+  11: 'B',
+  12: 'C',
+  13: 'D',
+  14: 'E',
+  15: 'F'
+};
+var hexOne = function hexOne(value) {
   value = Math.min(Math.round(value), 255);
-  const high = Math.floor(value / 16);
-  const low = value % 16;
-  return `${INT_HEX_MAP[high] || high}${INT_HEX_MAP[low] || low}`;
+  var high = Math.floor(value / 16);
+  var low = value % 16;
+  return "".concat(INT_HEX_MAP[high] || high).concat(INT_HEX_MAP[low] || low);
 };
-var toHex = function({ r, g, b }) {
+var toHex = function toHex(_ref) {
+  var r = _ref.r,
+    g = _ref.g,
+    b = _ref.b;
   if (Number.isNaN(+r) || Number.isNaN(+g) || Number.isNaN(+b)) {
-    return "";
+    return '';
   }
-  return `#${hexOne(r)}${hexOne(g)}${hexOne(b)}`;
+  return "#".concat(hexOne(r)).concat(hexOne(g)).concat(hexOne(b));
 };
-var HEX_INT_MAP = { A: 10, B: 11, C: 12, D: 13, E: 14, F: 15 };
-var parseHexChannel = function(hex) {
+var HEX_INT_MAP = {
+  A: 10,
+  B: 11,
+  C: 12,
+  D: 13,
+  E: 14,
+  F: 15
+};
+var parseHexChannel = function parseHexChannel(hex) {
   if (hex.length === 2) {
     return (HEX_INT_MAP[hex[0].toUpperCase()] || +hex[0]) * 16 + (HEX_INT_MAP[hex[1].toUpperCase()] || +hex[1]);
   }
   return HEX_INT_MAP[hex[1].toUpperCase()] || +hex[1];
 };
-var hsl2hsv = function(hue, sat, light) {
+var hsl2hsv = function hsl2hsv(hue, sat, light) {
   sat = sat / 100;
   light = light / 100;
-  let smin = sat;
-  const lmin = Math.max(light, 0.01);
+  var smin = sat;
+  var lmin = Math.max(light, 0.01);
+  // let sv
+  // let v
+
   light *= 2;
   sat *= light <= 1 ? light : 2 - light;
   smin *= lmin <= 1 ? lmin : 2 - lmin;
-  const v = (light + sat) / 2;
-  const sv = light === 0 ? 2 * smin / (lmin + smin) : 2 * sat / (light + sat);
+  var v = (light + sat) / 2;
+  var sv = light === 0 ? 2 * smin / (lmin + smin) : 2 * sat / (light + sat);
   return {
     h: hue,
     s: sv * 100,
     v: v * 100
   };
 };
-var rgb2hsv = function(r, g, b) {
+
+// `rgbToHsv`
+// Converts an RGB color value to HSV
+// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
+// *Returns:* { h, s, v } in [0,1]
+var rgb2hsv = function rgb2hsv(r, g, b) {
   r = bound01(r, 255);
   g = bound01(g, 255);
   b = bound01(b, 255);
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  let h;
-  const v = max;
-  const d = max - min;
-  const s = max === 0 ? 0 : d / max;
+  var max = Math.max(r, g, b);
+  var min = Math.min(r, g, b);
+  var h;
+  var v = max;
+  var d = max - min;
+  var s = max === 0 ? 0 : d / max;
   if (max === min) {
-    h = 0;
+    h = 0; // achromatic
   } else {
     switch (max) {
-      case r: {
-        h = (g - b) / d + (g < b ? 6 : 0);
-        break;
-      }
-      case g: {
-        h = (b - r) / d + 2;
-        break;
-      }
-      case b: {
-        h = (r - g) / d + 4;
-        break;
-      }
+      case r:
+        {
+          h = (g - b) / d + (g < b ? 6 : 0);
+          break;
+        }
+      case g:
+        {
+          h = (b - r) / d + 2;
+          break;
+        }
+      case b:
+        {
+          h = (r - g) / d + 4;
+          break;
+        }
     }
     h /= 6;
   }
-  return { h: h * 360, s: s * 100, v: v * 100 };
+  return {
+    h: h * 360,
+    s: s * 100,
+    v: v * 100
+  };
 };
-var hsv2rgb = function(h, s, v) {
+
+// `hsvToRgb`
+// Converts an HSV color value to RGB.
+// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
+// *Returns:* { r, g, b } in the set [0, 255]
+var hsv2rgb = function hsv2rgb(h, s, v) {
   h = bound01(h, 360) * 6;
   s = bound01(s, 100);
   v = bound01(v, 100);
-  const i = Math.floor(h);
-  const f = h - i;
-  const p = v * (1 - s);
-  const q = v * (1 - f * s);
-  const t = v * (1 - (1 - f) * s);
-  const mod = i % 6;
-  const r = [v, q, p, p, t, v][mod];
-  const g = [t, v, v, q, p, p][mod];
-  const b = [p, p, t, v, v, q][mod];
+  var i = Math.floor(h);
+  var f = h - i;
+  var p = v * (1 - s);
+  var q = v * (1 - f * s);
+  var t = v * (1 - (1 - f) * s);
+  var mod = i % 6;
+  var r = [v, q, p, p, t, v][mod];
+  var g = [t, v, v, q, p, p][mod];
+  var b = [p, p, t, v, v, q][mod];
   return {
     r: Math.round(r * 255),
     g: Math.round(g * 255),
     b: Math.round(b * 255)
   };
 };
-var Color = class {
-  constructor(options) {
-    this._hue = 0;
-    this._saturation = 100;
-    this._value = 100;
-    this._alpha = 100;
-    this.enableAlpha = false;
-    this.format = "hex";
-    this.value = "";
+var Color = /*#__PURE__*/function () {
+  function Color(options) {
+    _classCallCheck(this, Color);
+    _defineProperty(this, "_hue", 0);
+    _defineProperty(this, "_saturation", 100);
+    _defineProperty(this, "_value", 100);
+    _defineProperty(this, "_alpha", 100);
+    _defineProperty(this, "enableAlpha", false);
+    _defineProperty(this, "format", 'hex');
+    _defineProperty(this, "value", '');
+    _defineProperty(this, "selected", void 0);
     options = options || {};
-    for (const option in options) {
+    for (var option in options) {
       if (Object.prototype.hasOwnProperty.call(options, option)) {
         this[option] = options[option];
       }
@@ -152,142 +185,197 @@ var Color = class {
       this.doOnChange();
     }
   }
-  set(prop, value) {
-    if (arguments.length === 1 && typeof prop === "object") {
-      for (const p in prop) {
-        if (Object.prototype.hasOwnProperty.call(prop, p)) {
-          this.set(p, prop[p]);
+  _createClass(Color, [{
+    key: "set",
+    value: function set(prop, value) {
+      if (arguments.length === 1 && _typeof(prop) === 'object') {
+        for (var p in prop) {
+          if (Object.prototype.hasOwnProperty.call(prop, p)) {
+            this.set(p, prop[p]);
+          }
         }
+        return;
       }
-      return;
-    }
-    this[`_${prop}`] = value;
-    this.doOnChange();
-  }
-  get(prop) {
-    if (prop === "alpha") {
-      return Math.floor(this[`_${prop}`]);
-    }
-    return this[`_${prop}`];
-  }
-  toRgb() {
-    return hsv2rgb(this._hue, this._saturation, this._value);
-  }
-  fromString(value) {
-    if (!value) {
-      this._hue = 0;
-      this._saturation = 100;
-      this._value = 100;
+      this["_".concat(prop)] = value;
       this.doOnChange();
-      return;
     }
-    const fromHSV = (h, s, v) => {
-      this._hue = Math.max(0, Math.min(360, h));
-      this._saturation = Math.max(0, Math.min(100, s));
-      this._value = Math.max(0, Math.min(100, v));
-      this.doOnChange();
-    };
-    if (value.includes("hsl")) {
-      const parts = value.replace(/hsla|hsl|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
-      if (parts.length === 4) {
-        this._alpha = Number.parseFloat(parts[3]) * 100;
-      } else if (parts.length === 3) {
-        this._alpha = 100;
-      }
-      if (parts.length >= 3) {
-        const { h, s, v } = hsl2hsv(parts[0], parts[1], parts[2]);
-        fromHSV(h, s, v);
-      }
-    } else if (value.includes("hsv")) {
-      const parts = value.replace(/hsva|hsv|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
-      if (parts.length === 4) {
-        this._alpha = Number.parseFloat(parts[3]) * 100;
-      } else if (parts.length === 3) {
-        this._alpha = 100;
+  }, {
+    key: "get",
+    value: function get(prop) {
+      if (prop === 'alpha') {
+        return Math.floor(this["_".concat(prop)]);
       }
-      if (parts.length >= 3) {
-        fromHSV(parts[0], parts[1], parts[2]);
-      }
-    } else if (value.includes("rgb")) {
-      const parts = value.replace(/rgba|rgb|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
-      if (parts.length === 4) {
-        this._alpha = Number.parseFloat(parts[3]) * 100;
-      } else if (parts.length === 3) {
-        this._alpha = 100;
-      }
-      if (parts.length >= 3) {
-        const { h, s, v } = rgb2hsv(parts[0], parts[1], parts[2]);
-        fromHSV(h, s, v);
-      }
-    } else if (value.includes("#")) {
-      const hex = value.replace("#", "").trim();
-      if (!/^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{8}$/.test(hex)) {
+      return this["_".concat(prop)];
+    }
+  }, {
+    key: "toRgb",
+    value: function toRgb() {
+      return hsv2rgb(this._hue, this._saturation, this._value);
+    }
+  }, {
+    key: "fromString",
+    value: function fromString(value) {
+      var _this = this;
+      if (!value) {
+        this._hue = 0;
+        this._saturation = 100;
+        this._value = 100;
+        this.doOnChange();
         return;
       }
-      let r, g, b;
-      if (hex.length === 3) {
-        r = parseHexChannel(hex[0] + hex[0]);
-        g = parseHexChannel(hex[1] + hex[1]);
-        b = parseHexChannel(hex[2] + hex[2]);
-      } else if (hex.length === 6 || hex.length === 8) {
-        r = parseHexChannel(hex.slice(0, 2));
-        g = parseHexChannel(hex.slice(2, 4));
-        b = parseHexChannel(hex.slice(4, 6));
-      }
-      if (hex.length === 8) {
-        this._alpha = parseHexChannel(hex.slice(6)) / 255 * 100;
-      } else if (hex.length === 3 || hex.length === 6) {
-        this._alpha = 100;
-      }
-      const { h, s, v } = rgb2hsv(r, g, b);
-      fromHSV(h, s, v);
-    }
-  }
-  compare(color) {
-    return Math.abs(color._hue - this._hue) < 2 && Math.abs(color._saturation - this._saturation) < 1 && Math.abs(color._value - this._value) < 1 && Math.abs(color._alpha - this._alpha) < 1;
-  }
-  doOnChange() {
-    const { _hue, _saturation, _value, _alpha, format } = this;
-    if (this.enableAlpha) {
-      switch (format) {
-        case "hsl": {
-          const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
-          this.value = `hsla(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%, ${this.get("alpha") / 100})`;
-          break;
+      var fromHSV = function fromHSV(h, s, v) {
+        _this._hue = Math.max(0, Math.min(360, h));
+        _this._saturation = Math.max(0, Math.min(100, s));
+        _this._value = Math.max(0, Math.min(100, v));
+        _this.doOnChange();
+      };
+      if (value.includes('hsl')) {
+        var parts = value.replace(/hsla|hsl|\(|\)/gm, '').split(/\s|,/g).filter(function (val) {
+          return val !== '';
+        }).map(function (val, index) {
+          return index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10);
+        });
+        if (parts.length === 4) {
+          this._alpha = Number.parseFloat(parts[3]) * 100;
+        } else if (parts.length === 3) {
+          this._alpha = 100;
         }
-        case "hsv": {
-          this.value = `hsva(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%, ${this.get("alpha") / 100})`;
-          break;
+        if (parts.length >= 3) {
+          var _hsl2hsv = hsl2hsv(parts[0], parts[1], parts[2]),
+            h = _hsl2hsv.h,
+            s = _hsl2hsv.s,
+            v = _hsl2hsv.v;
+          fromHSV(h, s, v);
         }
-        case "hex": {
-          this.value = `${toHex(hsv2rgb(_hue, _saturation, _value))}${hexOne(_alpha * 255 / 100)}`;
-          break;
+      } else if (value.includes('hsv')) {
+        var _parts = value.replace(/hsva|hsv|\(|\)/gm, '').split(/\s|,/g).filter(function (val) {
+          return val !== '';
+        }).map(function (val, index) {
+          return index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10);
+        });
+        if (_parts.length === 4) {
+          this._alpha = Number.parseFloat(_parts[3]) * 100;
+        } else if (_parts.length === 3) {
+          this._alpha = 100;
         }
-        default: {
-          const { r, g, b } = hsv2rgb(_hue, _saturation, _value);
-          this.value = `rgba(${r}, ${g}, ${b}, ${this.get("alpha") / 100})`;
+        if (_parts.length >= 3) {
+          fromHSV(_parts[0], _parts[1], _parts[2]);
         }
-      }
-    } else {
-      switch (format) {
-        case "hsl": {
-          const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
-          this.value = `hsl(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%)`;
-          break;
+      } else if (value.includes('rgb')) {
+        var _parts2 = value.replace(/rgba|rgb|\(|\)/gm, '').split(/\s|,/g).filter(function (val) {
+          return val !== '';
+        }).map(function (val, index) {
+          return index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10);
+        });
+        if (_parts2.length === 4) {
+          this._alpha = Number.parseFloat(_parts2[3]) * 100;
+        } else if (_parts2.length === 3) {
+          this._alpha = 100;
         }
-        case "hsv": {
-          this.value = `hsv(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%)`;
-          break;
+        if (_parts2.length >= 3) {
+          var _rgb2hsv = rgb2hsv(_parts2[0], _parts2[1], _parts2[2]),
+            _h = _rgb2hsv.h,
+            _s = _rgb2hsv.s,
+            _v = _rgb2hsv.v;
+          fromHSV(_h, _s, _v);
         }
-        case "rgb": {
-          const { r, g, b } = hsv2rgb(_hue, _saturation, _value);
-          this.value = `rgb(${r}, ${g}, ${b})`;
-          break;
+      } else if (value.includes('#')) {
+        var hex = value.replace('#', '').trim();
+        if (!/^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{8}$/.test(hex)) {
+          return;
+        }
+        var r, g, b;
+        if (hex.length === 3) {
+          r = parseHexChannel(hex[0] + hex[0]);
+          g = parseHexChannel(hex[1] + hex[1]);
+          b = parseHexChannel(hex[2] + hex[2]);
+        } else if (hex.length === 6 || hex.length === 8) {
+          r = parseHexChannel(hex.slice(0, 2));
+          g = parseHexChannel(hex.slice(2, 4));
+          b = parseHexChannel(hex.slice(4, 6));
         }
-        default: {
-          this.value = toHex(hsv2rgb(_hue, _saturation, _value));
+        if (hex.length === 8) {
+          this._alpha = parseHexChannel(hex.slice(6)) / 255 * 100;
+        } else if (hex.length === 3 || hex.length === 6) {
+          this._alpha = 100;
         }
+        var _rgb2hsv2 = rgb2hsv(r, g, b),
+          _h2 = _rgb2hsv2.h,
+          _s2 = _rgb2hsv2.s,
+          _v2 = _rgb2hsv2.v;
+        fromHSV(_h2, _s2, _v2);
       }
     }
-  }
-};
+  }, {
+    key: "compare",
+    value: function compare(color) {
+      return Math.abs(color._hue - this._hue) < 2 && Math.abs(color._saturation - this._saturation) < 1 && Math.abs(color._value - this._value) < 1 && Math.abs(color._alpha - this._alpha) < 1;
+    }
+  }, {
+    key: "doOnChange",
+    value: function doOnChange() {
+      var _hue = this._hue,
+        _saturation = this._saturation,
+        _value = this._value,
+        _alpha = this._alpha,
+        format = this.format;
+      if (this.enableAlpha) {
+        switch (format) {
+          case 'hsl':
+            {
+              var hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
+              this.value = "hsla(".concat(_hue, ", ").concat(Math.round(hsl[1] * 100), "%, ").concat(Math.round(hsl[2] * 100), "%, ").concat(this.get('alpha') / 100, ")");
+              break;
+            }
+          case 'hsv':
+            {
+              this.value = "hsva(".concat(_hue, ", ").concat(Math.round(_saturation), "%, ").concat(Math.round(_value), "%, ").concat(this.get('alpha') / 100, ")");
+              break;
+            }
+          case 'hex':
+            {
+              this.value = "".concat(toHex(hsv2rgb(_hue, _saturation, _value))).concat(hexOne(_alpha * 255 / 100));
+              break;
+            }
+          default:
+            {
+              var _hsv2rgb = hsv2rgb(_hue, _saturation, _value),
+                r = _hsv2rgb.r,
+                g = _hsv2rgb.g,
+                b = _hsv2rgb.b;
+              this.value = "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(this.get('alpha') / 100, ")");
+            }
+        }
+      } else {
+        switch (format) {
+          case 'hsl':
+            {
+              var _hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
+              this.value = "hsl(".concat(_hue, ", ").concat(Math.round(_hsl[1] * 100), "%, ").concat(Math.round(_hsl[2] * 100), "%)");
+              break;
+            }
+          case 'hsv':
+            {
+              this.value = "hsv(".concat(_hue, ", ").concat(Math.round(_saturation), "%, ").concat(Math.round(_value), "%)");
+              break;
+            }
+          case 'rgb':
+            {
+              var _hsv2rgb2 = hsv2rgb(_hue, _saturation, _value),
+                _r = _hsv2rgb2.r,
+                _g = _hsv2rgb2.g,
+                _b = _hsv2rgb2.b;
+              this.value = "rgb(".concat(_r, ", ").concat(_g, ", ").concat(_b, ")");
+              break;
+            }
+          default:
+            {
+              this.value = toHex(hsv2rgb(_hue, _saturation, _value));
+            }
+        }
+      }
+    }
+  }]);
+  return Color;
+}();
+export { Color as default };