ezii-os 1.1.0 → 2.0.1

data/node_modules/chartjs-color/node_modules/color-convert/index.js

@@ -0,0 +1,92 @@
+var conversions = require("./conversions");
+
+var convert = function() {
+   return new Converter();
+}
+
+for (var func in conversions) {
+  // export Raw versions
+  convert[func + "Raw"] =  (function(func) {
+    // accept array or plain args
+    return function(arg) {
+      if (typeof arg == "number")
+        arg = Array.prototype.slice.call(arguments);
+      return conversions[func](arg);
+    }
+  })(func);
+
+  var pair = /(\w+)2(\w+)/.exec(func),
+      from = pair[1],
+      to = pair[2];
+
+  // export rgb2hsl and ["rgb"]["hsl"]
+  convert[from] = convert[from] || {};
+
+  convert[from][to] = convert[func] = (function(func) { 
+    return function(arg) {
+      if (typeof arg == "number")
+        arg = Array.prototype.slice.call(arguments);
+      
+      var val = conversions[func](arg);
+      if (typeof val == "string" || val === undefined)
+        return val; // keyword
+
+      for (var i = 0; i < val.length; i++)
+        val[i] = Math.round(val[i]);
+      return val;
+    }
+  })(func);
+}
+
+
+/* Converter does lazy conversion and caching */
+var Converter = function() {
+   this.convs = {};
+};
+
+/* Either get the values for a space or
+  set the values for a space, depending on args */
+Converter.prototype.routeSpace = function(space, args) {
+   var values = args[0];
+   if (values === undefined) {
+      // color.rgb()
+      return this.getValues(space);
+   }
+   // color.rgb(10, 10, 10)
+   if (typeof values == "number") {
+      values = Array.prototype.slice.call(args);        
+   }
+
+   return this.setValues(space, values);
+};
+  
+/* Set the values for a space, invalidating cache */
+Converter.prototype.setValues = function(space, values) {
+   this.space = space;
+   this.convs = {};
+   this.convs[space] = values;
+   return this;
+};
+
+/* Get the values for a space. If there's already
+  a conversion for the space, fetch it, otherwise
+  compute it */
+Converter.prototype.getValues = function(space) {
+   var vals = this.convs[space];
+   if (!vals) {
+      var fspace = this.space,
+          from = this.convs[fspace];
+      vals = convert[fspace][space](from);
+
+      this.convs[space] = vals;
+   }
+  return vals;
+};
+
+["rgb", "hsl", "hsv", "cmyk", "keyword"].forEach(function(space) {
+   Converter.prototype[space] = function(vals) {
+      return this.routeSpace(space, arguments);
+   }
+});
+
+module.exports = convert;

data/node_modules/chartjs-color/node_modules/color-convert/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "color-convert",
+  "description": "Plain color conversion functions",
+  "version": "0.5.3",
+  "author": "Heather Arthur <fayearthur@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/harthur/color-convert.git"
+  },
+  "devDependencies": {
+  },
+  "scripts": {
+    "test": "node test/basic.js"
+  },
+  "keywords": [
+    "color",
+    "colour",
+    "rgb"
+  ]
+}

data/node_modules/chartjs-color/node_modules/color-convert/test/basic.js

