@dreamcommerce/aurora 2.25.0 → 2.25.1

package/build/esm/external/tinycolor2/esm/tinycolor.js

@@ -7,38 +7,39 @@ function _typeof(obj) {
   } : function (obj) {
     return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
   }, _typeof(obj);
-}
-
-// https://github.com/bgrins/TinyColor
+} // https://github.com/bgrins/TinyColor
 // Brian Grinstead, MIT License
 
+
 var trimLeft = /^\s+/;
 var trimRight = /\s+$/;
+
 function tinycolor(color, opts) {
   color = color ? color : "";
-  opts = opts || {};
+  opts = opts || {}; // If input is already a tinycolor, return itself
 
-  // If input is already a tinycolor, return itself
   if (color instanceof tinycolor) {
     return color;
-  }
-  // If we are called as a function, call using new instead
+  } // If we are called as a function, call using new instead
+
+
   if (!(this instanceof tinycolor)) {
     return new tinycolor(color, opts);
   }
+
   var rgb = inputToRGB(color);
   this._originalInput = color, this._r = rgb.r, this._g = rgb.g, this._b = rgb.b, this._a = rgb.a, this._roundA = Math.round(100 * this._a) / 100, this._format = opts.format || rgb.format;
-  this._gradientType = opts.gradientType;
-
-  // Don't let the range of [0,255] come back in [0,1].
+  this._gradientType = opts.gradientType; // Don't let the range of [0,255] come back in [0,1].
   // Potentially lose a little bit of precision here, but will fix issues where
   // .5 gets interpreted as half of the total, instead of half of 1
   // If it was supposed to be 128, this was already taken care of by `inputToRgb`
+
   if (this._r < 1) this._r = Math.round(this._r);
   if (this._g < 1) this._g = Math.round(this._g);
   if (this._b < 1) this._b = Math.round(this._b);
   this._ok = rgb.ok;
 }
