first commit

build/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

build/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.

build/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]

build/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();
+  }
+};

build/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
+});

build/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.

build/node_modules/clap/node_modules/ansi-styles/package.json

@@ -0,0 +1,93 @@
+{
+  "_args": [
+    [
+      "ansi-styles@2.2.1",
+      "/Users/asciidisco/Desktop/asciidisco.com/build"
+    ]
+  ],
+  "_from": "ansi-styles@2.2.1",
+  "_id": "ansi-styles@2.2.1",
+  "_inBundle": false,
+  "_integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=",
+  "_location": "/clap/ansi-styles",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "ansi-styles@2.2.1",
+    "name": "ansi-styles",
+    "escapedName": "ansi-styles",
+    "rawSpec": "2.2.1",
+    "saveSpec": null,
+    "fetchSpec": "2.2.1"
+  },
+  "_requiredBy": [
+    "/clap/chalk"
+  ],
+  "_resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
+  "_spec": "2.2.1",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "sindresorhus.com"
+  },
+  "bugs": {
+    "url": "https://github.com/chalk/ansi-styles/issues"
+  },
+  "description": "ANSI escape codes for styling strings in the terminal",
+  "devDependencies": {
+    "mocha": "*"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/chalk/ansi-styles#readme",
+  "keywords": [
+    "ansi",
+    "styles",
+    "color",
+    "colour",
+    "colors",
+    "terminal",
+    "console",
+    "cli",
+    "string",
+    "tty",
+    "escape",
+    "formatting",
+    "rgb",
+    "256",
+    "shell",
+    "xterm",
+    "log",
+    "logging",
+    "command-line",
+    "text"
+  ],
+  "license": "MIT",
+  "maintainers": [
+    {
+      "name": "Sindre Sorhus",
+      "email": "sindresorhus@gmail.com",
+      "url": "sindresorhus.com"
+    },
+    {
+      "name": "Joshua Appelman",
+      "email": "jappelman@xebia.com",
+      "url": "jbnicolai.com"
+    }
+  ],
+  "name": "ansi-styles",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chalk/ansi-styles.git"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "version": "2.2.1"
+}

build/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)

build/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;

build/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.

build/node_modules/clap/node_modules/chalk/package.json

@@ -0,0 +1,117 @@
+{
+  "_args": [
+    [
+      "chalk@1.1.3",
+      "/Users/asciidisco/Desktop/asciidisco.com/build"
+    ]
+  ],
+  "_from": "chalk@1.1.3",
+  "_id": "chalk@1.1.3",
+  "_inBundle": false,
+  "_integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
+  "_location": "/clap/chalk",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "chalk@1.1.3",
+    "name": "chalk",
+    "escapedName": "chalk",
+    "rawSpec": "1.1.3",
+    "saveSpec": null,
+    "fetchSpec": "1.1.3"
+  },
+  "_requiredBy": [
+    "/clap"
+  ],
+  "_resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
+  "_spec": "1.1.3",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build",
+  "bugs": {
+    "url": "https://github.com/chalk/chalk/issues"
+  },
+  "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"
+  },
+  "description": "Terminal string styling done right. Much color.",
+  "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": "*"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/chalk/chalk#readme",
+  "keywords": [
+    "color",
+    "colour",
+    "colors",
+    "terminal",
+    "console",
+    "cli",
+    "string",
+    "str",
+    "ansi",
+    "style",
+    "styles",
+    "tty",
+    "formatting",
+    "rgb",
+    "256",
+    "shell",
+    "xterm",
+    "log",
+    "logging",
+    "command-line",
+    "text"
+  ],
+  "license": "MIT",
+  "maintainers": [
+    {
+      "name": "Sindre Sorhus",
+      "email": "sindresorhus@gmail.com",
+      "url": "sindresorhus.com"
+    },
+    {
+      "name": "Joshua Appelman",
+      "email": "jappelman@xebia.com",
+      "url": "jbnicolai.com"
+    },
+    {
+      "name": "JD Ballard",
+      "email": "i.am.qix@gmail.com",
+      "url": "github.com/qix-"
+    }
+  ],
+  "name": "chalk",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chalk/chalk.git"
+  },
+  "scripts": {
+    "bench": "matcha benchmark.js",
+    "coverage": "nyc npm test && nyc report",
+    "coveralls": "nyc npm test && nyc report --reporter=text-lcov | coveralls",
+    "test": "xo && mocha"
+  },
+  "version": "1.1.3",
+  "xo": {
+    "envs": [
+      "node",
+      "mocha"
+    ]
+  }
+}

