aboutsummaryrefslogtreecommitdiff
path: root/node_modules/clap
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/clap')
-rw-r--r--node_modules/clap/HISTORY.md38
-rw-r--r--node_modules/clap/LICENSE19
-rw-r--r--node_modules/clap/README.md11
-rw-r--r--node_modules/clap/index.js950
-rw-r--r--node_modules/clap/node_modules/ansi-styles/index.js65
-rw-r--r--node_modules/clap/node_modules/ansi-styles/license21
-rw-r--r--node_modules/clap/node_modules/ansi-styles/package.json50
-rw-r--r--node_modules/clap/node_modules/ansi-styles/readme.md86
-rw-r--r--node_modules/clap/node_modules/chalk/index.js116
-rw-r--r--node_modules/clap/node_modules/chalk/license21
-rw-r--r--node_modules/clap/node_modules/chalk/package.json70
-rw-r--r--node_modules/clap/node_modules/chalk/readme.md213
-rw-r--r--node_modules/clap/node_modules/supports-color/index.js50
-rw-r--r--node_modules/clap/node_modules/supports-color/license21
-rw-r--r--node_modules/clap/node_modules/supports-color/package.json49
-rw-r--r--node_modules/clap/node_modules/supports-color/readme.md36
-rw-r--r--node_modules/clap/package.json36
17 files changed, 1852 insertions, 0 deletions
diff --git a/node_modules/clap/HISTORY.md b/node_modules/clap/HISTORY.md
new file mode 100644
index 00000000..e0007737
--- /dev/null
+++ b/node_modules/clap/HISTORY.md
@@ -0,0 +1,38 @@
+## 1.2.3 (September 20, 2017)
+
+- Rolled back passing params to `args()` back as array
+
+## 1.2.2 (September 18, 2017)
+
+- Fixed context passed to `Command#args()`, now it's a command as expected (#10)
+- Fixed consuming of literal arguments that wrongly concating with other arguments (i.e. anything going after `--` concats with arguments before `--`)
+
+## 1.2.1 (September 18, 2017)
+
+- Fixed multi value option processing (@tyanas & @smelukov, #9)
+
+## 1.2.0 (June 13, 2017)
+
+- Improved multi value option processing (@smelukov, #7)
+
+## 1.1.3 (March 16, 2017)
+
+- Fixed `Command#normalize()` issue when set a value for option with argument and no default value
+
+## 1.1.2 (December 3, 2016)
+
+- Fix exception on `Command#normalize()`
+
+## 1.1.1 (May 10, 2016)
+
+- Fix `chalk` version
+
+## 1.1.0 (March 19, 2016)
+
+- `Command#extend()` accepts parameters for passed function now
+- Implement `Command#end()` method to return to parent command definition
+- Fix suggestion bugs and add tests
+
+## 1.0.0 (Oct 12, 2014)
+
+- Initial release
diff --git a/node_modules/clap/LICENSE b/node_modules/clap/LICENSE
new file mode 100644
index 00000000..d3e3cd3a
--- /dev/null
+++ b/node_modules/clap/LICENSE
@@ -0,0 +1,19 @@
+Copyright (C) 2014-2016 by Roman Dvornov <rdvornov@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.
diff --git a/node_modules/clap/README.md b/node_modules/clap/README.md
new file mode 100644
index 00000000..fcc31e56
--- /dev/null
+++ b/node_modules/clap/README.md
@@ -0,0 +1,11 @@
+[![NPM version](https://img.shields.io/npm/v/clap.svg)](https://www.npmjs.com/package/clap)
+[![Dependency Status](https://img.shields.io/david/lahmatiy/clap.svg)](https://david-dm.org/lahmatiy/clap)
+[![Build Status](https://travis-ci.org/lahmatiy/clap.svg?branch=master)](https://travis-ci.org/lahmatiy/clap)
+
+# Clap.js
+
+Argument parser for command-line interfaces. It primary target to large tool sets that provides a lot of subcommands. Support for argument coercion and completion makes task run much easer, even if you doesn't use CLI.
+
+Inspired by TJ Holowaychuk [Commander](https://github.com/visionmedia/commander.js).
+
+[TODO: Complete readme]
diff --git a/node_modules/clap/index.js b/node_modules/clap/index.js
new file mode 100644
index 00000000..5d48311c
--- /dev/null
+++ b/node_modules/clap/index.js
@@ -0,0 +1,950 @@
+var MAX_LINE_WIDTH = process.stdout.columns || 200;
+var MIN_OFFSET = 25;
+
+var errorHandler;
+var commandsPath;
+
+var reAstral = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+var ansiRegex = /\x1B\[([0-9]{1,3}(;[0-9]{1,3})*)?[m|K]/g;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function stringLength(str){
+ return str
+ .replace(ansiRegex, '')
+ .replace(reAstral, ' ')
+ .length;
+}
+
+function camelize(name){
+ return name.replace(/-(.)/g, function(m, ch){
+ return ch.toUpperCase();
+ });
+}
+
+function assign(dest, source){
+ for (var key in source)
+ if (hasOwnProperty.call(source, key))
+ dest[key] = source[key];
+
+ return dest;
+}
+
+function returnFirstArg(value){
+ return value;
+}
+
+function pad(width, str){
+ return str + Array(Math.max(0, width - stringLength(str)) + 1).join(' ');
+}
+
+function noop(){
+ // nothing todo
+}
+
+function parseParams(str){
+ // params [..<required>] [..[optional]]
+ // <foo> - require
+ // [foo] - optional
+ var tmp;
+ var left = str.trim();
+ var result = {
+ minArgsCount: 0,
+ maxArgsCount: 0,
+ args: []
+ };
+
+ do {
+ tmp = left;
+ left = left.replace(/^<([a-zA-Z][a-zA-Z0-9\-\_]*)>\s*/, function(m, name){
+ result.args.push(new Argument(name, true));
+ result.minArgsCount++;
+ result.maxArgsCount++;
+
+ return '';
+ });
+ }
+ while (tmp != left);
+
+ do {
+ tmp = left;
+ left = left.replace(/^\[([a-zA-Z][a-zA-Z0-9\-\_]*)\]\s*/, function(m, name){
+ result.args.push(new Argument(name, false));
+ result.maxArgsCount++;
+
+ return '';
+ });
+ }
+ while (tmp != left);
+
+ if (left)
+ throw new SyntaxError('Bad parameter description: ' + str);
+
+ return result.args.length ? result : false;
+}
+
+/**
+* @class
+*/
+
+var SyntaxError = function(message){
+ this.message = message;
+};
+SyntaxError.prototype = Object.create(Error.prototype);
+SyntaxError.prototype.name = 'SyntaxError';
+SyntaxError.prototype.clap = true;
+
+/**
+* @class
+*/
+var Argument = function(name, required){
+ this.name = name;
+ this.required = required;
+};
+Argument.prototype = {
+ required: false,
+ name: '',
+ normalize: returnFirstArg,
+ suggest: function(){
+ return [];
+ }
+};
+
+/**
+* @class
+* @param {string} usage
+* @param {string} description
+*/
+var Option = function(usage, description){
+ var self = this;
+ var params;
+ var left = usage.trim()
+ // short usage
+ // -x
+ .replace(/^-([a-zA-Z])(?:\s*,\s*|\s+)/, function(m, name){
+ self.short = name;
+
+ return '';
+ })
+ // long usage
+ // --flag
+ // --no-flag - invert value if flag is boolean
+ .replace(/^--([a-zA-Z][a-zA-Z0-9\-\_]+)\s*/, function(m, name){
+ self.long = name;
+ self.name = name.replace(/(^|-)no-/, '$1');
+ self.defValue = self.name != self.long;
+
+ return '';
+ });
+
+ if (!this.long)
+ throw new SyntaxError('Usage has no long name: ' + usage);
+
+ try {
+ params = parseParams(left);
+ } catch(e) {
+ throw new SyntaxError('Bad paramenter description in usage for option: ' + usage, e);
+ }
+
+ if (params)
+ {
+ left = '';
+ this.name = this.long;
+ this.defValue = undefined;
+
+ assign(this, params);
+ }
+
+ if (left)
+ throw new SyntaxError('Bad usage description for option: ' + usage);
+
+ if (!this.name)
+ this.name = this.long;
+
+ this.description = description || '';
+ this.usage = usage.trim();
+ this.camelName = camelize(this.name);
+};
+
+Option.prototype = {
+ name: '',
+ description: '',
+ short: '',
+ long: '',
+
+ beforeInit: false,
+ required: false,
+ minArgsCount: 0,
+ maxArgsCount: 0,
+ args: null,
+
+ defValue: undefined,
+ normalize: returnFirstArg
+};
+
+
+//
+// Command
+//
+
+function createOption(usage, description, opt_1, opt_2){
+ var option = new Option(usage, description);
+
+ // if (option.bool && arguments.length > 2)
+ // throw new SyntaxError('bool flags can\'t has default value or validator');
+
+ if (arguments.length == 3)
+ {
+ if (opt_1 && opt_1.constructor === Object)
+ {
+ for (var key in opt_1)
+ if (key == 'normalize' ||
+ key == 'defValue' ||
+ key == 'beforeInit')
+ option[key] = opt_1[key];
+
+ // old name for `beforeInit` setting is `hot`
+ if (opt_1.hot)
+ option.beforeInit = true;
+ }
+ else
+ {
+ if (typeof opt_1 == 'function')
+ option.normalize = opt_1;
+ else
+ option.defValue = opt_1;
+ }
+ }
+
+ if (arguments.length == 4)
+ {
+ if (typeof opt_1 == 'function')
+ option.normalize = opt_1;
+
+ option.defValue = opt_2;
+ }
+
+ return option;
+}
+
+function addOptionToCommand(command, option){
+ var commandOption;
+
+ // short
+ if (option.short)
+ {
+ commandOption = command.short[option.short];
+
+ if (commandOption)
+ throw new SyntaxError('Short option name -' + option.short + ' already in use by ' + commandOption.usage + ' ' + commandOption.description);
+
+ command.short[option.short] = option;
+ }
+
+ // long
+ commandOption = command.long[option.long];
+
+ if (commandOption)
+ throw new SyntaxError('Long option --' + option.long + ' already in use by ' + commandOption.usage + ' ' + commandOption.description);
+
+ command.long[option.long] = option;
+
+ // camel
+ commandOption = command.options[option.camelName];
+
+ if (commandOption)
+ throw new SyntaxError('Name option ' + option.camelName + ' already in use by ' + commandOption.usage + ' ' + commandOption.description);
+
+ command.options[option.camelName] = option;
+
+ // set default value
+ if (typeof option.defValue != 'undefined')
+ command.setOption(option.camelName, option.defValue, true);
+
+ // add to suggestions
+ command.suggestions.push('--' + option.long);
+
+ return option;
+}
+
+function findVariants(obj, entry){
+ return obj.suggestions.filter(function(item){
+ return item.substr(0, entry.length) == entry;
+ });
+}
+
+function processArgs(command, args, suggest){
+ function processOption(option, command){
+ var params = [];
+
+ if (option.maxArgsCount)
+ {
+ for (var j = 0; j < option.maxArgsCount; j++)
+ {
+ var suggestPoint = suggest && i + 1 + j >= args.length - 1;
+ var nextToken = args[i + 1];
+
+ // TODO: suggestions for options
+ if (suggestPoint)
+ {
+ // search for suggest
+ noSuggestions = true;
+ i = args.length;
+ return;
+ }
+
+ if (!nextToken || nextToken[0] == '-')
+ break;
+
+ params.push(args[++i]);
+ }
+
+ if (params.length < option.minArgsCount)
+ throw new SyntaxError('Option ' + token + ' should be used with at least ' + option.minArgsCount + ' argument(s)\nUsage: ' + option.usage);
+
+ if (option.maxArgsCount == 1)
+ params = params[0];
+ }
+ else
+ {
+ params = !option.defValue;
+ }
+
+ //command.values[option.camelName] = newValue;
+ resultToken.options.push({
+ option: option,
+ value: params
+ });
+ }
+
+ var resultToken = {
+ command: command,
+ args: [],
+ literalArgs: [],
+ options: []
+ };
+ var result = [resultToken];
+
+ var suggestStartsWith = '';
+ var noSuggestions = false;
+ var collectArgs = false;
+ var commandArgs = [];
+ var noOptionsYet = true;
+ var option;
+
+ commandsPath = [command.name];
+
+ for (var i = 0; i < args.length; i++)
+ {
+ var suggestPoint = suggest && i == args.length - 1;
+ var token = args[i];
+
+ if (collectArgs)
+ {
+ commandArgs.push(token);
+ continue;
+ }
+
+ if (suggestPoint && (token == '--' || token == '-' || token[0] != '-'))
+ {
+ suggestStartsWith = token;
+ break; // returns long option & command list outside the loop
+ }
+
+ if (token == '--')
+ {
+ resultToken.args = commandArgs;
+ commandArgs = [];
+ noOptionsYet = false;
+ collectArgs = true;
+ continue;
+ }
+
+ if (token[0] == '-')
+ {
+ noOptionsYet = false;
+
+ if (commandArgs.length)
+ {
+ //command.args_.apply(command, commandArgs);
+ resultToken.args = commandArgs;
+ commandArgs = [];
+ }
+
+ if (token[1] == '-')
+ {
+ // long option
+ option = command.long[token.substr(2)];
+
+ if (!option)
+ {
+ // option doesn't exist
+ if (suggestPoint)
+ return findVariants(command, token);
+ else
+ throw new SyntaxError('Unknown option: ' + token);
+ }
+
+ // process option
+ processOption(option, command);
+ }
+ else
+ {
+ // short flags sequence
+ if (!/^-[a-zA-Z]+$/.test(token))
+ throw new SyntaxError('Wrong short option sequence: ' + token);
+
+ if (token.length == 2)
+ {
+ option = command.short[token[1]];
+
+ if (!option)
+ throw new SyntaxError('Unknown short option name: -' + token[1]);
+
+ // single option
+ processOption(option, command);
+ }
+ else
+ {
+ // short options sequence
+ for (var j = 1; j < token.length; j++)
+ {
+ option = command.short[token[j]];
+
+ if (!option)
+ throw new SyntaxError('Unknown short option name: -' + token[j]);
+
+ if (option.maxArgsCount)
+ throw new SyntaxError('Non-boolean option -' + token[j] + ' can\'t be used in short option sequence: ' + token);
+
+ processOption(option, command);
+ }
+ }
+ }
+ }
+ else
+ {
+ if (command.commands[token] && (!command.params || commandArgs.length >= command.params.minArgsCount))
+ {
+ if (noOptionsYet)
+ {
+ resultToken.args = commandArgs;
+ commandArgs = [];
+ }
+
+ if (command.params && resultToken.args.length < command.params.minArgsCount)
+ throw new SyntaxError('Missed required argument(s) for command `' + command.name + '`');
+
+ // switch control to another command
+ command = command.commands[token];
+ noOptionsYet = true;
+
+ commandsPath.push(command.name);
+
+ resultToken = {
+ command: command,
+ args: [],
+ literalArgs: [],
+ options: []
+ };
+ result.push(resultToken);
+ }
+ else
+ {
+ if (noOptionsYet && command.params && commandArgs.length < command.params.maxArgsCount)
+ {
+ commandArgs.push(token);
+ continue;
+ }
+
+ if (suggestPoint)
+ return findVariants(command, token);
+ else
+ throw new SyntaxError('Unknown command: ' + token);
+ }
+ }
+ }
+
+ if (suggest)
+ {
+ if (collectArgs || noSuggestions)
+ return [];
+
+ return findVariants(command, suggestStartsWith);
+ }
+ else
+ {
+ if (!noOptionsYet)
+ resultToken.literalArgs = commandArgs;
+ else
+ resultToken.args = commandArgs;
+
+ if (command.params && resultToken.args.length < command.params.minArgsCount)
+ throw new SyntaxError('Missed required argument(s) for command `' + command.name + '`');
+ }
+
+ return result;
+}
+
+function setFunctionFactory(name){
+ return function(fn){
+ var property = name + '_';
+
+ if (this[property] !== noop)
+ throw new SyntaxError('Method `' + name + '` could be invoked only once');
+
+ if (typeof fn != 'function')
+ throw new SyntaxError('Value for `' + name + '` method should be a function');
+
+ this[property] = fn;
+
+ return this;
+ }
+}
+
+/**
+* @class
+*/
+var Command = function(name, params){
+ this.name = name;
+ this.params = false;
+
+ try {
+ if (params)
+ this.params = parseParams(params);
+ } catch(e) {
+ throw new SyntaxError('Bad paramenter description in command definition: ' + this.name + ' ' + params);
+ }
+
+ this.commands = {};
+
+ this.options = {};
+ this.short = {};
+ this.long = {};
+ this.values = {};
+ this.defaults_ = {};
+
+ this.suggestions = [];
+
+ this.option('-h, --help', 'Output usage information', function(){
+ this.showHelp();
+ process.exit(0);
+ }, undefined);
+};
+
+Command.prototype = {
+ params: null,
+ commands: null,
+ options: null,
+ short: null,
+ long: null,
+ values: null,
+ defaults_: null,
+ suggestions: null,
+
+ description_: '',
+ version_: '',
+ initContext_: noop,
+ init_: noop,
+ delegate_: noop,
+ action_: noop,
+ args_: noop,
+ end_: null,
+
+ option: function(usage, description, opt_1, opt_2){
+ addOptionToCommand(this, createOption.apply(null, arguments));
+
+ return this;
+ },
+ shortcut: function(usage, description, fn, opt_1, opt_2){
+ if (typeof fn != 'function')
+ throw new SyntaxError('fn should be a function');
+
+ var command = this;
+ var option = addOptionToCommand(this, createOption(usage, description, opt_1, opt_2));
+ var normalize = option.normalize;
+
+ option.normalize = function(value){
+ var values;
+
+ value = normalize.call(command, value);
+ values = fn(value);
+
+ for (var name in values)
+ if (hasOwnProperty.call(values, name))
+ if (hasOwnProperty.call(command.options, name))
+ command.setOption(name, values[name]);
+ else
+ command.values[name] = values[name];
+
+ command.values[option.name] = value;
+
+ return value;
+ };
+
+ return this;
+ },
+ hasOption: function(name){
+ return hasOwnProperty.call(this.options, name);
+ },
+ hasOptions: function(){
+ return Object.keys(this.options).length > 0;
+ },
+ setOption: function(name, value, isDefault){
+ if (!this.hasOption(name))
+ throw new SyntaxError('Option `' + name + '` is not defined');
+
+ var option = this.options[name];
+ var oldValue = this.values[name];
+ var newValue = option.normalize.call(this, value, oldValue);
+
+ this.values[name] = option.maxArgsCount ? newValue : value;
+
+ if (isDefault && !hasOwnProperty.call(this.defaults_, name))
+ this.defaults_[name] = this.values[name];
+ },
+ setOptions: function(values){
+ for (var name in values)
+ if (hasOwnProperty.call(values, name) && this.hasOption(name))
+ this.setOption(name, values[name]);
+ },
+ reset: function(){
+ this.values = {};
+
+ assign(this.values, this.defaults_);
+ },
+
+ command: function(nameOrCommand, params){
+ var name;
+ var command;
+
+ if (nameOrCommand instanceof Command)
+ {
+ command = nameOrCommand;
+ name = command.name;
+ }
+ else
+ {
+ name = nameOrCommand;
+
+ if (!/^[a-zA-Z][a-zA-Z0-9\-\_]*$/.test(name))
+ throw new SyntaxError('Wrong command name: ' + name);
+ }
+
+ // search for existing one
+ var subcommand = this.commands[name];
+
+ if (!subcommand)
+ {
+ // create new one if not exists
+ subcommand = command || new Command(name, params);
+ subcommand.end_ = this;
+ this.commands[name] = subcommand;
+ this.suggestions.push(name);
+ }
+
+ return subcommand;
+ },
+ end: function() {
+ return this.end_;
+ },
+ hasCommands: function(){
+ return Object.keys(this.commands).length > 0;
+ },
+
+ version: function(version, usage, description){
+ if (this.version_)
+ throw new SyntaxError('Version for command could be set only once');
+
+ this.version_ = version;
+ this.option(
+ usage || '-v, --version',
+ description || 'Output version',
+ function(){
+ console.log(this.version_);
+ process.exit(0);
+ },
+ undefined
+ );
+
+ return this;
+ },
+ description: function(description){
+ if (this.description_)
+ throw new SyntaxError('Description for command could be set only once');
+
+ this.description_ = description;
+
+ return this;
+ },
+
+ init: setFunctionFactory('init'),
+ initContext: setFunctionFactory('initContext'),
+ args: setFunctionFactory('args'),
+ delegate: setFunctionFactory('delegate'),
+ action: setFunctionFactory('action'),
+
+ extend: function(fn){
+ fn.apply(null, [this].concat(Array.prototype.slice.call(arguments, 1)));
+ return this;
+ },
+
+ parse: function(args, suggest){
+ if (!args)
+ args = process.argv.slice(2);
+
+ if (!errorHandler)
+ return processArgs(this, args, suggest);
+ else
+ try {
+ return processArgs(this, args, suggest);
+ } catch(e) {
+ errorHandler(e.message || e);
+ }
+ },
+ run: function(args, context){
+ var commands = this.parse(args);
+
+ if (!commands)
+ return;
+
+ var prevCommand;
+ var context = assign({}, context || this.initContext_());
+ for (var i = 0; i < commands.length; i++)
+ {
+ var item = commands[i];
+ var command = item.command;
+
+ // reset command values
+ command.reset();
+ command.context = context;
+ command.root = this;
+
+ if (prevCommand)
+ prevCommand.delegate_(command);
+
+ // apply beforeInit options
+ item.options.forEach(function(entry){
+ if (entry.option.beforeInit)
+ command.setOption(entry.option.camelName, entry.value);
+ });
+
+ command.init_(item.args.slice()); // use slice to avoid args mutation in handler
+
+ if (item.args.length)
+ command.args_(item.args.slice()); // use slice to avoid args mutation in handler
+
+ // apply regular options
+ item.options.forEach(function(entry){
+ if (!entry.option.beforeInit)
+ command.setOption(entry.option.camelName, entry.value);
+ });
+
+ prevCommand = command;
+ }
+
+ // return last command action result
+ if (command)
+ return command.action_(item.args, item.literalArgs);
+ },
+
+ normalize: function(values){
+ var result = {};
+
+ if (!values)
+ values = {};
+
+ for (var name in this.values)
+ if (hasOwnProperty.call(this.values, name))
+ result[name] = hasOwnProperty.call(values, name) && hasOwnProperty.call(this.options, name)
+ ? this.options[name].normalize.call(this, values[name])
+ : this.values[name];
+
+ for (var name in values)
+ if (hasOwnProperty.call(values, name) && !hasOwnProperty.call(result, name))
+ result[name] = values[name];
+
+ return result;
+ },
+
+ showHelp: function(){
+ console.log(showCommandHelp(this));
+ }
+};
+
+
+//
+// help
+//
+
+/**
+ * Return program help documentation.
+ *
+ * @return {String}
+ * @api private
+ */
+
+function showCommandHelp(command){
+ function breakByLines(str, offset){
+ var words = str.split(' ');
+ var maxWidth = MAX_LINE_WIDTH - offset || 0;
+ var lines = [];
+ var line = '';
+
+ while (words.length)
+ {
+ var word = words.shift();
+ if (!line || (line.length + word.length + 1) < maxWidth)
+ {
+ line += (line ? ' ' : '') + word;
+ }
+ else
+ {
+ lines.push(line);
+ words.unshift(word);
+ line = '';
+ }
+ }
+
+ lines.push(line);
+
+ return lines.map(function(line, idx){
+ return (idx && offset ? pad(offset, '') : '') + line;
+ }).join('\n');
+ }
+
+ function args(command){
+ return command.params.args.map(function(arg){
+ return arg.required
+ ? '<' + arg.name + '>'
+ : '[' + arg.name + ']';
+ }).join(' ');
+ }
+
+ function commandsHelp(){
+ if (!command.hasCommands())
+ return '';
+
+ var maxNameLength = MIN_OFFSET - 2;
+ var lines = Object.keys(command.commands).sort().map(function(name){
+ var subcommand = command.commands[name];
+
+ var line = {
+ name: chalk.green(name) + chalk.gray(
+ (subcommand.params ? ' ' + args(subcommand) : '')
+ // (subcommand.hasOptions() ? ' [options]' : '')
+ ),
+ description: subcommand.description_ || ''
+ };
+
+ maxNameLength = Math.max(maxNameLength, stringLength(line.name));
+
+ return line;
+ });
+
+ return [
+ '',
+ 'Commands:',
+ '',
+ lines.map(function(line){
+ return ' ' + pad(maxNameLength, line.name) + ' ' + breakByLines(line.description, maxNameLength + 4);
+ }).join('\n'),
+ ''
+ ].join('\n');
+ }
+
+ function optionsHelp(){
+ if (!command.hasOptions())
+ return '';
+
+ var hasShortOptions = Object.keys(command.short).length > 0;
+ var maxNameLength = MIN_OFFSET - 2;
+ var lines = Object.keys(command.long).sort().map(function(name){
+ var option = command.long[name];
+ var line = {
+ name: option.usage
+ .replace(/^(?:-., |)/, function(m){
+ return m || (hasShortOptions ? ' ' : '');
+ })
+ .replace(/(^|\s)(-[^\s,]+)/ig, function(m, p, flag){
+ return p + chalk.yellow(flag);
+ }),
+ description: option.description
+ };
+
+ maxNameLength = Math.max(maxNameLength, stringLength(line.name));
+
+ return line;
+ });
+
+ // Prepend the help information
+ return [
+ '',
+ 'Options:',
+ '',
+ lines.map(function(line){
+ return ' ' + pad(maxNameLength, line.name) + ' ' + breakByLines(line.description, maxNameLength + 4);
+ }).join('\n'),
+ ''
+ ].join('\n');
+ }
+
+ var output = [];
+ var chalk = require('chalk');
+
+ chalk.enabled = module.exports.color && process.stdout.isTTY;
+
+ if (command.description_)
+ output.push(command.description_ + '\n');
+
+ output.push(
+ 'Usage:\n\n ' +
+ chalk.cyan(commandsPath ? commandsPath.join(' ') : command.name) +
+ (command.params ? ' ' + chalk.magenta(args(command)) : '') +
+ (command.hasOptions() ? ' [' + chalk.yellow('options') + ']' : '') +
+ (command.hasCommands() ? ' [' + chalk.green('command') + ']' : ''),
+ commandsHelp() +
+ optionsHelp()
+ );
+
+ return output.join('\n');
+};
+
+
+//
+// export
+//
+
+module.exports = {
+ color: true,
+
+ Error: SyntaxError,
+ Argument: Argument,
+ Command: Command,
+ Option: Option,
+
+ error: function(fn){
+ if (errorHandler)
+ throw new SyntaxError('Error handler should be set only once');
+
+ if (typeof fn != 'function')
+ throw new SyntaxError('Error handler should be a function');
+
+ errorHandler = fn;
+
+ return this;
+ },
+
+ create: function(name, params){
+ return new Command(name || require('path').basename(process.argv[1]) || 'cli', params);
+ },
+
+ confirm: function(message, fn){
+ process.stdout.write(message);
+ process.stdin.setEncoding('utf8');
+ process.stdin.once('data', function(val){
+ process.stdin.pause();
+ fn(/^y|yes|ok|true$/i.test(val.trim()));
+ });
+ process.stdin.resume();
+ }
+};
diff --git a/node_modules/clap/node_modules/ansi-styles/index.js b/node_modules/clap/node_modules/ansi-styles/index.js
new file mode 100644
index 00000000..78945278
--- /dev/null
+++ b/node_modules/clap/node_modules/ansi-styles/index.js
@@ -0,0 +1,65 @@
+'use strict';
+
+function assembleStyles () {
+ var styles = {
+ modifiers: {
+ reset: [0, 0],
+ bold: [1, 22], // 21 isn't widely supported and 22 does the same thing
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ colors: {
+ 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]
+ },
+ bgColors: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49]
+ }
+ };
+
+ // fix humans
+ styles.colors.grey = styles.colors.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: '\u001b[' + style[0] + 'm',
+ close: '\u001b[' + style[1] + 'm'
+ };
+ });
+
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
+ });
+
+ return styles;
+}
+
+Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+});
diff --git a/node_modules/clap/node_modules/ansi-styles/license b/node_modules/clap/node_modules/ansi-styles/license
new file mode 100644
index 00000000..654d0bfe
--- /dev/null
+++ b/node_modules/clap/node_modules/ansi-styles/license
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+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.
diff --git a/node_modules/clap/node_modules/ansi-styles/package.json b/node_modules/clap/node_modules/ansi-styles/package.json
new file mode 100644
index 00000000..78c535f7
--- /dev/null
+++ b/node_modules/clap/node_modules/ansi-styles/package.json
@@ -0,0 +1,50 @@
+{
+ "name": "ansi-styles",
+ "version": "2.2.1",
+ "description": "ANSI escape codes for styling strings in the terminal",
+ "license": "MIT",
+ "repository": "chalk/ansi-styles",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "maintainers": [
+ "Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)",
+ "Joshua Appelman <jappelman@xebia.com> (jbnicolai.com)"
+ ],
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "files": [
+ "index.js"
+ ],
+ "keywords": [
+ "ansi",
+ "styles",
+ "color",
+ "colour",
+ "colors",
+ "terminal",
+ "console",
+ "cli",
+ "string",
+ "tty",
+ "escape",
+ "formatting",
+ "rgb",
+ "256",
+ "shell",
+ "xterm",
+ "log",
+ "logging",
+ "command-line",
+ "text"
+ ],
+ "devDependencies": {
+ "mocha": "*"
+ }
+}
diff --git a/node_modules/clap/node_modules/ansi-styles/readme.md b/node_modules/clap/node_modules/ansi-styles/readme.md
new file mode 100644
index 00000000..3f933f61
--- /dev/null
+++ b/node_modules/clap/node_modules/ansi-styles/readme.md
@@ -0,0 +1,86 @@
+# ansi-styles [![Build Status](https://travis-ci.org/chalk/ansi-styles.svg?branch=master)](https://travis-ci.org/chalk/ansi-styles)
+
+> [ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles) for styling strings in the terminal
+
+You probably want the higher-level [chalk](https://github.com/chalk/chalk) module for styling your strings.
+
+![](screenshot.png)
+
+
+## Install
+
+```
+$ npm install --save ansi-styles
+```
+
+
+## Usage
+
+```js
+var ansi = require('ansi-styles');
+
+console.log(ansi.green.open + 'Hello world!' + ansi.green.close);
+```
+
+
+## API
+
+Each style has an `open` and `close` property.
+
+
+## Styles
+
+### Modifiers
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(not widely supported)*
+- `underline`
+- `inverse`
+- `hidden`
+- `strikethrough` *(not widely supported)*
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `gray`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+
+
+## Advanced usage
+
+By default you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
+
+- `ansi.modifiers`
+- `ansi.colors`
+- `ansi.bgColors`
+
+
+###### Example
+
+```js
+console.log(ansi.colors.green.open);
+```
+
+
+## License
+
+MIT © [Sindre Sorhus](http://sindresorhus.com)
diff --git a/node_modules/clap/node_modules/chalk/index.js b/node_modules/clap/node_modules/chalk/index.js
new file mode 100644
index 00000000..2d85a917
--- /dev/null
+++ b/node_modules/clap/node_modules/chalk/index.js
@@ -0,0 +1,116 @@
+'use strict';
+var escapeStringRegexp = require('escape-string-regexp');
+var ansiStyles = require('ansi-styles');
+var stripAnsi = require('strip-ansi');
+var hasAnsi = require('has-ansi');
+var supportsColor = require('supports-color');
+var defineProps = Object.defineProperties;
+var isSimpleWindowsTerm = process.platform === 'win32' && !/^xterm/i.test(process.env.TERM);
+
+function Chalk(options) {
+ // detect mode if not set manually
+ this.enabled = !options || options.enabled === undefined ? supportsColor : options.enabled;
+}
+
+// use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+ ansiStyles.blue.open = '\u001b[94m';
+}
+
+var styles = (function () {
+ var ret = {};
+
+ Object.keys(ansiStyles).forEach(function (key) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+
+ ret[key] = {
+ get: function () {
+ return build.call(this, this._styles.concat(key));
+ }
+ };
+ });
+
+ return ret;
+})();
+
+var proto = defineProps(function chalk() {}, styles);
+
+function build(_styles) {
+ var builder = function () {
+ return applyStyle.apply(builder, arguments);
+ };
+
+ builder._styles = _styles;
+ builder.enabled = this.enabled;
+ // __proto__ is used because we must return a function, but there is
+ // no way to create a function with a different prototype.
+ /* eslint-disable no-proto */
+ builder.__proto__ = proto;
+
+ return builder;
+}
+
+function applyStyle() {
+ // support varags, but simply cast to string in case there's only one arg
+ var args = arguments;
+ var argsLen = args.length;
+ var str = argsLen !== 0 && String(arguments[0]);
+
+ if (argsLen > 1) {
+ // don't slice `arguments`, it prevents v8 optimizations
+ for (var a = 1; a < argsLen; a++) {
+ str += ' ' + args[a];
+ }
+ }
+
+ if (!this.enabled || !str) {
+ return str;
+ }
+
+ var nestedStyles = this._styles;
+ var i = nestedStyles.length;
+
+ // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
+ // see https://github.com/chalk/chalk/issues/58
+ // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
+ var originalDim = ansiStyles.dim.open;
+ if (isSimpleWindowsTerm && (nestedStyles.indexOf('gray') !== -1 || nestedStyles.indexOf('grey') !== -1)) {
+ ansiStyles.dim.open = '';
+ }
+
+ while (i--) {
+ var code = ansiStyles[nestedStyles[i]];
+
+ // Replace any instances already present with a re-opening code
+ // otherwise only the part of the string until said closing code
+ // will be colored, and the rest will simply be 'plain'.
+ str = code.open + str.replace(code.closeRe, code.open) + code.close;
+ }
+
+ // Reset the original 'dim' if we changed it to work around the Windows dimmed gray issue.
+ ansiStyles.dim.open = originalDim;
+
+ return str;
+}
+
+function init() {
+ var ret = {};
+
+ Object.keys(styles).forEach(function (name) {
+ ret[name] = {
+ get: function () {
+ return build.call(this, [name]);
+ }
+ };
+ });
+
+ return ret;
+}
+
+defineProps(Chalk.prototype, init());
+
+module.exports = new Chalk();
+module.exports.styles = ansiStyles;
+module.exports.hasColor = hasAnsi;
+module.exports.stripColor = stripAnsi;
+module.exports.supportsColor = supportsColor;
diff --git a/node_modules/clap/node_modules/chalk/license b/node_modules/clap/node_modules/chalk/license
new file mode 100644
index 00000000..654d0bfe
--- /dev/null
+++ b/node_modules/clap/node_modules/chalk/license
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+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.
diff --git a/node_modules/clap/node_modules/chalk/package.json b/node_modules/clap/node_modules/chalk/package.json
new file mode 100644
index 00000000..2b5881e9
--- /dev/null
+++ b/node_modules/clap/node_modules/chalk/package.json
@@ -0,0 +1,70 @@
+{
+ "name": "chalk",
+ "version": "1.1.3",
+ "description": "Terminal string styling done right. Much color.",
+ "license": "MIT",
+ "repository": "chalk/chalk",
+ "maintainers": [
+ "Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)",
+ "Joshua Appelman <jappelman@xebia.com> (jbnicolai.com)",
+ "JD Ballard <i.am.qix@gmail.com> (github.com/qix-)"
+ ],
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "scripts": {
+ "test": "xo && mocha",
+ "bench": "matcha benchmark.js",
+ "coverage": "nyc npm test && nyc report",
+ "coveralls": "nyc npm test && nyc report --reporter=text-lcov | coveralls"
+ },
+ "files": [
+ "index.js"
+ ],
+ "keywords": [
+ "color",
+ "colour",
+ "colors",
+ "terminal",
+ "console",
+ "cli",
+ "string",
+ "str",
+ "ansi",
+ "style",
+ "styles",
+ "tty",
+ "formatting",
+ "rgb",
+ "256",
+ "shell",
+ "xterm",
+ "log",
+ "logging",
+ "command-line",
+ "text"
+ ],
+ "dependencies": {
+ "ansi-styles": "^2.2.1",
+ "escape-string-regexp": "^1.0.2",
+ "has-ansi": "^2.0.0",
+ "strip-ansi": "^3.0.0",
+ "supports-color": "^2.0.0"
+ },
+ "devDependencies": {
+ "coveralls": "^2.11.2",
+ "matcha": "^0.6.0",
+ "mocha": "*",
+ "nyc": "^3.0.0",
+ "require-uncached": "^1.0.2",
+ "resolve-from": "^1.0.0",
+ "semver": "^4.3.3",
+ "xo": "*"
+ },
+ "xo": {
+ "envs": [
+ "node",
+ "mocha"
+ ]
+ }
+}
diff --git a/node_modules/clap/node_modules/chalk/readme.md b/node_modules/clap/node_modules/chalk/readme.md
new file mode 100644
index 00000000..5cf111e3
--- /dev/null
+++ b/node_modules/clap/node_modules/chalk/readme.md
@@ -0,0 +1,213 @@
+<h1 align="center">
+ <br>
+ <br>
+ <img width="360" src="https://cdn.rawgit.com/chalk/chalk/19935d6484811c5e468817f846b7b3d417d7bf4a/logo.svg" alt="chalk">
+ <br>
+ <br>
+ <br>
+</h1>
+
+> Terminal string styling done right
+
+[![Build Status](https://travis-ci.org/chalk/chalk.svg?branch=master)](https://travis-ci.org/chalk/chalk)
+[![Coverage Status](https://coveralls.io/repos/chalk/chalk/badge.svg?branch=master)](https://coveralls.io/r/chalk/chalk?branch=master)
+[![](http://img.shields.io/badge/unicorn-approved-ff69b4.svg)](https://www.youtube.com/watch?v=9auOCbH5Ns4)
+
+
+[colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68). Although there are other ones, they either do too much or not enough.
+
+**Chalk is a clean and focused alternative.**
+
+![](https://github.com/chalk/ansi-styles/raw/master/screenshot.png)
+
+
+## Why
+
+- Highly performant
+- Doesn't extend `String.prototype`
+- Expressive API
+- Ability to nest styles
+- Clean and focused
+- Auto-detects color support
+- Actively maintained
+- [Used by ~4500 modules](https://www.npmjs.com/browse/depended/chalk) as of July 15, 2015
+
+
+## Install
+
+```
+$ npm install --save chalk
+```
+
+
+## Usage
+
+Chalk comes with an easy to use composable API where you just chain and nest the styles you want.
+
+```js
+var chalk = require('chalk');
+
+// style a string
+chalk.blue('Hello world!');
+
+// combine styled and normal strings
+chalk.blue('Hello') + 'World' + chalk.red('!');
+
+// compose multiple styles using the chainable API
+chalk.blue.bgRed.bold('Hello world!');
+
+// pass in multiple arguments
+chalk.blue('Hello', 'World!', 'Foo', 'bar', 'biz', 'baz');
+
+// nest styles
+chalk.red('Hello', chalk.underline.bgBlue('world') + '!');
+
+// nest styles of the same type even (color, underline, background)
+chalk.green(
+ 'I am a green line ' +
+ chalk.blue.underline.bold('with a blue substring') +
+ ' that becomes green again!'
+);
+```
+
+Easily define your own themes.
+
+```js
+var chalk = require('chalk');
+var error = chalk.bold.red;
+console.log(error('Error!'));
+```
+
+Take advantage of console.log [string substitution](http://nodejs.org/docs/latest/api/console.html#console_console_log_data).
+
+```js
+var name = 'Sindre';
+console.log(chalk.green('Hello %s'), name);
+//=> Hello Sindre
+```
+
+
+## API
+
+### chalk.`<style>[.<style>...](string, [string...])`
+
+Example: `chalk.red.bold.underline('Hello', 'world');`
+
+Chain [styles](#styles) and call the last one as a method with a string argument. Order doesn't matter, and later styles take precedent in case of a conflict. This simply means that `Chalk.red.yellow.green` is equivalent to `Chalk.green`.
+
+Multiple arguments will be separated by space.
+
+### chalk.enabled
+
+Color support is automatically detected, but you can override it by setting the `enabled` property. You should however only do this in your own code as it applies globally to all chalk consumers.
+
+If you need to change this in a reusable module create a new instance:
+
+```js
+var ctx = new chalk.constructor({enabled: false});
+```
+
+### chalk.supportsColor
+
+Detect whether the terminal [supports color](https://github.com/chalk/supports-color). Used internally and handled for you, but exposed for convenience.
+
+Can be overridden by the user with the flags `--color` and `--no-color`. For situations where using `--color` is not possible, add an environment variable `FORCE_COLOR` with any value to force color. Trumps `--no-color`.
+
+### chalk.styles
+
+Exposes the styles as [ANSI escape codes](https://github.com/chalk/ansi-styles).
+
+Generally not useful, but you might need just the `.open` or `.close` escape code if you're mixing externally styled strings with your own.
+
+```js
+var chalk = require('chalk');
+
+console.log(chalk.styles.red);
+//=> {open: '\u001b[31m', close: '\u001b[39m'}
+
+console.log(chalk.styles.red.open + 'Hello' + chalk.styles.red.close);
+```
+
+### chalk.hasColor(string)
+
+Check whether a string [has color](https://github.com/chalk/has-ansi).
+
+### chalk.stripColor(string)
+
+[Strip color](https://github.com/chalk/strip-ansi) from a string.
+
+Can be useful in combination with `.supportsColor` to strip color on externally styled text when it's not supported.
+
+Example:
+
+```js
+var chalk = require('chalk');
+var styledString = getText();
+
+if (!chalk.supportsColor) {
+ styledString = chalk.stripColor(styledString);
+}
+```
+
+
+## Styles
+
+### Modifiers
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(not widely supported)*
+- `underline`
+- `inverse`
+- `hidden`
+- `strikethrough` *(not widely supported)*
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue` *(on Windows the bright version is used as normal blue is illegible)*
+- `magenta`
+- `cyan`
+- `white`
+- `gray`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+
+
+## 256-colors
+
+Chalk does not support anything other than the base eight colors, which guarantees it will work on all terminals and systems. Some terminals, specifically `xterm` compliant ones, will support the full range of 8-bit colors. For this the lower level [ansi-256-colors](https://github.com/jbnicolai/ansi-256-colors) package can be used.
+
+
+## Windows
+
+If you're on Windows, do yourself a favor and use [`cmder`](http://bliker.github.io/cmder/) instead of `cmd.exe`.
+
+
+## Related
+
+- [chalk-cli](https://github.com/chalk/chalk-cli) - CLI for this module
+- [ansi-styles](https://github.com/chalk/ansi-styles/) - ANSI escape codes for styling strings in the terminal
+- [supports-color](https://github.com/chalk/supports-color/) - Detect whether a terminal supports color
+- [strip-ansi](https://github.com/chalk/strip-ansi) - Strip ANSI escape codes
+- [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes
+- [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes
+- [wrap-ansi](https://github.com/chalk/wrap-ansi) - Wordwrap a string with ANSI escape codes
+
+
+## License
+
+MIT © [Sindre Sorhus](http://sindresorhus.com)
diff --git a/node_modules/clap/node_modules/supports-color/index.js b/node_modules/clap/node_modules/supports-color/index.js
new file mode 100644
index 00000000..4346e272
--- /dev/null
+++ b/node_modules/clap/node_modules/supports-color/index.js
@@ -0,0 +1,50 @@
+'use strict';
+var argv = process.argv;
+
+var terminator = argv.indexOf('--');
+var hasFlag = function (flag) {
+ flag = '--' + flag;
+ var pos = argv.indexOf(flag);
+ return pos !== -1 && (terminator !== -1 ? pos < terminator : true);
+};
+
+module.exports = (function () {
+ if ('FORCE_COLOR' in process.env) {
+ return true;
+ }
+
+ if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ return false;
+ }
+
+ if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ return true;
+ }
+
+ if (process.stdout && !process.stdout.isTTY) {
+ return false;
+ }
+
+ if (process.platform === 'win32') {
+ return true;
+ }
+
+ if ('COLORTERM' in process.env) {
+ return true;
+ }
+
+ if (process.env.TERM === 'dumb') {
+ return false;
+ }
+
+ if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(process.env.TERM)) {
+ return true;
+ }
+
+ return false;
+})();
diff --git a/node_modules/clap/node_modules/supports-color/license b/node_modules/clap/node_modules/supports-color/license
new file mode 100644
index 00000000..654d0bfe
--- /dev/null
+++ b/node_modules/clap/node_modules/supports-color/license
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+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.
diff --git a/node_modules/clap/node_modules/supports-color/package.json b/node_modules/clap/node_modules/supports-color/package.json
new file mode 100644
index 00000000..3bb77ac1
--- /dev/null
+++ b/node_modules/clap/node_modules/supports-color/package.json
@@ -0,0 +1,49 @@
+{
+ "name": "supports-color",
+ "version": "2.0.0",
+ "description": "Detect whether a terminal supports color",
+ "license": "MIT",
+ "repository": "chalk/supports-color",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "maintainers": [
+ "Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)",
+ "Joshua Appelman <jappelman@xebia.com> (jbnicolai.com)"
+ ],
+ "engines": {
+ "node": ">=0.8.0"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "files": [
+ "index.js"
+ ],
+ "keywords": [
+ "color",
+ "colour",
+ "colors",
+ "terminal",
+ "console",
+ "cli",
+ "ansi",
+ "styles",
+ "tty",
+ "rgb",
+ "256",
+ "shell",
+ "xterm",
+ "command-line",
+ "support",
+ "supports",
+ "capability",
+ "detect"
+ ],
+ "devDependencies": {
+ "mocha": "*",
+ "require-uncached": "^1.0.2"
+ }
+}
diff --git a/node_modules/clap/node_modules/supports-color/readme.md b/node_modules/clap/node_modules/supports-color/readme.md
new file mode 100644
index 00000000..b4761f1e
--- /dev/null
+++ b/node_modules/clap/node_modules/supports-color/readme.md
@@ -0,0 +1,36 @@
+# supports-color [![Build Status](https://travis-ci.org/chalk/supports-color.svg?branch=master)](https://travis-ci.org/chalk/supports-color)
+
+> Detect whether a terminal supports color
+
+
+## Install
+
+```
+$ npm install --save supports-color
+```
+
+
+## Usage
+
+```js
+var supportsColor = require('supports-color');
+
+if (supportsColor) {
+ console.log('Terminal supports color');
+}
+```
+
+It obeys the `--color` and `--no-color` CLI flags.
+
+For situations where using `--color` is not possible, add an environment variable `FORCE_COLOR` with any value to force color. Trumps `--no-color`.
+
+
+## Related
+
+- [supports-color-cli](https://github.com/chalk/supports-color-cli) - CLI for this module
+- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right
+
+
+## License
+
+MIT © [Sindre Sorhus](http://sindresorhus.com)
diff --git a/node_modules/clap/package.json b/node_modules/clap/package.json
new file mode 100644
index 00000000..64502c47
--- /dev/null
+++ b/node_modules/clap/package.json
@@ -0,0 +1,36 @@
+{
+ "name": "clap",
+ "title": "Command line argument parser",
+ "description": "Command line argument parser",
+ "author": "Roman Dvornov <rdvornov@gmail.com>",
+ "license": "MIT",
+ "version": "1.2.3",
+ "keywords": [
+ "cli",
+ "command",
+ "option",
+ "argument",
+ "completion"
+ ],
+ "homepage": "https://github.com/lahmatiy/clap",
+ "repository": "lahmatiy/clap",
+ "main": "index.js",
+ "files": [
+ "index.js",
+ "HISTORY.md",
+ "LICENSE",
+ "README.md"
+ ],
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "dependencies": {
+ "chalk": "^1.1.3"
+ },
+ "devDependencies": {
+ "mocha": "^2.4.5"
+ },
+ "scripts": {
+ "test": "mocha test -R spec"
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-10-04 11:14:40 +0000