+
 tinycolor.prototype = {
   isDark: function isDark() {
     return this.getBrightness() < 128;
@@ -92,8 +93,8 @@ tinycolor.prototype = {
   toHsvString: function toHsvString() {
     var hsv = rgbToHsv(this._r, this._g, this._b);
     var h = Math.round(hsv.h * 360),
-      s = Math.round(hsv.s * 100),
-      v = Math.round(hsv.v * 100);
+        s = Math.round(hsv.s * 100),
+        v = Math.round(hsv.v * 100);
     return this._a == 1 ? "hsv(" + h + ", " + s + "%, " + v + "%)" : "hsva(" + h + ", " + s + "%, " + v + "%, " + this._roundA + ")";
   },
   toHsl: function toHsl() {
@@ -108,8 +109,8 @@ tinycolor.prototype = {
   toHslString: function toHslString() {
     var hsl = rgbToHsl(this._r, this._g, this._b);
     var h = Math.round(hsl.h * 360),
-      s = Math.round(hsl.s * 100),
-      l = Math.round(hsl.l * 100);
+        s = Math.round(hsl.s * 100),
+        l = Math.round(hsl.l * 100);
     return this._a == 1 ? "hsl(" + h + ", " + s + "%, " + l + "%)" : "hsla(" + h + ", " + s + "%, " + l + "%, " + this._roundA + ")";
   },
   toHex: function toHex(allow3Char) {
@@ -150,19 +151,23 @@ tinycolor.prototype = {
     if (this._a === 0) {
       return "transparent";
     }
+
     if (this._a < 1) {
       return false;
     }
+
     return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
   },
   toFilter: function toFilter(secondColor) {
     var hex8String = "#" + rgbaToArgbHex(this._r, this._g, this._b, this._a);
     var secondHex8String = hex8String;
     var gradientType = this._gradientType ? "GradientType = 1, " : "";
+
     if (secondColor) {
       var s = tinycolor(secondColor);
       secondHex8String = "#" + rgbaToArgbHex(s._r, s._g, s._b, s._a);
     }
+
     return "progid:DXImageTransform.Microsoft.gradient(" + gradientType + "startColorstr=" + hex8String + ",endColorstr=" + secondHex8String + ")";
   },
   toString: function toString(format) {
@@ -171,41 +176,53 @@ tinycolor.prototype = {
     var formattedString = false;
     var hasAlpha = this._a < 1 && this._a >= 0;
     var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name");
+
     if (needsAlphaFormat) {
       // Special case for "transparent", all other non-alpha formats
       // will return rgba when there is transparency.
       if (format === "name" && this._a === 0) {
         return this.toName();
       }
+
       return this.toRgbString();
     }
+
     if (format === "rgb") {
       formattedString = this.toRgbString();
     }
+
     if (format === "prgb") {
       formattedString = this.toPercentageRgbString();
     }
+
     if (format === "hex" || format === "hex6") {
       formattedString = this.toHexString();
     }
+
     if (format === "hex3") {
       formattedString = this.toHexString(true);
     }
+
     if (format === "hex4") {
       formattedString = this.toHex8String(true);
     }
+
     if (format === "hex8") {
       formattedString = this.toHex8String();
     }
+
     if (format === "name") {
       formattedString = this.toName();
     }
+
     if (format === "hsl") {
       formattedString = this.toHslString();
     }
+
     if (format === "hsv") {
       formattedString = this.toHsvString();
     }
+
     return formattedString || this.toHexString();
   },
   clone: function clone() {
@@ -265,13 +282,13 @@ tinycolor.prototype = {
   tetrad: function tetrad() {
     return this._applyCombination(polyad, [4]);
   }
-};
-
-// If input is an object, force 1 into "1.0" to handle ratios properly
+}; // If input is an object, force 1 into "1.0" to handle ratios properly
 // String input requires "1.0" as input, so 1 will be treated as 1
+
 tinycolor.fromRatio = function (color, opts) {
   if (_typeof(color) == "object") {
     var newColor = {};
+
     for (var i in color) {
       if (color.hasOwnProperty(i)) {
         if (i === "a") {
@@ -281,12 +298,12 @@ tinycolor.fromRatio = function (color, opts) {
         }
       }
     }
+
     color = newColor;
   }
-  return tinycolor(color, opts);
-};
 
-// Given a string or object, convert that input to RGB
+  return tinycolor(color, opts);
+}; // Given a string or object, convert that input to RGB
 // Possible string inputs:
 //
 //     "red"
@@ -301,6 +318,8 @@ tinycolor.fromRatio = function (color, opts) {
 //     "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
 //     "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
 //
+
+
 function inputToRGB(color) {
   var rgb = {
     r: 0,
@@ -313,9 +332,11 @@ function inputToRGB(color) {
   var l = null;
   var ok = false;
   var format = false;
+
   if (typeof color == "string") {
     color = stringInputToObject(color);
   }
+
   if (_typeof(color) == "object") {
     if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
       rgb = rgbToRgb(color.r, color.g, color.b);
@@ -334,10 +355,12 @@ function inputToRGB(color) {
       ok = true;
       format = "hsl";
     }
+
     if (color.hasOwnProperty("a")) {
       a = color.a;
     }
   }
+
   a = boundAlpha(a);
   return {
     ok: ok,
@@ -347,74 +370,79 @@ function inputToRGB(color) {
     b: Math.min(255, Math.max(rgb.b, 0)),
     a: a
   };
-}
-
-// Conversion Functions
+} // Conversion Functions
 // --------------------
-
 // `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
 // <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
-
 // `rgbToRgb`
 // Handle bounds / percentage checking to conform to CSS color spec
 // <http://www.w3.org/TR/css3-color/>
 // *Assumes:* r, g, b in [0, 255] or [0, 1]
 // *Returns:* { r, g, b } in [0, 255]
+
+
 function rgbToRgb(r, g, b) {
   return {
     r: bound01(r, 255) * 255,
     g: bound01(g, 255) * 255,
     b: bound01(b, 255) * 255
   };
-}
-
-// `rgbToHsl`
+} // `rgbToHsl`
 // Converts an RGB color value to HSL.
 // *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
 // *Returns:* { h, s, l } in [0,1]
+
+
 function rgbToHsl(r, g, b) {
   r = bound01(r, 255);
   g = bound01(g, 255);
   b = bound01(b, 255);
   var max = Math.max(r, g, b),
-    min = Math.min(r, g, b);
+      min = Math.min(r, g, b);
   var h,
-    s,
-    l = (max + min) / 2;
+      s,
+      l = (max + min) / 2;
+
   if (max == min) {
     h = s = 0; // achromatic
   } else {
     var d = max - min;
     s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
     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;
     }
+
     h /= 6;
   }
+
   return {
     h: h,
     s: s,
     l: l
   };
-}
-
-// `hslToRgb`
+} // `hslToRgb`
 // Converts an HSL color value to RGB.
 // *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
 // *Returns:* { r, g, b } in the set [0, 255]
+
+
 function hslToRgb(h, s, l) {
   var r, g, b;
   h = bound01(h, 360);
   s = bound01(s, 100);
   l = bound01(l, 100);
+
   function hue2rgb(p, q, t) {
     if (t < 0) t += 1;
     if (t > 1) t -= 1;
@@ -423,6 +451,7 @@ function hslToRgb(h, s, l) {
     if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
     return p;
   }
+
   if (s === 0) {
     r = g = b = l; // achromatic
   } else {
@@ -432,28 +461,30 @@ function hslToRgb(h, s, l) {
     g = hue2rgb(p, q, h);
     b = hue2rgb(p, q, h - 1 / 3);
   }
+
   return {
     r: r * 255,
     g: g * 255,
     b: b * 255
   };
-}
-
-// `rgbToHsv`
+} // `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]
+
+
 function rgbToHsv(r, g, b) {
   r = bound01(r, 255);
   g = bound01(g, 255);
   b = bound01(b, 255);
   var max = Math.max(r, g, b),
-    min = Math.min(r, g, b);
+      min = Math.min(r, g, b);
   var h,
-    s,
-    v = max;
+      s,
+      v = max;
   var d = max - min;
   s = max === 0 ? 0 : d / max;
+
   if (max == min) {
     h = 0; // achromatic
   } else {
@@ -461,101 +492,105 @@ function rgbToHsv(r, g, b) {
       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,
     s: s,
     v: v
   };
-}
-
-// `hsvToRgb`
+} // `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]
+
+
 function hsvToRgb(h, s, v) {
   h = bound01(h, 360) * 6;
   s = bound01(s, 100);
   v = bound01(v, 100);
   var i = Math.floor(h),
-    f = h - i,
-    p = v * (1 - s),
-    q = v * (1 - f * s),
-    t = v * (1 - (1 - f) * s),
-    mod = i % 6,
-    r = [v, q, p, p, t, v][mod],
-    g = [t, v, v, q, p, p][mod],
-    b = [p, p, t, v, v, q][mod];
+      f = h - i,
+      p = v * (1 - s),
+      q = v * (1 - f * s),
+      t = v * (1 - (1 - f) * s),
+      mod = i % 6,
+      r = [v, q, p, p, t, v][mod],
+      g = [t, v, v, q, p, p][mod],
+      b = [p, p, t, v, v, q][mod];
   return {
     r: r * 255,
     g: g * 255,
     b: b * 255
   };
-}
-
-// `rgbToHex`
+} // `rgbToHex`
 // Converts an RGB color to hex
 // Assumes r, g, and b are contained in the set [0, 255]
 // Returns a 3 or 6 character hex
+
+
 function rgbToHex(r, g, b, allow3Char) {
-  var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];
+  var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))]; // Return a 3 character hex if possible
 
-  // Return a 3 character hex if possible
   if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {
     return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
   }
-  return hex.join("");
-}
 
-// `rgbaToHex`
+  return hex.join("");
+} // `rgbaToHex`
 // Converts an RGBA color plus alpha transparency to hex
 // Assumes r, g, b are contained in the set [0, 255] and
 // a in [0, 1]. Returns a 4 or 8 character rgba hex
+
+
 function rgbaToHex(r, g, b, a, allow4Char) {
-  var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16)), pad2(convertDecimalToHex(a))];
+  var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16)), pad2(convertDecimalToHex(a))]; // Return a 4 character hex if possible
 
-  // Return a 4 character hex if possible
   if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {
     return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
   }
-  return hex.join("");
-}
 
-// `rgbaToArgbHex`
+  return hex.join("");
+} // `rgbaToArgbHex`
 // Converts an RGBA color to an ARGB Hex8 string
 // Rarely used, but required for "toFilter()"
+
+
 function rgbaToArgbHex(r, g, b, a) {
   var hex = [pad2(convertDecimalToHex(a)), pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];
   return hex.join("");
-}
-
-// `equals`
+} // `equals`
 // Can be called with any tinycolor input
+
+
 tinycolor.equals = function (color1, color2) {
   if (!color1 || !color2) return false;
   return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
 };
+
 tinycolor.random = function () {
   return tinycolor.fromRatio({
     r: Math.random(),
     g: Math.random(),
     b: Math.random()
   });
-};
-
-// Modification Functions
+}; // Modification Functions
 // ----------------------
 // Thanks to less.js for some of the basics here
 // <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>
 
+
 function _desaturate(color, amount) {
   amount = amount === 0 ? 0 : amount || 10;
   var hsl = tinycolor(color).toHsl();
@@ -563,6 +598,7 @@ function _desaturate(color, amount) {
   hsl.s = clamp01(hsl.s);
   return tinycolor(hsl);
 }
+
 function _saturate(color, amount) {
   amount = amount === 0 ? 0 : amount || 10;
   var hsl = tinycolor(color).toHsl();
@@ -570,9 +606,11 @@ function _saturate(color, amount) {
   hsl.s = clamp01(hsl.s);
   return tinycolor(hsl);
 }
+
 function _greyscale(color) {
   return tinycolor(color).desaturate(100);
 }
+
 function _lighten(color, amount) {
   amount = amount === 0 ? 0 : amount || 10;
   var hsl = tinycolor(color).toHsl();
@@ -580,6 +618,7 @@ function _lighten(color, amount) {
   hsl.l = clamp01(hsl.l);
   return tinycolor(hsl);
 }
+
 function _brighten(color, amount) {
   amount = amount === 0 ? 0 : amount || 10;
   var rgb = tinycolor(color).toRgb();
@@ -588,40 +627,43 @@ function _brighten(color, amount) {
   rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
   return tinycolor(rgb);
 }
+
 function _darken(color, amount) {
   amount = amount === 0 ? 0 : amount || 10;
   var hsl = tinycolor(color).toHsl();
   hsl.l -= amount / 100;
   hsl.l = clamp01(hsl.l);
   return tinycolor(hsl);
-}
-
-// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
+} // Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
 // Values outside of this range will be wrapped into this range.
+
+
 function _spin(color, amount) {
   var hsl = tinycolor(color).toHsl();
   var hue = (hsl.h + amount) % 360;
   hsl.h = hue < 0 ? 360 + hue : hue;
   return tinycolor(hsl);
-}
-
-// Combination Functions
+} // Combination Functions
 // ---------------------
 // Thanks to jQuery xColor for some of the ideas behind these
 // <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>
 
+
 function _complement(color) {
   var hsl = tinycolor(color).toHsl();
   hsl.h = (hsl.h + 180) % 360;
   return tinycolor(hsl);
 }
+
 function polyad(color, number) {
   if (isNaN(number) || number <= 0) {
     throw new Error("Argument to polyad must be a positive number");
   }
+
   var hsl = tinycolor(color).toHsl();
   var result = [tinycolor(color)];
   var step = 360 / number;
+
   for (var i = 1; i < number; i++) {
     result.push(tinycolor({
       h: (hsl.h + i * step) % 360,
@@ -629,8 +671,10 @@ function polyad(color, number) {
       l: hsl.l
     }));
   }
+
   return result;
 }
+
 function _splitcomplement(color) {
   var hsl = tinycolor(color).toHsl();
   var h = hsl.h;
@@ -644,26 +688,31 @@ function _splitcomplement(color) {
     l: hsl.l
   })];
 }
+
 function _analogous(color, results, slices) {
   results = results || 6;
   slices = slices || 30;
   var hsl = tinycolor(color).toHsl();
   var part = 360 / slices;
   var ret = [tinycolor(color)];
+
   for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results;) {
     hsl.h = (hsl.h + part) % 360;
     ret.push(tinycolor(hsl));
   }
+
   return ret;
 }
+
 function _monochromatic(color, results) {
   results = results || 6;
   var hsv = tinycolor(color).toHsv();
   var h = hsv.h,
-    s = hsv.s,
-    v = hsv.v;
+      s = hsv.s,
+      v = hsv.v;
   var ret = [];
   var modification = 1 / results;
+
   while (results--) {
     ret.push(tinycolor({
       h: h,
@@ -672,12 +721,12 @@ function _monochromatic(color, results) {
     }));
     v = (v + modification) % 1;
   }
-  return ret;
-}
 
-// Utility Functions
+  return ret;
+} // Utility Functions
 // ---------------------
 
+
 tinycolor.mix = function (color1, color2, amount) {
   amount = amount === 0 ? 0 : amount || 50;
   var rgb1 = tinycolor(color1).toRgb();
@@ -690,51 +739,51 @@ tinycolor.mix = function (color1, color2, amount) {
     a: (rgb2.a - rgb1.a) * p + rgb1.a
   };
   return tinycolor(rgba);
-};
-
-// Readability Functions
+}; // Readability Functions
 // ---------------------
 // <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)
-
 // `contrast`
 // Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
+
+
 tinycolor.readability = function (color1, color2) {
   var c1 = tinycolor(color1);
   var c2 = tinycolor(color2);
   return (Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) / (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05);
-};
-
-// `isReadable`
+}; // `isReadable`
 // Ensure that foreground and background color combinations meet WCAG2 guidelines.
 // The third argument is an optional Object.
 //      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
 //      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
 // If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
-
 // *Example*
 //    tinycolor.isReadable("#000", "#111") => false
 //    tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false
+
+
 tinycolor.isReadable = function (color1, color2, wcag2) {
   var readability = tinycolor.readability(color1, color2);
   var wcag2Parms, out;
   out = false;
   wcag2Parms = validateWCAG2Parms(wcag2);
+
   switch (wcag2Parms.level + wcag2Parms.size) {
     case "AAsmall":
     case "AAAlarge":
       out = readability >= 4.5;
       break;
+
     case "AAlarge":
       out = readability >= 3;
       break;
+
     case "AAAsmall":
       out = readability >= 7;
       break;
   }
-  return out;
-};
 
-// `mostReadable`
+  return out;
+}; // `mostReadable`
 // Given a base color and a list of possible foreground or background
 // colors for that base, returns the most readable color.
 // Optionally returns Black or White if the most readable color is unreadable.
@@ -743,6 +792,8 @@ tinycolor.isReadable = function (color1, color2, wcag2) {
 //    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString();  // "#ffffff"
 //    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3"
 //    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff"
+
+
 tinycolor.mostReadable = function (baseColor, colorList, args) {
   var bestColor = null;
   var bestScore = 0;
@@ -752,13 +803,16 @@ tinycolor.mostReadable = function (baseColor, colorList, args) {
   includeFallbackColors = args.includeFallbackColors;
   level = args.level;
   size = args.size;
+
   for (var i = 0; i < colorList.length; i++) {
     readability = tinycolor.readability(baseColor, colorList[i]);
+
     if (readability > bestScore) {
       bestScore = readability;
       bestColor = tinycolor(colorList[i]);
     }
   }
+
   if (tinycolor.isReadable(baseColor, bestColor, {
     level: level,
     size: size
@@ -768,11 +822,11 @@ tinycolor.mostReadable = function (baseColor, colorList, args) {
     args.includeFallbackColors = false;
     return tinycolor.mostReadable(baseColor, ["#fff", "#000"], args);
   }
-};
-
-// Big List of Colors
+}; // Big List of Colors
 // ------------------
 // <https://www.w3.org/TR/css-color-4/#named-colors>
+
+
 var names = tinycolor.names = {
   aliceblue: "f0f8ff",
   antiquewhite: "faebd7",
@@ -923,109 +977,109 @@ var names = tinycolor.names = {
   whitesmoke: "f5f5f5",
   yellow: "ff0",
   yellowgreen: "9acd32"
-};
+}; // Make it easy to access colors via `hexNames[hex]`
 
-// Make it easy to access colors via `hexNames[hex]`
-var hexNames = tinycolor.hexNames = flip(names);
-
-// Utilities
+var hexNames = tinycolor.hexNames = flip(names); // Utilities
 // ---------
-
 // `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
+
 function flip(o) {
   var flipped = {};
+
   for (var i in o) {
     if (o.hasOwnProperty(i)) {
       flipped[o[i]] = i;
     }
   }
+
   return flipped;
-}
+} // Return a valid alpha value [0,1] with all invalid values being set to 1
+
 
-// Return a valid alpha value [0,1] with all invalid values being set to 1
 function boundAlpha(a) {
   a = parseFloat(a);
+
   if (isNaN(a) || a < 0 || a > 1) {
     a = 1;
   }
+
   return a;
-}
+} // Take input from [0, n] and return it as [0, 1]
+
 
-// Take input from [0, n] and return it as [0, 1]
 function bound01(n, max) {
   if (isOnePointZero(n)) n = "100%";
   var processPercent = isPercentage(n);
-  n = Math.min(max, Math.max(0, parseFloat(n)));
+  n = Math.min(max, Math.max(0, parseFloat(n))); // Automatically convert percentage into number
 
-  // Automatically convert percentage into number
   if (processPercent) {
     n = parseInt(n * max, 10) / 100;
-  }
+  } // Handle floating point rounding errors
+
 
-  // Handle floating point rounding errors
   if (Math.abs(n - max) < 0.000001) {
     return 1;
-  }
+  } // Convert into [0, 1] range if it isn't already
+
 
-  // Convert into [0, 1] range if it isn't already
   return n % max / parseFloat(max);
-}
+} // Force a number between 0 and 1
+
 