@@ -0,0 +1,187 @@
+var convert = require("../index"),
+    assert = require("assert");
+
+assert.deepEqual(convert.rgb2hsl([140, 200, 100]), [96, 48, 59]);
+assert.deepEqual(convert.rgb2hsv([140, 200, 100]), [96, 50, 78]);
+assert.deepEqual(convert.rgb2hwb([140, 200, 100]), [96, 39, 22]);
+assert.deepEqual(convert.rgb2cmyk([140, 200, 100]), [30, 0, 50, 22]);
+assert.deepEqual(convert.rgb2cmyk([0,0,0,1]), [0,0,0,100]);
+assert.deepEqual(convert.rgb2keyword([255, 228, 196]), "bisque");
+assert.deepEqual(convert.rgb2xyz([92, 191, 84]), [25, 40, 15]);
+assert.deepEqual(convert.rgb2lab([92, 191, 84]), [70, -50, 45]);
+assert.deepEqual(convert.rgb2lch([92, 191, 84]), [70, 67, 138]);
+
+assert.deepEqual(convert.hsl2rgb([96, 48, 59]), [140, 201, 100]);
+assert.deepEqual(convert.hsl2hsv([96, 48, 59]), [96, 50, 79]); // colorpicker says [96,50,79]
+assert.deepEqual(convert.hsl2hwb([96, 48, 59]), [96, 39, 21]); // computer round to 21, should be 22
+assert.deepEqual(convert.hsl2cmyk([96, 48, 59]), [30, 0, 50, 21]);
+assert.deepEqual(convert.hsl2keyword([240, 100, 50]), "blue");
+
+assert.deepEqual(convert.hsv2rgb([96, 50, 78]), [139, 199, 99]);
+assert.deepEqual(convert.hsv2hsl([96, 50, 78]), [96, 47, 59]);
+assert.deepEqual(convert.hsv2hsl([0,0,0]), [0,0,0]);
+assert.deepEqual(convert.hsv2hwb([96, 50, 78]), [96, 39, 22]);
+assert.deepEqual(convert.hsv2cmyk([96, 50, 78]), [30, 0, 50, 22]);
+assert.deepEqual(convert.hsv2keyword([240, 100, 100]), "blue");
+
+assert.deepEqual(convert.cmyk2rgb([30, 0, 50, 22]), [139, 199, 99]);
+assert.deepEqual(convert.cmyk2hsl([30, 0, 50, 22]), [96, 47, 59]);
+assert.deepEqual(convert.cmyk2hsv([30, 0, 50, 22]), [96, 50, 78]);
+assert.deepEqual(convert.cmyk2hwb([30, 0, 50, 22]), [96, 39, 22]);
+assert.deepEqual(convert.cmyk2keyword([100, 100, 0, 0]), "blue");
+
+assert.deepEqual(convert.keyword2rgb("blue"), [0, 0, 255]);
+assert.deepEqual(convert.keyword2hsl("blue"), [240, 100, 50]);
+assert.deepEqual(convert.keyword2hsv("blue"), [240, 100, 100]);
+assert.deepEqual(convert.keyword2hwb("blue"), [240, 0, 0]);
+assert.deepEqual(convert.keyword2cmyk("blue"), [100, 100, 0, 0]);
+assert.deepEqual(convert.keyword2lab("blue"), [32, 79, -108]);
+assert.deepEqual(convert.keyword2xyz("blue"), [18, 7, 95]);
+
+assert.deepEqual(convert.xyz2rgb([25, 40, 15]), [97, 190, 85]);
+assert.deepEqual(convert.xyz2rgb([50, 100, 100]), [0, 255, 241]);
+assert.deepEqual(convert.xyz2lab([25, 40, 15]), [69, -48, 44]);
+assert.deepEqual(convert.xyz2lch([25, 40, 15]), [69, 65, 137]);
+
+assert.deepEqual(convert.lab2xyz([69, -48, 44]), [25, 39, 15]);
+assert.deepEqual(convert.lab2rgb([75, 20, -30]), [194, 175, 240]);
+assert.deepEqual(convert.lab2lch([69, -48, 44]), [69, 65, 137]);
+
+assert.deepEqual(convert.lch2lab([69, 65, 137]), [69, -48, 44]);
+assert.deepEqual(convert.lch2xyz([69, 65, 137]), [25, 39, 15]);
+assert.deepEqual(convert.lch2rgb([69, 65, 137]), [98, 188, 83]);
+
+// non-array arguments
+assert.deepEqual(convert.hsl2rgb(96, 48, 59), [140, 201, 100]);
+
+// raw functions
+function round(vals) {
+  for (var i = 0; i < vals.length; i++)
+    vals[i] = vals[i].toFixed(1);
+  return vals;
+}
+
+assert.deepEqual(round(convert.hsl2rgbRaw([96, 48, 59])), [140.4, 200.6, 100.3]);
+assert.deepEqual(round(convert.rgb2hslRaw([140, 200, 100])), [96, 47.6, 58.8]);
+
+assert.deepEqual(round(convert.hsv2rgbRaw([96, 50, 78])), [139.2, 198.9, 99.5]);
+assert.deepEqual(round(convert.rgb2hsvRaw([140, 200, 100])), [96, 50, 78.4]);
+
+assert.deepEqual(round(convert.hwb2rgbRaw([96, 39, 22])), [139.2, 198.9, 99.5]);
+assert.deepEqual(round(convert.rgb2hwbRaw([140, 200, 100])), [96, 39.2, 21.6]);
+
+assert.deepEqual(round(convert.cmyk2rgbRaw([30, 0, 50, 22])), [139.2, 198.9, 99.5]);
+assert.deepEqual(round(convert.rgb2cmykRaw([140, 200, 100])), [30, 0, 50, 21.6]);
+
+assert.deepEqual(round(convert.keyword2rgbRaw("blue")), [0, 0, 255]);
+assert.deepEqual(convert.rgb2keywordRaw([255, 228, 196]), "bisque");
+
+assert.deepEqual(round(convert.hsv2hslRaw([96, 50, 78])), [96, 47, 58.5]);
+assert.deepEqual(round(convert.hsl2hsvRaw([96, 48, 59])), [96, 50, 78.7]);
+
+assert.deepEqual(round(convert.hsl2hsvRaw([96, 48, 59])), [96, 50, 78.7]);
+
+assert.deepEqual(round(convert.xyz2rgbRaw([25, 40, 15])), [97.4, 189.9, 85]);
+assert.deepEqual(round(convert.rgb2xyzRaw([92, 191, 84])), [24.6, 40.2, 14.8]);
+
+assert.deepEqual(round(convert.rgb2labRaw([92, 191, 84])), [69.6, -50.1, 44.6]);
+
+// hashed
+var val = [140, 200, 100];
+assert.deepEqual(convert["rgb"]["hsl"](val), convert.rgb2hsl(val));
+assert.deepEqual(convert["rgb"]["hsv"](val), convert.rgb2hsv(val));
+assert.deepEqual(convert["rgb"]["hwb"](val), convert.rgb2hwb(val));
+assert.deepEqual(convert["rgb"]["cmyk"](val), convert.rgb2cmyk(val));
+assert.deepEqual(convert["rgb"]["xyz"](val), convert.rgb2xyz(val));
+assert.deepEqual(convert["rgb"]["lab"](val), convert.rgb2lab(val));
+assert.deepEqual(convert["rgb"]["keyword"]([255, 228, 196]), "bisque");
+
+val = [96, 48, 59];
+assert.deepEqual(convert["hsl"]["rgb"](val), convert.hsl2rgb(val));
+assert.deepEqual(convert["hsl"]["hsv"](val), convert.hsl2hsv(val));
+assert.deepEqual(convert["hsl"]["hwb"](val), convert.hsl2hwb(val));
+assert.deepEqual(convert["hsl"]["cmyk"](val), convert.hsl2cmyk(val));
+assert.deepEqual(convert["hsl"]["keyword"](val), convert.hsl2keyword(val  ));
+
+val = [96, 50, 78];
+assert.deepEqual(convert["hsv"]["rgb"](val), convert.hsv2rgb(val));
+assert.deepEqual(convert["hsv"]["hsl"](val), convert.hsv2hsl(val));
+assert.deepEqual(convert["hsv"]["hwb"](val), convert.hsv2hwb(val));
+assert.deepEqual(convert["hsv"]["cmyk"](val), convert.hsv2cmyk(val));
+assert.deepEqual(convert["hsv"]["keyword"](val), convert.hsv2keyword(val));
+
+val = [30, 0, 50, 22];
+assert.deepEqual(convert["cmyk"]["rgb"](val), convert.cmyk2rgb(val));
+assert.deepEqual(convert["cmyk"]["hsl"](val), convert.cmyk2hsl(val));
+assert.deepEqual(convert["cmyk"]["hsv"](val), convert.cmyk2hsv(val));
+assert.deepEqual(convert["cmyk"]["hwb"](val), convert.cmyk2hwb(val));
+assert.deepEqual(convert["cmyk"]["keyword"](val), convert.cmyk2keyword(val));
+
+val = "blue";
+assert.deepEqual(convert["keyword"]["rgb"](val), convert.keyword2rgb(val));
+assert.deepEqual(convert["keyword"]["hsl"](val), convert.keyword2hsl(val));
+assert.deepEqual(convert["keyword"]["hsv"](val), convert.keyword2hsv(val));
+assert.deepEqual(convert["keyword"]["hwb"](val), convert.keyword2hwb(val));
+assert.deepEqual(convert["keyword"]["cmyk"](val), convert.keyword2cmyk(val));
+assert.deepEqual(convert["keyword"]["lab"](val), convert.keyword2lab(val));
+assert.deepEqual(convert["keyword"]["xyz"](val), convert.keyword2xyz(val));
+
+val = [25, 40, 15]
+assert.deepEqual(convert["xyz"]["rgb"](val), convert.xyz2rgb(val));
+assert.deepEqual(convert["xyz"]["lab"](val), convert.xyz2lab(val));
+
+val = [69, -48, 44];
+assert.deepEqual(convert["lab"]["xyz"](val), [25, 39, 15]);
+
+
+// converter
+var converter = convert();
+
+var vals = [140, 200, 100];
+converter.rgb(140, 200, 100);
+
+assert.deepEqual(converter.hsl(), convert.rgb2hsl(vals));
+assert.deepEqual(converter.hsv(), convert.rgb2hsv(vals));
+assert.deepEqual(converter.cmyk(), convert.rgb2cmyk(vals));
+assert.deepEqual(converter.rgb(), vals);
+assert.deepEqual(converter.rgb([255, 228, 196]).keyword(), "bisque");
+
+vals = [96, 48, 59];
+converter.hsl(vals);
+assert.deepEqual(converter.rgb(), convert.hsl2rgb(vals));
+assert.deepEqual(converter.hsv(), convert.hsl2hsv(vals));
+assert.deepEqual(converter.cmyk(), convert.hsl2cmyk(vals));
+assert.deepEqual(converter.keyword(), convert.hsl2keyword(vals));
+
+// hwb
+// http://dev.w3.org/csswg/css-color/#hwb-examples
+
+// all extrem value should give black, white or grey
+for(var angle = 0; angle <= 360; angle ++) {
+  assert.deepEqual(convert.hwb2rgb([angle, 0, 100]), [0, 0, 0]);
+  assert.deepEqual(convert.hwb2rgb([angle, 100, 0]), [255, 255, 255]);
+  assert.deepEqual(convert.hwb2rgb([angle, 100, 100]), [128, 128, 128]);
+}
+
+assert.deepEqual(convert.hwb2rgb([0, 0, 0]), [255,0,0]);
+assert.deepEqual(convert.hwb2rgb([0, 20, 40]), [153, 51, 51]);
+assert.deepEqual(convert.hwb2rgb([0, 40, 40]), [153, 102, 102]);
+assert.deepEqual(convert.hwb2rgb([0, 40, 20]), [204, 102, 102]);
+
+assert.deepEqual(convert.hwb2rgb([120, 0, 0]), [0,255,0]);
+assert.deepEqual(convert.hwb2rgb([120, 20, 40]), [51, 153, 51]);
+assert.deepEqual(convert.hwb2rgb([120, 40, 40]), [102, 153, 102]);
+assert.deepEqual(convert.hwb2rgb([120, 40, 20]), [102, 204, 102]);
+
+assert.deepEqual(convert.hwb2rgb([240, 0, 0]), [0,0,255]);
+assert.deepEqual(convert.hwb2rgb([240, 20, 40]), [51, 51, 153]);
+assert.deepEqual(convert.hwb2rgb([240, 40, 40]), [102, 102, 153]);
+assert.deepEqual(convert.hwb2rgb([240, 40, 20]), [102, 102, 204]);
+
+
+// black should always stay black
+val = [0, 0, 0];
+assert.deepEqual(convert.hsl2hsv(val), val);
+assert.deepEqual(convert.hsl2rgb(val), val);
+assert.deepEqual(convert.hsl2hwb(val), [0, 0, 100]);
+assert.deepEqual(convert.hsl2cmyk(val), [0, 0, 0, 100]);

