| /* |
| |
| The MIT License (MIT) |
| |
| Original Library |
| - Copyright (c) Marak Squires |
| |
| Additional functionality |
| - Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.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. |
| |
| */ |
| |
| var colors = {}; |
| module['exports'] = colors; |
| |
| colors.themes = {}; |
| |
| var util = require('util'); |
| var ansiStyles = colors.styles = require('./styles'); |
| var defineProps = Object.defineProperties; |
| var newLineRegex = new RegExp(/[\r\n]+/g); |
| |
| colors.supportsColor = require('./system/supports-colors').supportsColor; |
| |
| if (typeof colors.enabled === 'undefined') { |
| colors.enabled = colors.supportsColor() !== false; |
| } |
| |
| colors.enable = function() { |
| colors.enabled = true; |
| }; |
| |
| colors.disable = function() { |
| colors.enabled = false; |
| }; |
| |
| colors.stripColors = colors.strip = function(str) { |
| return ('' + str).replace(/\x1B\[\d+m/g, ''); |
| }; |
| |
| // eslint-disable-next-line no-unused-vars |
| var stylize = colors.stylize = function stylize(str, style) { |
| if (!colors.enabled) { |
| return str+''; |
| } |
| |
| var styleMap = ansiStyles[style]; |
| |
| // Stylize should work for non-ANSI styles, too |
| if(!styleMap && style in colors){ |
| // Style maps like trap operate as functions on strings; |
| // they don't have properties like open or close. |
| return colors[style](str); |
| } |
| |
| return styleMap.open + str + styleMap.close; |
| }; |
| |
| var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g; |
| var escapeStringRegexp = function(str) { |
| if (typeof str !== 'string') { |
| throw new TypeError('Expected a string'); |
| } |
| return str.replace(matchOperatorsRe, '\\$&'); |
| }; |
| |
| function build(_styles) { |
| var builder = function builder() { |
| return applyStyle.apply(builder, arguments); |
| }; |
| builder._styles = _styles; |
| // __proto__ is used because we must return a function, but there is |
| // no way to create a function with a different prototype. |
| builder.__proto__ = proto; |
| return builder; |
| } |
| |
| var styles = (function() { |
| var ret = {}; |
| ansiStyles.grey = ansiStyles.gray; |
| Object.keys(ansiStyles).forEach(function(key) { |
| ansiStyles[key].closeRe = |
| new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g'); |
| ret[key] = { |
| get: function() { |
| return build(this._styles.concat(key)); |
| }, |
| }; |
| }); |
| return ret; |
| })(); |
| |
| var proto = defineProps(function colors() {}, styles); |
| |
| function applyStyle() { |
| var args = Array.prototype.slice.call(arguments); |
| |
| var str = args.map(function(arg) { |
| // Use weak equality check so we can colorize null/undefined in safe mode |
| if (arg != null && arg.constructor === String) { |
| return arg; |
| } else { |
| return util.inspect(arg); |
| } |
| }).join(' '); |
| |
| if (!colors.enabled || !str) { |
| return str; |
| } |
| |
| var newLinesPresent = str.indexOf('\n') != -1; |
| |
| var nestedStyles = this._styles; |
| |
| var i = nestedStyles.length; |
| while (i--) { |
| var code = ansiStyles[nestedStyles[i]]; |
| str = code.open + str.replace(code.closeRe, code.open) + code.close; |
| if (newLinesPresent) { |
| str = str.replace(newLineRegex, function(match) { |
| return code.close + match + code.open; |
| }); |
| } |
| } |
| |
| return str; |
| } |
| |
| colors.setTheme = function(theme) { |
| if (typeof theme === 'string') { |
| console.log('colors.setTheme now only accepts an object, not a string. ' + |
| 'If you are trying to set a theme from a file, it is now your (the ' + |
| 'caller\'s) responsibility to require the file. The old syntax ' + |
| 'looked like colors.setTheme(__dirname + ' + |
| '\'/../themes/generic-logging.js\'); The new syntax looks like '+ |
| 'colors.setTheme(require(__dirname + ' + |
| '\'/../themes/generic-logging.js\'));'); |
| return; |
| } |
| for (var style in theme) { |
| (function(style) { |
| colors[style] = function(str) { |
| if (typeof theme[style] === 'object') { |
| var out = str; |
| for (var i in theme[style]) { |
| out = colors[theme[style][i]](out); |
| } |
| return out; |
| } |
| return colors[theme[style]](str); |
| }; |
| })(style); |
| } |
| }; |
| |
| function init() { |
| var ret = {}; |
| Object.keys(styles).forEach(function(name) { |
| ret[name] = { |
| get: function() { |
| return build([name]); |
| }, |
| }; |
| }); |
| return ret; |
| } |
| |
| var sequencer = function sequencer(map, str) { |
| var exploded = str.split(''); |
| exploded = exploded.map(map); |
| return exploded.join(''); |
| }; |
| |
| // custom formatter methods |
| colors.trap = require('./custom/trap'); |
| colors.zalgo = require('./custom/zalgo'); |
| |
| // maps |
| colors.maps = {}; |
| colors.maps.america = require('./maps/america')(colors); |
| colors.maps.zebra = require('./maps/zebra')(colors); |
| colors.maps.rainbow = require('./maps/rainbow')(colors); |
| colors.maps.random = require('./maps/random')(colors); |
| |
| for (var map in colors.maps) { |
| (function(map) { |
| colors[map] = function(str) { |
| return sequencer(colors.maps[map], str); |
| }; |
| })(map); |
| } |
| |
| defineProps(colors, init()); |