-// Force a number between 0 and 1
 function clamp01(val) {
   return Math.min(1, Math.max(0, val));
-}
+} // Parse a base-16 hex value into a base-10 integer
+
 
-// Parse a base-16 hex value into a base-10 integer
 function parseIntFromHex(val) {
   return parseInt(val, 16);
-}
-
-// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 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>
+
+
 function isOnePointZero(n) {
   return typeof n == "string" && n.indexOf(".") != -1 && parseFloat(n) === 1;
-}
+} // Check to see if string passed in is a percentage
+
 
-// Check to see if string passed in is a percentage
 function isPercentage(n) {
   return typeof n === "string" && n.indexOf("%") != -1;
-}
+} // Force a hex value to have 2 characters
+
 
-// Force a hex value to have 2 characters
 function pad2(c) {
   return c.length == 1 ? "0" + c : "" + c;
-}
+} // Replace a decimal with it's percentage value
+
 
-// Replace a decimal with it's percentage value
 function convertToPercentage(n) {
   if (n <= 1) {
     n = n * 100 + "%";
   }
+
   return n;
-}
+} // Converts a decimal to a hex value
+
 
-// Converts a decimal to a hex value
 function convertDecimalToHex(d) {
   return Math.round(parseFloat(d) * 255).toString(16);
-}
-// Converts a hex value to a decimal
+} // Converts a hex value to a decimal
+
+
 function convertHexToDecimal(h) {
   return parseIntFromHex(h) / 255;
 }
+
 var matchers = function () {
   // <http://www.w3.org/TR/css3-values/#integers>
-  var CSS_INTEGER = "[-\\+]?\\d+%?";
-
-  // <http://www.w3.org/TR/css3-values/#number-value>
-  var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
+  var CSS_INTEGER = "[-\\+]?\\d+%?"; // <http://www.w3.org/TR/css3-values/#number-value>
 
-  // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
-  var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
+  var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?"; // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
 
-  // Actual matching.
+  var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")"; // Actual matching.
   // Parentheses and commas are optional, but not required.
   // Whitespace can take the place of commas or opening paren
+
   var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
   var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
   return {
@@ -1041,21 +1095,22 @@ var matchers = function () {
     hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
     hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
   };
-}();
-
-// `isValidCSSUnit`
+}(); // `isValidCSSUnit`
 // Take in a single string / number and check to see if it looks like a CSS unit
 // (see `matchers` above for definition).
