| /* MIT license */ |
| var cssKeywords = require('./css-keywords'); |
| |
| // NOTE: conversions should only return primitive values (i.e. arrays, or |
| // values that give correct `typeof` results). |
| // do not use box values types (i.e. Number(), String(), etc.) |
| |
| var reverseKeywords = {}; |
| for (var key in cssKeywords) { |
| if (cssKeywords.hasOwnProperty(key)) { |
| reverseKeywords[cssKeywords[key].join()] = key; |
| } |
| } |
| |
| var convert = module.exports = { |
| rgb: {}, |
| hsl: {}, |
| hsv: {}, |
| hwb: {}, |
| cmyk: {}, |
| xyz: {}, |
| lab: {}, |
| lch: {}, |
| hex: {}, |
| keyword: {}, |
| ansi16: {}, |
| ansi256: {} |
| }; |
| |
| convert.rgb.hsl = function (rgb) { |
| var r = rgb[0] / 255; |
| var g = rgb[1] / 255; |
| var b = rgb[2] / 255; |
| var min = Math.min(r, g, b); |
| var max = Math.max(r, g, b); |
| var delta = max - min; |
| var h; |
| var s; |
| var l; |
| |
| if (max === min) { |
| h = 0; |
| } else if (r === max) { |
| h = (g - b) / delta; |
| } else if (g === max) { |
| h = 2 + (b - r) / delta; |
| } else if (b === max) { |
| h = 4 + (r - g) / delta; |
| } |
| |
| h = Math.min(h * 60, 360); |
| |
| if (h < 0) { |
| h += 360; |
| } |
| |
| l = (min + max) / 2; |
| |
| if (max === min) { |
| s = 0; |
| } else if (l <= 0.5) { |
| s = delta / (max + min); |
| } else { |
| s = delta / (2 - max - min); |
| } |
| |
| return [h, s * 100, l * 100]; |
| }; |
| |
| convert.rgb.hsv = function (rgb) { |
| var r = rgb[0]; |
| var g = rgb[1]; |
| var b = rgb[2]; |
| var min = Math.min(r, g, b); |
| var max = Math.max(r, g, b); |
| var delta = max - min; |
| var h; |
| var s; |
| var v; |
| |
| if (max === 0) { |
| s = 0; |
| } else { |
| s = (delta / max * 1000) / 10; |
| } |
| |
| if (max === min) { |
| h = 0; |
| } else if (r === max) { |
| h = (g - b) / delta; |
| } else if (g === max) { |
| h = 2 + (b - r) / delta; |
| } else if (b === max) { |
| h = 4 + (r - g) / delta; |
| } |
| |
| h = Math.min(h * 60, 360); |
| |
| if (h < 0) { |
| h += 360; |
| } |
| |
| v = ((max / 255) * 1000) / 10; |
| |
| return [h, s, v]; |
| }; |
| |
| convert.rgb.hwb = function (rgb) { |
| var r = rgb[0]; |
| var g = rgb[1]; |
| var b = rgb[2]; |
| var h = convert.rgb.hsl(rgb)[0]; |
| var w = 1 / 255 * Math.min(r, Math.min(g, b)); |
| |
| b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); |
| |
| return [h, w * 100, b * 100]; |
| }; |
| |
| convert.rgb.cmyk = function (rgb) { |
| var r = rgb[0] / 255; |
| var g = rgb[1] / 255; |
| var b = rgb[2] / 255; |
| var c; |
| var m; |
| var y; |
| var k; |
| |
| k = Math.min(1 - r, 1 - g, 1 - b); |
| c = (1 - r - k) / (1 - k) || 0; |
| m = (1 - g - k) / (1 - k) || 0; |
| y = (1 - b - k) / (1 - k) || 0; |
| |
| return [c * 100, m * 100, y * 100, k * 100]; |
| }; |
| |
| convert.rgb.keyword = function (rgb) { |
| return reverseKeywords[rgb.join()]; |
| }; |
| |
| convert.keyword.rgb = function (keyword) { |
| return cssKeywords[keyword]; |
| }; |
| |
| convert.rgb.xyz = function (rgb) { |
| var r = rgb[0] / 255; |
| var g = rgb[1] / 255; |
| var b = rgb[2] / 255; |
| |
| // assume sRGB |
| r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92); |
| g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92); |
| b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92); |
| |
| var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805); |
| var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722); |
| var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505); |
| |
| return [x * 100, y * 100, z * 100]; |
| }; |
| |
| convert.rgb.lab = function (rgb) { |
| var xyz = convert.rgb.xyz(rgb); |
| var x = xyz[0]; |
| var y = xyz[1]; |
| var z = xyz[2]; |
| var l; |
| var a; |
| var b; |
| |
| x /= 95.047; |
| y /= 100; |
| z /= 108.883; |
| |
| x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116); |
| y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116); |
| z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116); |
| |
| l = (116 * y) - 16; |
| a = 500 * (x - y); |
| b = 200 * (y - z); |
| |
| return [l, a, b]; |
| }; |
| |
| convert.hsl.rgb = function (hsl) { |
| var h = hsl[0] / 360; |
| var s = hsl[1] / 100; |
| var l = hsl[2] / 100; |
| var t1; |
| var t2; |
| var t3; |
| var rgb; |
| var val; |
| |
| if (s === 0) { |
| val = l * 255; |
| return [val, val, val]; |
| } |
| |
| if (l < 0.5) { |
| t2 = l * (1 + s); |
| } else { |
| t2 = l + s - l * s; |
| } |
| |
| t1 = 2 * l - t2; |
| |
| rgb = [0, 0, 0]; |
| for (var i = 0; i < 3; i++) { |
| t3 = h + 1 / 3 * -(i - 1); |
| if (t3 < 0) { |
| t3++; |
| } |
| if (t3 > 1) { |
| t3--; |
| } |
| |
| if (6 * t3 < 1) { |
| val = t1 + (t2 - t1) * 6 * t3; |
| } else if (2 * t3 < 1) { |
| val = t2; |
| } else if (3 * t3 < 2) { |
| val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; |
| } else { |
| val = t1; |
| } |
| |
| rgb[i] = val * 255; |
| } |
| |
| return rgb; |
| }; |
| |
| convert.hsl.hsv = function (hsl) { |
| var h = hsl[0]; |
| var s = hsl[1] / 100; |
| var l = hsl[2] / 100; |
| var sv; |
| var v; |
| |
| if (l === 0) { |
| // no need to do calc on black |
| // also avoids divide by 0 error |
| return [0, 0, 0]; |
| } |
| |
| l *= 2; |
| s *= (l <= 1) ? l : 2 - l; |
| v = (l + s) / 2; |
| sv = (2 * s) / (l + s); |
| |
| return [h, sv * 100, v * 100]; |
| }; |
| |
| convert.hsv.rgb = function (hsv) { |
| var h = hsv[0] / 60; |
| var s = hsv[1] / 100; |
| var v = hsv[2] / 100; |
| var hi = Math.floor(h) % 6; |
| |
| var f = h - Math.floor(h); |
| var p = 255 * v * (1 - s); |
| var q = 255 * v * (1 - (s * f)); |
| var t = 255 * v * (1 - (s * (1 - f))); |
| v *= 255; |
| |
| switch (hi) { |
| case 0: |
| return [v, t, p]; |
| case 1: |
| return [q, v, p]; |
| case 2: |
| return [p, v, t]; |
| case 3: |
| return [p, q, v]; |
| case 4: |
| return [t, p, v]; |
| case 5: |
| return [v, p, q]; |
| } |
| }; |
| |
| convert.hsv.hsl = function (hsv) { |
| var h = hsv[0]; |
| var s = hsv[1] / 100; |
| var v = hsv[2] / 100; |
| var sl; |
| var l; |
| |
| l = (2 - s) * v; |
| sl = s * v; |
| sl /= (l <= 1) ? l : 2 - l; |
| sl = sl || 0; |
| l /= 2; |
| |
| return [h, sl * 100, l * 100]; |
| }; |
| |
| // http://dev.w3.org/csswg/css-color/#hwb-to-rgb |
| convert.hwb.rgb = function (hwb) { |
| var h = hwb[0] / 360; |
| var wh = hwb[1] / 100; |
| var bl = hwb[2] / 100; |
| var ratio = wh + bl; |
| var i; |
| var v; |
| var f; |
| var n; |
| |
| // wh + bl cant be > 1 |
| if (ratio > 1) { |
| wh /= ratio; |
| bl /= ratio; |
| } |
| |
| i = Math.floor(6 * h); |
| v = 1 - bl; |
| f = 6 * h - i; |
| |
| if ((i & 0x01) !== 0) { |
| f = 1 - f; |
| } |
| |
| n = wh + f * (v - wh); // linear interpolation |
| |
| var r; |
| var g; |
| var b; |
| switch (i) { |
| default: |
| case 6: |
| case 0: r = v; g = n; b = wh; break; |
| case 1: r = n; g = v; b = wh; break; |
| case 2: r = wh; g = v; b = n; break; |
| case 3: r = wh; g = n; b = v; break; |
| case 4: r = n; g = wh; b = v; break; |
| case 5: r = v; g = wh; b = n; break; |
| } |
| |
| return [r * 255, g * 255, b * 255]; |
| }; |
| |
| convert.cmyk.rgb = function (cmyk) { |
| var c = cmyk[0] / 100; |
| var m = cmyk[1] / 100; |
| var y = cmyk[2] / 100; |
| var k = cmyk[3] / 100; |
| var r; |
| var g; |
| var b; |
| |
| r = 1 - Math.min(1, c * (1 - k) + k); |
| g = 1 - Math.min(1, m * (1 - k) + k); |
| b = 1 - Math.min(1, y * (1 - k) + k); |
| |
| return [r * 255, g * 255, b * 255]; |
| }; |
| |
| convert.xyz.rgb = function (xyz) { |
| var x = xyz[0] / 100; |
| var y = xyz[1] / 100; |
| var z = xyz[2] / 100; |
| var r; |
| var g; |
| var b; |
| |
| r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986); |
| g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415); |
| b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570); |
| |
| // assume sRGB |
| r = r > 0.0031308 |
| ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055) |
| : r *= 12.92; |
| |
| g = g > 0.0031308 |
| ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055) |
| : g *= 12.92; |
| |
| b = b > 0.0031308 |
| ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055) |
| : b *= 12.92; |
| |
| r = Math.min(Math.max(0, r), 1); |
| g = Math.min(Math.max(0, g), 1); |
| b = Math.min(Math.max(0, b), 1); |
| |
| return [r * 255, g * 255, b * 255]; |
| }; |
| |
| convert.xyz.lab = function (xyz) { |
| var x = xyz[0]; |
| var y = xyz[1]; |
| var z = xyz[2]; |
| var l; |
| var a; |
| var b; |
| |
| x /= 95.047; |
| y /= 100; |
| z /= 108.883; |
| |
| x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116); |
| y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116); |
| z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116); |
| |
| l = (116 * y) - 16; |
| a = 500 * (x - y); |
| b = 200 * (y - z); |
| |
| return [l, a, b]; |
| }; |
| |
| convert.lab.xyz = function (lab) { |
| var l = lab[0]; |
| var a = lab[1]; |
| var b = lab[2]; |
| var x; |
| var y; |
| var z; |
| var y2; |
| |
| if (l <= 8) { |
| y = (l * 100) / 903.3; |
| y2 = (7.787 * (y / 100)) + (16 / 116); |
| } else { |
| y = 100 * Math.pow((l + 16) / 116, 3); |
| y2 = Math.pow(y / 100, 1 / 3); |
| } |
| |
| x = x / 95.047 <= 0.008856 |
| ? x = (95.047 * ((a / 500) + y2 - (16 / 116))) / 7.787 |
| : 95.047 * Math.pow((a / 500) + y2, 3); |
| z = z / 108.883 <= 0.008859 |
| ? z = (108.883 * (y2 - (b / 200) - (16 / 116))) / 7.787 |
| : 108.883 * Math.pow(y2 - (b / 200), 3); |
| |
| return [x, y, z]; |
| }; |
| |
| convert.lab.lch = function (lab) { |
| var l = lab[0]; |
| var a = lab[1]; |
| var b = lab[2]; |
| var hr; |
| var h; |
| var c; |
| |
| hr = Math.atan2(b, a); |
| h = hr * 360 / 2 / Math.PI; |
| |
| if (h < 0) { |
| h += 360; |
| } |
| |
| c = Math.sqrt(a * a + b * b); |
| |
| return [l, c, h]; |
| }; |
| |
| convert.lch.lab = function (lch) { |
| var l = lch[0]; |
| var c = lch[1]; |
| var h = lch[2]; |
| var a; |
| var b; |
| var hr; |
| |
| hr = h / 360 * 2 * Math.PI; |
| a = c * Math.cos(hr); |
| b = c * Math.sin(hr); |
| |
| return [l, a, b]; |
| }; |
| |
| convert.rgb.ansi16 = function (args) { |
| var r = args[0]; |
| var g = args[1]; |
| var b = args[2]; |
| var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization |
| |
| value = Math.round(value / 50); |
| |
| if (value === 0) { |
| return 30; |
| } |
| |
| var ansi = 30 |
| + ((Math.round(b / 255) << 2) |
| | (Math.round(g / 255) << 1) |
| | Math.round(r / 255)); |
| |
| if (value === 2) { |
| ansi += 60; |
| } |
| |
| return ansi; |
| }; |
| |
| convert.hsv.ansi16 = function (args) { |
| // optimization here; we already know the value and don't need to get |
| // it converted for us. |
| return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); |
| }; |
| |
| convert.rgb.ansi256 = function (args) { |
| var r = args[0]; |
| var g = args[1]; |
| var b = args[2]; |
| |
| // we use the extended greyscale palette here, with the exception of |
| // black and white. normal palette only has 4 greyscale shades. |
| if (r === g && g === b) { |
| if (r < 8) { |
| return 16; |
| } |
| |
| if (r > 248) { |
| return 231; |
| } |
| |
| return Math.round(((r - 8) / 247) * 24) + 232; |
| } |
| |
| var ansi = 16 |
| + (36 * Math.round(r / 255 * 5)) |
| + (6 * Math.round(g / 255 * 5)) |
| + Math.round(b / 255 * 5); |
| |
| return ansi; |
| }; |
| |
| convert.ansi16.rgb = function (args) { |
| var color = args % 10; |
| |
| // handle greyscale |
| if (color === 0 || color === 7) { |
| if (args > 50) { |
| color += 3.5; |
| } |
| |
| color = color / 10.5 * 255; |
| |
| return [color, color, color]; |
| } |
| |
| var mult = (~~(args > 50) + 1) * 0.5; |
| var r = ((color & 1) * mult) * 255; |
| var g = (((color >> 1) & 1) * mult) * 255; |
| var b = (((color >> 2) & 1) * mult) * 255; |
| |
| return [r, g, b]; |
| }; |
| |
| convert.ansi256.rgb = function (args) { |
| // handle greyscale |
| if (args >= 232) { |
| var c = (args - 232) * 10 + 8; |
| return [c, c, c]; |
| } |
| |
| args -= 16; |
| |
| var rem; |
| var r = Math.floor(args / 36) / 5 * 255; |
| var g = Math.floor((rem = args % 36) / 6) / 5 * 255; |
| var b = (rem % 6) / 5 * 255; |
| |
| return [r, g, b]; |
| }; |
| |
| convert.rgb.hex = function (args) { |
| var integer = ((Math.round(args[0]) & 0xFF) << 16) |
| + ((Math.round(args[1]) & 0xFF) << 8) |
| + (Math.round(args[2]) & 0xFF); |
| |
| var string = integer.toString(16).toUpperCase(); |
| return '000000'.substring(string.length) + string; |
| }; |
| |
| convert.hex.rgb = function (args) { |
| var match = args.toString(16).match(/[a-f0-9]{6}/i); |
| if (!match) { |
| return [0, 0, 0]; |
| } |
| |
| var integer = parseInt(match[0], 16); |
| var r = (integer >> 16) & 0xFF; |
| var g = (integer >> 8) & 0xFF; |
| var b = integer & 0xFF; |
| |
| return [r, g, b]; |
| }; |