pleeease 0.0.2

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/CMYK.js

@@ -0,0 +1,31 @@
+/*global one*/
+INCLUDE('lib:color.js');
+
+installColorSpace('CMYK', ['cyan', 'magenta', 'yellow', 'black', 'alpha'], {
+    rgb: function () {
+        return new ONECOLOR.RGB((1 - this._cyan * (1 - this._black) - this._black),
+                                 (1 - this._magenta * (1 - this._black) - this._black),
+                                 (1 - this._yellow * (1 - this._black) - this._black),
+                                 this._alpha);
+    },
+
+    fromRgb: function () { // Becomes one.color.RGB.prototype.cmyk
+        // Adapted from http://www.javascripter.net/faq/rgb2cmyk.htm
+        var red = this._red,
+            green = this._green,
+            blue = this._blue,
+            cyan = 1 - red,
+            magenta = 1 - green,
+            yellow = 1 - blue,
+            black = 1;
+        if (red || green || blue) {
+            black = Math.min(cyan, Math.min(magenta, yellow));
+            cyan = (cyan - black) / (1 - black);
+            magenta = (magenta - black) / (1 - black);
+            yellow = (yellow - black) / (1 - black);
+        } else {
+            black = 1;
+        }
+        return new ONECOLOR.CMYK(cyan, magenta, yellow, black, this._alpha);
+    }
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/HSL.js

@@ -0,0 +1,30 @@
+/*global one*/
+INCLUDE('lib:color.js');
+
+INCLUDE('lib:color/HSV.js');
+
+installColorSpace('HSL', ['hue', 'saturation', 'lightness', 'alpha'], {
+    hsv: function () {
+        // Algorithm adapted from http://wiki.secondlife.com/wiki/Color_conversion_scripts
+        var l = this._lightness * 2,
+            s = this._saturation * ((l <= 1) ? l : 2 - l),
+            saturation;
+
+        // Avoid division by zero when l + s is very small (approaching black):
+        if (l + s < 1e-9) {
+            saturation = 0;
+        } else {
+            saturation = (2 * s) / (l + s);
+        }
+
+        return new ONECOLOR.HSV(this._hue, saturation, (l + s) / 2, this._alpha);
+    },
+
+    rgb: function () {
+        return this.hsv().rgb();
+    },
+
+    fromRgb: function () { // Becomes one.color.RGB.prototype.hsv
+        return this.hsv().hsl();
+    }
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/HSV.js

@@ -0,0 +1,94 @@
+/*global one*/
+INCLUDE('lib:color.js');
+
+installColorSpace('HSV', ['hue', 'saturation', 'value', 'alpha'], {
+    rgb: function () {
+        var hue = this._hue,
+            saturation = this._saturation,
+            value = this._value,
+            i = Math.min(5, Math.floor(hue * 6)),
+            f = hue * 6 - i,
+            p = value * (1 - saturation),
+            q = value * (1 - f * saturation),
+            t = value * (1 - (1 - f) * saturation),
+            red,
+            green,
+            blue;
+        switch (i) {
+        case 0:
+            red = value;
+            green = t;
+            blue = p;
+            break;
+        case 1:
+            red = q;
+            green = value;
+            blue = p;
+            break;
+        case 2:
+            red = p;
+            green = value;
+            blue = t;
+            break;
+        case 3:
+            red = p;
+            green = q;
+            blue = value;
+            break;
+        case 4:
+            red = t;
+            green = p;
+            blue = value;
+            break;
+        case 5:
+            red = value;
+            green = p;
+            blue = q;
+            break;
+        }
+        return new ONECOLOR.RGB(red, green, blue, this._alpha);
+    },
+
+    hsl: function () {
+        var l = (2 - this._saturation) * this._value,
+            sv = this._saturation * this._value,
+            svDivisor = l <= 1 ? l : (2 - l),
+            saturation;
+
+        // Avoid division by zero when lightness approaches zero:
+        if (svDivisor < 1e-9) {
+            saturation = 0;
+        } else {
+            saturation = sv / svDivisor;
+        }
+        return new ONECOLOR.HSL(this._hue, saturation, l / 2, this._alpha);
+    },
+
+    fromRgb: function () { // Becomes one.color.RGB.prototype.hsv
+        var red = this._red,
+            green = this._green,
+            blue = this._blue,
+            max = Math.max(red, green, blue),
+            min = Math.min(red, green, blue),
+            delta = max - min,
+            hue,
+            saturation = (max === 0) ? 0 : (delta / max),
+            value = max;
+        if (delta === 0) {
+            hue = 0;
+        } else {
+            switch (max) {
+            case red:
+                hue = (green - blue) / delta / 6 + (green < blue ? 1 : 0);
+                break;
+            case green:
+                hue = (blue - red) / delta / 6 + 1 / 3;
+                break;
+            case blue:
+                hue = (red - green) / delta / 6 + 2 / 3;
+                break;
+            }
+        }
+        return new ONECOLOR.HSV(hue, saturation, value, this._alpha);
+    }
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/LAB.js

@@ -0,0 +1,33 @@
+/*global INCLUDE, installColorSpace, ONECOLOR*/
+INCLUDE('lib:color.js');
+INCLUDE('lib:color/XYZ.js');
+
+installColorSpace('LAB', ['l', 'a', 'b', 'alpha'], {
+    fromRgb: function () {
+        return this.xyz().lab();
+    },
+
+    rgb: function () {
+        return this.xyz().rgb();
+    },
+
+    xyz: function () {
+        // http://www.easyrgb.com/index.php?X=MATH&H=08#text8
+        var convert = function (channel) {
+                var pow = Math.pow(channel, 3);
+                return pow > 0.008856 ?
+                    pow :
+                    (channel - 16 / 116) / 7.87;
+            },
+            y = (this._l + 16) / 116,
+            x = this._a / 500 + y,
+            z = y - this._b / 200;
+
+        return new ONECOLOR.XYZ(
+            convert(x) *  95.047,
+            convert(y) * 100.000,
+            convert(z) * 108.883,
+            this._alpha
+        );
+    }
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/XYZ.js

@@ -0,0 +1,65 @@
+/*global INCLUDE, installColorSpace, ONECOLOR*/
+INCLUDE('lib:color.js');
+
+installColorSpace('XYZ', ['x', 'y', 'z', 'alpha'], {
+    fromRgb: function () {
+        // http://www.easyrgb.com/index.php?X=MATH&H=02#text2
+        var convert = function (channel) {
+                return channel > 0.04045 ?
+                    Math.pow((channel + 0.055) / 1.055, 2.4) :
+                    channel / 12.92;
+            },
+            r = convert(this._red),
+            g = convert(this._green),
+            b = convert(this._blue);
+
+        // Reference white point sRGB D65:
+        // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+        return new ONECOLOR.XYZ(
+            r * 0.4124564 + g * 0.3575761 + b * 0.1804375,
+            r * 0.2126729 + g * 0.7151522 + b * 0.0721750,
+            r * 0.0193339 + g * 0.1191920 + b * 0.9503041,
+            this._alpha
+        );
+    },
+
+    rgb: function () {
+        // http://www.easyrgb.com/index.php?X=MATH&H=01#text1
+        var x = this._x,
+            y = this._y,
+            z = this._z,
+            convert = function (channel) {
+                return channel > 0.0031308 ?
+                    1.055 * Math.pow(channel, 1 / 2.4) - 0.055 :
+                    12.92 * channel;
+            };
+
+        // Reference white point sRGB D65:
+        // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+        return new ONECOLOR.RGB(
+            convert(x *  3.2404542 + y * -1.5371385 + z * -0.4985314),
+            convert(x * -0.9692660 + y *  1.8760108 + z *  0.0415560),
+            convert(x *  0.0556434 + y * -0.2040259 + z *  1.0572252),
+            this._alpha
+        );
+    },
+
+    lab: function () {
+        // http://www.easyrgb.com/index.php?X=MATH&H=07#text7
+        var convert = function (channel) {
+                return channel > 0.008856 ?
+                    Math.pow(channel, 1 / 3) :
+                    7.787037 * channel + 4 / 29;
+            },
+            x = convert(this._x /  95.047),
+            y = convert(this._y / 100.000),
+            z = convert(this._z / 108.883);
+
+        return new ONECOLOR.LAB(
+            (116 * y) - 16,
+            500 * (x - y),
+            200 * (y - z),
+            this._alpha
+        );
+    }
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/_all.js

@@ -0,0 +1,25 @@
+/*global one*/
+
+// This file is purely for the build system
+INCLUDE('lib:color.js');
+INCLUDE('lib:color-namedColors.js');
+
+// Order is important to prevent channel name clashes. Lab <-> hsL
+INCLUDE('lib:color/XYZ.js');
+INCLUDE('lib:color/LAB.js');
+INCLUDE('lib:color/HSV.js');
+INCLUDE('lib:color/HSL.js');
+INCLUDE('lib:color/CMYK.js');
+
+// Convenience functions
+INCLUDE('lib:color/plugins/clearer.js');
+INCLUDE('lib:color/plugins/darken.js');
+INCLUDE('lib:color/plugins/desaturate.js');
+INCLUDE('lib:color/plugins/greyscale.js');
+INCLUDE('lib:color/plugins/lighten.js');
+INCLUDE('lib:color/plugins/mix.js');
+INCLUDE('lib:color/plugins/negate.js');
+INCLUDE('lib:color/plugins/opaquer.js');
+INCLUDE('lib:color/plugins/rotate.js');
+INCLUDE('lib:color/plugins/saturate.js');
+INCLUDE('lib:color/plugins/toAlpha.js');

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/_base.js

@@ -0,0 +1,6 @@
+/*global one*/
+
+// This file is purely for the build system
+INCLUDE('lib:color.js');
+INCLUDE('lib:color/HSV.js');
+INCLUDE('lib:color/HSL.js');

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/clearer.js

@@ -0,0 +1,3 @@
+ONECOLOR.installMethod('clearer', function (amount) {
+    return this.alpha(isNaN(amount) ? -0.1 : -amount, true);
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/darken.js

@@ -0,0 +1,5 @@
+INCLUDE('../HSL.js');
+
+ONECOLOR.installMethod('darken', function (amount) {
+    return this.lightness(isNaN(amount) ? -0.1 : -amount, true);
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/desaturate.js

@@ -0,0 +1,5 @@
+INCLUDE('../HSL.js');
+
+ONECOLOR.installMethod('desaturate', function (amount) {
+    return this.saturation(isNaN(amount) ? -0.1 : -amount, true);
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/greyscale.js

@@ -0,0 +1,9 @@
+function gs () {
+    var rgb = this.rgb(),
+        val = rgb._red * 0.3 + rgb._green * 0.59 + rgb._blue * 0.11;
+
+    return new ONECOLOR.RGB(val, val, val, this._alpha);
+};
+
+ONECOLOR.installMethod('greyscale', gs);
+ONECOLOR.installMethod('grayscale', gs);

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/lighten.js

@@ -0,0 +1,5 @@
+INCLUDE('../HSL.js');
+
+ONECOLOR.installMethod('lighten', function (amount) {
+    return this.lightness(isNaN(amount) ? 0.1 : amount, true);
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/mix.js

@@ -0,0 +1,17 @@
+ONECOLOR.installMethod('mix', function (otherColor, weight) {
+    otherColor = ONECOLOR(otherColor).rgb();
+    weight = 1 - (isNaN(weight) ? 0.5 : weight);
+
+    var w = weight * 2 - 1,
+        a = this._alpha - otherColor._alpha,
+        weight1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2,
+        weight2 = 1 - weight1,
+        rgb = this.rgb();
+
+    return new ONECOLOR.RGB(
+        rgb._red * weight1 + otherColor._red * weight2,
+        rgb._green * weight1 + otherColor._green * weight2,
+        rgb._blue * weight1 + otherColor._blue * weight2,
+        rgb._alpha * weight + otherColor._alpha * (1 - weight)
+    );
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/negate.js

@@ -0,0 +1,4 @@
+ONECOLOR.installMethod('negate', function () {
+    var rgb = this.rgb();
+    return new ONECOLOR.RGB(1 - rgb._red, 1 - rgb._green, 1 - rgb._blue, this._alpha);
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/opaquer.js

@@ -0,0 +1,3 @@
+ONECOLOR.installMethod('opaquer', function (amount) {
+    return this.alpha(isNaN(amount) ? 0.1 : amount, true);
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/rotate.js

@@ -0,0 +1,3 @@
+ONECOLOR.installMethod('rotate', function (degrees) {
+    return this.hue((degrees || 0) / 360, true);
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/saturate.js

@@ -0,0 +1,5 @@
+INCLUDE('../HSL.js');
+
+ONECOLOR.installMethod('saturate', function (amount) {
+    return this.saturation(isNaN(amount) ? 0.1 : amount, true);
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/color/plugins/toAlpha.js

@@ -0,0 +1,46 @@
+// Adapted from http://gimp.sourcearchive.com/documentation/2.6.6-1ubuntu1/color-to-alpha_8c-source.html
+/*
+    toAlpha returns a color where the values of the argument have been converted to alpha
+*/
+ONECOLOR.installMethod('toAlpha', function (color) {
+    var me = this.rgb(),
+        other = ONECOLOR(color).rgb(),
+        epsilon = 1e-10,
+        a = new ONECOLOR.RGB(0, 0, 0, me._alpha),
+        channels = ['_red', '_green', '_blue'];
+
+    channels.forEach(function (channel) {
+        if (me[channel] < epsilon) {
+            a[channel] = me[channel];
+        } else if (me[channel] > other[channel]) {
+            a[channel] = (me[channel] - other[channel]) / (1 - other[channel]);
+        } else if (me[channel] > other[channel]) {
+            a[channel] = (other[channel] - me[channel]) / other[channel];
+        } else {
+            a[channel] = 0;
+        }
+    });
+
+    if (a._red > a._green) {
+        if (a._red > a._blue) {
+            me._alpha = a._red;
+        } else {
+            me._alpha = a._blue;
+        }
+    } else if (a._green > a._blue) {
+        me._alpha = a._green;
+    } else {
+        me._alpha = a._blue;
+    }
+
+    if (me._alpha < epsilon) {
+        return me;
+    }
+
+    channels.forEach(function (channel) {
+        me[channel] = (me[channel] - other[channel]) / me._alpha + other[channel];
+    });
+    me._alpha *= a._alpha;
+
+    return me;
+});

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/ender.js

@@ -0,0 +1,5 @@
+!function ($) {
+    $.ender({
+        color: one.color
+    });
+}(ender);

data/node_modules/pleeease/node_modules/csswring/node_modules/onecolor/lib/es5-shim.js

@@ -0,0 +1,97 @@
+// This is copied from es5-shim https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js
+(function () {
+    var prepareString = "a"[0] !== "a",
+        // ES5 9.9
+        // http://es5.github.com/#x9.9
+        toObject = function (o) {
+            if (o === null) { // this matches both null and undefined
+                throw new TypeError("can't convert " + o + " to object");
+            }
+            // If the implementation doesn't support by-index access of
+            // string characters (ex. IE < 9), split the string
+            if (prepareString && typeof o === "string" && o) {
+                return o.split("");
+            }
+            return new Object(o);
+        };
+
+
+    // ES5 15.4.4.18
+    // http://es5.github.com/#x15.4.4.18
+    // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach
+    if (!Array.prototype.forEach) {
+        Array.prototype.forEach = function forEach(fun /*, thisp*/) {
+            var self = toObject(this),
+                thisp = arguments[1],
+                i = -1,
+                length = self.length >>> 0;
+
+            // If no callback function or if callback is not a callable function
+            if (typeof fun !== "function") {
+                throw new TypeError(); // TODO message
+            }
+
+            while (++i < length) {
+                if (i in self) {
+                    // Invoke the callback function with call, passing arguments:
+                    // context, property value, property key, thisArg object context
+                    fun.call(thisp, self[i], i, self);
+                }
+            }
+        };
+    }
+
+    // ES5 15.4.4.19
+    // http://es5.github.com/#x15.4.4.19
+    // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+    if (!Array.prototype.map) {
+        Array.prototype.map = function map(fun /*, thisp*/) {
+            var self = toObject(this),
+                length = self.length >>> 0,
+                result = new Array(length),
+                thisp = arguments[1],
+                i;
+
+            // If no callback function or if callback is not a callable function
+            if (typeof fun !== "function") {
+                throw new TypeError(fun + " is not a function");
+            }
+
+            for (i = 0; i < length; i += 1) {
+                if (i in self) {
+                    result[i] = fun.call(thisp, self[i], i, self);
+                }
+            }
+            return result;
+        };
+    }
+
+    // ES5 15.4.4.20
+    // http://es5.github.com/#x15.4.4.20
+    // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+    if (!Array.prototype.filter) {
+        Array.prototype.filter = function filter(fun /*, thisp */) {
+            var self = toObject(this),
+                length = self.length >>> 0,
+                result = [],
+                value,
+                thisp = arguments[1],
+                i;
+
+            // If no callback function or if callback is not a callable function
+            if (typeof fun !== "function") {
+                throw new TypeError(fun + " is not a function");
+            }
+
+            for (i = 0; i < length; i += 1) {
+                if (i in self) {
+                    value = self[i];
+                    if (fun.call(thisp, value, i, self)) {
+                        result.push(value);
+                    }
+                }
+            }
+            return result;
+        };
+    }
+}());