+
+
 function isValidCSSUnit(color) {
   return !!matchers.CSS_UNIT.exec(color);
-}
-
-// `stringInputToObject`
+} // `stringInputToObject`
 // Permissive string parsing.  Take in a number of formats, and output an object
 // based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
+
+
 function stringInputToObject(color) {
   color = color.replace(trimLeft, "").replace(trimRight, "").toLowerCase();
   var named = false;
+
   if (names[color]) {
     color = names[color];
     named = true;
@@ -1067,13 +1122,14 @@ function stringInputToObject(color) {
       a: 0,
       format: "name"
     };
-  }
-
-  // Try to match string input using regular expressions.
+  } // Try to match string input using regular expressions.
   // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
   // Just return an object and let the conversion functions handle that.
   // This way the result will be the same whether the tinycolor is initialized with string or object.
+
+
   var match;
+
   if (match = matchers.rgb.exec(color)) {
     return {
       r: match[1],
@@ -1081,6 +1137,7 @@ function stringInputToObject(color) {
       b: match[3]
     };
   }
+
   if (match = matchers.rgba.exec(color)) {
     return {
       r: match[1],
@@ -1089,6 +1146,7 @@ function stringInputToObject(color) {
       a: match[4]
     };
   }
+
   if (match = matchers.hsl.exec(color)) {
     return {
       h: match[1],
@@ -1096,6 +1154,7 @@ function stringInputToObject(color) {
       l: match[3]
     };
   }
+
   if (match = matchers.hsla.exec(color)) {
     return {
       h: match[1],
@@ -1104,6 +1163,7 @@ function stringInputToObject(color) {
       a: match[4]
     };
   }
+
   if (match = matchers.hsv.exec(color)) {
     return {
       h: match[1],
@@ -1111,6 +1171,7 @@ function stringInputToObject(color) {
       v: match[3]
     };
   }
+
   if (match = matchers.hsva.exec(color)) {
     return {
       h: match[1],
@@ -1119,6 +1180,7 @@ function stringInputToObject(color) {
       a: match[4]
     };
   }
+
   if (match = matchers.hex8.exec(color)) {
     return {
       r: parseIntFromHex(match[1]),
@@ -1128,6 +1190,7 @@ function stringInputToObject(color) {
       format: named ? "name" : "hex8"
     };
   }
+
   if (match = matchers.hex6.exec(color)) {
     return {
       r: parseIntFromHex(match[1]),
@@ -1136,6 +1199,7 @@ function stringInputToObject(color) {
       format: named ? "name" : "hex"
     };
   }
+
   if (match = matchers.hex4.exec(color)) {
     return {
       r: parseIntFromHex(match[1] + "" + match[1]),
@@ -1145,6 +1209,7 @@ function stringInputToObject(color) {
       format: named ? "name" : "hex8"
     };
   }
+
   if (match = matchers.hex3.exec(color)) {
     return {
       r: parseIntFromHex(match[1] + "" + match[1]),
@@ -1153,8 +1218,10 @@ function stringInputToObject(color) {
       format: named ? "name" : "hex"
     };
   }
+
   return false;
 }
+
 function validateWCAG2Parms(parms) {
   // return valid WCAG2 parms for isReadable.
   // If input parms are invalid, return {"level":"AA", "size":"small"}
@@ -1165,12 +1232,15 @@ function validateWCAG2Parms(parms) {
   };
   level = (parms.level || "AA").toUpperCase();
   size = (parms.size || "small").toLowerCase();
+
   if (level !== "AA" && level !== "AAA") {
     level = "AA";
   }
+
   if (size !== "small" && size !== "large") {
     size = "small";
   }
+
   return {
     level: level,
     size: size