data/node_modules/chartjs-color/node_modules/color-convert/test/speed.js

@@ -0,0 +1,23 @@
+var convert = require("../index");
+
+var converter = convert();
+
+var times = 10000;
+
+console.time("cached");
+converter.rgb(10, 2, 30);
+for(var i = 0; i < times; i++) {
+   converter.hsv();
+   converter.hsl();
+   converter.cmyk();
+}
+console.timeEnd("cached");
+
+console.time("uncached");
+for(var i = 0; i < times; i++) {
+   convert.rgb2hsl(10, 2, 30);
+   convert.rgb2hsv(10, 2, 30);
+   convert.rgb2cmyk(10, 2, 30);
+}
+console.timeEnd("uncached");
+

data/node_modules/chartjs-color/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "chartjs-color",
+  "version": "2.3.0",
+  "description": "Color conversion and manipulation with CSS string support",
+  "keywords": [
+    "color",
+    "colour",
+    "css"
+  ],
+  "authors": [
+    "Heather Arthur <fayearthur@gmail.com>",
+    "Maxime Thirouin",
+    "Josh Junon"
+  ],
+  "license": "MIT",
+  "repository": "chartjs/chartjs-color",
+  "xo": {
+    "envs": ["browser", "node"],
+    "rules": {
+      "one-var": [2, { "initialized": "never" }],
+      "linebreak-style": 0,
+      "no-cond-assign": 0,
+      "new-cap": 0
+    }
+  },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "index.js"
+  ],
+  "scripts": {
+    "pretest": "xo",
+    "test": "mocha"
+  },
+  "dependencies": {
+    "color-convert": "^0.5.3",
+    "chartjs-color-string": "^0.6.0"
+  },
+  "devDependencies": {
+    "browserify": "^10.1.3",
+    "gulp": "^3.8.11",
+    "gulp-rename": "^1.2.2",
+    "gulp-uglify": "^1.2.0",
+    "gulp-streamify": "^1.0.2",
+    "mocha": "^2.2.5",
+    "vinyl-source-stream": "^1.1.0",
+    "xo": "^0.12.1"
+  }
+}

