Last active
September 14, 2023 13:14
-
-
Save kentaromiura/f593043724c84488f52bf0bd4cd308df to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| (function (modules, global) { | |
| var cache = {}, require = function (id) { | |
| var module = cache[id]; | |
| if (!module) { | |
| module = cache[id] = {}; | |
| var exports = module.exports = {}; | |
| modules[id].call(exports, require, module, exports, global); | |
| } | |
| return module.exports; | |
| }; | |
| require('0'); | |
| }({ | |
| '0': function (require, module, exports, global) { | |
| 'use strict'; | |
| global.pretty = require('1'); | |
| }, | |
| '1': function (require, module, exports, global) { | |
| 'use strict'; | |
| 'use strict'; | |
| var style = require('2'); | |
| var toString = Object.prototype.toString; | |
| var toISOString = Date.prototype.toISOString; | |
| var errorToString = Error.prototype.toString; | |
| var regExpToString = RegExp.prototype.toString; | |
| var symbolToString = Symbol.prototype.toString; | |
| var SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/; | |
| var NEWLINE_REGEXP = /\n/gi; | |
| var getSymbols = Object.getOwnPropertySymbols || function (obj) { | |
| return []; | |
| }; | |
| function isToStringedArrayType(toStringed) { | |
| return toStringed === '[object Array]' || toStringed === '[object ArrayBuffer]' || toStringed === '[object DataView]' || toStringed === '[object Float32Array]' || toStringed === '[object Float64Array]' || toStringed === '[object Int8Array]' || toStringed === '[object Int16Array]' || toStringed === '[object Int32Array]' || toStringed === '[object Uint8Array]' || toStringed === '[object Uint8ClampedArray]' || toStringed === '[object Uint16Array]' || toStringed === '[object Uint32Array]'; | |
| } | |
| function printNumber(val) { | |
| if (val != +val) { | |
| return 'NaN'; | |
| } | |
| var isNegativeZero = val === 0 && 1 / val < 0; | |
| return isNegativeZero ? '-0' : '' + val; | |
| } | |
| function printFunction(val, printFunctionName) { | |
| if (!printFunctionName) { | |
| return '[Function]'; | |
| } else if (val.name === '') { | |
| return '[Function anonymous]'; | |
| } else { | |
| return '[Function ' + val.name + ']'; | |
| } | |
| } | |
| function printSymbol(val) { | |
| return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)'); | |
| } | |
| function printError(val) { | |
| return '[' + errorToString.call(val) + ']'; | |
| } | |
| function printBasicValue(val, printFunctionName, escapeRegex) { | |
| if (val === true || val === false) { | |
| return '' + val; | |
| } | |
| if (val === undefined) { | |
| return 'undefined'; | |
| } | |
| if (val === null) { | |
| return 'null'; | |
| } | |
| var typeOf = typeof val; | |
| if (typeOf === 'number') { | |
| return printNumber(val); | |
| } | |
| if (typeOf === 'string') { | |
| return '"' + val.replace(/"|\\/g, '\\$&') + '"'; | |
| } | |
| if (typeOf === 'function') { | |
| return printFunction(val, printFunctionName); | |
| } | |
| if (typeOf === 'symbol') { | |
| return printSymbol(val); | |
| } | |
| var toStringed = toString.call(val); | |
| if (toStringed === '[object WeakMap]') { | |
| return 'WeakMap {}'; | |
| } | |
| if (toStringed === '[object WeakSet]') { | |
| return 'WeakSet {}'; | |
| } | |
| if (toStringed === '[object Function]' || toStringed === '[object GeneratorFunction]') { | |
| return printFunction(val, printFunctionName); | |
| } | |
| if (toStringed === '[object Symbol]') { | |
| return printSymbol(val); | |
| } | |
| if (toStringed === '[object Date]') { | |
| return toISOString.call(val); | |
| } | |
| if (toStringed === '[object Error]') { | |
| return printError(val); | |
| } | |
| if (toStringed === '[object RegExp]') { | |
| if (escapeRegex) { | |
| return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&'); | |
| } | |
| return regExpToString.call(val); | |
| } | |
| if (toStringed === '[object Arguments]' && val.length === 0) { | |
| return 'Arguments []'; | |
| } | |
| if (isToStringedArrayType(toStringed) && val.length === 0) { | |
| return val.constructor.name + ' []'; | |
| } | |
| if (val instanceof Error) { | |
| return printError(val); | |
| } | |
| return false; | |
| } | |
| function printList(list, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| var body = ''; | |
| if (list.length) { | |
| body += edgeSpacing; | |
| var innerIndent = prevIndent + indent; | |
| for (var i = 0; i < list.length; i++) { | |
| body += innerIndent + print(list[i], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| if (i < list.length - 1) { | |
| body += ',' + spacing; | |
| } | |
| } | |
| body += (min ? '' : ',') + edgeSpacing + prevIndent; | |
| } | |
| return '[' + body + ']'; | |
| } | |
| function printArguments(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| return (min ? '' : 'Arguments ') + printList(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } | |
| function printArray(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| return (min ? '' : val.constructor.name + ' ') + printList(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } | |
| function printMap(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| var result = 'Map {'; | |
| var iterator = val.entries(); | |
| var current = iterator.next(); | |
| if (!current.done) { | |
| result += edgeSpacing; | |
| var innerIndent = prevIndent + indent; | |
| while (!current.done) { | |
| var key = print(current.value[0], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| var value = print(current.value[1], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| result += innerIndent + key + ' => ' + value; | |
| current = iterator.next(); | |
| if (!current.done) { | |
| result += ',' + spacing; | |
| } | |
| } | |
| result += (min ? '' : ',') + edgeSpacing + prevIndent; | |
| } | |
| return result + '}'; | |
| } | |
| function printObject(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| var constructor = min ? '' : val.constructor ? val.constructor.name + ' ' : 'Object '; | |
| var result = constructor + '{'; | |
| var keys = Object.keys(val).sort(); | |
| var symbols = getSymbols(val); | |
| if (symbols.length) { | |
| keys = keys.filter(function (key) { | |
| return !(typeof key === 'symbol' || toString.call(key) === '[object Symbol]'); | |
| }).concat(symbols); | |
| } | |
| if (keys.length) { | |
| result += edgeSpacing; | |
| var innerIndent = prevIndent + indent; | |
| for (var i = 0; i < keys.length; i++) { | |
| var key = keys[i]; | |
| var name = print(key, indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| var value = print(val[key], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| result += innerIndent + name + ': ' + value; | |
| if (i < keys.length - 1) { | |
| result += ',' + spacing; | |
| } | |
| } | |
| result += (min ? '' : ',') + edgeSpacing + prevIndent; | |
| } | |
| return result + '}'; | |
| } | |
| function printSet(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| var result = 'Set {'; | |
| var iterator = val.entries(); | |
| var current = iterator.next(); | |
| if (!current.done) { | |
| result += edgeSpacing; | |
| var innerIndent = prevIndent + indent; | |
| while (!current.done) { | |
| result += innerIndent + print(current.value[1], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| current = iterator.next(); | |
| if (!current.done) { | |
| result += ',' + spacing; | |
| } | |
| } | |
| result += (min ? '' : ',') + edgeSpacing + prevIndent; | |
| } | |
| return result + '}'; | |
| } | |
| function printComplexValue(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| refs = refs.slice(); | |
| if (refs.indexOf(val) > -1) { | |
| return '[Circular]'; | |
| } else { | |
| refs.push(val); | |
| } | |
| currentDepth++; | |
| var hitMaxDepth = currentDepth > maxDepth; | |
| if (callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === 'function') { | |
| return print(val.toJSON(), indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } | |
| var toStringed = toString.call(val); | |
| if (toStringed === '[object Arguments]') { | |
| return hitMaxDepth ? '[Arguments]' : printArguments(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } else if (isToStringedArrayType(toStringed)) { | |
| return hitMaxDepth ? '[Array]' : printArray(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } else if (toStringed === '[object Map]') { | |
| return hitMaxDepth ? '[Map]' : printMap(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } else if (toStringed === '[object Set]') { | |
| return hitMaxDepth ? '[Set]' : printSet(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } | |
| return hitMaxDepth ? '[Object]' : printObject(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } | |
| function printPlugin(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| var match = false; | |
| var plugin; | |
| for (var p = 0; p < plugins.length; p++) { | |
| plugin = plugins[p]; | |
| if (plugin.test(val)) { | |
| match = true; | |
| break; | |
| } | |
| } | |
| if (!match) { | |
| return false; | |
| } | |
| function boundPrint(val) { | |
| return print(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } | |
| function boundIndent(str) { | |
| var indentation = prevIndent + indent; | |
| return indentation + str.replace(NEWLINE_REGEXP, '\n' + indentation); | |
| } | |
| var opts = { | |
| edgeSpacing: edgeSpacing, | |
| min: min, | |
| spacing: spacing | |
| }; | |
| return plugin.print(val, boundPrint, boundIndent, opts, colors); | |
| } | |
| function print(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors) { | |
| var basic = printBasicValue(val, printFunctionName, escapeRegex); | |
| if (basic) { | |
| return basic; | |
| } | |
| var plugin = printPlugin(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| if (plugin) { | |
| return plugin; | |
| } | |
| return printComplexValue(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex, colors); | |
| } | |
| var DEFAULTS = { | |
| callToJSON: true, | |
| escapeRegex: false, | |
| highlight: false, | |
| indent: 2, | |
| maxDepth: Infinity, | |
| min: false, | |
| plugins: [], | |
| printFunctionName: true, | |
| theme: { | |
| content: 'reset', | |
| prop: 'yellow', | |
| tag: 'cyan', | |
| value: 'green' | |
| } | |
| }; | |
| function validateOptions(opts) { | |
| Object.keys(opts).forEach(function (key) { | |
| if (!DEFAULTS.hasOwnProperty(key)) { | |
| throw new Error('prettyFormat: Invalid option: ' + key); | |
| } | |
| }); | |
| if (opts.min && opts.indent !== undefined && opts.indent !== 0) { | |
| throw new Error('prettyFormat: Cannot run with min option and indent'); | |
| } | |
| } | |
| function normalizeOptions(opts) { | |
| var result = {}; | |
| Object.keys(DEFAULTS).forEach(function (key) { | |
| return result[key] = opts.hasOwnProperty(key) ? opts[key] : DEFAULTS[key]; | |
| }); | |
| if (result.min) { | |
| result.indent = 0; | |
| } | |
| return result; | |
| } | |
| function createIndent(indent) { | |
| return new Array(indent + 1).join(' '); | |
| } | |
| function prettyFormat(val, opts) { | |
| if (!opts) { | |
| opts = DEFAULTS; | |
| } else { | |
| validateOptions(opts); | |
| opts = normalizeOptions(opts); | |
| } | |
| var colors = {}; | |
| Object.keys(opts.theme).forEach(function (key) { | |
| if (opts.highlight) { | |
| colors[key] = style[opts.theme[key]]; | |
| } else { | |
| colors[key] = { | |
| close: '', | |
| open: '' | |
| }; | |
| } | |
| }); | |
| var indent; | |
| var refs; | |
| var prevIndent = ''; | |
| var currentDepth = 0; | |
| var spacing = opts.min ? ' ' : '\n'; | |
| var edgeSpacing = opts.min ? '' : '\n'; | |
| if (opts && opts.plugins.length) { | |
| indent = createIndent(opts.indent); | |
| refs = []; | |
| var pluginsResult = printPlugin(val, indent, prevIndent, spacing, edgeSpacing, refs, opts.maxDepth, currentDepth, opts.plugins, opts.min, opts.callToJSON, opts.printFunctionName, opts.escapeRegex, colors); | |
| if (pluginsResult) { | |
| return pluginsResult; | |
| } | |
| } | |
| var basicResult = printBasicValue(val, opts.printFunctionName, opts.escapeRegex); | |
| if (basicResult) { | |
| return basicResult; | |
| } | |
| if (!indent) { | |
| indent = createIndent(opts.indent); | |
| } | |
| if (!refs) { | |
| refs = []; | |
| } | |
| return printComplexValue(val, indent, prevIndent, spacing, edgeSpacing, refs, opts.maxDepth, currentDepth, opts.plugins, opts.min, opts.callToJSON, opts.printFunctionName, opts.escapeRegex, colors); | |
| } | |
| module.exports = prettyFormat; | |
| }, | |
| '2': function (require, module, exports, global) { | |
| 'use strict'; | |
| 'use strict'; | |
| var colorConvert = require('3'); | |
| var wrapAnsi16 = function (fn, offset) { | |
| return function () { | |
| var code = fn.apply(colorConvert, arguments); | |
| return '\x1b[' + (code + offset) + 'm'; | |
| }; | |
| }; | |
| var wrapAnsi256 = function (fn, offset) { | |
| return function () { | |
| var code = fn.apply(colorConvert, arguments); | |
| return '\x1b[' + (38 + offset) + ';5;' + code + 'm'; | |
| }; | |
| }; | |
| var wrapAnsi16m = function (fn, offset) { | |
| return function () { | |
| var rgb = fn.apply(colorConvert, arguments); | |
| return '\x1b[' + (38 + offset) + ';2;' + rgb[0] + ';' + rgb[1] + ';' + rgb[2] + 'm'; | |
| }; | |
| }; | |
| function assembleStyles() { | |
| var styles = { | |
| modifier: { | |
| reset: [ | |
| 0, | |
| 0 | |
| ], | |
| bold: [ | |
| 1, | |
| 22 | |
| ], | |
| dim: [ | |
| 2, | |
| 22 | |
| ], | |
| italic: [ | |
| 3, | |
| 23 | |
| ], | |
| underline: [ | |
| 4, | |
| 24 | |
| ], | |
| inverse: [ | |
| 7, | |
| 27 | |
| ], | |
| hidden: [ | |
| 8, | |
| 28 | |
| ], | |
| strikethrough: [ | |
| 9, | |
| 29 | |
| ] | |
| }, | |
| color: { | |
| black: [ | |
| 30, | |
| 39 | |
| ], | |
| red: [ | |
| 31, | |
| 39 | |
| ], | |
| green: [ | |
| 32, | |
| 39 | |
| ], | |
| yellow: [ | |
| 33, | |
| 39 | |
| ], | |
| blue: [ | |
| 34, | |
| 39 | |
| ], | |
| magenta: [ | |
| 35, | |
| 39 | |
| ], | |
| cyan: [ | |
| 36, | |
| 39 | |
| ], | |
| white: [ | |
| 37, | |
| 39 | |
| ], | |
| gray: [ | |
| 90, | |
| 39 | |
| ] | |
| }, | |
| bgColor: { | |
| bgBlack: [ | |
| 40, | |
| 49 | |
| ], | |
| bgRed: [ | |
| 41, | |
| 49 | |
| ], | |
| bgGreen: [ | |
| 42, | |
| 49 | |
| ], | |
| bgYellow: [ | |
| 43, | |
| 49 | |
| ], | |
| bgBlue: [ | |
| 44, | |
| 49 | |
| ], | |
| bgMagenta: [ | |
| 45, | |
| 49 | |
| ], | |
| bgCyan: [ | |
| 46, | |
| 49 | |
| ], | |
| bgWhite: [ | |
| 47, | |
| 49 | |
| ] | |
| } | |
| }; | |
| styles.color.grey = styles.color.gray; | |
| Object.keys(styles).forEach(function (groupName) { | |
| var group = styles[groupName]; | |
| Object.keys(group).forEach(function (styleName) { | |
| var style = group[styleName]; | |
| styles[styleName] = group[styleName] = { | |
| open: '\x1b[' + style[0] + 'm', | |
| close: '\x1b[' + style[1] + 'm' | |
| }; | |
| }); | |
| Object.defineProperty(styles, groupName, { | |
| value: group, | |
| enumerable: false | |
| }); | |
| }); | |
| var rgb2rgb = function (r, g, b) { | |
| return [ | |
| r, | |
| g, | |
| b | |
| ]; | |
| }; | |
| styles.color.close = '\x1b[39m'; | |
| styles.bgColor.close = '\x1b[49m'; | |
| styles.color.ansi = {}; | |
| styles.color.ansi256 = {}; | |
| styles.color.ansi16m = { rgb: wrapAnsi16m(rgb2rgb, 0) }; | |
| styles.bgColor.ansi = {}; | |
| styles.bgColor.ansi256 = {}; | |
| styles.bgColor.ansi16m = { rgb: wrapAnsi16m(rgb2rgb, 10) }; | |
| return styles; | |
| } | |
| Object.defineProperty(module, 'exports', { | |
| enumerable: true, | |
| get: assembleStyles | |
| }); | |
| }, | |
| '3': function (require, module, exports, global) { | |
| 'use strict'; | |
| var conversions = require('4'); | |
| var route = require('5'); | |
| var convert = {}; | |
| var models = Object.keys(conversions); | |
| function wrapRaw(fn) { | |
| var wrappedFn = function (args) { | |
| if (args === undefined || args === null) { | |
| return args; | |
| } | |
| if (arguments.length > 1) { | |
| args = Array.prototype.slice.call(arguments); | |
| } | |
| return fn(args); | |
| }; | |
| if ('conversion' in fn) { | |
| wrappedFn.conversion = fn.conversion; | |
| } | |
| return wrappedFn; | |
| } | |
| function wrapRounded(fn) { | |
| var wrappedFn = function (args) { | |
| if (args === undefined || args === null) { | |
| return args; | |
| } | |
| if (arguments.length > 1) { | |
| args = Array.prototype.slice.call(arguments); | |
| } | |
| var result = fn(args); | |
| if (typeof result === 'object') { | |
| for (var len = result.length, i = 0; i < len; i++) { | |
| result[i] = Math.round(result[i]); | |
| } | |
| } | |
| return result; | |
| }; | |
| if ('conversion' in fn) { | |
| wrappedFn.conversion = fn.conversion; | |
| } | |
| return wrappedFn; | |
| } | |
| models.forEach(function (fromModel) { | |
| convert[fromModel] = {}; | |
| Object.defineProperty(convert[fromModel], 'channels', { value: conversions[fromModel].channels }); | |
| Object.defineProperty(convert[fromModel], 'labels', { value: conversions[fromModel].labels }); | |
| var routes = route(fromModel); | |
| var routeModels = Object.keys(routes); | |
| routeModels.forEach(function (toModel) { | |
| var fn = routes[toModel]; | |
| convert[fromModel][toModel] = wrapRounded(fn); | |
| convert[fromModel][toModel].raw = wrapRaw(fn); | |
| }); | |
| }); | |
| module.exports = convert; | |
| }, | |
| '4': function (require, module, exports, global) { | |
| 'use strict'; | |
| var cssKeywords = require('6'); | |
| var reverseKeywords = {}; | |
| for (var key in cssKeywords) { | |
| if (cssKeywords.hasOwnProperty(key)) { | |
| reverseKeywords[cssKeywords[key]] = key; | |
| } | |
| } | |
| var convert = module.exports = { | |
| rgb: { | |
| channels: 3, | |
| labels: 'rgb' | |
| }, | |
| hsl: { | |
| channels: 3, | |
| labels: 'hsl' | |
| }, | |
| hsv: { | |
| channels: 3, | |
| labels: 'hsv' | |
| }, | |
| hwb: { | |
| channels: 3, | |
| labels: 'hwb' | |
| }, | |
| cmyk: { | |
| channels: 4, | |
| labels: 'cmyk' | |
| }, | |
| xyz: { | |
| channels: 3, | |
| labels: 'xyz' | |
| }, | |
| lab: { | |
| channels: 3, | |
| labels: 'lab' | |
| }, | |
| lch: { | |
| channels: 3, | |
| labels: 'lch' | |
| }, | |
| hex: { | |
| channels: 1, | |
| labels: ['hex'] | |
| }, | |
| keyword: { | |
| channels: 1, | |
| labels: ['keyword'] | |
| }, | |
| ansi16: { | |
| channels: 1, | |
| labels: ['ansi16'] | |
| }, | |
| ansi256: { | |
| channels: 1, | |
| labels: ['ansi256'] | |
| }, | |
| hcg: { | |
| channels: 3, | |
| labels: [ | |
| 'h', | |
| 'c', | |
| 'g' | |
| ] | |
| }, | |
| apple: { | |
| channels: 3, | |
| labels: [ | |
| 'r16', | |
| 'g16', | |
| 'b16' | |
| ] | |
| }, | |
| gray: { | |
| channels: 1, | |
| labels: ['gray'] | |
| } | |
| }; | |
| for (var model in convert) { | |
| if (convert.hasOwnProperty(model)) { | |
| if (!('channels' in convert[model])) { | |
| throw new Error('missing channels property: ' + model); | |
| } | |
| if (!('labels' in convert[model])) { | |
| throw new Error('missing channel labels property: ' + model); | |
| } | |
| if (convert[model].labels.length !== convert[model].channels) { | |
| throw new Error('channel and label counts mismatch: ' + model); | |
| } | |
| var channels = convert[model].channels; | |
| var labels = convert[model].labels; | |
| delete convert[model].channels; | |
| delete convert[model].labels; | |
| Object.defineProperty(convert[model], 'channels', { value: channels }); | |
| Object.defineProperty(convert[model], 'labels', { value: labels }); | |
| } | |
| } | |
| 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 | |
| ]; | |
| }; | |
| function comparativeDistance(x, y) { | |
| return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2); | |
| } | |
| convert.rgb.keyword = function (rgb) { | |
| var reversed = reverseKeywords[rgb]; | |
| if (reversed) { | |
| return reversed; | |
| } | |
| var currentClosestDistance = Infinity; | |
| var currentClosestKeyword; | |
| for (var keyword in cssKeywords) { | |
| if (cssKeywords.hasOwnProperty(keyword)) { | |
| var value = cssKeywords[keyword]; | |
| var distance = comparativeDistance(rgb, value); | |
| if (distance < currentClosestDistance) { | |
| currentClosestDistance = distance; | |
| currentClosestKeyword = keyword; | |
| } | |
| } | |
| } | |
| return currentClosestKeyword; | |
| }; | |
| 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; | |
| 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 smin = s; | |
| var lmin = Math.max(l, 0.01); | |
| var sv; | |
| var v; | |
| l *= 2; | |
| s *= l <= 1 ? l : 2 - l; | |
| smin *= lmin <= 1 ? lmin : 2 - lmin; | |
| v = (l + s) / 2; | |
| sv = l === 0 ? 2 * smin / (lmin + smin) : 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 vmin = Math.max(v, 0.01); | |
| var lmin; | |
| var sl; | |
| var l; | |
| l = (2 - s) * v; | |
| lmin = (2 - s) * vmin; | |
| sl = s * vmin; | |
| sl /= lmin <= 1 ? lmin : 2 - lmin; | |
| sl = sl || 0; | |
| l /= 2; | |
| return [ | |
| h, | |
| sl * 100, | |
| l * 100 | |
| ]; | |
| }; | |
| 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; | |
| if (ratio > 1) { | |
| wh /= ratio; | |
| bl /= ratio; | |
| } | |
| i = Math.floor(6 * h); | |
| v = 1 - bl; | |
| f = 6 * h - i; | |
| if ((i & 1) !== 0) { | |
| f = 1 - f; | |
| } | |
| n = wh + f * (v - wh); | |
| 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.204 + z * 1.057; | |
| r = r > 0.0031308 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : r * 12.92; | |
| g = g > 0.0031308 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : g * 12.92; | |
| b = b > 0.0031308 ? 1.055 * Math.pow(b, 1 / 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; | |
| y = (l + 16) / 116; | |
| x = a / 500 + y; | |
| z = y - b / 200; | |
| var y2 = Math.pow(y, 3); | |
| var x2 = Math.pow(x, 3); | |
| var z2 = Math.pow(z, 3); | |
| y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787; | |
| x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787; | |
| z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787; | |
| x *= 95.047; | |
| y *= 100; | |
| z *= 108.883; | |
| 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]; | |
| 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) { | |
| 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]; | |
| 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; | |
| 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) { | |
| 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]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255); | |
| 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}|[a-f0-9]{3}/i); | |
| if (!match) { | |
| return [ | |
| 0, | |
| 0, | |
| 0 | |
| ]; | |
| } | |
| var colorString = match[0]; | |
| if (match[0].length === 3) { | |
| colorString = colorString.split('').map(function (char) { | |
| return char + char; | |
| }).join(''); | |
| } | |
| var integer = parseInt(colorString, 16); | |
| var r = integer >> 16 & 255; | |
| var g = integer >> 8 & 255; | |
| var b = integer & 255; | |
| return [ | |
| r, | |
| g, | |
| b | |
| ]; | |
| }; | |
| convert.rgb.hcg = function (rgb) { | |
| var r = rgb[0] / 255; | |
| var g = rgb[1] / 255; | |
| var b = rgb[2] / 255; | |
| var max = Math.max(Math.max(r, g), b); | |
| var min = Math.min(Math.min(r, g), b); | |
| var chroma = max - min; | |
| var grayscale; | |
| var hue; | |
| if (chroma < 1) { | |
| grayscale = min / (1 - chroma); | |
| } else { | |
| grayscale = 0; | |
| } | |
| if (chroma <= 0) { | |
| hue = 0; | |
| } else if (max === r) { | |
| hue = (g - b) / chroma % 6; | |
| } else if (max === g) { | |
| hue = 2 + (b - r) / chroma; | |
| } else { | |
| hue = 4 + (r - g) / chroma + 4; | |
| } | |
| hue /= 6; | |
| hue %= 1; | |
| return [ | |
| hue * 360, | |
| chroma * 100, | |
| grayscale * 100 | |
| ]; | |
| }; | |
| convert.hsl.hcg = function (hsl) { | |
| var s = hsl[1] / 100; | |
| var l = hsl[2] / 100; | |
| var c = 1; | |
| var f = 0; | |
| if (l < 0.5) { | |
| c = 2 * s * l; | |
| } else { | |
| c = 2 * s * (1 - l); | |
| } | |
| if (c < 1) { | |
| f = (l - 0.5 * c) / (1 - c); | |
| } | |
| return [ | |
| hsl[0], | |
| c * 100, | |
| f * 100 | |
| ]; | |
| }; | |
| convert.hsv.hcg = function (hsv) { | |
| var s = hsv[1] / 100; | |
| var v = hsv[2] / 100; | |
| var c = s * v; | |
| var f = 0; | |
| if (c < 1) { | |
| f = (v - c) / (1 - c); | |
| } | |
| return [ | |
| hsv[0], | |
| c * 100, | |
| f * 100 | |
| ]; | |
| }; | |
| convert.hcg.rgb = function (hcg) { | |
| var h = hcg[0] / 360; | |
| var c = hcg[1] / 100; | |
| var g = hcg[2] / 100; | |
| if (c === 0) { | |
| return [ | |
| g * 255, | |
| g * 255, | |
| g * 255 | |
| ]; | |
| } | |
| var pure = [ | |
| 0, | |
| 0, | |
| 0 | |
| ]; | |
| var hi = h % 1 * 6; | |
| var v = hi % 1; | |
| var w = 1 - v; | |
| var mg = 0; | |
| switch (Math.floor(hi)) { | |
| case 0: | |
| pure[0] = 1; | |
| pure[1] = v; | |
| pure[2] = 0; | |
| break; | |
| case 1: | |
| pure[0] = w; | |
| pure[1] = 1; | |
| pure[2] = 0; | |
| break; | |
| case 2: | |
| pure[0] = 0; | |
| pure[1] = 1; | |
| pure[2] = v; | |
| break; | |
| case 3: | |
| pure[0] = 0; | |
| pure[1] = w; | |
| pure[2] = 1; | |
| break; | |
| case 4: | |
| pure[0] = v; | |
| pure[1] = 0; | |
| pure[2] = 1; | |
| break; | |
| default: | |
| pure[0] = 1; | |
| pure[1] = 0; | |
| pure[2] = w; | |
| } | |
| mg = (1 - c) * g; | |
| return [ | |
| (c * pure[0] + mg) * 255, | |
| (c * pure[1] + mg) * 255, | |
| (c * pure[2] + mg) * 255 | |
| ]; | |
| }; | |
| convert.hcg.hsv = function (hcg) { | |
| var c = hcg[1] / 100; | |
| var g = hcg[2] / 100; | |
| var v = c + g * (1 - c); | |
| var f = 0; | |
| if (v > 0) { | |
| f = c / v; | |
| } | |
| return [ | |
| hcg[0], | |
| f * 100, | |
| v * 100 | |
| ]; | |
| }; | |
| convert.hcg.hsl = function (hcg) { | |
| var c = hcg[1] / 100; | |
| var g = hcg[2] / 100; | |
| var l = g * (1 - c) + 0.5 * c; | |
| var s = 0; | |
| if (l > 0 && l < 0.5) { | |
| s = c / (2 * l); | |
| } else if (l >= 0.5 && l < 1) { | |
| s = c / (2 * (1 - l)); | |
| } | |
| return [ | |
| hcg[0], | |
| s * 100, | |
| l * 100 | |
| ]; | |
| }; | |
| convert.hcg.hwb = function (hcg) { | |
| var c = hcg[1] / 100; | |
| var g = hcg[2] / 100; | |
| var v = c + g * (1 - c); | |
| return [ | |
| hcg[0], | |
| (v - c) * 100, | |
| (1 - v) * 100 | |
| ]; | |
| }; | |
| convert.hwb.hcg = function (hwb) { | |
| var w = hwb[1] / 100; | |
| var b = hwb[2] / 100; | |
| var v = 1 - b; | |
| var c = v - w; | |
| var g = 0; | |
| if (c < 1) { | |
| g = (v - c) / (1 - c); | |
| } | |
| return [ | |
| hwb[0], | |
| c * 100, | |
| g * 100 | |
| ]; | |
| }; | |
| convert.apple.rgb = function (apple) { | |
| return [ | |
| apple[0] / 65535 * 255, | |
| apple[1] / 65535 * 255, | |
| apple[2] / 65535 * 255 | |
| ]; | |
| }; | |
| convert.rgb.apple = function (rgb) { | |
| return [ | |
| rgb[0] / 255 * 65535, | |
| rgb[1] / 255 * 65535, | |
| rgb[2] / 255 * 65535 | |
| ]; | |
| }; | |
| convert.gray.rgb = function (args) { | |
| return [ | |
| args[0] / 100 * 255, | |
| args[0] / 100 * 255, | |
| args[0] / 100 * 255 | |
| ]; | |
| }; | |
| convert.gray.hsl = convert.gray.hsv = function (args) { | |
| return [ | |
| 0, | |
| 0, | |
| args[0] | |
| ]; | |
| }; | |
| convert.gray.hwb = function (gray) { | |
| return [ | |
| 0, | |
| 100, | |
| gray[0] | |
| ]; | |
| }; | |
| convert.gray.cmyk = function (gray) { | |
| return [ | |
| 0, | |
| 0, | |
| 0, | |
| gray[0] | |
| ]; | |
| }; | |
| convert.gray.lab = function (gray) { | |
| return [ | |
| gray[0], | |
| 0, | |
| 0 | |
| ]; | |
| }; | |
| convert.gray.hex = function (gray) { | |
| var val = Math.round(gray[0] / 100 * 255) & 255; | |
| var integer = (val << 16) + (val << 8) + val; | |
| var string = integer.toString(16).toUpperCase(); | |
| return '000000'.substring(string.length) + string; | |
| }; | |
| convert.rgb.gray = function (rgb) { | |
| var val = (rgb[0] + rgb[1] + rgb[2]) / 3; | |
| return [val / 255 * 100]; | |
| }; | |
| }, | |
| '5': function (require, module, exports, global) { | |
| 'use strict'; | |
| var conversions = require('4'); | |
| var models = Object.keys(conversions); | |
| function buildGraph() { | |
| var graph = {}; | |
| for (var len = models.length, i = 0; i < len; i++) { | |
| graph[models[i]] = { | |
| distance: -1, | |
| parent: null | |
| }; | |
| } | |
| return graph; | |
| } | |
| function deriveBFS(fromModel) { | |
| var graph = buildGraph(); | |
| var queue = [fromModel]; | |
| graph[fromModel].distance = 0; | |
| while (queue.length) { | |
| var current = queue.pop(); | |
| var adjacents = Object.keys(conversions[current]); | |
| for (var len = adjacents.length, i = 0; i < len; i++) { | |
| var adjacent = adjacents[i]; | |
| var node = graph[adjacent]; | |
| if (node.distance === -1) { | |
| node.distance = graph[current].distance + 1; | |
| node.parent = current; | |
| queue.unshift(adjacent); | |
| } | |
| } | |
| } | |
| return graph; | |
| } | |
| function link(from, to) { | |
| return function (args) { | |
| return to(from(args)); | |
| }; | |
| } | |
| function wrapConversion(toModel, graph) { | |
| var path = [ | |
| graph[toModel].parent, | |
| toModel | |
| ]; | |
| var fn = conversions[graph[toModel].parent][toModel]; | |
| var cur = graph[toModel].parent; | |
| while (graph[cur].parent) { | |
| path.unshift(graph[cur].parent); | |
| fn = link(conversions[graph[cur].parent][cur], fn); | |
| cur = graph[cur].parent; | |
| } | |
| fn.conversion = path; | |
| return fn; | |
| } | |
| module.exports = function (fromModel) { | |
| var graph = deriveBFS(fromModel); | |
| var conversion = {}; | |
| var models = Object.keys(graph); | |
| for (var len = models.length, i = 0; i < len; i++) { | |
| var toModel = models[i]; | |
| var node = graph[toModel]; | |
| if (node.parent === null) { | |
| continue; | |
| } | |
| conversion[toModel] = wrapConversion(toModel, graph); | |
| } | |
| return conversion; | |
| }; | |
| }, | |
| '6': function (require, module, exports, global) { | |
| 'use strict'; | |
| module.exports = { | |
| 'aliceblue': [ | |
| 240, | |
| 248, | |
| 255 | |
| ], | |
| 'antiquewhite': [ | |
| 250, | |
| 235, | |
| 215 | |
| ], | |
| 'aqua': [ | |
| 0, | |
| 255, | |
| 255 | |
| ], | |
| 'aquamarine': [ | |
| 127, | |
| 255, | |
| 212 | |
| ], | |
| 'azure': [ | |
| 240, | |
| 255, | |
| 255 | |
| ], | |
| 'beige': [ | |
| 245, | |
| 245, | |
| 220 | |
| ], | |
| 'bisque': [ | |
| 255, | |
| 228, | |
| 196 | |
| ], | |
| 'black': [ | |
| 0, | |
| 0, | |
| 0 | |
| ], | |
| 'blanchedalmond': [ | |
| 255, | |
| 235, | |
| 205 | |
| ], | |
| 'blue': [ | |
| 0, | |
| 0, | |
| 255 | |
| ], | |
| 'blueviolet': [ | |
| 138, | |
| 43, | |
| 226 | |
| ], | |
| 'brown': [ | |
| 165, | |
| 42, | |
| 42 | |
| ], | |
| 'burlywood': [ | |
| 222, | |
| 184, | |
| 135 | |
| ], | |
| 'cadetblue': [ | |
| 95, | |
| 158, | |
| 160 | |
| ], | |
| 'chartreuse': [ | |
| 127, | |
| 255, | |
| 0 | |
| ], | |
| 'chocolate': [ | |
| 210, | |
| 105, | |
| 30 | |
| ], | |
| 'coral': [ | |
| 255, | |
| 127, | |
| 80 | |
| ], | |
| 'cornflowerblue': [ | |
| 100, | |
| 149, | |
| 237 | |
| ], | |
| 'cornsilk': [ | |
| 255, | |
| 248, | |
| 220 | |
| ], | |
| 'crimson': [ | |
| 220, | |
| 20, | |
| 60 | |
| ], | |
| 'cyan': [ | |
| 0, | |
| 255, | |
| 255 | |
| ], | |
| 'darkblue': [ | |
| 0, | |
| 0, | |
| 139 | |
| ], | |
| 'darkcyan': [ | |
| 0, | |
| 139, | |
| 139 | |
| ], | |
| 'darkgoldenrod': [ | |
| 184, | |
| 134, | |
| 11 | |
| ], | |
| 'darkgray': [ | |
| 169, | |
| 169, | |
| 169 | |
| ], | |
| 'darkgreen': [ | |
| 0, | |
| 100, | |
| 0 | |
| ], | |
| 'darkgrey': [ | |
| 169, | |
| 169, | |
| 169 | |
| ], | |
| 'darkkhaki': [ | |
| 189, | |
| 183, | |
| 107 | |
| ], | |
| 'darkmagenta': [ | |
| 139, | |
| 0, | |
| 139 | |
| ], | |
| 'darkolivegreen': [ | |
| 85, | |
| 107, | |
| 47 | |
| ], | |
| 'darkorange': [ | |
| 255, | |
| 140, | |
| 0 | |
| ], | |
| 'darkorchid': [ | |
| 153, | |
| 50, | |
| 204 | |
| ], | |
| 'darkred': [ | |
| 139, | |
| 0, | |
| 0 | |
| ], | |
| 'darksalmon': [ | |
| 233, | |
| 150, | |
| 122 | |
| ], | |
| 'darkseagreen': [ | |
| 143, | |
| 188, | |
| 143 | |
| ], | |
| 'darkslateblue': [ | |
| 72, | |
| 61, | |
| 139 | |
| ], | |
| 'darkslategray': [ | |
| 47, | |
| 79, | |
| 79 | |
| ], | |
| 'darkslategrey': [ | |
| 47, | |
| 79, | |
| 79 | |
| ], | |
| 'darkturquoise': [ | |
| 0, | |
| 206, | |
| 209 | |
| ], | |
| 'darkviolet': [ | |
| 148, | |
| 0, | |
| 211 | |
| ], | |
| 'deeppink': [ | |
| 255, | |
| 20, | |
| 147 | |
| ], | |
| 'deepskyblue': [ | |
| 0, | |
| 191, | |
| 255 | |
| ], | |
| 'dimgray': [ | |
| 105, | |
| 105, | |
| 105 | |
| ], | |
| 'dimgrey': [ | |
| 105, | |
| 105, | |
| 105 | |
| ], | |
| 'dodgerblue': [ | |
| 30, | |
| 144, | |
| 255 | |
| ], | |
| 'firebrick': [ | |
| 178, | |
| 34, | |
| 34 | |
| ], | |
| 'floralwhite': [ | |
| 255, | |
| 250, | |
| 240 | |
| ], | |
| 'forestgreen': [ | |
| 34, | |
| 139, | |
| 34 | |
| ], | |
| 'fuchsia': [ | |
| 255, | |
| 0, | |
| 255 | |
| ], | |
| 'gainsboro': [ | |
| 220, | |
| 220, | |
| 220 | |
| ], | |
| 'ghostwhite': [ | |
| 248, | |
| 248, | |
| 255 | |
| ], | |
| 'gold': [ | |
| 255, | |
| 215, | |
| 0 | |
| ], | |
| 'goldenrod': [ | |
| 218, | |
| 165, | |
| 32 | |
| ], | |
| 'gray': [ | |
| 128, | |
| 128, | |
| 128 | |
| ], | |
| 'green': [ | |
| 0, | |
| 128, | |
| 0 | |
| ], | |
| 'greenyellow': [ | |
| 173, | |
| 255, | |
| 47 | |
| ], | |
| 'grey': [ | |
| 128, | |
| 128, | |
| 128 | |
| ], | |
| 'honeydew': [ | |
| 240, | |
| 255, | |
| 240 | |
| ], | |
| 'hotpink': [ | |
| 255, | |
| 105, | |
| 180 | |
| ], | |
| 'indianred': [ | |
| 205, | |
| 92, | |
| 92 | |
| ], | |
| 'indigo': [ | |
| 75, | |
| 0, | |
| 130 | |
| ], | |
| 'ivory': [ | |
| 255, | |
| 255, | |
| 240 | |
| ], | |
| 'khaki': [ | |
| 240, | |
| 230, | |
| 140 | |
| ], | |
| 'lavender': [ | |
| 230, | |
| 230, | |
| 250 | |
| ], | |
| 'lavenderblush': [ | |
| 255, | |
| 240, | |
| 245 | |
| ], | |
| 'lawngreen': [ | |
| 124, | |
| 252, | |
| 0 | |
| ], | |
| 'lemonchiffon': [ | |
| 255, | |
| 250, | |
| 205 | |
| ], | |
| 'lightblue': [ | |
| 173, | |
| 216, | |
| 230 | |
| ], | |
| 'lightcoral': [ | |
| 240, | |
| 128, | |
| 128 | |
| ], | |
| 'lightcyan': [ | |
| 224, | |
| 255, | |
| 255 | |
| ], | |
| 'lightgoldenrodyellow': [ | |
| 250, | |
| 250, | |
| 210 | |
| ], | |
| 'lightgray': [ | |
| 211, | |
| 211, | |
| 211 | |
| ], | |
| 'lightgreen': [ | |
| 144, | |
| 238, | |
| 144 | |
| ], | |
| 'lightgrey': [ | |
| 211, | |
| 211, | |
| 211 | |
| ], | |
| 'lightpink': [ | |
| 255, | |
| 182, | |
| 193 | |
| ], | |
| 'lightsalmon': [ | |
| 255, | |
| 160, | |
| 122 | |
| ], | |
| 'lightseagreen': [ | |
| 32, | |
| 178, | |
| 170 | |
| ], | |
| 'lightskyblue': [ | |
| 135, | |
| 206, | |
| 250 | |
| ], | |
| 'lightslategray': [ | |
| 119, | |
| 136, | |
| 153 | |
| ], | |
| 'lightslategrey': [ | |
| 119, | |
| 136, | |
| 153 | |
| ], | |
| 'lightsteelblue': [ | |
| 176, | |
| 196, | |
| 222 | |
| ], | |
| 'lightyellow': [ | |
| 255, | |
| 255, | |
| 224 | |
| ], | |
| 'lime': [ | |
| 0, | |
| 255, | |
| 0 | |
| ], | |
| 'limegreen': [ | |
| 50, | |
| 205, | |
| 50 | |
| ], | |
| 'linen': [ | |
| 250, | |
| 240, | |
| 230 | |
| ], | |
| 'magenta': [ | |
| 255, | |
| 0, | |
| 255 | |
| ], | |
| 'maroon': [ | |
| 128, | |
| 0, | |
| 0 | |
| ], | |
| 'mediumaquamarine': [ | |
| 102, | |
| 205, | |
| 170 | |
| ], | |
| 'mediumblue': [ | |
| 0, | |
| 0, | |
| 205 | |
| ], | |
| 'mediumorchid': [ | |
| 186, | |
| 85, | |
| 211 | |
| ], | |
| 'mediumpurple': [ | |
| 147, | |
| 112, | |
| 219 | |
| ], | |
| 'mediumseagreen': [ | |
| 60, | |
| 179, | |
| 113 | |
| ], | |
| 'mediumslateblue': [ | |
| 123, | |
| 104, | |
| 238 | |
| ], | |
| 'mediumspringgreen': [ | |
| 0, | |
| 250, | |
| 154 | |
| ], | |
| 'mediumturquoise': [ | |
| 72, | |
| 209, | |
| 204 | |
| ], | |
| 'mediumvioletred': [ | |
| 199, | |
| 21, | |
| 133 | |
| ], | |
| 'midnightblue': [ | |
| 25, | |
| 25, | |
| 112 | |
| ], | |
| 'mintcream': [ | |
| 245, | |
| 255, | |
| 250 | |
| ], | |
| 'mistyrose': [ | |
| 255, | |
| 228, | |
| 225 | |
| ], | |
| 'moccasin': [ | |
| 255, | |
| 228, | |
| 181 | |
| ], | |
| 'navajowhite': [ | |
| 255, | |
| 222, | |
| 173 | |
| ], | |
| 'navy': [ | |
| 0, | |
| 0, | |
| 128 | |
| ], | |
| 'oldlace': [ | |
| 253, | |
| 245, | |
| 230 | |
| ], | |
| 'olive': [ | |
| 128, | |
| 128, | |
| 0 | |
| ], | |
| 'olivedrab': [ | |
| 107, | |
| 142, | |
| 35 | |
| ], | |
| 'orange': [ | |
| 255, | |
| 165, | |
| 0 | |
| ], | |
| 'orangered': [ | |
| 255, | |
| 69, | |
| 0 | |
| ], | |
| 'orchid': [ | |
| 218, | |
| 112, | |
| 214 | |
| ], | |
| 'palegoldenrod': [ | |
| 238, | |
| 232, | |
| 170 | |
| ], | |
| 'palegreen': [ | |
| 152, | |
| 251, | |
| 152 | |
| ], | |
| 'paleturquoise': [ | |
| 175, | |
| 238, | |
| 238 | |
| ], | |
| 'palevioletred': [ | |
| 219, | |
| 112, | |
| 147 | |
| ], | |
| 'papayawhip': [ | |
| 255, | |
| 239, | |
| 213 | |
| ], | |
| 'peachpuff': [ | |
| 255, | |
| 218, | |
| 185 | |
| ], | |
| 'peru': [ | |
| 205, | |
| 133, | |
| 63 | |
| ], | |
| 'pink': [ | |
| 255, | |
| 192, | |
| 203 | |
| ], | |
| 'plum': [ | |
| 221, | |
| 160, | |
| 221 | |
| ], | |
| 'powderblue': [ | |
| 176, | |
| 224, | |
| 230 | |
| ], | |
| 'purple': [ | |
| 128, | |
| 0, | |
| 128 | |
| ], | |
| 'rebeccapurple': [ | |
| 102, | |
| 51, | |
| 153 | |
| ], | |
| 'red': [ | |
| 255, | |
| 0, | |
| 0 | |
| ], | |
| 'rosybrown': [ | |
| 188, | |
| 143, | |
| 143 | |
| ], | |
| 'royalblue': [ | |
| 65, | |
| 105, | |
| 225 | |
| ], | |
| 'saddlebrown': [ | |
| 139, | |
| 69, | |
| 19 | |
| ], | |
| 'salmon': [ | |
| 250, | |
| 128, | |
| 114 | |
| ], | |
| 'sandybrown': [ | |
| 244, | |
| 164, | |
| 96 | |
| ], | |
| 'seagreen': [ | |
| 46, | |
| 139, | |
| 87 | |
| ], | |
| 'seashell': [ | |
| 255, | |
| 245, | |
| 238 | |
| ], | |
| 'sienna': [ | |
| 160, | |
| 82, | |
| 45 | |
| ], | |
| 'silver': [ | |
| 192, | |
| 192, | |
| 192 | |
| ], | |
| 'skyblue': [ | |
| 135, | |
| 206, | |
| 235 | |
| ], | |
| 'slateblue': [ | |
| 106, | |
| 90, | |
| 205 | |
| ], | |
| 'slategray': [ | |
| 112, | |
| 128, | |
| 144 | |
| ], | |
| 'slategrey': [ | |
| 112, | |
| 128, | |
| 144 | |
| ], | |
| 'snow': [ | |
| 255, | |
| 250, | |
| 250 | |
| ], | |
| 'springgreen': [ | |
| 0, | |
| 255, | |
| 127 | |
| ], | |
| 'steelblue': [ | |
| 70, | |
| 130, | |
| 180 | |
| ], | |
| 'tan': [ | |
| 210, | |
| 180, | |
| 140 | |
| ], | |
| 'teal': [ | |
| 0, | |
| 128, | |
| 128 | |
| ], | |
| 'thistle': [ | |
| 216, | |
| 191, | |
| 216 | |
| ], | |
| 'tomato': [ | |
| 255, | |
| 99, | |
| 71 | |
| ], | |
| 'turquoise': [ | |
| 64, | |
| 224, | |
| 208 | |
| ], | |
| 'violet': [ | |
| 238, | |
| 130, | |
| 238 | |
| ], | |
| 'wheat': [ | |
| 245, | |
| 222, | |
| 179 | |
| ], | |
| 'white': [ | |
| 255, | |
| 255, | |
| 255 | |
| ], | |
| 'whitesmoke': [ | |
| 245, | |
| 245, | |
| 245 | |
| ], | |
| 'yellow': [ | |
| 255, | |
| 255, | |
| 0 | |
| ], | |
| 'yellowgreen': [ | |
| 154, | |
| 205, | |
| 50 | |
| ] | |
| }; | |
| } | |
| }, this)); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment