@alexlit/lint-kit 186.2.2 → 186.3.1

package/packages/config-stylelint/node_modules/argparse/lib/argument_parser.js

@@ -1,1161 +0,0 @@
-/**
- * class ArgumentParser
- *
- * Object for parsing command line strings into js objects.
- *
- * Inherited from [[ActionContainer]]
- **/
-'use strict';
-
-var util    = require('util');
-var format  = require('util').format;
-var Path    = require('path');
-var sprintf = require('sprintf-js').sprintf;
-
-// Constants
-var c = require('./const');
-
-var $$ = require('./utils');
-
-var ActionContainer = require('./action_container');
-
-// Errors
-var argumentErrorHelper = require('./argument/error');
-
-var HelpFormatter = require('./help/formatter');
-
-var Namespace = require('./namespace');
-
-
-/**
- * new ArgumentParser(options)
- *
- * Create a new ArgumentParser object.
- *
- * ##### Options:
- * - `prog`  The name of the program (default: Path.basename(process.argv[1]))
- * - `usage`  A usage message (default: auto-generated from arguments)
- * - `description`  A description of what the program does
- * - `epilog`  Text following the argument descriptions
- * - `parents`  Parsers whose arguments should be copied into this one
- * - `formatterClass`  HelpFormatter class for printing help messages
- * - `prefixChars`  Characters that prefix optional arguments
- * - `fromfilePrefixChars` Characters that prefix files containing additional arguments
- * - `argumentDefault`  The default value for all arguments
- * - `addHelp`  Add a -h/-help option
- * - `conflictHandler`  Specifies how to handle conflicting argument names
- * - `debug`  Enable debug mode. Argument errors throw exception in
- *   debug mode and process.exit in normal. Used for development and
- *   testing (default: false)
- *
- * See also [original guide][1]
- *
- * [1]:http://docs.python.org/dev/library/argparse.html#argumentparser-objects
- **/
-function ArgumentParser(options) {
-  if (!(this instanceof ArgumentParser)) {
-    return new ArgumentParser(options);
-  }
-  var self = this;
-  options = options || {};
-
-  options.description = (options.description || null);
-  options.argumentDefault = (options.argumentDefault || null);
-  options.prefixChars = (options.prefixChars || '-');
-  options.conflictHandler = (options.conflictHandler || 'error');
-  ActionContainer.call(this, options);
-
-  options.addHelp = typeof options.addHelp === 'undefined' || !!options.addHelp;
-  options.parents = options.parents || [];
-  // default program name
-  options.prog = (options.prog || Path.basename(process.argv[1]));
-  this.prog = options.prog;
-  this.usage = options.usage;
-  this.epilog = options.epilog;
-  this.version = options.version;
-
-  this.debug = (options.debug === true);
-
-  this.formatterClass = (options.formatterClass || HelpFormatter);
-  this.fromfilePrefixChars = options.fromfilePrefixChars || null;
-  this._positionals = this.addArgumentGroup({ title: 'Positional arguments' });
-  this._optionals = this.addArgumentGroup({ title: 'Optional arguments' });
-  this._subparsers = null;
-
-  // register types
-  function FUNCTION_IDENTITY(o) {
-    return o;
-  }
-  this.register('type', 'auto', FUNCTION_IDENTITY);
-  this.register('type', null, FUNCTION_IDENTITY);
-  this.register('type', 'int', function (x) {
-    var result = parseInt(x, 10);
-    if (isNaN(result)) {
-      throw new Error(x + ' is not a valid integer.');
-    }
-    return result;
-  });
-  this.register('type', 'float', function (x) {
-    var result = parseFloat(x);
-    if (isNaN(result)) {
-      throw new Error(x + ' is not a valid float.');
-    }
-    return result;
-  });
-  this.register('type', 'string', function (x) {
-    return '' + x;
-  });
-
-  // add help and version arguments if necessary
-  var defaultPrefix = (this.prefixChars.indexOf('-') > -1) ? '-' : this.prefixChars[0];
-  if (options.addHelp) {
-    this.addArgument(
-      [ defaultPrefix + 'h', defaultPrefix + defaultPrefix + 'help' ],
-      {
-        action: 'help',
-        defaultValue: c.SUPPRESS,
-        help: 'Show this help message and exit.'
-      }
-    );
-  }
-  if (typeof this.version !== 'undefined') {
-    this.addArgument(
-      [ defaultPrefix + 'v', defaultPrefix + defaultPrefix + 'version' ],
-      {
-        action: 'version',
-        version: this.version,
-        defaultValue: c.SUPPRESS,
-        help: "Show program's version number and exit."
-      }
-    );
-  }
-
-  // add parent arguments and defaults
-  options.parents.forEach(function (parent) {
-    self._addContainerActions(parent);
-    if (typeof parent._defaults !== 'undefined') {
-      for (var defaultKey in parent._defaults) {
-        if (parent._defaults.hasOwnProperty(defaultKey)) {
-          self._defaults[defaultKey] = parent._defaults[defaultKey];
-        }
-      }
-    }
-  });
-}
-
-util.inherits(ArgumentParser, ActionContainer);
-
-/**
- * ArgumentParser#addSubparsers(options) -> [[ActionSubparsers]]
- * - options (object): hash of options see [[ActionSubparsers.new]]
- *
- * See also [subcommands][1]
- *
- * [1]:http://docs.python.org/dev/library/argparse.html#sub-commands
- **/
-ArgumentParser.prototype.addSubparsers = function (options) {
-  if (this._subparsers) {
-    this.error('Cannot have multiple subparser arguments.');
-  }
-
-  options = options || {};
-  options.debug = (this.debug === true);
-  options.optionStrings = [];
-  options.parserClass = (options.parserClass || ArgumentParser);
-
-
-  if (!!options.title || !!options.description) {
-
-    this._subparsers = this.addArgumentGroup({
-      title: (options.title || 'subcommands'),
-      description: options.description
-    });
-    delete options.title;
-    delete options.description;
-
-  } else {
-    this._subparsers = this._positionals;
-  }
-
-  // prog defaults to the usage message of this parser, skipping
-  // optional arguments and with no "usage:" prefix
-  if (!options.prog) {
-    var formatter = this._getFormatter();
-    var positionals = this._getPositionalActions();
-    var groups = this._mutuallyExclusiveGroups;
-    formatter.addUsage(this.usage, positionals, groups, '');
-    options.prog = formatter.formatHelp().trim();
-  }
-
-  // create the parsers action and add it to the positionals list
-  var ParsersClass = this._popActionClass(options, 'parsers');
-  var action = new ParsersClass(options);
-  this._subparsers._addAction(action);
-
-  // return the created parsers action
-  return action;
-};
-
-ArgumentParser.prototype._addAction = function (action) {
-  if (action.isOptional()) {
-    this._optionals._addAction(action);
-  } else {
-    this._positionals._addAction(action);
-  }
-  return action;
-};
-
-ArgumentParser.prototype._getOptionalActions = function () {
-  return this._actions.filter(function (action) {
-    return action.isOptional();
-  });
-};
-
-ArgumentParser.prototype._getPositionalActions = function () {
-  return this._actions.filter(function (action) {
-    return action.isPositional();
-  });
-};
-
-
-/**
- * ArgumentParser#parseArgs(args, namespace) -> Namespace|Object
- * - args (array): input elements
- * - namespace (Namespace|Object): result object
- *
- * Parsed args and throws error if some arguments are not recognized
- *
- * See also [original guide][1]
- *
- * [1]:http://docs.python.org/dev/library/argparse.html#the-parse-args-method
- **/
-ArgumentParser.prototype.parseArgs = function (args, namespace) {
-  var argv;
-  var result = this.parseKnownArgs(args, namespace);
-
-  args = result[0];
-  argv = result[1];
-  if (argv && argv.length > 0) {
-    this.error(
-      format('Unrecognized arguments: %s.', argv.join(' '))
-    );
-  }
-  return args;
-};
-
-/**
- * ArgumentParser#parseKnownArgs(args, namespace) -> array
- * - args (array): input options
- * - namespace (Namespace|Object): result object
- *
- * Parse known arguments and return tuple of result object
- * and unknown args
- *
- * See also [original guide][1]
- *
- * [1]:http://docs.python.org/dev/library/argparse.html#partial-parsing
- **/
-ArgumentParser.prototype.parseKnownArgs = function (args, namespace) {
-  var self = this;
-
-  // args default to the system args
-  args = args || process.argv.slice(2);
-
-  // default Namespace built from parser defaults
-  namespace = namespace || new Namespace();
-
-  self._actions.forEach(function (action) {
-    if (action.dest !== c.SUPPRESS) {
-      if (!$$.has(namespace, action.dest)) {
-        if (action.defaultValue !== c.SUPPRESS) {
-          var defaultValue = action.defaultValue;
-          if (typeof action.defaultValue === 'string') {
-            defaultValue = self._getValue(action, defaultValue);
-          }
-          namespace[action.dest] = defaultValue;
-        }
-      }
-    }
-  });
-
-  Object.keys(self._defaults).forEach(function (dest) {
-    namespace[dest] = self._defaults[dest];
-  });
-
-  // parse the arguments and exit if there are any errors
-  try {
-    var res = this._parseKnownArgs(args, namespace);
-
-    namespace = res[0];
-    args = res[1];
-    if ($$.has(namespace, c._UNRECOGNIZED_ARGS_ATTR)) {
-      args = $$.arrayUnion(args, namespace[c._UNRECOGNIZED_ARGS_ATTR]);
-      delete namespace[c._UNRECOGNIZED_ARGS_ATTR];
-    }
-    return [ namespace, args ];
-  } catch (e) {
-    this.error(e);
-  }
-};
-
-ArgumentParser.prototype._parseKnownArgs = function (argStrings, namespace) {
-  var self = this;
-
-  var extras = [];
-
-  // replace arg strings that are file references
-  if (this.fromfilePrefixChars !== null) {
-    argStrings = this._readArgsFromFiles(argStrings);
-  }
-  // map all mutually exclusive arguments to the other arguments
-  // they can't occur with
-  // Python has 'conflicts = action_conflicts.setdefault(mutex_action, [])'
-  // though I can't conceive of a way in which an action could be a member
-  // of two different mutually exclusive groups.
-
-  function actionHash(action) {
-    // some sort of hashable key for this action
-    // action itself cannot be a key in actionConflicts
-    // I think getName() (join of optionStrings) is unique enough
-    return action.getName();
-  }
-
-  var conflicts, key;
-  var actionConflicts = {};
-
-  this._mutuallyExclusiveGroups.forEach(function (mutexGroup) {
-    mutexGroup._groupActions.forEach(function (mutexAction, i, groupActions) {
-      key = actionHash(mutexAction);
-      if (!$$.has(actionConflicts, key)) {
-        actionConflicts[key] = [];
-      }
-      conflicts = actionConflicts[key];
-      conflicts.push.apply(conflicts, groupActions.slice(0, i));
-      conflicts.push.apply(conflicts, groupActions.slice(i + 1));
-    });
-  });
-
-  // find all option indices, and determine the arg_string_pattern
-  // which has an 'O' if there is an option at an index,
-  // an 'A' if there is an argument, or a '-' if there is a '--'
-  var optionStringIndices = {};
-
-  var argStringPatternParts = [];
-
-  argStrings.forEach(function (argString, argStringIndex) {
-    if (argString === '--') {
-      argStringPatternParts.push('-');
-      while (argStringIndex < argStrings.length) {
-        argStringPatternParts.push('A');
-        argStringIndex++;
-      }
-    } else {
-      // otherwise, add the arg to the arg strings
-      // and note the index if it was an option
-      var pattern;
-      var optionTuple = self._parseOptional(argString);
-      if (!optionTuple) {
-        pattern = 'A';
-      } else {
-        optionStringIndices[argStringIndex] = optionTuple;
-        pattern = 'O';
-      }
-      argStringPatternParts.push(pattern);
-    }
-  });
-  var argStringsPattern = argStringPatternParts.join('');
-
-  var seenActions = [];
-  var seenNonDefaultActions = [];
-
-
-  function takeAction(action, argumentStrings, optionString) {
-    seenActions.push(action);
-    var argumentValues = self._getValues(action, argumentStrings);
-
-    // error if this argument is not allowed with other previously
-    // seen arguments, assuming that actions that use the default
-    // value don't really count as "present"
-    if (argumentValues !== action.defaultValue) {
-      seenNonDefaultActions.push(action);
-      if (actionConflicts[actionHash(action)]) {
-        actionConflicts[actionHash(action)].forEach(function (actionConflict) {
-          if (seenNonDefaultActions.indexOf(actionConflict) >= 0) {
-            throw argumentErrorHelper(
-              action,
-              format('Not allowed with argument "%s".', actionConflict.getName())
-            );
-          }
-        });
-      }
-    }
-
-    if (argumentValues !== c.SUPPRESS) {
-      action.call(self, namespace, argumentValues, optionString);
-    }
-  }
-
-  function consumeOptional(startIndex) {
-    // get the optional identified at this index
-    var optionTuple = optionStringIndices[startIndex];
-    var action = optionTuple[0];
-    var optionString = optionTuple[1];
-    var explicitArg = optionTuple[2];
-
-    // identify additional optionals in the same arg string
-    // (e.g. -xyz is the same as -x -y -z if no args are required)
-    var actionTuples = [];
-
-    var args, argCount, start, stop;
-
-    for (;;) {
-      if (!action) {
-        extras.push(argStrings[startIndex]);
-        return startIndex + 1;
-      }
-      if (explicitArg) {
-        argCount = self._matchArgument(action, 'A');
-
-        // if the action is a single-dash option and takes no
-        // arguments, try to parse more single-dash options out
-        // of the tail of the option string
-        var chars = self.prefixChars;
-        if (argCount === 0 && chars.indexOf(optionString[1]) < 0) {
-          actionTuples.push([ action, [], optionString ]);
-          optionString = optionString[0] + explicitArg[0];
-          var newExplicitArg = explicitArg.slice(1) || null;
-          var optionalsMap = self._optionStringActions;
-
-          if (Object.keys(optionalsMap).indexOf(optionString) >= 0) {
-            action = optionalsMap[optionString];
-            explicitArg = newExplicitArg;
-          } else {
-            throw argumentErrorHelper(action, sprintf('ignored explicit argument %r', explicitArg));
-          }
-        } else if (argCount === 1) {
-          // if the action expect exactly one argument, we've
-          // successfully matched the option; exit the loop
-          stop = startIndex + 1;
-          args = [ explicitArg ];
-          actionTuples.push([ action, args, optionString ]);
-          break;
-        } else {
-          // error if a double-dash option did not use the
-          // explicit argument
-          throw argumentErrorHelper(action, sprintf('ignored explicit argument %r', explicitArg));
-        }
-      } else {
-        // if there is no explicit argument, try to match the
-        // optional's string arguments with the following strings
-        // if successful, exit the loop
-
-        start = startIndex + 1;
-        var selectedPatterns = argStringsPattern.substr(start);
-
-        argCount = self._matchArgument(action, selectedPatterns);
-        stop = start + argCount;
-
-
-        args = argStrings.slice(start, stop);
-
-        actionTuples.push([ action, args, optionString ]);
-        break;
-      }
-
-    }
-
-    // add the Optional to the list and return the index at which
-    // the Optional's string args stopped
-    if (actionTuples.length < 1) {
-      throw new Error('length should be > 0');
-    }
-    for (var i = 0; i < actionTuples.length; i++) {
-      takeAction.apply(self, actionTuples[i]);
-    }
-    return stop;
-  }
-
-  // the list of Positionals left to be parsed; this is modified
-  // by consume_positionals()
-  var positionals = self._getPositionalActions();
-
-  function consumePositionals(startIndex) {
-    // match as many Positionals as possible
-    var selectedPattern = argStringsPattern.substr(startIndex);
-    var argCounts = self._matchArgumentsPartial(positionals, selectedPattern);
-
-    // slice off the appropriate arg strings for each Positional
-    // and add the Positional and its args to the list
-    for (var i = 0; i < positionals.length; i++) {
-      var action = positionals[i];
-      var argCount = argCounts[i];
-      if (typeof argCount === 'undefined') {
-        continue;
-      }
-      var args = argStrings.slice(startIndex, startIndex + argCount);
-
-      startIndex += argCount;
-      takeAction(action, args);
-    }
-
-    // slice off the Positionals that we just parsed and return the
-    // index at which the Positionals' string args stopped
-    positionals = positionals.slice(argCounts.length);
-    return startIndex;
-  }
-
-  // consume Positionals and Optionals alternately, until we have
-  // passed the last option string
-  var startIndex = 0;
-  var position;
-
-  var maxOptionStringIndex = -1;
-
-  Object.keys(optionStringIndices).forEach(function (position) {
-    maxOptionStringIndex = Math.max(maxOptionStringIndex, parseInt(position, 10));
-  });
-
-  var positionalsEndIndex, nextOptionStringIndex;
-
-  while (startIndex <= maxOptionStringIndex) {
-    // consume any Positionals preceding the next option
-    nextOptionStringIndex = null;
-    for (position in optionStringIndices) {
-      if (!optionStringIndices.hasOwnProperty(position)) { continue; }
-
-      position = parseInt(position, 10);
-      if (position >= startIndex) {
-        if (nextOptionStringIndex !== null) {
-          nextOptionStringIndex = Math.min(nextOptionStringIndex, position);
-        } else {
-          nextOptionStringIndex = position;
-        }
-      }
-    }
-
-    if (startIndex !== nextOptionStringIndex) {
-      positionalsEndIndex = consumePositionals(startIndex);
-      // only try to parse the next optional if we didn't consume
-      // the option string during the positionals parsing
-      if (positionalsEndIndex > startIndex) {
-        startIndex = positionalsEndIndex;
-        continue;
-      } else {
-        startIndex = positionalsEndIndex;
-      }
-    }
-
-    // if we consumed all the positionals we could and we're not
-    // at the index of an option string, there were extra arguments
-    if (!optionStringIndices[startIndex]) {
-      var strings = argStrings.slice(startIndex, nextOptionStringIndex);
-      extras = extras.concat(strings);
-      startIndex = nextOptionStringIndex;
-    }
-    // consume the next optional and any arguments for it
-    startIndex = consumeOptional(startIndex);
-  }
-
-  // consume any positionals following the last Optional
-  var stopIndex = consumePositionals(startIndex);
-
-  // if we didn't consume all the argument strings, there were extras
-  extras = extras.concat(argStrings.slice(stopIndex));
-
-  // if we didn't use all the Positional objects, there were too few
-  // arg strings supplied.
-  if (positionals.length > 0) {
-    self.error('too few arguments');
-  }
-
-  // make sure all required actions were present
-  self._actions.forEach(function (action) {
-    if (action.required) {
-      if (seenActions.indexOf(action) < 0) {
-        self.error(format('Argument "%s" is required', action.getName()));
-      }
-    }
-  });
-
-  // make sure all required groups have one option present
-  var actionUsed = false;
-  self._mutuallyExclusiveGroups.forEach(function (group) {
-    if (group.required) {
-      actionUsed = group._groupActions.some(function (action) {
-        return seenNonDefaultActions.indexOf(action) !== -1;
-      });
-
-      // if no actions were used, report the error
-      if (!actionUsed) {
-        var names = [];
-        group._groupActions.forEach(function (action) {
-          if (action.help !== c.SUPPRESS) {
-            names.push(action.getName());
-          }
-        });
-        names = names.join(' ');
-        var msg = 'one of the arguments ' + names + ' is required';
-        self.error(msg);
-      }
-    }
-  });
-
-  // return the updated namespace and the extra arguments
-  return [ namespace, extras ];
-};
-
-ArgumentParser.prototype._readArgsFromFiles = function (argStrings) {
-  // expand arguments referencing files
-  var self = this;
-  var fs = require('fs');
-  var newArgStrings = [];
-  argStrings.forEach(function (argString) {
-    if (self.fromfilePrefixChars.indexOf(argString[0]) < 0) {
-      // for regular arguments, just add them back into the list
-      newArgStrings.push(argString);
-    } else {
-      // replace arguments referencing files with the file content
-      try {
-        var argstrs = [];
-        var filename = argString.slice(1);
-        var content = fs.readFileSync(filename, 'utf8');
-        content = content.trim().split('\n');
-        content.forEach(function (argLine) {
-          self.convertArgLineToArgs(argLine).forEach(function (arg) {
-            argstrs.push(arg);
-          });
-          argstrs = self._readArgsFromFiles(argstrs);
-        });
-        newArgStrings.push.apply(newArgStrings, argstrs);
-      } catch (error) {
-        return self.error(error.message);
-      }
-    }
-  });
-  return newArgStrings;
-};
-
-ArgumentParser.prototype.convertArgLineToArgs = function (argLine) {
-  return [ argLine ];
-};
-
-ArgumentParser.prototype._matchArgument = function (action, regexpArgStrings) {
-
-  // match the pattern for this action to the arg strings
-  var regexpNargs = new RegExp('^' + this._getNargsPattern(action));
-  var matches = regexpArgStrings.match(regexpNargs);
-  var message;
-
-  // throw an exception if we weren't able to find a match
-  if (!matches) {
-    switch (action.nargs) {
-      /*eslint-disable no-undefined*/
-      case undefined:
-      case null:
-        message = 'Expected one argument.';
-        break;
-      case c.OPTIONAL:
-        message = 'Expected at most one argument.';
-        break;
-      case c.ONE_OR_MORE:
-        message = 'Expected at least one argument.';
-        break;
-      default:
-        message = 'Expected %s argument(s)';
-    }
-
-    throw argumentErrorHelper(
-      action,
-      format(message, action.nargs)
-    );
-  }
-  // return the number of arguments matched
-  return matches[1].length;
-};
-
-ArgumentParser.prototype._matchArgumentsPartial = function (actions, regexpArgStrings) {
-  // progressively shorten the actions list by slicing off the
-  // final actions until we find a match
-  var self = this;
-  var result = [];
-  var actionSlice, pattern, matches;
-  var i, j;
-
-  function getLength(string) {
-    return string.length;
-  }
-
-  for (i = actions.length; i > 0; i--) {
-    pattern = '';
-    actionSlice = actions.slice(0, i);
-    for (j = 0; j < actionSlice.length; j++) {
-      pattern += self._getNargsPattern(actionSlice[j]);
-    }
-
-    pattern = new RegExp('^' + pattern);
-    matches = regexpArgStrings.match(pattern);
-
-    if (matches && matches.length > 0) {
-      // need only groups
-      matches = matches.splice(1);
-      result = result.concat(matches.map(getLength));
-      break;
-    }
-  }
-
-  // return the list of arg string counts
-  return result;
-};
-
-ArgumentParser.prototype._parseOptional = function (argString) {
-  var action, optionString, argExplicit, optionTuples;
-
-  // if it's an empty string, it was meant to be a positional
-  if (!argString) {
-    return null;
-  }
-
-  // if it doesn't start with a prefix, it was meant to be positional
-  if (this.prefixChars.indexOf(argString[0]) < 0) {
-    return null;
-  }
-
-  // if the option string is present in the parser, return the action
-  if (this._optionStringActions[argString]) {
-    return [ this._optionStringActions[argString], argString, null ];
-  }
-
-  // if it's just a single character, it was meant to be positional
-  if (argString.length === 1) {
-    return null;
-  }
-
-  // if the option string before the "=" is present, return the action
-  if (argString.indexOf('=') >= 0) {
-    optionString = argString.split('=', 1)[0];
-    argExplicit = argString.slice(optionString.length + 1);
-
-    if (this._optionStringActions[optionString]) {
-      action = this._optionStringActions[optionString];
-      return [ action, optionString, argExplicit ];
-    }
-  }
-
-  // search through all possible prefixes of the option string
-  // and all actions in the parser for possible interpretations
-  optionTuples = this._getOptionTuples(argString);
-
-  // if multiple actions match, the option string was ambiguous
-  if (optionTuples.length > 1) {
-    var optionStrings = optionTuples.map(function (optionTuple) {
-      return optionTuple[1];
-    });
-    this.error(format(
-          'Ambiguous option: "%s" could match %s.',
-          argString, optionStrings.join(', ')
-    ));
-  // if exactly one action matched, this segmentation is good,
-  // so return the parsed action
-  } else if (optionTuples.length === 1) {
-    return optionTuples[0];
-  }
-
-  // if it was not found as an option, but it looks like a negative
-  // number, it was meant to be positional
-  // unless there are negative-number-like options
-  if (argString.match(this._regexpNegativeNumber)) {
-    if (!this._hasNegativeNumberOptionals.some(Boolean)) {
-      return null;
-    }
-  }
-  // if it contains a space, it was meant to be a positional
-  if (argString.search(' ') >= 0) {
-    return null;
-  }
-
-  // it was meant to be an optional but there is no such option
-  // in this parser (though it might be a valid option in a subparser)
-  return [ null, argString, null ];
-};
-
-ArgumentParser.prototype._getOptionTuples = function (optionString) {
-  var result = [];
-  var chars = this.prefixChars;
-  var optionPrefix;
-  var argExplicit;
-  var action;
-  var actionOptionString;
-
-  // option strings starting with two prefix characters are only split at
-  // the '='
-  if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) >= 0) {
-    if (optionString.indexOf('=') >= 0) {
-      var optionStringSplit = optionString.split('=', 1);
-
-      optionPrefix = optionStringSplit[0];
-      argExplicit = optionStringSplit[1];
-    } else {
-      optionPrefix = optionString;
-      argExplicit = null;
-    }
-
-    for (actionOptionString in this._optionStringActions) {
-      if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) {
-        action = this._optionStringActions[actionOptionString];
-        result.push([ action, actionOptionString, argExplicit ]);
-      }
-    }
-
-  // single character options can be concatenated with their arguments
-  // but multiple character options always have to have their argument
-  // separate
-  } else if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) < 0) {
-    optionPrefix = optionString;
-    argExplicit = null;
-    var optionPrefixShort = optionString.substr(0, 2);
-    var argExplicitShort = optionString.substr(2);
-
-    for (actionOptionString in this._optionStringActions) {
-      if (!$$.has(this._optionStringActions, actionOptionString)) continue;
-
-      action = this._optionStringActions[actionOptionString];
-      if (actionOptionString === optionPrefixShort) {
-        result.push([ action, actionOptionString, argExplicitShort ]);
-      } else if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) {
-        result.push([ action, actionOptionString, argExplicit ]);
-      }
-    }
-
-  // shouldn't ever get here
-  } else {
-    throw new Error(format('Unexpected option string: %s.', optionString));
-  }
-  // return the collected option tuples
-  return result;
-};
-
-ArgumentParser.prototype._getNargsPattern = function (action) {
-  // in all examples below, we have to allow for '--' args
-  // which are represented as '-' in the pattern
-  var regexpNargs;
-
-  switch (action.nargs) {
-    // the default (null) is assumed to be a single argument
-    case undefined:
-    case null:
-      regexpNargs = '(-*A-*)';
-      break;
-    // allow zero or more arguments
-    case c.OPTIONAL:
-      regexpNargs = '(-*A?-*)';
-      break;
-    // allow zero or more arguments
-    case c.ZERO_OR_MORE:
-      regexpNargs = '(-*[A-]*)';
-      break;
-    // allow one or more arguments
-    case c.ONE_OR_MORE:
-      regexpNargs = '(-*A[A-]*)';
-      break;
-    // allow any number of options or arguments
-    case c.REMAINDER:
-      regexpNargs = '([-AO]*)';
-      break;
-    // allow one argument followed by any number of options or arguments
-    case c.PARSER:
-      regexpNargs = '(-*A[-AO]*)';
-      break;
-    // all others should be integers
-    default:
-      regexpNargs = '(-*' + $$.repeat('-*A', action.nargs) + '-*)';
-  }
-
-  // if this is an optional action, -- is not allowed
-  if (action.isOptional()) {
-    regexpNargs = regexpNargs.replace(/-\*/g, '');
-    regexpNargs = regexpNargs.replace(/-/g, '');
-  }
-
-  // return the pattern
-  return regexpNargs;
-};
-
-//
-// Value conversion methods
-//
-
-ArgumentParser.prototype._getValues = function (action, argStrings) {
-  var self = this;
-
-  // for everything but PARSER args, strip out '--'
-  if (action.nargs !== c.PARSER && action.nargs !== c.REMAINDER) {
-    argStrings = argStrings.filter(function (arrayElement) {
-      return arrayElement !== '--';
-    });
-  }
-
-  var value, argString;
-
-  // optional argument produces a default when not present
-  if (argStrings.length === 0 && action.nargs === c.OPTIONAL) {
-
-    value = (action.isOptional()) ? action.constant : action.defaultValue;
-
-    if (typeof (value) === 'string') {
-      value = this._getValue(action, value);
-      this._checkValue(action, value);
-    }
-
-  // when nargs='*' on a positional, if there were no command-line
-  // args, use the default if it is anything other than None
-  } else if (argStrings.length === 0 && action.nargs === c.ZERO_OR_MORE &&
-    action.optionStrings.length === 0) {
-
-    value = (action.defaultValue || argStrings);
-    this._checkValue(action, value);
-
-  // single argument or optional argument produces a single value
-  } else if (argStrings.length === 1 &&
-        (!action.nargs || action.nargs === c.OPTIONAL)) {
-
-    argString = argStrings[0];
-    value = this._getValue(action, argString);
-    this._checkValue(action, value);
-
-  // REMAINDER arguments convert all values, checking none
-  } else if (action.nargs === c.REMAINDER) {
-    value = argStrings.map(function (v) {
-      return self._getValue(action, v);
-    });
-
-  // PARSER arguments convert all values, but check only the first
-  } else if (action.nargs === c.PARSER) {
-    value = argStrings.map(function (v) {
-      return self._getValue(action, v);
-    });
-    this._checkValue(action, value[0]);
-
-  // all other types of nargs produce a list
-  } else {
-    value = argStrings.map(function (v) {
-      return self._getValue(action, v);
-    });
-    value.forEach(function (v) {
-      self._checkValue(action, v);
-    });
-  }
-
-  // return the converted value
-  return value;
-};
-
-ArgumentParser.prototype._getValue = function (action, argString) {
-  var result;
-
-  var typeFunction = this._registryGet('type', action.type, action.type);
-  if (typeof typeFunction !== 'function') {
-    var message = format('%s is not callable', typeFunction);
-    throw argumentErrorHelper(action, message);
-  }
-
-  // convert the value to the appropriate type
-  try {
-    result = typeFunction(argString);
-
-    // ArgumentTypeErrors indicate errors
-    // If action.type is not a registered string, it is a function
-    // Try to deduce its name for inclusion in the error message
-    // Failing that, include the error message it raised.
-  } catch (e) {
-    var name = null;
-    if (typeof action.type === 'string') {
-      name = action.type;
-    } else {
-      name = action.type.name || action.type.displayName || '<function>';
-    }
-    var msg = format('Invalid %s value: %s', name, argString);
-    if (name === '<function>') { msg += '\n' + e.message; }
-    throw argumentErrorHelper(action, msg);
-  }
-  // return the converted value
-  return result;
-};
-
-ArgumentParser.prototype._checkValue = function (action, value) {
-  // converted value must be one of the choices (if specified)
-  var choices = action.choices;
-  if (choices) {
-    // choise for argument can by array or string
-    if ((typeof choices === 'string' || Array.isArray(choices)) &&
-        choices.indexOf(value) !== -1) {
-      return;
-    }
-    // choise for subparsers can by only hash
-    if (typeof choices === 'object' && !Array.isArray(choices) && choices[value]) {
-      return;
-    }
-
-    if (typeof choices === 'string') {
-      choices = choices.split('').join(', ');
-    } else if (Array.isArray(choices)) {
-      choices =  choices.join(', ');
-    } else {
-      choices =  Object.keys(choices).join(', ');
-    }
-    var message = format('Invalid choice: %s (choose from [%s])', value, choices);
-    throw argumentErrorHelper(action, message);
-  }
-};
-
-//
-// Help formatting methods
-//
-
-/**
- * ArgumentParser#formatUsage -> string
- *
- * Return usage string
- *
- * See also [original guide][1]
- *
- * [1]:http://docs.python.org/dev/library/argparse.html#printing-help
- **/
-ArgumentParser.prototype.formatUsage = function () {
-  var formatter = this._getFormatter();
-  formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups);
-  return formatter.formatHelp();
-};
-
-/**
- * ArgumentParser#formatHelp -> string
- *
- * Return help
- *
- * See also [original guide][1]
- *
- * [1]:http://docs.python.org/dev/library/argparse.html#printing-help
- **/
-ArgumentParser.prototype.formatHelp = function () {
-  var formatter = this._getFormatter();
-
-  // usage
-  formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups);
-
-  // description
-  formatter.addText(this.description);
-
-  // positionals, optionals and user-defined groups
-  this._actionGroups.forEach(function (actionGroup) {
-    formatter.startSection(actionGroup.title);
-    formatter.addText(actionGroup.description);
-    formatter.addArguments(actionGroup._groupActions);
-    formatter.endSection();
-  });
-
-  // epilog
-  formatter.addText(this.epilog);
-
-  // determine help from format above
-  return formatter.formatHelp();
-};
-
-ArgumentParser.prototype._getFormatter = function () {
-  var FormatterClass = this.formatterClass;
-  var formatter = new FormatterClass({ prog: this.prog });
-  return formatter;
-};
-
-//
-//  Print functions
-//
-
-/**
- * ArgumentParser#printUsage() -> Void
- *
- * Print usage
- *
- * See also [original guide][1]
- *
- * [1]:http://docs.python.org/dev/library/argparse.html#printing-help
- **/
-ArgumentParser.prototype.printUsage = function () {
-  this._printMessage(this.formatUsage());
-};
-
-/**
- * ArgumentParser#printHelp() -> Void
- *
- * Print help
- *
- * See also [original guide][1]
- *
- * [1]:http://docs.python.org/dev/library/argparse.html#printing-help
- **/
-ArgumentParser.prototype.printHelp = function () {
-  this._printMessage(this.formatHelp());
-};
-
-ArgumentParser.prototype._printMessage = function (message, stream) {
-  if (!stream) {
-    stream = process.stdout;
-  }
-  if (message) {
-    stream.write('' + message);
-  }
-};
-
-//
-//  Exit functions
-//
-
-/**
- * ArgumentParser#exit(status=0, message) -> Void
- * - status (int): exit status
- * - message (string): message
- *
- * Print message in stderr/stdout and exit program
- **/
-ArgumentParser.prototype.exit = function (status, message) {
-  if (message) {
-    if (status === 0) {
-      this._printMessage(message);
-    } else {
-      this._printMessage(message, process.stderr);
-    }
-  }
-
-  process.exit(status);
-};
-
-/**
- * ArgumentParser#error(message) -> Void
- * - err (Error|string): message
- *
- * Error method Prints a usage message incorporating the message to stderr and
- * exits. If you override this in a subclass,
- * it should not return -- it should
- * either exit or throw an exception.
- *
- **/
-ArgumentParser.prototype.error = function (err) {
-  var message;
-  if (err instanceof Error) {
-    if (this.debug === true) {
-      throw err;
-    }
-    message = err.message;
-  } else {
-    message = err;
-  }
-  var msg = format('%s: error: %s', this.prog, message) + c.EOL;
-
-  if (this.debug === true) {
-    throw new Error(msg);
-  }
-
-  this.printUsage(process.stderr);
-
-  return this.exit(2, msg);
-};
-
-module.exports = ArgumentParser;