@turbotic/taai-agent 0.0.1

package/script-frame/node_modules/command-line-args/dist/index.cjs

@@ -0,0 +1,978 @@
+'use strict';
+
+var arrayify = require('array-back');
+var findReplace = require('find-replace');
+var t = require('typical');
+var camelCase = require('lodash.camelcase');
+
+/**
+ * Some useful tools for working with `process.argv`.
+ *
+ * @module argv-tools
+ * @typicalName argvTools
+ * @example
+ * const argvTools = require('argv-tools')
+ */
+
+/**
+ * Regular expressions for matching option formats.
+ * @static
+ */
+const re = {
+  short: /^-([^\d-])$/,
+  long: /^--(\S+)/,
+  combinedShort: /^-[^\d-]{2,}$/,
+  optEquals: /^(--\S+?)=(.*)/
+};
+
+/**
+ * Array subclass encapsulating common operations on `process.argv`.
+ * @static
+ */
+class ArgvArray extends Array {
+  /**
+   * Clears the array has loads the supplied input.
+   * @param {string[]} argv - The argv list to load. Defaults to `process.argv`.
+   */
+  load (argv) {
+    this.clear();
+    if (argv && argv !== process.argv) {
+      argv = arrayify(argv);
+    } else {
+      /* if no argv supplied, assume we are parsing process.argv */
+      argv = process.argv.slice(0);
+      const deleteCount = process.execArgv.some(isExecArg) ? 1 : 2;
+      argv.splice(0, deleteCount);
+    }
+    argv.forEach(arg => this.push(String(arg)));
+  }
+
+  /**
+   * Clear the array.
+   */
+  clear () {
+    this.length = 0;
+  }
+
+  /**
+   * expand ``--option=value` style args.
+   */
+  expandOptionEqualsNotation () {
+    if (this.some(arg => re.optEquals.test(arg))) {
+      const expandedArgs = [];
+      this.forEach(arg => {
+        const matches = arg.match(re.optEquals);
+        if (matches) {
+          expandedArgs.push(matches[1], matches[2]);
+        } else {
+          expandedArgs.push(arg);
+        }
+      });
+      this.clear();
+      this.load(expandedArgs);
+    }
+  }
+
+  /**
+   * expand getopt-style combinedShort options.
+   */
+  expandGetoptNotation () {
+    if (this.hasCombinedShortOptions()) {
+      findReplace(this, re.combinedShort, expandCombinedShortArg);
+    }
+  }
+
+  /**
+   * Returns true if the array contains combined short options (e.g. `-ab`).
+   * @returns {boolean}
+   */
+  hasCombinedShortOptions () {
+    return this.some(arg => re.combinedShort.test(arg))
+  }
+
+  static from (argv) {
+    const result = new this();
+    result.load(argv);
+    return result
+  }
+}
+
+/**
+ * Expand a combined short option.
+ * @param {string} - the string to expand, e.g. `-ab`
+ * @returns {string[]}
+ * @static
+ */
+function expandCombinedShortArg (arg) {
+  /* remove initial hypen */
+  arg = arg.slice(1);
+  return arg.split('').map(letter => '-' + letter)
+}
+
+/**
+ * Returns true if the supplied arg matches `--option=value` notation.
+ * @param {string} - the arg to test, e.g. `--one=something`
+ * @returns {boolean}
+ * @static
+ */
+function isOptionEqualsNotation (arg) {
+  return re.optEquals.test(arg)
+}
+
+/**
+ * Returns true if the supplied arg is in either long (`--one`) or short (`-o`) format.
+ * @param {string} - the arg to test, e.g. `--one`
+ * @returns {boolean}
+ * @static
+ */
+function isOption (arg) {
+  return (re.short.test(arg) || re.long.test(arg)) && !re.optEquals.test(arg)
+}
+
+/**
+ * Returns true if the supplied arg is in long (`--one`) format.
+ * @param {string} - the arg to test, e.g. `--one`
+ * @returns {boolean}
+ * @static
+ */
+function isLongOption (arg) {
+  return re.long.test(arg) && !isOptionEqualsNotation(arg)
+}
+
+/**
+ * Returns the name from a long, short or `--options=value` arg.
+ * @param {string} - the arg to inspect, e.g. `--one`
+ * @returns {string}
+ * @static
+ */
+function getOptionName (arg) {
+  if (re.short.test(arg)) {
+    return arg.match(re.short)[1]
+  } else if (isLongOption(arg)) {
+    return arg.match(re.long)[1]
+  } else if (isOptionEqualsNotation(arg)) {
+    return arg.match(re.optEquals)[1].replace(/^--/, '')
+  } else {
+    return null
+  }
+}
+
+function isValue (arg) {
+  return !(isOption(arg) || re.combinedShort.test(arg) || re.optEquals.test(arg))
+}
+
+function isExecArg (arg) {
+  return ['--eval', '-e'].indexOf(arg) > -1 || arg.startsWith('--eval=')
+}
+
+/**
+ * @module option-definition
+ */
+
+/**
+ * Describes a command-line option. Additionally, if generating a usage guide with [command-line-usage](https://github.com/75lb/command-line-usage) you could optionally add `description` and `typeLabel` properties to each definition.
+ *
+ * @alias module:option-definition
+ * @typicalname option
+ */
+class OptionDefinition {
+  constructor (definition) {
+    /**
+    * The only required definition property is `name`, so the simplest working example is
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'file' },
+    *   { name: 'depth' }
+    * ]
+    * ```
+    *
+    * Where a `type` property is not specified it will default to `String`.
+    *
+    * | #   | argv input | commandLineArgs() output |
+    * | --- | -------------------- | ------------ |
+    * | 1   | `--file` | `{ file: null }` |
+    * | 2   | `--file lib.js` | `{ file: 'lib.js' }` |
+    * | 3   | `--depth 2` | `{ depth: '2' }` |
+    *
+    * Unicode option names and aliases are valid, for example:
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'один' },
+    *   { name: '两' },
+    *   { name: 'три', alias: 'т' }
+    * ]
+    * ```
+    * @type {string}
+    */
+    this.name = definition.name;
+
+    /**
+    * The `type` value is a setter function (you receive the output from this), enabling you to be specific about the type and value received.
+    *
+    * The most common values used are `String` (the default), `Number` and `Boolean` but you can use a custom function, for example:
+    *
+    * ```js
+    * const fs = require('fs')
+    *
+    * class FileDetails {
+    *   constructor (filename) {
+    *     this.filename = filename
+    *     this.exists = fs.existsSync(filename)
+    *   }
+    * }
+    *
+    * const cli = commandLineArgs([
+    *   { name: 'file', type: filename => new FileDetails(filename) },
+    *   { name: 'depth', type: Number }
+    * ])
+    * ```
+    *
+    * | #   | argv input | commandLineArgs() output |
+    * | --- | ----------------- | ------------ |
+    * | 1   | `--file asdf.txt` | `{ file: { filename: 'asdf.txt', exists: false } }` |
+    *
+    * The `--depth` option expects a `Number`. If no value was set, you will receive `null`.
+    *
+    * | #   | argv input | commandLineArgs() output |
+    * | --- | ----------------- | ------------ |
+    * | 2   | `--depth` | `{ depth: null }` |
+    * | 3   | `--depth 2` | `{ depth: 2 }` |
+    *
+    * @type {function}
+    * @default String
+    */
+    this.type = definition.type || String;
+
+    /**
+    * getopt-style short option names. Can be any single character (unicode included) except a digit or hyphen.
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'hot', alias: 'h', type: Boolean },
+    *   { name: 'discount', alias: 'd', type: Boolean },
+    *   { name: 'courses', alias: 'c' , type: Number }
+    * ]
+    * ```
+    *
+    * | #   | argv input | commandLineArgs() output |
+    * | --- | ------------ | ------------ |
+    * | 1   | `-hcd` | `{ hot: true, courses: null, discount: true }` |
+    * | 2   | `-hdc 3` | `{ hot: true, discount: true, courses: 3 }` |
+    *
+    * @type {string}
+    */
+    this.alias = definition.alias;
+
+    /**
+    * Set this flag if the option takes a list of values. You will receive an array of values, each passed through the `type` function (if specified).
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'files', type: String, multiple: true }
+    * ]
+    * ```
+    *
+    * Note, examples 1 and 3 below demonstrate "greedy" parsing which can be disabled by using `lazyMultiple`.
+    *
+    * | #   | argv input | commandLineArgs() output |
+    * | --- | ------------ | ------------ |
+    * | 1   | `--files one.js two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+    * | 2   | `--files one.js --files two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+    * | 3   | `--files *` | `{ files: [ 'one.js', 'two.js' ] }` |
+    *
+    * @type {boolean}
+    */
+    this.multiple = definition.multiple;
+
+    /**
+     * Identical to `multiple` but with greedy parsing disabled.
+     *
+     * ```js
+     * const optionDefinitions = [
+     *   { name: 'files', lazyMultiple: true },
+     *   { name: 'verbose', alias: 'v', type: Boolean, lazyMultiple: true }
+     * ]
+     * ```
+     *
+     * | #   | argv input | commandLineArgs() output |
+     * | --- | ------------ | ------------ |
+     * | 1   | `--files one.js --files two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+     * | 2   | `-vvv` | `{ verbose: [ true, true, true ] }` |
+     *
+     * @type {boolean}
+     */
+    this.lazyMultiple = definition.lazyMultiple;
+
+    /**
+    * Any values unaccounted for by an option definition will be set on the `defaultOption`. This flag is typically set on the most commonly-used option to make for more concise usage (i.e. `$ example *.js` instead of `$ example --files *.js`).
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'files', multiple: true, defaultOption: true }
+    * ]
+    * ```
+    *
+    * | #   | argv input | commandLineArgs() output |
+    * | --- | ------------ | ------------ |
+    * | 1   | `--files one.js two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+    * | 2   | `one.js two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+    * | 3   | `*` | `{ files: [ 'one.js', 'two.js' ] }` |
+    *
+    * @type {boolean}
+    */
+    this.defaultOption = definition.defaultOption;
+
+    /**
+    * An initial value for the option.
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'files', multiple: true, defaultValue: [ 'one.js' ] },
+    *   { name: 'max', type: Number, defaultValue: 3 }
+    * ]
+    * ```
+    *
+    * | #   | argv input | commandLineArgs() output |
+    * | --- | ------------ | ------------ |
+    * | 1   |  | `{ files: [ 'one.js' ], max: 3 }` |
+    * | 2   | `--files two.js` | `{ files: [ 'two.js' ], max: 3 }` |
+    * | 3   | `--max 4` | `{ files: [ 'one.js' ], max: 4 }` |
+    *
+    * @type {*}
+    */
+    this.defaultValue = definition.defaultValue;
+
+    /**
+    * When your app has a large amount of options it makes sense to organise them in groups.
+    *
+    * There are two automatic groups: `_all` (contains all options) and `_none` (contains options without a `group` specified in their definition).
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'verbose', group: 'standard' },
+    *   { name: 'help', group: [ 'standard', 'main' ] },
+    *   { name: 'compress', group: [ 'server', 'main' ] },
+    *   { name: 'static', group: 'server' },
+    *   { name: 'debug' }
+    * ]
+    * ```
+    *
+    *<table>
+    *  <tr>
+    *    <th>#</th><th>Command Line</th><th>commandLineArgs() output</th>
+    *  </tr>
+    *  <tr>
+    *    <td>1</td><td><code>--verbose</code></td><td><pre><code>
+    *{
+    *  _all: { verbose: true },
+    *  standard: { verbose: true }
+    *}
+    *</code></pre></td>
+    *  </tr>
+    *  <tr>
+    *    <td>2</td><td><code>--debug</code></td><td><pre><code>
+    *{
+    *  _all: { debug: true },
+    *  _none: { debug: true }
+    *}
+    *</code></pre></td>
+    *  </tr>
+    *  <tr>
+    *    <td>3</td><td><code>--verbose --debug --compress</code></td><td><pre><code>
+    *{
+    *  _all: {
+    *    verbose: true,
+    *    debug: true,
+    *    compress: true
+    *  },
+    *  standard: { verbose: true },
+    *  server: { compress: true },
+    *  main: { compress: true },
+    *  _none: { debug: true }
+    *}
+    *</code></pre></td>
+    *  </tr>
+    *  <tr>
+    *    <td>4</td><td><code>--compress</code></td><td><pre><code>
+    *{
+    *  _all: { compress: true },
+    *  server: { compress: true },
+    *  main: { compress: true }
+    *}
+    *</code></pre></td>
+    *  </tr>
+    *</table>
+    *
+    * @type {string|string[]}
+    */
+    this.group = definition.group;
+
+    /* pick up any remaining properties */
+    for (const prop in definition) {
+      if (!this[prop]) this[prop] = definition[prop];
+    }
+  }
+
+  isBoolean () {
+    return this.type === Boolean || (t.isFunction(this.type) && this.type.name === 'Boolean')
+  }
+
+  isMultiple () {
+    return this.multiple || this.lazyMultiple
+  }
+
+  static create (def) {
+    const result = new this(def);
+    return result
+  }
+}
+
+/**
+ * @module option-definitions
+ */
+
+/**
+ * @alias module:option-definitions
+ */
+class Definitions extends Array {
+  /**
+   * validate option definitions
+   * @param {boolean} [caseInsensitive=false] - whether arguments will be parsed in a case insensitive manner
+   * @returns {string}
+   */
+  validate (caseInsensitive) {
+    const someHaveNoName = this.some(def => !def.name);
+    if (someHaveNoName) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definitions: the `name` property is required on each definition'
+      );
+    }
+
+    const someDontHaveFunctionType = this.some(def => def.type && typeof def.type !== 'function');
+    if (someDontHaveFunctionType) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definitions: the `type` property must be a setter fuction (default: `Boolean`)'
+      );
+    }
+
+    let invalidOption;
+
+    const numericAlias = this.some(def => {
+      invalidOption = def;
+      return t.isDefined(def.alias) && t.isNumber(def.alias)
+    });
+    if (numericAlias) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definition: to avoid ambiguity an alias cannot be numeric [--' + invalidOption.name + ' alias is -' + invalidOption.alias + ']'
+      );
+    }
+
+    const multiCharacterAlias = this.some(def => {
+      invalidOption = def;
+      return t.isDefined(def.alias) && def.alias.length !== 1
+    });
+    if (multiCharacterAlias) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definition: an alias must be a single character'
+      );
+    }
+
+    const hypenAlias = this.some(def => {
+      invalidOption = def;
+      return def.alias === '-'
+    });
+    if (hypenAlias) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definition: an alias cannot be "-"'
+      );
+    }
+
+    const duplicateName = hasDuplicates(this.map(def => caseInsensitive ? def.name.toLowerCase() : def.name));
+    if (duplicateName) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Two or more option definitions have the same name'
+      );
+    }
+
+    const duplicateAlias = hasDuplicates(this.map(def => caseInsensitive && t.isDefined(def.alias) ? def.alias.toLowerCase() : def.alias));
+    if (duplicateAlias) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Two or more option definitions have the same alias'
+      );
+    }
+
+    const duplicateDefaultOption = this.filter(def => def.defaultOption === true).length > 1;
+    if (duplicateDefaultOption) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Only one option definition can be the defaultOption'
+      );
+    }
+
+    const defaultBoolean = this.some(def => {
+      invalidOption = def;
+      return def.isBoolean() && def.defaultOption
+    });
+    if (defaultBoolean) {
+      halt(
+        'INVALID_DEFINITIONS',
+        `A boolean option ["${invalidOption.name}"] can not also be the defaultOption.`
+      );
+    }
+  }
+
+  /**
+   * Get definition by option arg (e.g. `--one` or `-o`)
+   * @param {string} [arg] the argument name to get the definition for
+   * @param {boolean} [caseInsensitive] whether to use case insensitive comparisons when finding the appropriate definition
+   * @returns {Definition}
+   */
+  get (arg, caseInsensitive) {
+    if (isOption(arg)) {
+      if (re.short.test(arg)) {
+        const shortOptionName = getOptionName(arg);
+        if (caseInsensitive) {
+          const lowercaseShortOptionName = shortOptionName.toLowerCase();
+          return this.find(def => t.isDefined(def.alias) && def.alias.toLowerCase() === lowercaseShortOptionName)
+        } else {
+          return this.find(def => def.alias === shortOptionName)
+        }
+      } else {
+        const optionName = getOptionName(arg);
+        if (caseInsensitive) {
+          const lowercaseOptionName = optionName.toLowerCase();
+          return this.find(def => def.name.toLowerCase() === lowercaseOptionName)
+        } else {
+          return this.find(def => def.name === optionName)
+        }
+      }
+    } else {
+      return this.find(def => def.name === arg)
+    }
+  }
+
+  getDefault () {
+    return this.find(def => def.defaultOption === true)
+  }
+
+  isGrouped () {
+    return this.some(def => def.group)
+  }
+
+  whereGrouped () {
+    return this.filter(containsValidGroup)
+  }
+
+  whereNotGrouped () {
+    return this.filter(def => !containsValidGroup(def))
+  }
+
+  whereDefaultValueSet () {
+    return this.filter(def => t.isDefined(def.defaultValue))
+  }
+
+  static from (definitions, caseInsensitive) {
+    if (definitions instanceof this) return definitions
+    const result = super.from(arrayify(definitions), def => OptionDefinition.create(def));
+    result.validate(caseInsensitive);
+    return result
+  }
+}
+
+function halt (name, message) {
+  const err = new Error(message);
+  err.name = name;
+  throw err
+}
+
+function containsValidGroup (def) {
+  return arrayify(def.group).some(group => group)
+}
+
+function hasDuplicates (array) {
+  const items = {};
+  for (let i = 0; i < array.length; i++) {
+    const value = array[i];
+    if (items[value]) {
+      return true
+    } else {
+      if (t.isDefined(value)) items[value] = true;
+    }
+  }
+}
+
+/**
+ * @module argv-parser
+ */
+
+/**
+ * @alias module:argv-parser
+ */
+class ArgvParser {
+  /**
+   * @param {OptionDefinitions} - Definitions array
+   * @param {object} [options] - Options
+   * @param {string[]} [options.argv] - Overrides `process.argv`
+   * @param {boolean} [options.stopAtFirstUnknown] -
+   * @param {boolean} [options.caseInsensitive] - Arguments will be parsed in a case insensitive manner. Defaults to false.
+   */
+  constructor (definitions, options) {
+    this.options = Object.assign({}, options);
+    /**
+     * Option Definitions
+     */
+    this.definitions = Definitions.from(definitions, this.options.caseInsensitive);
+
+    /**
+     * Argv
+     */
+    this.argv = ArgvArray.from(this.options.argv);
+    if (this.argv.hasCombinedShortOptions()) {
+      findReplace(this.argv, re.combinedShort.test.bind(re.combinedShort), arg => {
+        arg = arg.slice(1);
+        return arg.split('').map(letter => ({ origArg: `-${arg}`, arg: '-' + letter }))
+      });
+    }
+  }
+
+  /**
+   * Yields one `{ event, name, value, arg, def }` argInfo object for each arg in `process.argv` (or `options.argv`).
+   */
+  * [Symbol.iterator] () {
+    const definitions = this.definitions;
+
+    let def;
+    let value;
+    let name;
+    let event;
+    let singularDefaultSet = false;
+    let unknownFound = false;
+    let origArg;
+
+    for (let arg of this.argv) {
+      if (t.isPlainObject(arg)) {
+        origArg = arg.origArg;
+        arg = arg.arg;
+      }
+
+      if (unknownFound && this.options.stopAtFirstUnknown) {
+        yield { event: 'unknown_value', arg, name: '_unknown', value: undefined };
+        continue
+      }
+
+      /* handle long or short option */
+      if (isOption(arg)) {
+        def = definitions.get(arg, this.options.caseInsensitive);
+        value = undefined;
+        if (def) {
+          value = def.isBoolean() ? true : null;
+          event = 'set';
+        } else {
+          event = 'unknown_option';
+        }
+
+      /* handle --option-value notation */
+      } else if (isOptionEqualsNotation(arg)) {
+        const matches = arg.match(re.optEquals);
+        def = definitions.get(matches[1], this.options.caseInsensitive);
+        if (def) {
+          if (def.isBoolean()) {
+            yield { event: 'unknown_value', arg, name: '_unknown', value, def };
+            event = 'set';
+            value = true;
+          } else {
+            event = 'set';
+            value = matches[2];
+          }
+        } else {
+          event = 'unknown_option';
+        }
+
+      /* handle value */
+      } else if (isValue(arg)) {
+        if (def) {
+          value = arg;
+          event = 'set';
+        } else {
+          /* get the defaultOption */
+          def = this.definitions.getDefault();
+          if (def && !singularDefaultSet) {
+            value = arg;
+            event = 'set';
+          } else {
+            event = 'unknown_value';
+            def = undefined;
+          }
+        }
+      }
+
+      name = def ? def.name : '_unknown';
+      const argInfo = { event, arg, name, value, def };
+      if (origArg) {
+        argInfo.subArg = arg;
+        argInfo.arg = origArg;
+      }
+      yield argInfo;
+
+      /* unknownFound logic */
+      if (name === '_unknown') unknownFound = true;
+
+      /* singularDefaultSet logic */
+      if (def && def.defaultOption && !def.isMultiple() && event === 'set') singularDefaultSet = true;
+
+      /* reset values once consumed and yielded */
+      if (def && def.isBoolean()) def = undefined;
+      /* reset the def if it's a singular which has been set */
+      if (def && !def.multiple && t.isDefined(value) && value !== null) {
+        def = undefined;
+      }
+      value = undefined;
+      event = undefined;
+      name = undefined;
+      origArg = undefined;
+    }
+  }
+}
+
+const _value = new WeakMap();
+
+/**
+ * Encapsulates behaviour (defined by an OptionDefinition) when setting values
+ */
+class Option {
+  constructor (definition) {
+    this.definition = new OptionDefinition(definition);
+    this.state = null; /* set or default */
+    this.resetToDefault();
+  }
+
+  get () {
+    return _value.get(this)
+  }
+
+  set (val) {
+    this._set(val, 'set');
+  }
+
+  _set (val, state) {
+    const def = this.definition;
+    if (def.isMultiple()) {
+      /* don't add null or undefined to a multiple */
+      if (val !== null && val !== undefined) {
+        const arr = this.get();
+        if (this.state === 'default') arr.length = 0;
+        arr.push(def.type(val));
+        this.state = state;
+      }
+    } else {
+      /* throw if already set on a singlar defaultOption */
+      if (!def.isMultiple() && this.state === 'set') {
+        const err = new Error(`Singular option already set [${this.definition.name}=${this.get()}]`);
+        err.name = 'ALREADY_SET';
+        err.value = val;
+        err.optionName = def.name;
+        throw err
+      } else if (val === null || val === undefined) {
+        _value.set(this, val);
+        // /* required to make 'partial: defaultOption with value equal to defaultValue 2' pass */
+        // if (!(def.defaultOption && !def.isMultiple())) {
+        //   this.state = state
+        // }
+      } else {
+        _value.set(this, def.type(val));
+        this.state = state;
+      }
+    }
+  }
+
+  resetToDefault () {
+    if (t.isDefined(this.definition.defaultValue)) {
+      if (this.definition.isMultiple()) {
+        _value.set(this, arrayify(this.definition.defaultValue).slice());
+      } else {
+        _value.set(this, this.definition.defaultValue);
+      }
+    } else {
+      if (this.definition.isMultiple()) {
+        _value.set(this, []);
+      } else {
+        _value.set(this, null);
+      }
+    }
+    this.state = 'default';
+  }
+
+  static create (definition) {
+    definition = new OptionDefinition(definition);
+    if (definition.isBoolean()) {
+      return FlagOption.create(definition)
+    } else {
+      return new this(definition)
+    }
+  }
+}
+
+class FlagOption extends Option {
+  set (val) {
+    super.set(true);
+  }
+
+  static create (def) {
+    return new this(def)
+  }
+}
+
+/**
+ * A map of { DefinitionNameString: Option }. By default, an Output has an `_unknown` property and any options with defaultValues.
+ */
+class Output extends Map {
+  constructor (definitions) {
+    super();
+    /**
+     * @type {OptionDefinitions}
+     */
+    this.definitions = Definitions.from(definitions);
+
+    /* by default, an Output has an `_unknown` property and any options with defaultValues */
+    this.set('_unknown', Option.create({ name: '_unknown', multiple: true }));
+    for (const def of this.definitions.whereDefaultValueSet()) {
+      this.set(def.name, Option.create(def));
+    }
+  }
+
+  toObject (options) {
+    options = options || {};
+    const output = {};
+    for (const item of this) {
+      const name = options.camelCase && item[0] !== '_unknown' ? camelCase(item[0]) : item[0];
+      const option = item[1];
+      if (name === '_unknown' && !option.get().length) continue
+      output[name] = option.get();
+    }
+
+    if (options.skipUnknown) delete output._unknown;
+    return output
+  }
+}
+
+class GroupedOutput extends Output {
+  toObject (options) {
+    const superOutputNoCamel = super.toObject({ skipUnknown: options.skipUnknown });
+    const superOutput = super.toObject(options);
+    const unknown = superOutput._unknown;
+    delete superOutput._unknown;
+    const grouped = {
+      _all: superOutput
+    };
+    if (unknown && unknown.length) grouped._unknown = unknown;
+
+    this.definitions.whereGrouped().forEach(def => {
+      const name = options.camelCase ? camelCase(def.name) : def.name;
+      const outputValue = superOutputNoCamel[def.name];
+      for (const groupName of arrayify(def.group)) {
+        grouped[groupName] = grouped[groupName] || {};
+        if (t.isDefined(outputValue)) {
+          grouped[groupName][name] = outputValue;
+        }
+      }
+    });
+
+    this.definitions.whereNotGrouped().forEach(def => {
+      const name = options.camelCase ? camelCase(def.name) : def.name;
+      const outputValue = superOutputNoCamel[def.name];
+      if (t.isDefined(outputValue)) {
+        if (!grouped._none) grouped._none = {};
+        grouped._none[name] = outputValue;
+      }
+    });
+    return grouped
+  }
+}
+
+/**
+ * @module command-line-args
+ */
+
+/**
+ * Returns an object containing all option values set on the command line. By default it parses the global  [`process.argv`](https://nodejs.org/api/process.html#process_process_argv) array.
+ *
+ * Parsing is strict by default - an exception is thrown if the user sets a singular option more than once or sets an unknown value or option (one without a valid [definition](https://github.com/75lb/command-line-args/blob/master/doc/option-definition.md)). To be more permissive, enabling [partial](https://github.com/75lb/command-line-args/wiki/Partial-mode-example) or [stopAtFirstUnknown](https://github.com/75lb/command-line-args/wiki/stopAtFirstUnknown) modes will return known options in the usual manner while collecting unknown arguments in a separate `_unknown` property.
+ *
+ * @param {Array<OptionDefinition>} - An array of [OptionDefinition](https://github.com/75lb/command-line-args/blob/master/doc/option-definition.md) objects
+ * @param {object} [options] - Options.
+ * @param {string[]} [options.argv] - An array of strings which, if present will be parsed instead  of `process.argv`.
+ * @param {boolean} [options.partial] - If `true`, an array of unknown arguments is returned in the `_unknown` property of the output.
+ * @param {boolean} [options.stopAtFirstUnknown] - If `true`, parsing will stop at the first unknown argument and the remaining arguments returned in `_unknown`. When set, `partial: true` is also implied.
+ * @param {boolean} [options.camelCase] - If `true`, options with hypenated names (e.g. `move-to`) will be returned in camel-case (e.g. `moveTo`).
+ * @param {boolean} [options.caseInsensitive] - If `true`, the case of each option name or alias parsed is insignificant. In other words, both `--Verbose` and `--verbose`, `-V` and `-v` would be equivalent. Defaults to false.
+ * @returns {object}
+ * @throws `UNKNOWN_OPTION` If `options.partial` is false and the user set an undefined option. The `err.optionName` property contains the arg that specified an unknown option, e.g. `--one`.
+ * @throws `UNKNOWN_VALUE` If `options.partial` is false and the user set a value unaccounted for by an option definition. The `err.value` property contains the unknown value, e.g. `5`.
+ * @throws `ALREADY_SET` If a user sets a singular, non-multiple option more than once. The `err.optionName` property contains the option name that has already been set, e.g. `one`.
+ * @throws `INVALID_DEFINITIONS`
+ *   - If an option definition is missing the required `name` property
+ *   - If an option definition has a `type` value that's not a function
+ *   - If an alias is numeric, a hyphen or a length other than 1
+ *   - If an option definition name was used more than once
+ *   - If an option definition alias was used more than once
+ *   - If more than one option definition has `defaultOption: true`
+ *   - If a `Boolean` option is also set as the `defaultOption`.
+ * @alias module:command-line-args
+ */
+function commandLineArgs (optionDefinitions, options) {
+  options = options || {};
+  if (options.stopAtFirstUnknown) options.partial = true;
+  optionDefinitions = Definitions.from(optionDefinitions, options.caseInsensitive);
+
+  const parser = new ArgvParser(optionDefinitions, {
+    argv: options.argv,
+    stopAtFirstUnknown: options.stopAtFirstUnknown,
+    caseInsensitive: options.caseInsensitive
+  });
+
+  const OutputClass = optionDefinitions.isGrouped() ? GroupedOutput : Output;
+  const output = new OutputClass(optionDefinitions);
+
+  /* Iterate the parser setting each known value to the output. Optionally, throw on unknowns. */
+  for (const argInfo of parser) {
+    const arg = argInfo.subArg || argInfo.arg;
+    if (!options.partial) {
+      if (argInfo.event === 'unknown_value') {
+        const err = new Error(`Unknown value: ${arg}`);
+        err.name = 'UNKNOWN_VALUE';
+        err.value = arg;
+        throw err
+      } else if (argInfo.event === 'unknown_option') {
+        const err = new Error(`Unknown option: ${arg}`);
+        err.name = 'UNKNOWN_OPTION';
+        err.optionName = arg;
+        throw err
+      }
+    }
+
+    let option;
+    if (output.has(argInfo.name)) {
+      option = output.get(argInfo.name);
+    } else {
+      option = Option.create(argInfo.def);
+      output.set(argInfo.name, option);
+    }
+
+    if (argInfo.name === '_unknown') {
+      option.set(arg);
+    } else {
+      option.set(argInfo.value);
+    }
+  }
+
+  return output.toObject({ skipUnknown: !options.partial, camelCase: options.camelCase })
+}
+
+module.exports = commandLineArgs;