build/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)

build/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;
+})();

build/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.

build/node_modules/clap/node_modules/supports-color/package.json

@@ -0,0 +1,92 @@
+{
+  "_args": [
+    [
+      "supports-color@2.0.0",
+      "/Users/asciidisco/Desktop/asciidisco.com/build"
+    ]
+  ],
+  "_from": "supports-color@2.0.0",
+  "_id": "supports-color@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
+  "_location": "/clap/supports-color",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "supports-color@2.0.0",
+    "name": "supports-color",
+    "escapedName": "supports-color",
+    "rawSpec": "2.0.0",
+    "saveSpec": null,
+    "fetchSpec": "2.0.0"
+  },
+  "_requiredBy": [
+    "/clap/chalk"
+  ],
+  "_resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
+  "_spec": "2.0.0",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "sindresorhus.com"
+  },
+  "bugs": {
+    "url": "https://github.com/chalk/supports-color/issues"
+  },
+  "description": "Detect whether a terminal supports color",
+  "devDependencies": {
+    "mocha": "*",
+    "require-uncached": "^1.0.2"
+  },
+  "engines": {
+    "node": ">=0.8.0"
+  },
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/chalk/supports-color#readme",
+  "keywords": [
+    "color",
+    "colour",
+    "colors",
+    "terminal",
+    "console",
+    "cli",
+    "ansi",
+    "styles",
+    "tty",
+    "rgb",
+    "256",
+    "shell",
+    "xterm",
+    "command-line",
+    "support",
+    "supports",
+    "capability",
+    "detect"
+  ],
+  "license": "MIT",
+  "maintainers": [
+    {
+      "name": "Sindre Sorhus",
+      "email": "sindresorhus@gmail.com",
+      "url": "sindresorhus.com"
+    },
+    {
+      "name": "Joshua Appelman",
+      "email": "jappelman@xebia.com",
+      "url": "jbnicolai.com"
+    }
+  ],
+  "name": "supports-color",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chalk/supports-color.git"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "version": "2.0.0"
+}

build/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)

build/node_modules/clap/package.json

@@ -0,0 +1,77 @@
+{
+  "_args": [
+    [
+      "clap@1.2.3",
+      "/Users/asciidisco/Desktop/asciidisco.com/build"
+    ]
+  ],
+  "_from": "clap@1.2.3",
+  "_id": "clap@1.2.3",
+  "_inBundle": false,
+  "_integrity": "sha512-4CoL/A3hf90V3VIEjeuhSvlGFEHKzOz+Wfc2IVZc+FaUgU0ZQafJTP49fvnULipOPcAfqhyI2duwQyns6xqjYA==",
+  "_location": "/clap",
+  "_phantomChildren": {
+    "escape-string-regexp": "1.0.5",
+    "has-ansi": "2.0.0",
+    "strip-ansi": "3.0.1"
+  },
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "clap@1.2.3",
+    "name": "clap",
+    "escapedName": "clap",
+    "rawSpec": "1.2.3",
+    "saveSpec": null,
+    "fetchSpec": "1.2.3"
+  },
+  "_requiredBy": [
+    "/csso"
+  ],
+  "_resolved": "https://registry.npmjs.org/clap/-/clap-1.2.3.tgz",
+  "_spec": "1.2.3",
+  "_where": "/Users/asciidisco/Desktop/asciidisco.com/build",
+  "author": {
+    "name": "Roman Dvornov",
+    "email": "rdvornov@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/lahmatiy/clap/issues"
+  },
+  "dependencies": {
+    "chalk": "^1.1.3"
+  },
+  "description": "Command line argument parser",
+  "devDependencies": {
+    "mocha": "^2.4.5"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "files": [
+    "index.js",
+    "HISTORY.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "homepage": "https://github.com/lahmatiy/clap",
+  "keywords": [
+    "cli",
+    "command",
+    "option",
+    "argument",
+    "completion"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "clap",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lahmatiy/clap.git"
+  },
+  "scripts": {
+    "test": "mocha test -R spec"
+  },
+  "title": "Command line argument parser",
+  "version": "1.2.3"
+}