data/node_modules/chartjs-color-string/CHANGELOG.md

@@ -0,0 +1,11 @@
+# 0.3.0
+
+- Fixed: HSL alpha channel ([#16](https://github.com/harthur/color-string/pull/16))
+- Fixed: ability to parse signed number ([#15](https://github.com/harthur/color-string/pull/15))
+- Removed: component.json
+- Removed: browser build
+- Added: license field to package.json ([#17](https://github.com/harthur/color-string/pull/17))
+
+---
+
+Check out commit logs for earlier releases

data/node_modules/chartjs-color-string/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Heather Arthur <fayearthur@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/node_modules/chartjs-color-string/README.md

@@ -0,0 +1,46 @@
+# chartjs-color-string
+
+[![npm](https://img.shields.io/npm/v/chartjs-color-string.svg?style=flat-square&maxAge=600)](https://npmjs.com/package/chartjs-color-string) [![Travis](https://img.shields.io/travis/chartjs/chartjs-color-string.svg?style=flat-square&maxAge=600)](https://travis-ci.org/chartjs/chartjs-color-string)
+
+> library for parsing and generating CSS color strings.
+
+## Install
+
+With [npm](http://npmjs.org/):
+
+```console
+$ npm install color-string
+```
+
+## Usage
+
+### Parsing
+
+```js
+colorString.getRgb("blue")                       // [0, 0, 255]
+colorString.getRgb("#FFF")                       // [255, 255, 255]
+colorString.getRgba("#FFFA")                     //[255, 255, 255, 0.67]}
+colorString.getRgba("#FFFFFFAA")                 // [255, 255, 255, 0.67]}
+
+colorString.getRgba("rgba(200, 60, 60, 0.3)")    // [200, 60, 60, 0.3]
+colorString.getRgba("rgb(200, 200, 200)")        // [200, 200, 200, 1]
+
+colorString.getHsl("hsl(360, 100%, 50%)")        // [360, 100, 50]
+colorString.getHsla("hsla(360, 60%, 50%, 0.4)")  // [360, 60, 50, 0.4]
+
+colorString.getAlpha("rgba(200, 0, 12, 0.6)")    // 0.6
+```
+
+### Generation
+
+```js
+colorString.hexString([255, 255, 255])   // "#FFFFFF"
+colorString.hexString([0, 0, 255, 0.4])    // "#0000FF66"
+colorString.hexString([0, 0, 255], 0.4)    // "#0000FF66"
+colorString.rgbString([255, 255, 255])   // "rgb(255, 255, 255)"
+colorString.rgbString([0, 0, 255, 0.4])  // "rgba(0, 0, 255, 0.4)"
+colorString.rgbString([0, 0, 255], 0.4)  // "rgba(0, 0, 255, 0.4)"
+colorString.percentString([0, 0, 255])   // "rgb(0%, 0%, 100%)"
+colorString.keyword([255, 255, 0])       // "yellow"
+colorString.hslString([360, 100, 100])   // "hsl(360, 100%, 100%)"
+```

data/node_modules/chartjs-color-string/color-string.js

@@ -0,0 +1,237 @@
+/* MIT license */
+var colorNames = require('color-name');
+
+module.exports = {
+   getRgba: getRgba,
+   getHsla: getHsla,
+   getRgb: getRgb,
+   getHsl: getHsl,
+   getHwb: getHwb,
+   getAlpha: getAlpha,
+
+   hexString: hexString,
+   rgbString: rgbString,
+   rgbaString: rgbaString,
+   percentString: percentString,
+   percentaString: percentaString,
+   hslString: hslString,
+   hslaString: hslaString,
+   hwbString: hwbString,
+   keyword: keyword
+}
+
+function getRgba(string) {
+   if (!string) {
+      return;
+   }
+   var abbr =  /^#([a-fA-F0-9]{3,4})$/i,
+       hex =  /^#([a-fA-F0-9]{6}([a-fA-F0-9]{2})?)$/i,
+       rgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
+       per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
+       keyword = /(\w+)/;
+
+   var rgb = [0, 0, 0],
+       a = 1,
+       match = string.match(abbr),
+       hexAlpha = "";
+   if (match) {
+      match = match[1];
+      hexAlpha = match[3];
+      for (var i = 0; i < rgb.length; i++) {
+         rgb[i] = parseInt(match[i] + match[i], 16);
+      }
+      if (hexAlpha) {
+         a = Math.round((parseInt(hexAlpha + hexAlpha, 16) / 255) * 100) / 100;
+      }
+   }
+   else if (match = string.match(hex)) {
+      hexAlpha = match[2];
+      match = match[1];
+      for (var i = 0; i < rgb.length; i++) {
+         rgb[i] = parseInt(match.slice(i * 2, i * 2 + 2), 16);
+      }
+      if (hexAlpha) {
+         a = Math.round((parseInt(hexAlpha, 16) / 255) * 100) / 100;
+      }
+   }
+   else if (match = string.match(rgba)) {
+      for (var i = 0; i < rgb.length; i++) {
+         rgb[i] = parseInt(match[i + 1]);
+      }
+      a = parseFloat(match[4]);
+   }
+   else if (match = string.match(per)) {
+      for (var i = 0; i < rgb.length; i++) {
+         rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
+      }
+      a = parseFloat(match[4]);
+   }
+   else if (match = string.match(keyword)) {
+      if (match[1] == "transparent") {
+         return [0, 0, 0, 0];
+      }
+      rgb = colorNames[match[1]];
+      if (!rgb) {
+         return;
+      }
+   }
+
+   for (var i = 0; i < rgb.length; i++) {
+      rgb[i] = scale(rgb[i], 0, 255);
+   }
+   if (!a && a != 0) {
+      a = 1;
+   }
+   else {
+      a = scale(a, 0, 1);
+   }
+   rgb[3] = a;
+   return rgb;
+}
+
+function getHsla(string) {
+   if (!string) {
+      return;
+   }
+   var hsl = /^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/;
+   var match = string.match(hsl);
+   if (match) {
+      var alpha = parseFloat(match[4]);
+      var h = scale(parseInt(match[1]), 0, 360),
+          s = scale(parseFloat(match[2]), 0, 100),
+          l = scale(parseFloat(match[3]), 0, 100),
+          a = scale(isNaN(alpha) ? 1 : alpha, 0, 1);
+      return [h, s, l, a];
+   }
+}
+
+function getHwb(string) {
+   if (!string) {
+      return;
+   }
+   var hwb = /^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/;
+   var match = string.match(hwb);
+   if (match) {
+    var alpha = parseFloat(match[4]);
+      var h = scale(parseInt(match[1]), 0, 360),
+          w = scale(parseFloat(match[2]), 0, 100),
+          b = scale(parseFloat(match[3]), 0, 100),
+          a = scale(isNaN(alpha) ? 1 : alpha, 0, 1);
+      return [h, w, b, a];
+   }
+}
+
+function getRgb(string) {
+   var rgba = getRgba(string);
+   return rgba && rgba.slice(0, 3);
+}
+
+function getHsl(string) {
+  var hsla = getHsla(string);
+  return hsla && hsla.slice(0, 3);
+}
+
+function getAlpha(string) {
+   var vals = getRgba(string);
+   if (vals) {
+      return vals[3];
+   }
+   else if (vals = getHsla(string)) {
+      return vals[3];
+   }
+   else if (vals = getHwb(string)) {
+      return vals[3];
+   }
+}
+
+// generators
+function hexString(rgba, a) {
+   var a = (a !== undefined && rgba.length === 3) ? a : rgba[3];
+   return "#" + hexDouble(rgba[0]) 
+              + hexDouble(rgba[1])
+              + hexDouble(rgba[2])
+              + (
+                 (a >= 0 && a < 1)
+                 ? hexDouble(Math.round(a * 255))
+                 : ""
+              );
+}
+
+function rgbString(rgba, alpha) {
+   if (alpha < 1 || (rgba[3] && rgba[3] < 1)) {
+      return rgbaString(rgba, alpha);
+   }
+   return "rgb(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2] + ")";
+}
+
+function rgbaString(rgba, alpha) {
+   if (alpha === undefined) {
+      alpha = (rgba[3] !== undefined ? rgba[3] : 1);
+   }
+   return "rgba(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2]
+           + ", " + alpha + ")";
+}
+
+function percentString(rgba, alpha) {
+   if (alpha < 1 || (rgba[3] && rgba[3] < 1)) {
+      return percentaString(rgba, alpha);
+   }
+   var r = Math.round(rgba[0]/255 * 100),
+       g = Math.round(rgba[1]/255 * 100),
+       b = Math.round(rgba[2]/255 * 100);
+
+   return "rgb(" + r + "%, " + g + "%, " + b + "%)";
+}
+
+function percentaString(rgba, alpha) {
+   var r = Math.round(rgba[0]/255 * 100),
+       g = Math.round(rgba[1]/255 * 100),
+       b = Math.round(rgba[2]/255 * 100);
+   return "rgba(" + r + "%, " + g + "%, " + b + "%, " + (alpha || rgba[3] || 1) + ")";
+}
+
+function hslString(hsla, alpha) {
+   if (alpha < 1 || (hsla[3] && hsla[3] < 1)) {
+      return hslaString(hsla, alpha);
+   }
+   return "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)";
+}
+
+function hslaString(hsla, alpha) {
+   if (alpha === undefined) {
+      alpha = (hsla[3] !== undefined ? hsla[3] : 1);
+   }
+   return "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, "
+           + alpha + ")";
+}
+
+// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax
+// (hwb have alpha optional & 1 is default value)
+function hwbString(hwb, alpha) {
+   if (alpha === undefined) {
+      alpha = (hwb[3] !== undefined ? hwb[3] : 1);
+   }
+   return "hwb(" + hwb[0] + ", " + hwb[1] + "%, " + hwb[2] + "%"
+           + (alpha !== undefined && alpha !== 1 ? ", " + alpha : "") + ")";
+}
+
+function keyword(rgb) {
+  return reverseNames[rgb.slice(0, 3)];
+}
+
+// helpers
+function scale(num, min, max) {
+   return Math.min(Math.max(min, num), max);
+}
+
+function hexDouble(num) {
+  var str = num.toString(16).toUpperCase();
+  return (str.length < 2) ? "0" + str : str;
+}
+
+
+//create a list of reverse color names
+var reverseNames = {};
+for (var name in colorNames) {
+   reverseNames[colorNames[name]] = name;
+}