@sveltejs/kit 1.0.0-next.168 → 1.0.0-next.171

package/dist/chunks/index.js

@@ -1,17 +1,16 @@
-import require$$0, { EventEmitter } from 'events';
+import require$$0$2, { EventEmitter } from 'events';
 import fs__default from 'fs';
 import path__default from 'path';
 import { URL } from 'url';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
-import { c as createCommonjsModule } from './_commonjsHelpers.js';
-import util from 'util';
-import os from 'os';
-import http from 'http';
-import https from 'https';
+import require$$0$1 from 'util';
+import require$$0 from 'os';
+import http$1 from 'http';
+import https$1 from 'https';
 import require$$1 from 'child_process';
-import require$$0$1 from 'domain';
+import require$$0$3 from 'domain';
 import 'querystring';
-import vm from 'vm';
+import require$$10 from 'vm';
 import CheapWatch from 'cheap-watch';
 import { r as rimraf, c as copy_assets, p as print_config_conflicts, a as resolve_entry, $ } from '../cli.js';
 import vite from 'vite';
@@ -19,7 +18,6 @@ import { respond } from '../ssr.js';
 import { d as deep_merge, c as create_manifest_data, a as create_app } from './index2.js';
 import { __fetch_polyfill } from '../install-fetch.js';
 import { getRawBody } from '../node.js';
-import { g as get_server } from './index3.js';
 import { S as SVELTE_KIT, a as SVELTE_KIT_ASSETS } from './constants.js';
 import { c as coalesce_to_error } from './error.js';
 import 'sade';
@@ -30,6 +28,14 @@ import 'zlib';
 import 'stream';
 import 'crypto';
 
+var amphtmlValidator = {};
+
+var safe = {exports: {}};
+
+var colors$1 = {exports: {}};
+
+var styles = {exports: {}};
+
 /*
 The MIT License (MIT)
 
@@ -55,7 +61,7 @@ THE SOFTWARE.
 
 */
 
-var styles_1 = createCommonjsModule(function (module) {
+(function (module) {
 var styles = {};
 module['exports'] = styles;
 
@@ -126,7 +132,7 @@ Object.keys(codes).forEach(function(key) {
   style.open = '\u001b[' + val[0] + 'm';
   style.close = '\u001b[' + val[1] + 'm';
 });
-});
+}(styles));
 
 /*
 MIT License
@@ -152,7 +158,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-var hasFlag = function(flag, argv) {
+var hasFlag$1 = function(flag, argv) {
   argv = argv || process.argv;
 
   var terminatorPos = argv.indexOf('--');
@@ -187,8 +193,8 @@ THE SOFTWARE.
 
 */
 
-
-
+var os = require$$0;
+var hasFlag = hasFlag$1;
 
 var env = process.env;
 
@@ -312,7 +318,9 @@ var supportsColors = {
   stderr: getSupportLevel(process.stderr),
 };
 
-var trap = createCommonjsModule(function (module) {
+var trap = {exports: {}};
+
+(function (module) {
 module['exports'] = function runTheTrap(text, options) {
   var result = '';
   text = text || 'Run the trap, drop the bass';
@@ -359,9 +367,11 @@ module['exports'] = function runTheTrap(text, options) {
   });
   return result;
 };
-});
+}(trap));
+
+var zalgo = {exports: {}};
 
-var zalgo = createCommonjsModule(function (module) {
+(function (module) {
 // please no
 module['exports'] = function zalgo(text, options) {
   text = text || '   he is here   ';
@@ -471,9 +481,11 @@ module['exports'] = function zalgo(text, options) {
   // don't summon him
   return heComes(text, options);
 };
-});
+}(zalgo));
+
+var america = {exports: {}};
 
-var america = createCommonjsModule(function (module) {
+(function (module) {
 module['exports'] = function(colors) {
   return function(letter, i, exploded) {
     if (letter === ' ') return letter;
@@ -484,17 +496,21 @@ module['exports'] = function(colors) {
     }
   };
 };
-});
+}(america));
+
+var zebra = {exports: {}};
 
-var zebra = createCommonjsModule(function (module) {
+(function (module) {
 module['exports'] = function(colors) {
   return function(letter, i, exploded) {
     return i % 2 === 0 ? letter : colors.inverse(letter);
   };
 };
-});
+}(zebra));
+
+var rainbow = {exports: {}};
 
-var rainbow = createCommonjsModule(function (module) {
+(function (module) {
 module['exports'] = function(colors) {
   // RoY G BiV
   var rainbowColors = ['red', 'yellow', 'green', 'blue', 'magenta'];
@@ -506,9 +522,11 @@ module['exports'] = function(colors) {
     }
   };
 };
-});
+}(rainbow));
+
+var random = {exports: {}};
 
-var random = createCommonjsModule(function (module) {
+(function (module) {
 module['exports'] = function(colors) {
   var available = ['underline', 'inverse', 'grey', 'yellow', 'red', 'green',
     'blue', 'white', 'cyan', 'magenta', 'brightYellow', 'brightRed',
@@ -520,7 +538,7 @@ module['exports'] = function(colors) {
       ](letter);
   };
 };
-});
+}(random));
 
 /*
 
@@ -552,14 +570,14 @@ THE SOFTWARE.
 
 */
 
-var colors_1 = createCommonjsModule(function (module) {
+(function (module) {
 var colors = {};
 module['exports'] = colors;
 
 colors.themes = {};
 
-
-var ansiStyles = colors.styles = styles_1;
+var util = require$$0$1;
+var ansiStyles = colors.styles = styles.exports;
 var defineProps = Object.defineProperties;
 var newLineRegex = new RegExp(/[\r\n]+/g);
 
@@ -618,7 +636,7 @@ function build(_styles) {
   return builder;
 }
 
-var styles = (function() {
+var styles$1 = (function() {
   var ret = {};
   ansiStyles.grey = ansiStyles.gray;
   Object.keys(ansiStyles).forEach(function(key) {
@@ -633,7 +651,7 @@ var styles = (function() {
   return ret;
 })();
 
-var proto = defineProps(function colors() {}, styles);
+var proto = defineProps(function colors() {}, styles$1);
 
 function applyStyle() {
   var args = Array.prototype.slice.call(arguments);
@@ -698,7 +716,7 @@ colors.setTheme = function(theme) {
 
 function init() {
   var ret = {};
-  Object.keys(styles).forEach(function(name) {
+  Object.keys(styles$1).forEach(function(name) {
     ret[name] = {
       get: function() {
         return build([name]);
@@ -715,15 +733,15 @@ var sequencer = function sequencer(map, str) {
 };
 
 // custom formatter methods
-colors.trap = trap;
-colors.zalgo = zalgo;
+colors.trap = trap.exports;
+colors.zalgo = zalgo.exports;
 
 // maps
 colors.maps = {};
-colors.maps.america = america(colors);
-colors.maps.zebra = zebra(colors);
-colors.maps.rainbow = rainbow(colors);
-colors.maps.random = random(colors);
+colors.maps.america = america.exports(colors);
+colors.maps.zebra = zebra.exports(colors);
+colors.maps.rainbow = rainbow.exports(colors);
+colors.maps.random = random.exports(colors);
 
 for (var map in colors.maps) {
   (function(map) {
@@ -734,9 +752,9 @@ for (var map in colors.maps) {
 }
 
 defineProps(colors, init());
-});
+}(colors$1));
 
-var safe = createCommonjsModule(function (module) {
+(function (module) {
 //
 // Remark: Requiring this file will use the "safe" colors API,
 // which will not touch String.prototype.
@@ -745,1243 +763,2227 @@ var safe = createCommonjsModule(function (module) {
 //   colors.red("foo")
 //
 //
+var colors = colors$1.exports;
+module['exports'] = colors;
+}(safe));
 
-module['exports'] = colors_1;
-});
+var commander = {exports: {}};
 
 /**
  * Module dependencies.
  */
 
-var commander = createCommonjsModule(function (module, exports) {
-var EventEmitter = require$$0.EventEmitter;
-var spawn = require$$1.spawn;
-
-var dirname = path__default.dirname;
-var basename = path__default.basename;
+(function (module, exports) {
+const EventEmitter = require$$0$2.EventEmitter;
+const childProcess = require$$1;
+const path = path__default;
+const fs = fs__default;
 
+// @ts-check
 
-/**
- * Inherit `Command` from `EventEmitter.prototype`.
- */
-
-util.inherits(Command, EventEmitter);
-
-/**
- * Expose the root command.
- */
+// Although this is a class, methods are static in style to allow override using subclass or just functions.
+class Help {
+  constructor() {
+    this.helpWidth = undefined;
+    this.sortSubcommands = false;
+    this.sortOptions = false;
+  }
 
-exports = module.exports = new Command();
+  /**
+   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+   *
+   * @param {Command} cmd
+   * @returns {Command[]}
+   */
 
-/**
- * Expose `Command`.
- */
+  visibleCommands(cmd) {
+    const visibleCommands = cmd.commands.filter(cmd => !cmd._hidden);
+    if (cmd._hasImplicitHelpCommand()) {
+      // Create a command matching the implicit help command.
+      const args = cmd._helpCommandnameAndArgs.split(/ +/);
+      const helpCommand = cmd.createCommand(args.shift())
+        .helpOption(false);
+      helpCommand.description(cmd._helpCommandDescription);
+      helpCommand._parseExpectedArgs(args);
+      visibleCommands.push(helpCommand);
+    }
+    if (this.sortSubcommands) {
+      visibleCommands.sort((a, b) => {
+        return a.name().localeCompare(b.name());
+      });
+    }
+    return visibleCommands;
+  }
 
-exports.Command = Command;
+  /**
+   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+   *
+   * @param {Command} cmd
+   * @returns {Option[]}
+   */
 
-/**
- * Expose `Option`.
- */
+  visibleOptions(cmd) {
+    const visibleOptions = cmd.options.filter((option) => !option.hidden);
+    // Implicit help
+    const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
+    const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
+    if (showShortHelpFlag || showLongHelpFlag) {
+      let helpOption;
+      if (!showShortHelpFlag) {
+        helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
+      } else if (!showLongHelpFlag) {
+        helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
+      } else {
+        helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
+      }
+      visibleOptions.push(helpOption);
+    }
+    if (this.sortOptions) {
+      const getSortKey = (option) => {
+        // WYSIWYG for order displayed in help with short before long, no special handling for negated.
+        return option.short ? option.short.replace(/^-/, '') : option.long.replace(/^--/, '');
+      };
+      visibleOptions.sort((a, b) => {
+        return getSortKey(a).localeCompare(getSortKey(b));
+      });
+    }
+    return visibleOptions;
+  }
 
-exports.Option = Option;
+  /**
+   * Get an array of the arguments which have descriptions.
+   *
+   * @param {Command} cmd
+   * @returns {{ term: string, description:string }[]}
+   */
 
-/**
- * Initialize a new `Option` with the given `flags` and `description`.
- *
- * @param {String} flags
- * @param {String} description
- * @api public
- */
+  visibleArguments(cmd) {
+    if (cmd._argsDescription && cmd._args.length) {
+      return cmd._args.map((argument) => {
+        return { term: argument.name, description: cmd._argsDescription[argument.name] || '' };
+      }, 0);
+    }
+    return [];
+  }
 
-function Option(flags, description) {
-  this.flags = flags;
-  this.required = ~flags.indexOf('<');
-  this.optional = ~flags.indexOf('[');
-  this.bool = !~flags.indexOf('-no-');
-  flags = flags.split(/[ ,|]+/);
-  if (flags.length > 1 && !/^[[<]/.test(flags[1])) this.short = flags.shift();
-  this.long = flags.shift();
-  this.description = description || '';
-}
+  /**
+   * Get the command term to show in the list of subcommands.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
 
-/**
- * Return option name.
- *
- * @return {String}
- * @api private
- */
+  subcommandTerm(cmd) {
+    // Legacy. Ignores custom usage string, and nested commands.
+    const args = cmd._args.map(arg => humanReadableArgName(arg)).join(' ');
+    return cmd._name +
+      (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') +
+      (cmd.options.length ? ' [options]' : '') + // simplistic check for non-help option
+      (args ? ' ' + args : '');
+  }
 
-Option.prototype.name = function() {
-  return this.long
-    .replace('--', '')
-    .replace('no-', '');
-};
+  /**
+   * Get the option term to show in the list of options.
+   *
+   * @param {Option} option
+   * @returns {string}
+   */
 
-/**
- * Return option name, in a camelcase format that can be used
- * as a object attribute key.
- *
- * @return {String}
- * @api private
- */
+  optionTerm(option) {
+    return option.flags;
+  }
 
-Option.prototype.attributeName = function() {
-  return camelcase(this.name());
-};
+  /**
+   * Get the longest command term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
 
-/**
- * Check if `arg` matches the short or long flag.
- *
- * @param {String} arg
- * @return {Boolean}
- * @api private
- */
+  longestSubcommandTermLength(cmd, helper) {
+    return helper.visibleCommands(cmd).reduce((max, command) => {
+      return Math.max(max, helper.subcommandTerm(command).length);
+    }, 0);
+  };
 
-Option.prototype.is = function(arg) {
-  return this.short === arg || this.long === arg;
-};
+  /**
+   * Get the longest option term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
 
-/**
- * Initialize a new `Command`.
- *
- * @param {String} name
- * @api public
- */
+  longestOptionTermLength(cmd, helper) {
+    return helper.visibleOptions(cmd).reduce((max, option) => {
+      return Math.max(max, helper.optionTerm(option).length);
+    }, 0);
+  };
 
-function Command(name) {
-  this.commands = [];
-  this.options = [];
-  this._execs = {};
-  this._allowUnknownOption = false;
-  this._args = [];
-  this._name = name || '';
-}
+  /**
+   * Get the longest argument term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
 
-/**
- * Add command `name`.
- *
- * The `.action()` callback is invoked when the
- * command `name` is specified via __ARGV__,
- * and the remaining arguments are applied to the
- * function for access.
- *
- * When the `name` is "*" an un-matched command
- * will be passed as the first arg, followed by
- * the rest of __ARGV__ remaining.
- *
- * Examples:
- *
- *      program
- *        .version('0.0.1')
- *        .option('-C, --chdir <path>', 'change the working directory')
- *        .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
- *        .option('-T, --no-tests', 'ignore test hook')
- *
- *      program
- *        .command('setup')
- *        .description('run remote setup commands')
- *        .action(function() {
- *          console.log('setup');
- *        });
- *
- *      program
- *        .command('exec <cmd>')
- *        .description('run the given remote command')
- *        .action(function(cmd) {
- *          console.log('exec "%s"', cmd);
- *        });
- *
- *      program
- *        .command('teardown <dir> [otherDirs...]')
- *        .description('run teardown commands')
- *        .action(function(dir, otherDirs) {
- *          console.log('dir "%s"', dir);
- *          if (otherDirs) {
- *            otherDirs.forEach(function (oDir) {
- *              console.log('dir "%s"', oDir);
- *            });
- *          }
- *        });
- *
- *      program
- *        .command('*')
- *        .description('deploy the given env')
- *        .action(function(env) {
- *          console.log('deploying "%s"', env);
- *        });
- *
- *      program.parse(process.argv);
-  *
- * @param {String} name
- * @param {String} [desc] for git-style sub-commands
- * @return {Command} the new command
- * @api public
- */
+  longestArgumentTermLength(cmd, helper) {
+    return helper.visibleArguments(cmd).reduce((max, argument) => {
+      return Math.max(max, argument.term.length);
+    }, 0);
+  };
 
-Command.prototype.command = function(name, desc, opts) {
-  if (typeof desc === 'object' && desc !== null) {
-    opts = desc;
-    desc = null;
-  }
-  opts = opts || {};
-  var args = name.split(/ +/);
-  var cmd = new Command(args.shift());
+  /**
+   * Get the command usage to be displayed at the top of the built-in help.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
 
-  if (desc) {
-    cmd.description(desc);
-    this.executables = true;
-    this._execs[cmd._name] = true;
-    if (opts.isDefault) this.defaultExecutable = cmd._name;
+  commandUsage(cmd) {
+    // Usage
+    let cmdName = cmd._name;
+    if (cmd._aliases[0]) {
+      cmdName = cmdName + '|' + cmd._aliases[0];
+    }
+    let parentCmdNames = '';
+    for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
+      parentCmdNames = parentCmd.name() + ' ' + parentCmdNames;
+    }
+    return parentCmdNames + cmdName + ' ' + cmd.usage();
   }
-  cmd._noHelp = !!opts.noHelp;
-  this.commands.push(cmd);
-  cmd.parseExpectedArgs(args);
-  cmd.parent = this;
-
-  if (desc) return this;
-  return cmd;
-};
-
-/**
- * Define argument syntax for the top-level command.
- *
- * @api public
- */
 
-Command.prototype.arguments = function(desc) {
-  return this.parseExpectedArgs(desc.split(/ +/));
-};
+  /**
+   * Get the description for the command.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
 
-/**
- * Add an implicit `help [cmd]` subcommand
- * which invokes `--help` for the given command.
- *
- * @api private
- */
+  commandDescription(cmd) {
+    // @ts-ignore: overloaded return type
+    return cmd.description();
+  }
 
-Command.prototype.addImplicitHelpCommand = function() {
-  this.command('help [cmd]', 'display help for [cmd]');
-};
+  /**
+   * Get the command description to show in the list of subcommands.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
 
-/**
- * Parse expected `args`.
- *
- * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
- *
- * @param {Array} args
- * @return {Command} for chaining
- * @api public
- */
+  subcommandDescription(cmd) {
+    // @ts-ignore: overloaded return type
+    return cmd.description();
+  }
 
-Command.prototype.parseExpectedArgs = function(args) {
-  if (!args.length) return;
-  var self = this;
-  args.forEach(function(arg) {
-    var argDetails = {
-      required: false,
-      name: '',
-      variadic: false
-    };
+  /**
+   * Get the option description to show in the list of options.
+   *
+   * @param {Option} option
+   * @return {string}
+   */
 
-    switch (arg[0]) {
-      case '<':
-        argDetails.required = true;
-        argDetails.name = arg.slice(1, -1);
-        break;
-      case '[':
-        argDetails.name = arg.slice(1, -1);
-        break;
+  optionDescription(option) {
+    if (option.negate) {
+      return option.description;
     }
-
-    if (argDetails.name.length > 3 && argDetails.name.slice(-3) === '...') {
-      argDetails.variadic = true;
-      argDetails.name = argDetails.name.slice(0, -3);
+    const extraInfo = [];
+    if (option.argChoices) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`);
     }
-    if (argDetails.name) {
-      self._args.push(argDetails);
+    if (option.defaultValue !== undefined) {
+      extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
     }
-  });
-  return this;
-};
-
-/**
- * Register callback `fn` for the command.
- *
- * Examples:
- *
- *      program
- *        .command('help')
- *        .description('display verbose help')
- *        .action(function() {
- *           // output help here
- *        });
- *
- * @param {Function} fn
- * @return {Command} for chaining
- * @api public
- */
-
-Command.prototype.action = function(fn) {
-  var self = this;
-  var listener = function(args, unknown) {
-    // Parse any so-far unknown options
-    args = args || [];
-    unknown = unknown || [];
-
-    var parsed = self.parseOptions(unknown);
-
-    // Output help if necessary
-    outputHelpIfNecessary(self, parsed.unknown);
-
-    // If there are still any unknown options, then we simply
-    // die, unless someone asked for help, in which case we give it
-    // to them, and then we die.
-    if (parsed.unknown.length > 0) {
-      self.unknownOption(parsed.unknown[0]);
+    if (extraInfo.length > 0) {
+      return `${option.description} (${extraInfo.join(', ')})`;
     }
+    return option.description;
+  };
 
-    // Leftover arguments need to be pushed back. Fixes issue #56
-    if (parsed.args.length) args = parsed.args.concat(args);
-
-    self._args.forEach(function(arg, i) {
-      if (arg.required && args[i] == null) {
-        self.missingArgument(arg.name);
-      } else if (arg.variadic) {
-        if (i !== self._args.length - 1) {
-          self.variadicArgNotLast(arg.name);
-        }
+  /**
+   * Generate the built-in help text.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {string}
+   */
 
-        args[i] = args.splice(i);
+  formatHelp(cmd, helper) {
+    const termWidth = helper.padWidth(cmd, helper);
+    const helpWidth = helper.helpWidth || 80;
+    const itemIndentWidth = 2;
+    const itemSeparatorWidth = 2; // between term and description
+    function formatItem(term, description) {
+      if (description) {
+        const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+        return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
       }
-    });
-
-    // Always append ourselves to the end of the arguments,
-    // to make sure we match the number of arguments the user
-    // expects
-    if (self._args.length) {
-      args[self._args.length] = self;
-    } else {
-      args.push(self);
+      return term;
+    }    function formatList(textArray) {
+      return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
     }
 
-    fn.apply(self, args);
-  };
-  var parent = this.parent || this;
-  var name = parent === this ? '*' : this._name;
-  parent.on('command:' + name, listener);
-  if (this._alias) parent.on('command:' + this._alias, listener);
-  return this;
-};
-
-/**
- * Define option with `flags`, `description` and optional
- * coercion `fn`.
- *
- * The `flags` string should contain both the short and long flags,
- * separated by comma, a pipe or space. The following are all valid
- * all will output this way when `--help` is used.
- *
- *    "-p, --pepper"
- *    "-p|--pepper"
- *    "-p --pepper"
- *
- * Examples:
- *
- *     // simple boolean defaulting to false
- *     program.option('-p, --pepper', 'add pepper');
- *
- *     --pepper
- *     program.pepper
- *     // => Boolean
- *
- *     // simple boolean defaulting to true
- *     program.option('-C, --no-cheese', 'remove cheese');
- *
- *     program.cheese
- *     // => true
- *
- *     --no-cheese
- *     program.cheese
- *     // => false
- *
- *     // required argument
- *     program.option('-C, --chdir <path>', 'change the working directory');
- *
- *     --chdir /tmp
- *     program.chdir
- *     // => "/tmp"
- *
- *     // optional argument
- *     program.option('-c, --cheese [type]', 'add cheese [marble]');
- *
- * @param {String} flags
- * @param {String} description
- * @param {Function|*} [fn] or default
- * @param {*} [defaultValue]
- * @return {Command} for chaining
- * @api public
- */
-
-Command.prototype.option = function(flags, description, fn, defaultValue) {
-  var self = this,
-    option = new Option(flags, description),
-    oname = option.name(),
-    name = option.attributeName();
+    // Usage
+    let output = [`Usage: ${helper.commandUsage(cmd)}`, ''];
 
-  // default as 3rd arg
-  if (typeof fn !== 'function') {
-    if (fn instanceof RegExp) {
-      var regex = fn;
-      fn = function(val, def) {
-        var m = regex.exec(val);
-        return m ? m[0] : def;
-      };
-    } else {
-      defaultValue = fn;
-      fn = null;
+    // Description
+    const commandDescription = helper.commandDescription(cmd);
+    if (commandDescription.length > 0) {
+      output = output.concat([commandDescription, '']);
     }
-  }
 
-  // preassign default value only for --no-*, [optional], or <required>
-  if (!option.bool || option.optional || option.required) {
-    // when --no-* we make sure default is true
-    if (!option.bool) defaultValue = true;
-    // preassign only if we have a default
-    if (defaultValue !== undefined) {
-      self[name] = defaultValue;
-      option.defaultValue = defaultValue;
+    // Arguments
+    const argumentList = helper.visibleArguments(cmd).map((argument) => {
+      return formatItem(argument.term, argument.description);
+    });
+    if (argumentList.length > 0) {
+      output = output.concat(['Arguments:', formatList(argumentList), '']);
     }
-  }
-
-  // register the option
-  this.options.push(option);
 
-  // when it's passed assign the value
-  // and conditionally invoke the callback
-  this.on('option:' + oname, function(val) {
-    // coercion
-    if (val !== null && fn) {
-      val = fn(val, self[name] === undefined ? defaultValue : self[name]);
+    // Options
+    const optionList = helper.visibleOptions(cmd).map((option) => {
+      return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+    });
+    if (optionList.length > 0) {
+      output = output.concat(['Options:', formatList(optionList), '']);
     }
 
-    // unassigned or bool
-    if (typeof self[name] === 'boolean' || typeof self[name] === 'undefined') {
-      // if no value, bool true, and we have a default, then use it!
-      if (val == null) {
-        self[name] = option.bool
-          ? defaultValue || true
-          : false;
-      } else {
-        self[name] = val;
-      }
-    } else if (val !== null) {
-      // reassign
-      self[name] = val;
+    // Commands
+    const commandList = helper.visibleCommands(cmd).map((cmd) => {
+      return formatItem(helper.subcommandTerm(cmd), helper.subcommandDescription(cmd));
+    });
+    if (commandList.length > 0) {
+      output = output.concat(['Commands:', formatList(commandList), '']);
     }
-  });
 
-  return this;
-};
+    return output.join('\n');
+  }
 
-/**
- * Allow unknown options on the command line.
- *
- * @param {Boolean} arg if `true` or omitted, no error will be thrown
- * for unknown options.
- * @api public
- */
-Command.prototype.allowUnknownOption = function(arg) {
-  this._allowUnknownOption = arguments.length === 0 || arg;
-  return this;
-};
+  /**
+   * Calculate the pad width from the maximum term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
 
-/**
- * Parse `argv`, settings options and invoking commands when defined.
- *
- * @param {Array} argv
- * @return {Command} for chaining
- * @api public
- */
+  padWidth(cmd, helper) {
+    return Math.max(
+      helper.longestOptionTermLength(cmd, helper),
+      helper.longestSubcommandTermLength(cmd, helper),
+      helper.longestArgumentTermLength(cmd, helper)
+    );
+  };
 
-Command.prototype.parse = function(argv) {
-  // implicit help
-  if (this.executables) this.addImplicitHelpCommand();
+  /**
+   * Wrap the given string to width characters per line, with lines after the first indented.
+   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+   *
+   * @param {string} str
+   * @param {number} width
+   * @param {number} indent
+   * @param {number} [minColumnWidth=40]
+   * @return {string}
+   *
+   */
 
-  // store raw args
-  this.rawArgs = argv;
+  wrap(str, width, indent, minColumnWidth = 40) {
+    // Detect manually wrapped and indented strings by searching for line breaks
+    // followed by multiple spaces/tabs.
+    if (str.match(/[\n]\s+/)) return str;
+    // Do not wrap if not enough room for a wrapped column of text (as could end up with a word per line).
+    const columnWidth = width - indent;
+    if (columnWidth < minColumnWidth) return str;
+
+    const leadingStr = str.substr(0, indent);
+    const columnText = str.substr(indent);
+
+    const indentString = ' '.repeat(indent);
+    const regex = new RegExp('.{1,' + (columnWidth - 1) + '}([\\s\u200B]|$)|[^\\s\u200B]+?([\\s\u200B]|$)', 'g');
+    const lines = columnText.match(regex) || [];
+    return leadingStr + lines.map((line, i) => {
+      if (line.slice(-1) === '\n') {
+        line = line.slice(0, line.length - 1);
+      }
+      return ((i > 0) ? indentString : '') + line.trimRight();
+    }).join('\n');
+  }
+}
 
-  // guess name
-  this._name = this._name || basename(argv[1], '.js');
+class Option {
+  /**
+   * Initialize a new `Option` with the given `flags` and `description`.
+   *
+   * @param {string} flags
+   * @param {string} [description]
+   */
 
-  // github-style sub-commands with no sub-command
-  if (this.executables && argv.length < 3 && !this.defaultExecutable) {
-    // this user needs help
-    argv.push('--help');
+  constructor(flags, description) {
+    this.flags = flags;
+    this.description = description || '';
+
+    this.required = flags.includes('<'); // A value must be supplied when the option is specified.
+    this.optional = flags.includes('['); // A value is optional when the option is specified.
+    // variadic test ignores <value,...> et al which might be used to describe custom splitting of single argument
+    this.variadic = /\w\.\.\.[>\]]$/.test(flags); // The option can take multiple values.
+    this.mandatory = false; // The option must have a value after parsing, which usually means it must be specified on command line.
+    const optionFlags = _parseOptionFlags(flags);
+    this.short = optionFlags.shortFlag;
+    this.long = optionFlags.longFlag;
+    this.negate = false;
+    if (this.long) {
+      this.negate = this.long.startsWith('--no-');
+    }
+    this.defaultValue = undefined;
+    this.defaultValueDescription = undefined;
+    this.parseArg = undefined;
+    this.hidden = false;
+    this.argChoices = undefined;
   }
 
-  // process argv
-  var parsed = this.parseOptions(this.normalize(argv.slice(2)));
-  var args = this.args = parsed.args;
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   *
+   * @param {any} value
+   * @param {string} [description]
+   * @return {Option}
+   */
 
-  var result = this.parseArgs(this.args, parsed.unknown);
+  default(value, description) {
+    this.defaultValue = value;
+    this.defaultValueDescription = description;
+    return this;
+  };
 
-  // executable sub-commands
-  var name = result.args[0];
+  /**
+   * Set the custom handler for processing CLI option arguments into option values.
+   *
+   * @param {Function} [fn]
+   * @return {Option}
+   */
 
-  var aliasCommand = null;
-  // check alias of sub commands
-  if (name) {
-    aliasCommand = this.commands.filter(function(command) {
-      return command.alias() === name;
-    })[0];
-  }
+  argParser(fn) {
+    this.parseArg = fn;
+    return this;
+  };
 
-  if (this._execs[name] && typeof this._execs[name] !== 'function') {
-    return this.executeSubCommand(argv, args, parsed.unknown);
-  } else if (aliasCommand) {
-    // is alias of a subCommand
-    args[0] = aliasCommand._name;
-    return this.executeSubCommand(argv, args, parsed.unknown);
-  } else if (this.defaultExecutable) {
-    // use the default subcommand
-    args.unshift(this.defaultExecutable);
-    return this.executeSubCommand(argv, args, parsed.unknown);
-  }
+  /**
+   * Whether the option is mandatory and must have a value after parsing.
+   *
+   * @param {boolean} [mandatory=true]
+   * @return {Option}
+   */
 
-  return result;
-};
+  makeOptionMandatory(mandatory = true) {
+    this.mandatory = !!mandatory;
+    return this;
+  };
 
-/**
- * Execute a sub-command executable.
- *
- * @param {Array} argv
- * @param {Array} args
- * @param {Array} unknown
- * @api private
- */
+  /**
+   * Hide option in help.
+   *
+   * @param {boolean} [hide=true]
+   * @return {Option}
+   */
+
+  hideHelp(hide = true) {
+    this.hidden = !!hide;
+    return this;
+  };
 
-Command.prototype.executeSubCommand = function(argv, args, unknown) {
-  args = args.concat(unknown);
+  /**
+   * @api private
+   */
 
-  if (!args.length) this.help();
-  if (args[0] === 'help' && args.length === 1) this.help();
+  _concatValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
 
-  // <cmd> --help
-  if (args[0] === 'help') {
-    args[0] = args[1];
-    args[1] = '--help';
+    return previous.concat(value);
   }
 
-  // executable
-  var f = argv[1];
-  // name of the subcommand, link `pm-install`
-  var bin = basename(f, '.js') + '-' + args[0];
+  /**
+   * Only allow option value to be one of choices.
+   *
+   * @param {string[]} values
+   * @return {Option}
+   */
 
-  // In case of globally installed, get the base dir where executable
-  //  subcommand file should be located at
-  var baseDir,
-    link = fs__default.lstatSync(f).isSymbolicLink() ? fs__default.readlinkSync(f) : f;
+  choices(values) {
+    this.argChoices = values;
+    this.parseArg = (arg, previous) => {
+      if (!values.includes(arg)) {
+        throw new InvalidOptionArgumentError(`Allowed choices are ${values.join(', ')}.`);
+      }
+      if (this.variadic) {
+        return this._concatValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
+  };
 
-  // when symbolink is relative path
-  if (link !== f && link.charAt(0) !== '/') {
-    link = path__default.join(dirname(f), link);
-  }
-  baseDir = dirname(link);
+  /**
+   * Return option name.
+   *
+   * @return {string}
+   */
 
-  // prefer local `./<bin>` to bin in the $PATH
-  var localBin = path__default.join(baseDir, bin);
+  name() {
+    if (this.long) {
+      return this.long.replace(/^--/, '');
+    }
+    return this.short.replace(/^-/, '');
+  };
 
-  // whether bin file is a js script with explicit `.js` extension
-  var isExplicitJS = false;
-  if (exists(localBin + '.js')) {
-    bin = localBin + '.js';
-    isExplicitJS = true;
-  } else if (exists(localBin)) {
-    bin = localBin;
-  }
+  /**
+   * Return option name, in a camelcase format that can be used
+   * as a object attribute key.
+   *
+   * @return {string}
+   * @api private
+   */
 
-  args = args.slice(1);
+  attributeName() {
+    return camelcase(this.name().replace(/^no-/, ''));
+  };
 
-  var proc;
-  if (process.platform !== 'win32') {
-    if (isExplicitJS) {
-      args.unshift(bin);
-      // add executable arguments to spawn
-      args = (process.execArgv || []).concat(args);
+  /**
+   * Check if `arg` matches the short or long flag.
+   *
+   * @param {string} arg
+   * @return {boolean}
+   * @api private
+   */
 
-      proc = spawn(process.argv[0], args, { stdio: 'inherit', customFds: [0, 1, 2] });
-    } else {
-      proc = spawn(bin, args, { stdio: 'inherit', customFds: [0, 1, 2] });
+  is(arg) {
+    return this.short === arg || this.long === arg;
+  };
+}
+
+/**
+ * CommanderError class
+ * @class
+ */
+class CommanderError extends Error {
+  /**
+   * Constructs the CommanderError class
+   * @param {number} exitCode suggested exit code which could be used with process.exit
+   * @param {string} code an id string representing the error
+   * @param {string} message human-readable description of the error
+   * @constructor
+   */
+  constructor(exitCode, code, message) {
+    super(message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.exitCode = exitCode;
+    this.nestedError = undefined;
+  }
+}
+
+/**
+ * InvalidOptionArgumentError class
+ * @class
+ */
+class InvalidOptionArgumentError extends CommanderError {
+  /**
+   * Constructs the InvalidOptionArgumentError class
+   * @param {string} [message] explanation of why argument is invalid
+   * @constructor
+   */
+  constructor(message) {
+    super(1, 'commander.invalidOptionArgument', message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+  }
+}
+
+class Command extends EventEmitter {
+  /**
+   * Initialize a new `Command`.
+   *
+   * @param {string} [name]
+   */
+
+  constructor(name) {
+    super();
+    this.commands = [];
+    this.options = [];
+    this.parent = null;
+    this._allowUnknownOption = false;
+    this._allowExcessArguments = true;
+    this._args = [];
+    this.rawArgs = null;
+    this._scriptPath = null;
+    this._name = name || '';
+    this._optionValues = {};
+    this._storeOptionsAsProperties = false;
+    this._actionResults = [];
+    this._actionHandler = null;
+    this._executableHandler = false;
+    this._executableFile = null; // custom name for executable
+    this._defaultCommandName = null;
+    this._exitCallback = null;
+    this._aliases = [];
+    this._combineFlagAndOptionalValue = true;
+    this._description = '';
+    this._argsDescription = undefined;
+    this._enablePositionalOptions = false;
+    this._passThroughOptions = false;
+
+    // see .configureOutput() for docs
+    this._outputConfiguration = {
+      writeOut: (str) => process.stdout.write(str),
+      writeErr: (str) => process.stderr.write(str),
+      getOutHelpWidth: () => process.stdout.isTTY ? process.stdout.columns : undefined,
+      getErrHelpWidth: () => process.stderr.isTTY ? process.stderr.columns : undefined,
+      outputError: (str, write) => write(str)
+    };
+
+    this._hidden = false;
+    this._hasHelpOption = true;
+    this._helpFlags = '-h, --help';
+    this._helpDescription = 'display help for command';
+    this._helpShortFlag = '-h';
+    this._helpLongFlag = '--help';
+    this._addImplicitHelpCommand = undefined; // Deliberately undefined, not decided whether true or false
+    this._helpCommandName = 'help';
+    this._helpCommandnameAndArgs = 'help [command]';
+    this._helpCommandDescription = 'display help for command';
+    this._helpConfiguration = {};
+  }
+
+  /**
+   * Define a command.
+   *
+   * There are two styles of command: pay attention to where to put the description.
+   *
+   * Examples:
+   *
+   *      // Command implemented using action handler (description is supplied separately to `.command`)
+   *      program
+   *        .command('clone <source> [destination]')
+   *        .description('clone a repository into a newly created directory')
+   *        .action((source, destination) => {
+   *          console.log('clone command called');
+   *        });
+   *
+   *      // Command implemented using separate executable file (description is second parameter to `.command`)
+   *      program
+   *        .command('start <service>', 'start named service')
+   *        .command('stop [service]', 'stop named service, or all if no name supplied');
+   *
+   * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
+   * @param {Object|string} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
+   * @param {Object} [execOpts] - configuration options (for executable)
+   * @return {Command} returns new command for action handler, or `this` for executable command
+   */
+
+  command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
+    let desc = actionOptsOrExecDesc;
+    let opts = execOpts;
+    if (typeof desc === 'object' && desc !== null) {
+      opts = desc;
+      desc = null;
     }
-  } else {
-    args.unshift(bin);
-    proc = spawn(process.execPath, args, { stdio: 'inherit' });
+    opts = opts || {};
+    const args = nameAndArgs.split(/ +/);
+    const cmd = this.createCommand(args.shift());
+
+    if (desc) {
+      cmd.description(desc);
+      cmd._executableHandler = true;
+    }
+    if (opts.isDefault) this._defaultCommandName = cmd._name;
+
+    cmd._outputConfiguration = this._outputConfiguration;
+
+    cmd._hidden = !!(opts.noHelp || opts.hidden); // noHelp is deprecated old name for hidden
+    cmd._hasHelpOption = this._hasHelpOption;
+    cmd._helpFlags = this._helpFlags;
+    cmd._helpDescription = this._helpDescription;
+    cmd._helpShortFlag = this._helpShortFlag;
+    cmd._helpLongFlag = this._helpLongFlag;
+    cmd._helpCommandName = this._helpCommandName;
+    cmd._helpCommandnameAndArgs = this._helpCommandnameAndArgs;
+    cmd._helpCommandDescription = this._helpCommandDescription;
+    cmd._helpConfiguration = this._helpConfiguration;
+    cmd._exitCallback = this._exitCallback;
+    cmd._storeOptionsAsProperties = this._storeOptionsAsProperties;
+    cmd._combineFlagAndOptionalValue = this._combineFlagAndOptionalValue;
+    cmd._allowExcessArguments = this._allowExcessArguments;
+    cmd._enablePositionalOptions = this._enablePositionalOptions;
+
+    cmd._executableFile = opts.executableFile || null; // Custom name for executable file, set missing to null to match constructor
+    this.commands.push(cmd);
+    cmd._parseExpectedArgs(args);
+    cmd.parent = this;
+
+    if (desc) return this;
+    return cmd;
+  };
+
+  /**
+   * Factory routine to create a new unattached command.
+   *
+   * See .command() for creating an attached subcommand, which uses this routine to
+   * create the command. You can override createCommand to customise subcommands.
+   *
+   * @param {string} [name]
+   * @return {Command} new command
+   */
+
+  createCommand(name) {
+    return new Command(name);
+  };
+
+  /**
+   * You can customise the help with a subclass of Help by overriding createHelp,
+   * or by overriding Help properties using configureHelp().
+   *
+   * @return {Help}
+   */
+
+  createHelp() {
+    return Object.assign(new Help(), this.configureHelp());
+  };
+
+  /**
+   * You can customise the help by overriding Help properties using configureHelp(),
+   * or with a subclass of Help by overriding createHelp().
+   *
+   * @param {Object} [configuration] - configuration options
+   * @return {Command|Object} `this` command for chaining, or stored configuration
+   */
+
+  configureHelp(configuration) {
+    if (configuration === undefined) return this._helpConfiguration;
+
+    this._helpConfiguration = configuration;
+    return this;
+  }
+
+  /**
+   * The default output goes to stdout and stderr. You can customise this for special
+   * applications. You can also customise the display of errors by overriding outputError.
+   *
+   * The configuration properties are all functions:
+   *
+   *    // functions to change where being written, stdout and stderr
+   *    writeOut(str)
+   *    writeErr(str)
+   *    // matching functions to specify width for wrapping help
+   *    getOutHelpWidth()
+   *    getErrHelpWidth()
+   *    // functions based on what is being written out
+   *    outputError(str, write) // used for displaying errors, and not used for displaying help
+   *
+   * @param {Object} [configuration] - configuration options
+   * @return {Command|Object} `this` command for chaining, or stored configuration
+   */
+
+  configureOutput(configuration) {
+    if (configuration === undefined) return this._outputConfiguration;
+
+    Object.assign(this._outputConfiguration, configuration);
+    return this;
   }
 
-  var signals = ['SIGUSR1', 'SIGUSR2', 'SIGTERM', 'SIGINT', 'SIGHUP'];
-  signals.forEach(function(signal) {
-    process.on(signal, function() {
-      if (proc.killed === false && proc.exitCode === null) {
-        proc.kill(signal);
+  /**
+   * Add a prepared subcommand.
+   *
+   * See .command() for creating an attached subcommand which inherits settings from its parent.
+   *
+   * @param {Command} cmd - new subcommand
+   * @param {Object} [opts] - configuration options
+   * @return {Command} `this` command for chaining
+   */
+
+  addCommand(cmd, opts) {
+    if (!cmd._name) throw new Error('Command passed to .addCommand() must have a name');
+
+    // To keep things simple, block automatic name generation for deeply nested executables.
+    // Fail fast and detect when adding rather than later when parsing.
+    function checkExplicitNames(commandArray) {
+      commandArray.forEach((cmd) => {
+        if (cmd._executableHandler && !cmd._executableFile) {
+          throw new Error(`Must specify executableFile for deeply nested executable: ${cmd.name()}`);
+        }
+        checkExplicitNames(cmd.commands);
+      });
+    }
+    checkExplicitNames(cmd.commands);
+
+    opts = opts || {};
+    if (opts.isDefault) this._defaultCommandName = cmd._name;
+    if (opts.noHelp || opts.hidden) cmd._hidden = true; // modifying passed command due to existing implementation
+
+    this.commands.push(cmd);
+    cmd.parent = this;
+    return this;
+  };
+
+  /**
+   * Define argument syntax for the command.
+   */
+
+  arguments(desc) {
+    return this._parseExpectedArgs(desc.split(/ +/));
+  };
+
+  /**
+   * Override default decision whether to add implicit help command.
+   *
+   *    addHelpCommand() // force on
+   *    addHelpCommand(false); // force off
+   *    addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
+   *
+   * @return {Command} `this` command for chaining
+   */
+
+  addHelpCommand(enableOrNameAndArgs, description) {
+    if (enableOrNameAndArgs === false) {
+      this._addImplicitHelpCommand = false;
+    } else {
+      this._addImplicitHelpCommand = true;
+      if (typeof enableOrNameAndArgs === 'string') {
+        this._helpCommandName = enableOrNameAndArgs.split(' ')[0];
+        this._helpCommandnameAndArgs = enableOrNameAndArgs;
+      }
+      this._helpCommandDescription = description || this._helpCommandDescription;
+    }
+    return this;
+  };
+
+  /**
+   * @return {boolean}
+   * @api private
+   */
+
+  _hasImplicitHelpCommand() {
+    if (this._addImplicitHelpCommand === undefined) {
+      return this.commands.length && !this._actionHandler && !this._findCommand('help');
+    }
+    return this._addImplicitHelpCommand;
+  };
+
+  /**
+   * Parse expected `args`.
+   *
+   * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
+   *
+   * @param {Array} args
+   * @return {Command} `this` command for chaining
+   * @api private
+   */
+
+  _parseExpectedArgs(args) {
+    if (!args.length) return;
+    args.forEach((arg) => {
+      const argDetails = {
+        required: false,
+        name: '',
+        variadic: false
+      };
+
+      switch (arg[0]) {
+        case '<':
+          argDetails.required = true;
+          argDetails.name = arg.slice(1, -1);
+          break;
+        case '[':
+          argDetails.name = arg.slice(1, -1);
+          break;
+      }
+
+      if (argDetails.name.length > 3 && argDetails.name.slice(-3) === '...') {
+        argDetails.variadic = true;
+        argDetails.name = argDetails.name.slice(0, -3);
+      }
+      if (argDetails.name) {
+        this._args.push(argDetails);
       }
     });
-  });
-  proc.on('close', process.exit.bind(process));
-  proc.on('error', function(err) {
-    if (err.code === 'ENOENT') {
-      console.error('\n  %s(1) does not exist, try --help\n', bin);
-    } else if (err.code === 'EACCES') {
-      console.error('\n  %s(1) not executable. try chmod or run with root\n', bin);
+    this._args.forEach((arg, i) => {
+      if (arg.variadic && i < this._args.length - 1) {
+        throw new Error(`only the last argument can be variadic '${arg.name}'`);
+      }
+    });
+    return this;
+  };
+
+  /**
+   * Register callback to use as replacement for calling process.exit.
+   *
+   * @param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing
+   * @return {Command} `this` command for chaining
+   */
+
+  exitOverride(fn) {
+    if (fn) {
+      this._exitCallback = fn;
+    } else {
+      this._exitCallback = (err) => {
+        if (err.code !== 'commander.executeSubCommandAsync') {
+          throw err;
+        }
+      };
     }
-    process.exit(1);
-  });
+    return this;
+  };
 
-  // Store the reference to the child process
-  this.runningCommand = proc;
-};
+  /**
+   * Call process.exit, and _exitCallback if defined.
+   *
+   * @param {number} exitCode exit code for using with process.exit
+   * @param {string} code an id string representing the error
+   * @param {string} message human-readable description of the error
+   * @return never
+   * @api private
+   */
 
-/**
- * Normalize `args`, splitting joined short flags. For example
- * the arg "-abc" is equivalent to "-a -b -c".
- * This also normalizes equal sign and splits "--abc=def" into "--abc def".
- *
- * @param {Array} args
- * @return {Array}
- * @api private
- */
+  _exit(exitCode, code, message) {
+    if (this._exitCallback) {
+      this._exitCallback(new CommanderError(exitCode, code, message));
+      // Expecting this line is not reached.
+    }
+    process.exit(exitCode);
+  };
 
-Command.prototype.normalize = function(args) {
-  var ret = [],
-    arg,
-    lastOpt,
-    index;
-
-  for (var i = 0, len = args.length; i < len; ++i) {
-    arg = args[i];
-    if (i > 0) {
-      lastOpt = this.optionFor(args[i - 1]);
-    }
-
-    if (arg === '--') {
-      // Honor option terminator
-      ret = ret.concat(args.slice(i));
-      break;
-    } else if (lastOpt && lastOpt.required) {
-      ret.push(arg);
-    } else if (arg.length > 1 && arg[0] === '-' && arg[1] !== '-') {
-      arg.slice(1).split('').forEach(function(c) {
-        ret.push('-' + c);
-      });
-    } else if (/^--/.test(arg) && ~(index = arg.indexOf('='))) {
-      ret.push(arg.slice(0, index), arg.slice(index + 1));
+  /**
+   * Register callback `fn` for the command.
+   *
+   * Examples:
+   *
+   *      program
+   *        .command('help')
+   *        .description('display verbose help')
+   *        .action(function() {
+   *           // output help here
+   *        });
+   *
+   * @param {Function} fn
+   * @return {Command} `this` command for chaining
+   */
+
+  action(fn) {
+    const listener = (args) => {
+      // The .action callback takes an extra parameter which is the command or options.
+      const expectedArgsCount = this._args.length;
+      const actionArgs = args.slice(0, expectedArgsCount);
+      if (this._storeOptionsAsProperties) {
+        actionArgs[expectedArgsCount] = this; // backwards compatible "options"
+      } else {
+        actionArgs[expectedArgsCount] = this.opts();
+      }
+      actionArgs.push(this);
+
+      const actionResult = fn.apply(this, actionArgs);
+      // Remember result in case it is async. Assume parseAsync getting called on root.
+      let rootCommand = this;
+      while (rootCommand.parent) {
+        rootCommand = rootCommand.parent;
+      }
+      rootCommand._actionResults.push(actionResult);
+    };
+    this._actionHandler = listener;
+    return this;
+  };
+
+  /**
+   * Factory routine to create a new unattached option.
+   *
+   * See .option() for creating an attached option, which uses this routine to
+   * create the option. You can override createOption to return a custom option.
+   *
+   * @param {string} flags
+   * @param {string} [description]
+   * @return {Option} new option
+   */
+
+  createOption(flags, description) {
+    return new Option(flags, description);
+  };
+
+  /**
+   * Add an option.
+   *
+   * @param {Option} option
+   * @return {Command} `this` command for chaining
+   */
+  addOption(option) {
+    const oname = option.name();
+    const name = option.attributeName();
+
+    let defaultValue = option.defaultValue;
+
+    // preassign default value for --no-*, [optional], <required>, or plain flag if boolean value
+    if (option.negate || option.optional || option.required || typeof defaultValue === 'boolean') {
+      // when --no-foo we make sure default is true, unless a --foo option is already defined
+      if (option.negate) {
+        const positiveLongFlag = option.long.replace(/^--no-/, '--');
+        defaultValue = this._findOption(positiveLongFlag) ? this._getOptionValue(name) : true;
+      }
+      // preassign only if we have a default
+      if (defaultValue !== undefined) {
+        this._setOptionValue(name, defaultValue);
+      }
+    }
+
+    // register the option
+    this.options.push(option);
+
+    // when it's passed assign the value
+    // and conditionally invoke the callback
+    this.on('option:' + oname, (val) => {
+      const oldValue = this._getOptionValue(name);
+
+      // custom processing
+      if (val !== null && option.parseArg) {
+        try {
+          val = option.parseArg(val, oldValue === undefined ? defaultValue : oldValue);
+        } catch (err) {
+          if (err.code === 'commander.invalidOptionArgument') {
+            const message = `error: option '${option.flags}' argument '${val}' is invalid. ${err.message}`;
+            this._displayError(err.exitCode, err.code, message);
+          }
+          throw err;
+        }
+      } else if (val !== null && option.variadic) {
+        val = option._concatValue(val, oldValue);
+      }
+
+      // unassigned or boolean value
+      if (typeof oldValue === 'boolean' || typeof oldValue === 'undefined') {
+        // if no value, negate false, and we have a default, then use it!
+        if (val == null) {
+          this._setOptionValue(name, option.negate
+            ? false
+            : defaultValue || true);
+        } else {
+          this._setOptionValue(name, val);
+        }
+      } else if (val !== null) {
+        // reassign
+        this._setOptionValue(name, option.negate ? false : val);
+      }
+    });
+
+    return this;
+  }
+
+  /**
+   * Internal implementation shared by .option() and .requiredOption()
+   *
+   * @api private
+   */
+  _optionEx(config, flags, description, fn, defaultValue) {
+    const option = this.createOption(flags, description);
+    option.makeOptionMandatory(!!config.mandatory);
+    if (typeof fn === 'function') {
+      option.default(defaultValue).argParser(fn);
+    } else if (fn instanceof RegExp) {
+      // deprecated
+      const regex = fn;
+      fn = (val, def) => {
+        const m = regex.exec(val);
+        return m ? m[0] : def;
+      };
+      option.default(defaultValue).argParser(fn);
     } else {
-      ret.push(arg);
+      option.default(fn);
     }
+
+    return this.addOption(option);
   }
 
-  return ret;
-};
+  /**
+   * Define option with `flags`, `description` and optional
+   * coercion `fn`.
+   *
+   * The `flags` string contains the short and/or long flags,
+   * separated by comma, a pipe or space. The following are all valid
+   * all will output this way when `--help` is used.
+   *
+   *    "-p, --pepper"
+   *    "-p|--pepper"
+   *    "-p --pepper"
+   *
+   * Examples:
+   *
+   *     // simple boolean defaulting to undefined
+   *     program.option('-p, --pepper', 'add pepper');
+   *
+   *     program.pepper
+   *     // => undefined
+   *
+   *     --pepper
+   *     program.pepper
+   *     // => true
+   *
+   *     // simple boolean defaulting to true (unless non-negated option is also defined)
+   *     program.option('-C, --no-cheese', 'remove cheese');
+   *
+   *     program.cheese
+   *     // => true
+   *
+   *     --no-cheese
+   *     program.cheese
+   *     // => false
+   *
+   *     // required argument
+   *     program.option('-C, --chdir <path>', 'change the working directory');
+   *
+   *     --chdir /tmp
+   *     program.chdir
+   *     // => "/tmp"
+   *
+   *     // optional argument
+   *     program.option('-c, --cheese [type]', 'add cheese [marble]');
+   *
+   * @param {string} flags
+   * @param {string} [description]
+   * @param {Function|*} [fn] - custom option processing function or default value
+   * @param {*} [defaultValue]
+   * @return {Command} `this` command for chaining
+   */
 
-/**
- * Parse command `args`.
- *
- * When listener(s) are available those
- * callbacks are invoked, otherwise the "*"
- * event is emitted and those actions are invoked.
- *
- * @param {Array} args
- * @return {Command} for chaining
- * @api private
- */
+  option(flags, description, fn, defaultValue) {
+    return this._optionEx({}, flags, description, fn, defaultValue);
+  };
+
+  /**
+  * Add a required option which must have a value after parsing. This usually means
+  * the option must be specified on the command line. (Otherwise the same as .option().)
+  *
+  * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
+  *
+  * @param {string} flags
+  * @param {string} [description]
+  * @param {Function|*} [fn] - custom option processing function or default value
+  * @param {*} [defaultValue]
+  * @return {Command} `this` command for chaining
+  */
+
+  requiredOption(flags, description, fn, defaultValue) {
+    return this._optionEx({ mandatory: true }, flags, description, fn, defaultValue);
+  };
 
-Command.prototype.parseArgs = function(args, unknown) {
-  var name;
+  /**
+   * Alter parsing of short flags with optional values.
+   *
+   * Examples:
+   *
+   *    // for `.option('-f,--flag [value]'):
+   *    .combineFlagAndOptionalValue(true)  // `-f80` is treated like `--flag=80`, this is the default behaviour
+   *    .combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
+   *
+   * @param {Boolean} [combine=true] - if `true` or omitted, an optional value can be specified directly after the flag.
+   */
+  combineFlagAndOptionalValue(combine = true) {
+    this._combineFlagAndOptionalValue = !!combine;
+    return this;
+  };
 
-  if (args.length) {
-    name = args[0];
-    if (this.listeners('command:' + name).length) {
-      this.emit('command:' + args.shift(), args, unknown);
-    } else {
-      this.emit('command:*', args);
+  /**
+   * Allow unknown options on the command line.
+   *
+   * @param {Boolean} [allowUnknown=true] - if `true` or omitted, no error will be thrown
+   * for unknown options.
+   */
+  allowUnknownOption(allowUnknown = true) {
+    this._allowUnknownOption = !!allowUnknown;
+    return this;
+  };
+
+  /**
+   * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
+   *
+   * @param {Boolean} [allowExcess=true] - if `true` or omitted, no error will be thrown
+   * for excess arguments.
+   */
+  allowExcessArguments(allowExcess = true) {
+    this._allowExcessArguments = !!allowExcess;
+    return this;
+  };
+
+  /**
+   * Enable positional options. Positional means global options are specified before subcommands which lets
+   * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
+   * The default behaviour is non-positional and global options may appear anywhere on the command line.
+   *
+   * @param {Boolean} [positional=true]
+   */
+  enablePositionalOptions(positional = true) {
+    this._enablePositionalOptions = !!positional;
+    return this;
+  };
+
+  /**
+   * Pass through options that come after command-arguments rather than treat them as command-options,
+   * so actual command-options come before command-arguments. Turning this on for a subcommand requires
+   * positional options to have been enabled on the program (parent commands).
+   * The default behaviour is non-positional and options may appear before or after command-arguments.
+   *
+   * @param {Boolean} [passThrough=true]
+   * for unknown options.
+   */
+  passThroughOptions(passThrough = true) {
+    this._passThroughOptions = !!passThrough;
+    if (!!this.parent && passThrough && !this.parent._enablePositionalOptions) {
+      throw new Error('passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)');
     }
-  } else {
-    outputHelpIfNecessary(this, unknown);
+    return this;
+  };
 
-    // If there were no args and we have unknown options,
-    // then they are extraneous and we need to error.
-    if (unknown.length > 0) {
-      this.unknownOption(unknown[0]);
+  /**
+    * Whether to store option values as properties on command object,
+    * or store separately (specify false). In both cases the option values can be accessed using .opts().
+    *
+    * @param {boolean} [storeAsProperties=true]
+    * @return {Command} `this` command for chaining
+    */
+
+  storeOptionsAsProperties(storeAsProperties = true) {
+    this._storeOptionsAsProperties = !!storeAsProperties;
+    if (this.options.length) {
+      throw new Error('call .storeOptionsAsProperties() before adding options');
     }
-  }
+    return this;
+  };
 
-  return this;
-};
+  /**
+   * Store option value
+   *
+   * @param {string} key
+   * @param {Object} value
+   * @api private
+   */
 
-/**
- * Return an option matching `arg` if any.
- *
- * @param {String} arg
- * @return {Option}
- * @api private
- */
+  _setOptionValue(key, value) {
+    if (this._storeOptionsAsProperties) {
+      this[key] = value;
+    } else {
+      this._optionValues[key] = value;
+    }
+  };
+
+  /**
+   * Retrieve option value
+   *
+   * @param {string} key
+   * @return {Object} value
+   * @api private
+   */
 
-Command.prototype.optionFor = function(arg) {
-  for (var i = 0, len = this.options.length; i < len; ++i) {
-    if (this.options[i].is(arg)) {
-      return this.options[i];
+  _getOptionValue(key) {
+    if (this._storeOptionsAsProperties) {
+      return this[key];
     }
-  }
-};
+    return this._optionValues[key];
+  };
 
-/**
- * Parse options from `argv` returning `argv`
- * void of these options.
- *
- * @param {Array} argv
- * @return {Array}
- * @api public
- */
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * The default expectation is that the arguments are from node and have the application as argv[0]
+   * and the script being run in argv[1], with user parameters after that.
+   *
+   * Examples:
+   *
+   *      program.parse(process.argv);
+   *      program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
+   *      program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   *
+   * @param {string[]} [argv] - optional, defaults to process.argv
+   * @param {Object} [parseOptions] - optionally specify style of options with from: node/user/electron
+   * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
+   * @return {Command} `this` command for chaining
+   */
 
-Command.prototype.parseOptions = function(argv) {
-  var args = [],
-    len = argv.length,
-    literal,
-    option,
-    arg;
-
-  var unknownOptions = [];
-
-  // parse options
-  for (var i = 0; i < len; ++i) {
-    arg = argv[i];
-
-    // literal args after --
-    if (literal) {
-      args.push(arg);
-      continue;
-    }
-
-    if (arg === '--') {
-      literal = true;
-      continue;
-    }
-
-    // find matching Option
-    option = this.optionFor(arg);
-
-    // option is defined
-    if (option) {
-      // requires arg
-      if (option.required) {
-        arg = argv[++i];
-        if (arg == null) return this.optionMissingArgument(option);
-        this.emit('option:' + option.name(), arg);
-      // optional arg
-      } else if (option.optional) {
-        arg = argv[i + 1];
-        if (arg == null || (arg[0] === '-' && arg !== '-')) {
-          arg = null;
+  parse(argv, parseOptions) {
+    if (argv !== undefined && !Array.isArray(argv)) {
+      throw new Error('first parameter to parse must be array or undefined');
+    }
+    parseOptions = parseOptions || {};
+
+    // Default to using process.argv
+    if (argv === undefined) {
+      argv = process.argv;
+      // @ts-ignore: unknown property
+      if (process.versions && process.versions.electron) {
+        parseOptions.from = 'electron';
+      }
+    }
+    this.rawArgs = argv.slice();
+
+    // make it a little easier for callers by supporting various argv conventions
+    let userArgs;
+    switch (parseOptions.from) {
+      case undefined:
+      case 'node':
+        this._scriptPath = argv[1];
+        userArgs = argv.slice(2);
+        break;
+      case 'electron':
+        // @ts-ignore: unknown property
+        if (process.defaultApp) {
+          this._scriptPath = argv[1];
+          userArgs = argv.slice(2);
         } else {
-          ++i;
+          userArgs = argv.slice(1);
+        }
+        break;
+      case 'user':
+        userArgs = argv.slice(0);
+        break;
+      default:
+        throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
+    }
+    if (!this._scriptPath && require.main) {
+      this._scriptPath = require.main.filename;
+    }
+
+    // Guess name, used in usage in help.
+    this._name = this._name || (this._scriptPath && path.basename(this._scriptPath, path.extname(this._scriptPath)));
+
+    // Let's go!
+    this._parseCommand([], userArgs);
+
+    return this;
+  };
+
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
+   *
+   * The default expectation is that the arguments are from node and have the application as argv[0]
+   * and the script being run in argv[1], with user parameters after that.
+   *
+   * Examples:
+   *
+   *      program.parseAsync(process.argv);
+   *      program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
+   *      program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   *
+   * @param {string[]} [argv]
+   * @param {Object} [parseOptions]
+   * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
+   * @return {Promise}
+   */
+
+  parseAsync(argv, parseOptions) {
+    this.parse(argv, parseOptions);
+    return Promise.all(this._actionResults).then(() => this);
+  };
+
+  /**
+   * Execute a sub-command executable.
+   *
+   * @api private
+   */
+
+  _executeSubCommand(subcommand, args) {
+    args = args.slice();
+    let launchWithNode = false; // Use node for source targets so do not need to get permissions correct, and on Windows.
+    const sourceExt = ['.js', '.ts', '.tsx', '.mjs', '.cjs'];
+
+    // Not checking for help first. Unlikely to have mandatory and executable, and can't robustly test for help flags in external command.
+    this._checkForMissingMandatoryOptions();
+
+    // Want the entry script as the reference for command name and directory for searching for other files.
+    let scriptPath = this._scriptPath;
+    // Fallback in case not set, due to how Command created or called.
+    if (!scriptPath && require.main) {
+      scriptPath = require.main.filename;
+    }
+
+    let baseDir;
+    try {
+      const resolvedLink = fs.realpathSync(scriptPath);
+      baseDir = path.dirname(resolvedLink);
+    } catch (e) {
+      baseDir = '.'; // dummy, probably not going to find executable!
+    }
+
+    // name of the subcommand, like `pm-install`
+    let bin = path.basename(scriptPath, path.extname(scriptPath)) + '-' + subcommand._name;
+    if (subcommand._executableFile) {
+      bin = subcommand._executableFile;
+    }
+
+    const localBin = path.join(baseDir, bin);
+    if (fs.existsSync(localBin)) {
+      // prefer local `./<bin>` to bin in the $PATH
+      bin = localBin;
+    } else {
+      // Look for source files.
+      sourceExt.forEach((ext) => {
+        if (fs.existsSync(`${localBin}${ext}`)) {
+          bin = `${localBin}${ext}`;
         }
-        this.emit('option:' + option.name(), arg);
-      // bool
+      });
+    }
+    launchWithNode = sourceExt.includes(path.extname(bin));
+
+    let proc;
+    if (process.platform !== 'win32') {
+      if (launchWithNode) {
+        args.unshift(bin);
+        // add executable arguments to spawn
+        args = incrementNodeInspectorPort(process.execArgv).concat(args);
+
+        proc = childProcess.spawn(process.argv[0], args, { stdio: 'inherit' });
       } else {
-        this.emit('option:' + option.name());
+        proc = childProcess.spawn(bin, args, { stdio: 'inherit' });
       }
-      continue;
+    } else {
+      args.unshift(bin);
+      // add executable arguments to spawn
+      args = incrementNodeInspectorPort(process.execArgv).concat(args);
+      proc = childProcess.spawn(process.execPath, args, { stdio: 'inherit' });
     }
 
-    // looks like an option
-    if (arg.length > 1 && arg[0] === '-') {
-      unknownOptions.push(arg);
+    const signals = ['SIGUSR1', 'SIGUSR2', 'SIGTERM', 'SIGINT', 'SIGHUP'];
+    signals.forEach((signal) => {
+      // @ts-ignore
+      process.on(signal, () => {
+        if (proc.killed === false && proc.exitCode === null) {
+          proc.kill(signal);
+        }
+      });
+    });
 
-      // If the next argument looks like it might be
-      // an argument for this option, we pass it on.
-      // If it isn't, then it'll simply be ignored
-      if ((i + 1) < argv.length && argv[i + 1][0] !== '-') {
-        unknownOptions.push(argv[++i]);
+    // By default terminate process when spawned process terminates.
+    // Suppressing the exit if exitCallback defined is a bit messy and of limited use, but does allow process to stay running!
+    const exitCallback = this._exitCallback;
+    if (!exitCallback) {
+      proc.on('close', process.exit.bind(process));
+    } else {
+      proc.on('close', () => {
+        exitCallback(new CommanderError(process.exitCode || 0, 'commander.executeSubCommandAsync', '(close)'));
+      });
+    }
+    proc.on('error', (err) => {
+      // @ts-ignore
+      if (err.code === 'ENOENT') {
+        const executableMissing = `'${bin}' does not exist
+ - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name`;
+        throw new Error(executableMissing);
+      // @ts-ignore
+      } else if (err.code === 'EACCES') {
+        throw new Error(`'${bin}' not executable`);
+      }
+      if (!exitCallback) {
+        process.exit(1);
+      } else {
+        const wrappedError = new CommanderError(1, 'commander.executeSubCommandAsync', '(error)');
+        wrappedError.nestedError = err;
+        exitCallback(wrappedError);
       }
-      continue;
+    });
+
+    // Store the reference to the child process
+    this.runningCommand = proc;
+  };
+
+  /**
+   * @api private
+   */
+  _dispatchSubcommand(commandName, operands, unknown) {
+    const subCommand = this._findCommand(commandName);
+    if (!subCommand) this.help({ error: true });
+
+    if (subCommand._executableHandler) {
+      this._executeSubCommand(subCommand, operands.concat(unknown));
+    } else {
+      subCommand._parseCommand(operands, unknown);
     }
+  };
 
-    // arg
-    args.push(arg);
-  }
+  /**
+   * Process arguments in context of this command.
+   *
+   * @api private
+   */
 
-  return { args: args, unknown: unknownOptions };
-};
+  _parseCommand(operands, unknown) {
+    const parsed = this.parseOptions(unknown);
+    operands = operands.concat(parsed.operands);
+    unknown = parsed.unknown;
+    this.args = operands.concat(unknown);
+
+    if (operands && this._findCommand(operands[0])) {
+      this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
+    } else if (this._hasImplicitHelpCommand() && operands[0] === this._helpCommandName) {
+      if (operands.length === 1) {
+        this.help();
+      } else {
+        this._dispatchSubcommand(operands[1], [], [this._helpLongFlag]);
+      }
+    } else if (this._defaultCommandName) {
+      outputHelpIfRequested(this, unknown); // Run the help for default command from parent rather than passing to default command
+      this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
+    } else {
+      if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
+        // probably missing subcommand and no handler, user needs help
+        this.help({ error: true });
+      }
 
-/**
- * Return an object containing options as key-value pairs
- *
- * @return {Object}
- * @api public
- */
-Command.prototype.opts = function() {
-  var result = {},
-    len = this.options.length;
+      outputHelpIfRequested(this, parsed.unknown);
+      this._checkForMissingMandatoryOptions();
 
-  for (var i = 0; i < len; i++) {
-    var key = this.options[i].attributeName();
-    result[key] = key === this._versionOptionName ? this._version : this[key];
-  }
-  return result;
-};
+      // We do not always call this check to avoid masking a "better" error, like unknown command.
+      const checkForUnknownOptions = () => {
+        if (parsed.unknown.length > 0) {
+          this.unknownOption(parsed.unknown[0]);
+        }
+      };
 
-/**
- * Argument `name` is missing.
- *
- * @param {String} name
- * @api private
- */
+      const commandEvent = `command:${this.name()}`;
+      if (this._actionHandler) {
+        checkForUnknownOptions();
+        // Check expected arguments and collect variadic together.
+        const args = this.args.slice();
+        this._args.forEach((arg, i) => {
+          if (arg.required && args[i] == null) {
+            this.missingArgument(arg.name);
+          } else if (arg.variadic) {
+            args[i] = args.splice(i);
+            args.length = Math.min(i + 1, args.length);
+          }
+        });
+        if (args.length > this._args.length) {
+          this._excessArguments(args);
+        }
 
-Command.prototype.missingArgument = function(name) {
-  console.error();
-  console.error("  error: missing required argument `%s'", name);
-  console.error();
-  process.exit(1);
-};
+        this._actionHandler(args);
+        if (this.parent) this.parent.emit(commandEvent, operands, unknown); // legacy
+      } else if (this.parent && this.parent.listenerCount(commandEvent)) {
+        checkForUnknownOptions();
+        this.parent.emit(commandEvent, operands, unknown); // legacy
+      } else if (operands.length) {
+        if (this._findCommand('*')) { // legacy default command
+          this._dispatchSubcommand('*', operands, unknown);
+        } else if (this.listenerCount('command:*')) {
+          // skip option check, emit event for possible misspelling suggestion
+          this.emit('command:*', operands, unknown);
+        } else if (this.commands.length) {
+          this.unknownCommand();
+        } else {
+          checkForUnknownOptions();
+        }
+      } else if (this.commands.length) {
+        // This command has subcommands and nothing hooked up at this level, so display help.
+        this.help({ error: true });
+      } else {
+        checkForUnknownOptions();
+        // fall through for caller to handle after calling .parse()
+      }
+    }
+  };
 
-/**
- * `Option` is missing an argument, but received `flag` or nothing.
- *
- * @param {String} option
- * @param {String} flag
- * @api private
- */
+  /**
+   * Find matching command.
+   *
+   * @api private
+   */
+  _findCommand(name) {
+    if (!name) return undefined;
+    return this.commands.find(cmd => cmd._name === name || cmd._aliases.includes(name));
+  };
 
-Command.prototype.optionMissingArgument = function(option, flag) {
-  console.error();
-  if (flag) {
-    console.error("  error: option `%s' argument missing, got `%s'", option.flags, flag);
-  } else {
-    console.error("  error: option `%s' argument missing", option.flags);
+  /**
+   * Return an option matching `arg` if any.
+   *
+   * @param {string} arg
+   * @return {Option}
+   * @api private
+   */
+
+  _findOption(arg) {
+    return this.options.find(option => option.is(arg));
+  };
+
+  /**
+   * Display an error message if a mandatory option does not have a value.
+   * Lazy calling after checking for help flags from leaf subcommand.
+   *
+   * @api private
+   */
+
+  _checkForMissingMandatoryOptions() {
+    // Walk up hierarchy so can call in subcommand after checking for displaying help.
+    for (let cmd = this; cmd; cmd = cmd.parent) {
+      cmd.options.forEach((anOption) => {
+        if (anOption.mandatory && (cmd._getOptionValue(anOption.attributeName()) === undefined)) {
+          cmd.missingMandatoryOptionValue(anOption);
+        }
+      });
+    }
+  };
+
+  /**
+   * Parse options from `argv` removing known options,
+   * and return argv split into operands and unknown arguments.
+   *
+   * Examples:
+   *
+   *    argv => operands, unknown
+   *    --known kkk op => [op], []
+   *    op --known kkk => [op], []
+   *    sub --unknown uuu op => [sub], [--unknown uuu op]
+   *    sub -- --unknown uuu op => [sub --unknown uuu op], []
+   *
+   * @param {String[]} argv
+   * @return {{operands: String[], unknown: String[]}}
+   */
+
+  parseOptions(argv) {
+    const operands = []; // operands, not options or values
+    const unknown = []; // first unknown option and remaining unknown args
+    let dest = operands;
+    const args = argv.slice();
+
+    function maybeOption(arg) {
+      return arg.length > 1 && arg[0] === '-';
+    }
+
+    // parse options
+    let activeVariadicOption = null;
+    while (args.length) {
+      const arg = args.shift();
+
+      // literal
+      if (arg === '--') {
+        if (dest === unknown) dest.push(arg);
+        dest.push(...args);
+        break;
+      }
+
+      if (activeVariadicOption && !maybeOption(arg)) {
+        this.emit(`option:${activeVariadicOption.name()}`, arg);
+        continue;
+      }
+      activeVariadicOption = null;
+
+      if (maybeOption(arg)) {
+        const option = this._findOption(arg);
+        // recognised option, call listener to assign value with possible custom processing
+        if (option) {
+          if (option.required) {
+            const value = args.shift();
+            if (value === undefined) this.optionMissingArgument(option);
+            this.emit(`option:${option.name()}`, value);
+          } else if (option.optional) {
+            let value = null;
+            // historical behaviour is optional value is following arg unless an option
+            if (args.length > 0 && !maybeOption(args[0])) {
+              value = args.shift();
+            }
+            this.emit(`option:${option.name()}`, value);
+          } else { // boolean flag
+            this.emit(`option:${option.name()}`);
+          }
+          activeVariadicOption = option.variadic ? option : null;
+          continue;
+        }
+      }
+
+      // Look for combo options following single dash, eat first one if known.
+      if (arg.length > 2 && arg[0] === '-' && arg[1] !== '-') {
+        const option = this._findOption(`-${arg[1]}`);
+        if (option) {
+          if (option.required || (option.optional && this._combineFlagAndOptionalValue)) {
+            // option with value following in same argument
+            this.emit(`option:${option.name()}`, arg.slice(2));
+          } else {
+            // boolean option, emit and put back remainder of arg for further processing
+            this.emit(`option:${option.name()}`);
+            args.unshift(`-${arg.slice(2)}`);
+          }
+          continue;
+        }
+      }
+
+      // Look for known long flag with value, like --foo=bar
+      if (/^--[^=]+=/.test(arg)) {
+        const index = arg.indexOf('=');
+        const option = this._findOption(arg.slice(0, index));
+        if (option && (option.required || option.optional)) {
+          this.emit(`option:${option.name()}`, arg.slice(index + 1));
+          continue;
+        }
+      }
+
+      // Not a recognised option by this command.
+      // Might be a command-argument, or subcommand option, or unknown option, or help command or option.
+
+      // An unknown option means further arguments also classified as unknown so can be reprocessed by subcommands.
+      if (maybeOption(arg)) {
+        dest = unknown;
+      }
+
+      // If using positionalOptions, stop processing our options at subcommand.
+      if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
+        if (this._findCommand(arg)) {
+          operands.push(arg);
+          if (args.length > 0) unknown.push(...args);
+          break;
+        } else if (arg === this._helpCommandName && this._hasImplicitHelpCommand()) {
+          operands.push(arg);
+          if (args.length > 0) operands.push(...args);
+          break;
+        } else if (this._defaultCommandName) {
+          unknown.push(arg);
+          if (args.length > 0) unknown.push(...args);
+          break;
+        }
+      }
+
+      // If using passThroughOptions, stop processing options at first command-argument.
+      if (this._passThroughOptions) {
+        dest.push(arg);
+        if (args.length > 0) dest.push(...args);
+        break;
+      }
+
+      // add arg
+      dest.push(arg);
+    }
+
+    return { operands, unknown };
+  };
+
+  /**
+   * Return an object containing options as key-value pairs
+   *
+   * @return {Object}
+   */
+  opts() {
+    if (this._storeOptionsAsProperties) {
+      // Preserve original behaviour so backwards compatible when still using properties
+      const result = {};
+      const len = this.options.length;
+
+      for (let i = 0; i < len; i++) {
+        const key = this.options[i].attributeName();
+        result[key] = key === this._versionOptionName ? this._version : this[key];
+      }
+      return result;
+    }
+
+    return this._optionValues;
+  };
+
+  /**
+   * Internal bottleneck for handling of parsing errors.
+   *
+   * @api private
+   */
+  _displayError(exitCode, code, message) {
+    this._outputConfiguration.outputError(`${message}\n`, this._outputConfiguration.writeErr);
+    this._exit(exitCode, code, message);
   }
-  console.error();
-  process.exit(1);
-};
 
-/**
- * Unknown option `flag`.
- *
- * @param {String} flag
- * @api private
- */
+  /**
+   * Argument `name` is missing.
+   *
+   * @param {string} name
+   * @api private
+   */
+
+  missingArgument(name) {
+    const message = `error: missing required argument '${name}'`;
+    this._displayError(1, 'commander.missingArgument', message);
+  };
 
-Command.prototype.unknownOption = function(flag) {
-  if (this._allowUnknownOption) return;
-  console.error();
-  console.error("  error: unknown option `%s'", flag);
-  console.error();
-  process.exit(1);
-};
+  /**
+   * `Option` is missing an argument.
+   *
+   * @param {Option} option
+   * @api private
+   */
 
-/**
- * Variadic argument with `name` is not the last argument as required.
- *
- * @param {String} name
- * @api private
- */
+  optionMissingArgument(option) {
+    const message = `error: option '${option.flags}' argument missing`;
+    this._displayError(1, 'commander.optionMissingArgument', message);
+  };
 
-Command.prototype.variadicArgNotLast = function(name) {
-  console.error();
-  console.error("  error: variadic arguments must be last `%s'", name);
-  console.error();
-  process.exit(1);
-};
+  /**
+   * `Option` does not have a value, and is a mandatory option.
+   *
+   * @param {Option} option
+   * @api private
+   */
 
-/**
- * Set the program version to `str`.
- *
- * This method auto-registers the "-V, --version" flag
- * which will print the version number when passed.
- *
- * @param {String} str
- * @param {String} [flags]
- * @return {Command} for chaining
- * @api public
- */
+  missingMandatoryOptionValue(option) {
+    const message = `error: required option '${option.flags}' not specified`;
+    this._displayError(1, 'commander.missingMandatoryOptionValue', message);
+  };
 
-Command.prototype.version = function(str, flags) {
-  if (arguments.length === 0) return this._version;
-  this._version = str;
-  flags = flags || '-V, --version';
-  var versionOption = new Option(flags, 'output the version number');
-  this._versionOptionName = versionOption.long.substr(2) || 'version';
-  this.options.push(versionOption);
-  this.on('option:' + this._versionOptionName, function() {
-    process.stdout.write(str + '\n');
-    process.exit(0);
-  });
-  return this;
-};
+  /**
+   * Unknown option `flag`.
+   *
+   * @param {string} flag
+   * @api private
+   */
 
-/**
- * Set the description to `str`.
- *
- * @param {String} str
- * @param {Object} argsDescription
- * @return {String|Command}
- * @api public
- */
+  unknownOption(flag) {
+    if (this._allowUnknownOption) return;
+    const message = `error: unknown option '${flag}'`;
+    this._displayError(1, 'commander.unknownOption', message);
+  };
 
-Command.prototype.description = function(str, argsDescription) {
-  if (arguments.length === 0) return this._description;
-  this._description = str;
-  this._argsDescription = argsDescription;
-  return this;
-};
+  /**
+   * Excess arguments, more than expected.
+   *
+   * @param {string[]} receivedArgs
+   * @api private
+   */
 
-/**
- * Set an alias for the command
- *
- * @param {String} alias
- * @return {String|Command}
- * @api public
- */
+  _excessArguments(receivedArgs) {
+    if (this._allowExcessArguments) return;
 
-Command.prototype.alias = function(alias) {
-  var command = this;
-  if (this.commands.length !== 0) {
-    command = this.commands[this.commands.length - 1];
-  }
+    const expected = this._args.length;
+    const s = (expected === 1) ? '' : 's';
+    const forSubcommand = this.parent ? ` for '${this.name()}'` : '';
+    const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
+    this._displayError(1, 'commander.excessArguments', message);
+  };
 
-  if (arguments.length === 0) return command._alias;
+  /**
+   * Unknown command.
+   *
+   * @api private
+   */
 
-  if (alias === command._name) throw new Error('Command alias can\'t be the same as its name');
+  unknownCommand() {
+    const partCommands = [this.name()];
+    for (let parentCmd = this.parent; parentCmd; parentCmd = parentCmd.parent) {
+      partCommands.unshift(parentCmd.name());
+    }
+    const fullCommand = partCommands.join(' ');
+    const message = `error: unknown command '${this.args[0]}'.` +
+      (this._hasHelpOption ? ` See '${fullCommand} ${this._helpLongFlag}'.` : '');
+    this._displayError(1, 'commander.unknownCommand', message);
+  };
 
-  command._alias = alias;
-  return this;
-};
+  /**
+   * Set the program version to `str`.
+   *
+   * This method auto-registers the "-V, --version" flag
+   * which will print the version number when passed.
+   *
+   * You can optionally supply the  flags and description to override the defaults.
+   *
+   * @param {string} str
+   * @param {string} [flags]
+   * @param {string} [description]
+   * @return {this | string} `this` command for chaining, or version string if no arguments
+   */
 
-/**
- * Set / get the command usage `str`.
- *
- * @param {String} str
- * @return {String|Command}
- * @api public
- */
+  version(str, flags, description) {
+    if (str === undefined) return this._version;
+    this._version = str;
+    flags = flags || '-V, --version';
+    description = description || 'output the version number';
+    const versionOption = this.createOption(flags, description);
+    this._versionOptionName = versionOption.attributeName();
+    this.options.push(versionOption);
+    this.on('option:' + versionOption.name(), () => {
+      this._outputConfiguration.writeOut(`${str}\n`);
+      this._exit(0, 'commander.version', str);
+    });
+    return this;
+  };
 
-Command.prototype.usage = function(str) {
-  var args = this._args.map(function(arg) {
-    return humanReadableArgName(arg);
-  });
+  /**
+   * Set the description to `str`.
+   *
+   * @param {string} [str]
+   * @param {Object} [argsDescription]
+   * @return {string|Command}
+   */
+  description(str, argsDescription) {
+    if (str === undefined && argsDescription === undefined) return this._description;
+    this._description = str;
+    this._argsDescription = argsDescription;
+    return this;
+  };
 
-  var usage = '[options]' +
-    (this.commands.length ? ' [command]' : '') +
-    (this._args.length ? ' ' + args.join(' ') : '');
+  /**
+   * Set an alias for the command.
+   *
+   * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
+   *
+   * @param {string} [alias]
+   * @return {string|Command}
+   */
 
-  if (arguments.length === 0) return this._usage || usage;
-  this._usage = str;
+  alias(alias) {
+    if (alias === undefined) return this._aliases[0]; // just return first, for backwards compatibility
 
-  return this;
-};
+    let command = this;
+    if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
+      // assume adding alias for last added executable subcommand, rather than this
+      command = this.commands[this.commands.length - 1];
+    }
 
-/**
- * Get or set the name of the command
- *
- * @param {String} str
- * @return {String|Command}
- * @api public
- */
+    if (alias === command._name) throw new Error('Command alias can\'t be the same as its name');
 
-Command.prototype.name = function(str) {
-  if (arguments.length === 0) return this._name;
-  this._name = str;
-  return this;
-};
+    command._aliases.push(alias);
+    return this;
+  };
 
-/**
- * Return prepared commands.
- *
- * @return {Array}
- * @api private
- */
+  /**
+   * Set aliases for the command.
+   *
+   * Only the first alias is shown in the auto-generated help.
+   *
+   * @param {string[]} [aliases]
+   * @return {string[]|Command}
+   */
 
-Command.prototype.prepareCommands = function() {
-  return this.commands.filter(function(cmd) {
-    return !cmd._noHelp;
-  }).map(function(cmd) {
-    var args = cmd._args.map(function(arg) {
-      return humanReadableArgName(arg);
-    }).join(' ');
-
-    return [
-      cmd._name +
-        (cmd._alias ? '|' + cmd._alias : '') +
-        (cmd.options.length ? ' [options]' : '') +
-        (args ? ' ' + args : ''),
-      cmd._description
-    ];
-  });
-};
+  aliases(aliases) {
+    // Getter for the array of aliases is the main reason for having aliases() in addition to alias().
+    if (aliases === undefined) return this._aliases;
 
-/**
- * Return the largest command length.
- *
- * @return {Number}
- * @api private
- */
+    aliases.forEach((alias) => this.alias(alias));
+    return this;
+  };
 
-Command.prototype.largestCommandLength = function() {
-  var commands = this.prepareCommands();
-  return commands.reduce(function(max, command) {
-    return Math.max(max, command[0].length);
-  }, 0);
-};
+  /**
+   * Set / get the command usage `str`.
+   *
+   * @param {string} [str]
+   * @return {String|Command}
+   */
 
-/**
- * Return the largest option length.
- *
- * @return {Number}
- * @api private
- */
+  usage(str) {
+    if (str === undefined) {
+      if (this._usage) return this._usage;
 
-Command.prototype.largestOptionLength = function() {
-  var options = [].slice.call(this.options);
-  options.push({
-    flags: '-h, --help'
-  });
-  return options.reduce(function(max, option) {
-    return Math.max(max, option.flags.length);
-  }, 0);
-};
+      const args = this._args.map((arg) => {
+        return humanReadableArgName(arg);
+      });
+      return [].concat(
+        (this.options.length || this._hasHelpOption ? '[options]' : []),
+        (this.commands.length ? '[command]' : []),
+        (this._args.length ? args : [])
+      ).join(' ');
+    }
 
-/**
- * Return the largest arg length.
- *
- * @return {Number}
- * @api private
- */
+    this._usage = str;
+    return this;
+  };
 
-Command.prototype.largestArgLength = function() {
-  return this._args.reduce(function(max, arg) {
-    return Math.max(max, arg.name.length);
-  }, 0);
-};
+  /**
+   * Get or set the name of the command
+   *
+   * @param {string} [str]
+   * @return {string|Command}
+   */
 
-/**
- * Return the pad width.
- *
- * @return {Number}
- * @api private
- */
+  name(str) {
+    if (str === undefined) return this._name;
+    this._name = str;
+    return this;
+  };
+
+  /**
+   * Return program help documentation.
+   *
+   * @param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout
+   * @return {string}
+   */
 
-Command.prototype.padWidth = function() {
-  var width = this.largestOptionLength();
-  if (this._argsDescription && this._args.length) {
-    if (this.largestArgLength() > width) {
-      width = this.largestArgLength();
+  helpInformation(contextOptions) {
+    const helper = this.createHelp();
+    if (helper.helpWidth === undefined) {
+      helper.helpWidth = (contextOptions && contextOptions.error) ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
     }
-  }
+    return helper.formatHelp(this, helper);
+  };
 
-  if (this.commands && this.commands.length) {
-    if (this.largestCommandLength() > width) {
-      width = this.largestCommandLength();
+  /**
+   * @api private
+   */
+
+  _getHelpContext(contextOptions) {
+    contextOptions = contextOptions || {};
+    const context = { error: !!contextOptions.error };
+    let write;
+    if (context.error) {
+      write = (arg) => this._outputConfiguration.writeErr(arg);
+    } else {
+      write = (arg) => this._outputConfiguration.writeOut(arg);
     }
+    context.write = contextOptions.write || write;
+    context.command = this;
+    return context;
   }
 
-  return width;
-};
+  /**
+   * Output help information for this command.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   *
+   * @param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout
+   */
 
-/**
- * Return help for options.
- *
- * @return {String}
- * @api private
- */
+  outputHelp(contextOptions) {
+    let deprecatedCallback;
+    if (typeof contextOptions === 'function') {
+      deprecatedCallback = contextOptions;
+      contextOptions = undefined;
+    }
+    const context = this._getHelpContext(contextOptions);
 
-Command.prototype.optionHelp = function() {
-  var width = this.padWidth();
+    const groupListeners = [];
+    let command = this;
+    while (command) {
+      groupListeners.push(command); // ordered from current command to root
+      command = command.parent;
+    }
 
-  // Append the help information
-  return this.options.map(function(option) {
-    return pad(option.flags, width) + '  ' + option.description +
-      ((option.bool && option.defaultValue !== undefined) ? ' (default: ' + option.defaultValue + ')' : '');
-  }).concat([pad('-h, --help', width) + '  ' + 'output usage information'])
-    .join('\n');
-};
+    groupListeners.slice().reverse().forEach(command => command.emit('beforeAllHelp', context));
+    this.emit('beforeHelp', context);
 
-/**
- * Return command help documentation.
- *
- * @return {String}
- * @api private
- */
+    let helpInformation = this.helpInformation(context);
+    if (deprecatedCallback) {
+      helpInformation = deprecatedCallback(helpInformation);
+      if (typeof helpInformation !== 'string' && !Buffer.isBuffer(helpInformation)) {
+        throw new Error('outputHelp callback must return a string or a Buffer');
+      }
+    }
+    context.write(helpInformation);
 
-Command.prototype.commandHelp = function() {
-  if (!this.commands.length) return '';
-
-  var commands = this.prepareCommands();
-  var width = this.padWidth();
-
-  return [
-    '  Commands:',
-    '',
-    commands.map(function(cmd) {
-      var desc = cmd[1] ? '  ' + cmd[1] : '';
-      return (desc ? pad(cmd[0], width) : cmd[0]) + desc;
-    }).join('\n').replace(/^/gm, '    '),
-    ''
-  ].join('\n');
-};
+    this.emit(this._helpLongFlag); // deprecated
+    this.emit('afterHelp', context);
+    groupListeners.forEach(command => command.emit('afterAllHelp', context));
+  };
 
-/**
- * Return program help documentation.
- *
- * @return {String}
- * @api private
- */
+  /**
+   * You can pass in flags and a description to override the help
+   * flags and help description for your command. Pass in false to
+   * disable the built-in help option.
+   *
+   * @param {string | boolean} [flags]
+   * @param {string} [description]
+   * @return {Command} `this` command for chaining
+   */
 
-Command.prototype.helpInformation = function() {
-  var desc = [];
-  if (this._description) {
-    desc = [
-      '  ' + this._description,
-      ''
-    ];
-
-    var argsDescription = this._argsDescription;
-    if (argsDescription && this._args.length) {
-      var width = this.padWidth();
-      desc.push('  Arguments:');
-      desc.push('');
-      this._args.forEach(function(arg) {
-        desc.push('    ' + pad(arg.name, width) + '  ' + argsDescription[arg.name]);
-      });
-      desc.push('');
+  helpOption(flags, description) {
+    if (typeof flags === 'boolean') {
+      this._hasHelpOption = flags;
+      return this;
     }
-  }
+    this._helpFlags = flags || this._helpFlags;
+    this._helpDescription = description || this._helpDescription;
 
-  var cmdName = this._name;
-  if (this._alias) {
-    cmdName = cmdName + '|' + this._alias;
-  }
-  var usage = [
-    '',
-    '  Usage: ' + cmdName + ' ' + this.usage(),
-    ''
-  ];
+    const helpFlags = _parseOptionFlags(this._helpFlags);
+    this._helpShortFlag = helpFlags.shortFlag;
+    this._helpLongFlag = helpFlags.longFlag;
 
-  var cmds = [];
-  var commandHelp = this.commandHelp();
-  if (commandHelp) cmds = [commandHelp];
+    return this;
+  };
 
-  var options = [
-    '  Options:',
-    '',
-    '' + this.optionHelp().replace(/^/gm, '    '),
-    ''
-  ];
+  /**
+   * Output help information and exit.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   *
+   * @param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout
+   */
 
-  return usage
-    .concat(desc)
-    .concat(options)
-    .concat(cmds)
-    .join('\n');
-};
+  help(contextOptions) {
+    this.outputHelp(contextOptions);
+    let exitCode = process.exitCode || 0;
+    if (exitCode === 0 && contextOptions && typeof contextOptions !== 'function' && contextOptions.error) {
+      exitCode = 1;
+    }
+    // message: do not have all displayed text available so only passing placeholder.
+    this._exit(exitCode, 'commander.help', '(outputHelp)');
+  };
 
+  /**
+   * Add additional text to be displayed with the built-in help.
+   *
+   * Position is 'before' or 'after' to affect just this command,
+   * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
+   *
+   * @param {string} position - before or after built-in help
+   * @param {string | Function} text - string to add, or a function returning a string
+   * @return {Command} `this` command for chaining
+   */
+  addHelpText(position, text) {
+    const allowedValues = ['beforeAll', 'before', 'after', 'afterAll'];
+    if (!allowedValues.includes(position)) {
+      throw new Error(`Unexpected value for position to addHelpText.
+Expecting one of '${allowedValues.join("', '")}'`);
+    }
+    const helpEvent = `${position}Help`;
+    this.on(helpEvent, (context) => {
+      let helpStr;
+      if (typeof text === 'function') {
+        helpStr = text({ error: context.error, command: context.command });
+      } else {
+        helpStr = text;
+      }
+      // Ignore falsy value when nothing to output.
+      if (helpStr) {
+        context.write(`${helpStr}\n`);
+      }
+    });
+    return this;
+  }
+}
 /**
- * Output help information for this command
- *
- * @api public
+ * Expose the root command.
  */
 
-Command.prototype.outputHelp = function(cb) {
-  if (!cb) {
-    cb = function(passthru) {
-      return passthru;
-    };
-  }
-  process.stdout.write(cb(this.helpInformation()));
-  this.emit('--help');
-};
+exports = module.exports = new Command();
+exports.program = exports; // More explicit access to global command.
 
 /**
- * Output help information and exit.
- *
- * @api public
+ * Expose classes
  */
 
-Command.prototype.help = function(cb) {
-  this.outputHelp(cb);
-  process.exit();
-};
+exports.Command = Command;
+exports.Option = Option;
+exports.CommanderError = CommanderError;
+exports.InvalidOptionArgumentError = InvalidOptionArgumentError;
+exports.Help = Help;
 
 /**
  * Camel-case the given `flag`
  *
- * @param {String} flag
- * @return {String}
+ * @param {string} flag
+ * @return {string}
  * @api private
  */
 
 function camelcase(flag) {
-  return flag.split('-').reduce(function(str, word) {
+  return flag.split('-').reduce((str, word) => {
     return str + word[0].toUpperCase() + word.slice(1);
   });
 }
 
 /**
- * Pad `str` to `width`.
+ * Output help information if help flags specified
  *
- * @param {String} str
- * @param {Number} width
- * @return {String}
+ * @param {Command} cmd - command to output help for
+ * @param {Array} args - array of options to search for help flags
  * @api private
  */
 
-function pad(str, width) {
-  var len = Math.max(0, width - str.length);
-  return str + Array(len + 1).join(' ');
-}
-
-/**
- * Output help information if necessary
- *
- * @param {Command} command to output help for
- * @param {Array} array of options to search for -h or --help
- * @api private
- */
-
-function outputHelpIfNecessary(cmd, options) {
-  options = options || [];
-  for (var i = 0; i < options.length; i++) {
-    if (options[i] === '--help' || options[i] === '-h') {
-      cmd.outputHelp();
-      process.exit(0);
-    }
+function outputHelpIfRequested(cmd, args) {
+  const helpOption = cmd._hasHelpOption && args.find(arg => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag);
+  if (helpOption) {
+    cmd.outputHelp();
+    // (Do not have all displayed text available so only passing placeholder.)
+    cmd._exit(0, 'commander.helpDisplayed', '(outputHelp)');
   }
 }
 
 /**
- * Takes an argument an returns its human readable equivalent for help usage.
+ * Takes an argument and returns its human readable equivalent for help usage.
  *
  * @param {Object} arg
- * @return {String}
+ * @return {string}
  * @api private
  */
 
 function humanReadableArgName(arg) {
-  var nameOutput = arg.name + (arg.variadic === true ? '...' : '');
+  const nameOutput = arg.name + (arg.variadic === true ? '...' : '');
 
   return arg.required
     ? '<' + nameOutput + '>'
     : '[' + nameOutput + ']';
 }
 
-// for versions before node v0.8 when there weren't `fs.existsSync`
-function exists(file) {
-  try {
-    if (fs__default.statSync(file).isFile()) {
-      return true;
-    }
-  } catch (e) {
-    return false;
+/**
+ * Parse the short and long flag out of something like '-m,--mixed <value>'
+ *
+ * @api private
+ */
+
+function _parseOptionFlags(flags) {
+  let shortFlag;
+  let longFlag;
+  // Use original very loose parsing to maintain backwards compatibility for now,
+  // which allowed for example unintended `-sw, --short-word` [sic].
+  const flagParts = flags.split(/[ |,]+/);
+  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1])) shortFlag = flagParts.shift();
+  longFlag = flagParts.shift();
+  // Add support for lone short flag without significantly changing parsing!
+  if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+    shortFlag = longFlag;
+    longFlag = undefined;
   }
+  return { shortFlag, longFlag };
 }
-});
+
+/**
+ * Scan arguments and increment port number for inspect calls (to avoid conflicts when spawning new command).
+ *
+ * @param {string[]} args - array of arguments from node.execArgv
+ * @returns {string[]}
+ * @api private
+ */
+
+function incrementNodeInspectorPort(args) {
+  // Testing for these options:
+  //  --inspect[=[host:]port]
+  //  --inspect-brk[=[host:]port]
+  //  --inspect-port=[host:]port
+  return args.map((arg) => {
+    if (!arg.startsWith('--inspect')) {
+      return arg;
+    }
+    let debugOption;
+    let debugHost = '127.0.0.1';
+    let debugPort = '9229';
+    let match;
+    if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
+      // e.g. --inspect
+      debugOption = match[1];
+    } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
+      debugOption = match[1];
+      if (/^\d+$/.test(match[3])) {
+        // e.g. --inspect=1234
+        debugPort = match[3];
+      } else {
+        // e.g. --inspect=localhost
+        debugHost = match[3];
+      }
+    } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
+      // e.g. --inspect=localhost:1234
+      debugOption = match[1];
+      debugHost = match[3];
+      debugPort = match[4];
+    }
+
+    if (debugOption && debugPort !== '0') {
+      return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
+    }
+    return arg;
+  });
+}
+}(commander, commander.exports));
 
 var domain; // The domain module is executed on demand
 var hasSetImmediate = typeof setImmediate === "function";
@@ -1995,8 +2997,8 @@ var hasSetImmediate = typeof setImmediate === "function";
 // soon as possible, but if you use `rawAsap` directly, you are responsible to
 // either ensure that no exceptions are thrown from your task, or to manually
 // call `rawAsap.requestFlush` if an exception is thrown.
-var raw = rawAsap;
-function rawAsap(task) {
+var raw = rawAsap$1;
+function rawAsap$1(task) {
     if (!queue.length) {
         requestFlush();
         flushing = true;
@@ -2051,7 +3053,7 @@ function flush() {
     flushing = false;
 }
 
-rawAsap.requestFlush = requestFlush;
+rawAsap$1.requestFlush = requestFlush;
 function requestFlush() {
     // Ensure flushing is not bound to any domain.
     // It is not sufficient to exit the domain, because domains exist on a stack.
@@ -2061,7 +3063,7 @@ function requestFlush() {
         if (!domain) {
             // Lazy execute the domain module.
             // Only employed if the user elects to use domains.
-            domain = require$$0$1;
+            domain = require$$0$3;
         }
         domain.active = process.domain = null;
     }
@@ -2083,6 +3085,8 @@ function requestFlush() {
     }
 }
 
+var asap$2 = raw;
+
 function noop() {}
 
 // States:
@@ -2130,78 +3134,78 @@ function tryCallTwo(fn, a, b) {
   }
 }
 
-var core = Promise$1;
+var core = Promise$7;
 
-function Promise$1(fn) {
+function Promise$7(fn) {
   if (typeof this !== 'object') {
     throw new TypeError('Promises must be constructed via new');
   }
   if (typeof fn !== 'function') {
     throw new TypeError('Promise constructor\'s argument is not a function');
   }
-  this._75 = 0;
-  this._83 = 0;
-  this._18 = null;
-  this._38 = null;
+  this._U = 0;
+  this._V = 0;
+  this._W = null;
+  this._X = null;
   if (fn === noop) return;
   doResolve(fn, this);
 }
-Promise$1._47 = null;
-Promise$1._71 = null;
-Promise$1._44 = noop;
+Promise$7._Y = null;
+Promise$7._Z = null;
+Promise$7._0 = noop;
 
-Promise$1.prototype.then = function(onFulfilled, onRejected) {
-  if (this.constructor !== Promise$1) {
+Promise$7.prototype.then = function(onFulfilled, onRejected) {
+  if (this.constructor !== Promise$7) {
     return safeThen(this, onFulfilled, onRejected);
   }
-  var res = new Promise$1(noop);
+  var res = new Promise$7(noop);
   handle(this, new Handler(onFulfilled, onRejected, res));
   return res;
 };
 
 function safeThen(self, onFulfilled, onRejected) {
   return new self.constructor(function (resolve, reject) {
-    var res = new Promise$1(noop);
+    var res = new Promise$7(noop);
     res.then(resolve, reject);
     handle(self, new Handler(onFulfilled, onRejected, res));
   });
 }
 function handle(self, deferred) {
-  while (self._83 === 3) {
-    self = self._18;
+  while (self._V === 3) {
+    self = self._W;
   }
-  if (Promise$1._47) {
-    Promise$1._47(self);
+  if (Promise$7._Y) {
+    Promise$7._Y(self);
   }
-  if (self._83 === 0) {
-    if (self._75 === 0) {
-      self._75 = 1;
-      self._38 = deferred;
+  if (self._V === 0) {
+    if (self._U === 0) {
+      self._U = 1;
+      self._X = deferred;
       return;
     }
-    if (self._75 === 1) {
-      self._75 = 2;
-      self._38 = [self._38, deferred];
+    if (self._U === 1) {
+      self._U = 2;
+      self._X = [self._X, deferred];
       return;
     }
-    self._38.push(deferred);
+    self._X.push(deferred);
     return;
   }
   handleResolved(self, deferred);
 }
 
 function handleResolved(self, deferred) {
-  raw(function() {
-    var cb = self._83 === 1 ? deferred.onFulfilled : deferred.onRejected;
+  asap$2(function() {
+    var cb = self._V === 1 ? deferred.onFulfilled : deferred.onRejected;
     if (cb === null) {
-      if (self._83 === 1) {
-        resolve(deferred.promise, self._18);
+      if (self._V === 1) {
+        resolve(deferred.promise, self._W);
       } else {
-        reject(deferred.promise, self._18);
+        reject(deferred.promise, self._W);
       }
       return;
     }
-    var ret = tryCallOne(cb, self._18);
+    var ret = tryCallOne(cb, self._W);
     if (ret === IS_ERROR) {
       reject(deferred.promise, LAST_ERROR);
     } else {
@@ -2227,10 +3231,10 @@ function resolve(self, newValue) {
     }
     if (
       then === self.then &&
-      newValue instanceof Promise$1
+      newValue instanceof Promise$7
     ) {
-      self._83 = 3;
-      self._18 = newValue;
+      self._V = 3;
+      self._W = newValue;
       finale(self);
       return;
     } else if (typeof then === 'function') {
@@ -2238,29 +3242,29 @@ function resolve(self, newValue) {
       return;
     }
   }
-  self._83 = 1;
-  self._18 = newValue;
+  self._V = 1;
+  self._W = newValue;
   finale(self);
 }
 
 function reject(self, newValue) {
-  self._83 = 2;
-  self._18 = newValue;
-  if (Promise$1._71) {
-    Promise$1._71(self, newValue);
+  self._V = 2;
+  self._W = newValue;
+  if (Promise$7._Z) {
+    Promise$7._Z(self, newValue);
   }
   finale(self);
 }
 function finale(self) {
-  if (self._75 === 1) {
-    handle(self, self._38);
-    self._38 = null;
+  if (self._U === 1) {
+    handle(self, self._X);
+    self._X = null;
   }
-  if (self._75 === 2) {
-    for (var i = 0; i < self._38.length; i++) {
-      handle(self, self._38[i]);
+  if (self._U === 2) {
+    for (var i = 0; i < self._X.length; i++) {
+      handle(self, self._X[i]);
     }
-    self._38 = null;
+    self._X = null;
   }
 }
 
@@ -2293,7 +3297,8 @@ function doResolve(fn, promise) {
   }
 }
 
-core.prototype.done = function (onFulfilled, onRejected) {
+var Promise$6 = core;
+Promise$6.prototype.done = function (onFulfilled, onRejected) {
   var self = arguments.length ? this.then.apply(this, arguments) : this;
   self.then(null, function (err) {
     setTimeout(function () {
@@ -2302,18 +3307,23 @@ core.prototype.done = function (onFulfilled, onRejected) {
   });
 };
 
-core.prototype['finally'] = function (f) {
+var Promise$5 = core;
+Promise$5.prototype.finally = function (f) {
   return this.then(function (value) {
-    return core.resolve(f()).then(function () {
+    return Promise$5.resolve(f()).then(function () {
       return value;
     });
   }, function (err) {
-    return core.resolve(f()).then(function () {
+    return Promise$5.resolve(f()).then(function () {
       throw err;
     });
   });
 };
 
+//This file contains the ES6 extensions to the core Promises/A+ API
+
+var Promise$4 = core;
+
 /* Static Functions */
 
 var TRUE = valuePromise(true);
@@ -2324,13 +3334,13 @@ var ZERO = valuePromise(0);
 var EMPTYSTRING = valuePromise('');
 
 function valuePromise(value) {
-  var p = new core(core._44);
-  p._83 = 1;
-  p._18 = value;
+  var p = new Promise$4(Promise$4._0);
+  p._V = 1;
+  p._W = value;
   return p;
 }
-core.resolve = function (value) {
-  if (value instanceof core) return value;
+Promise$4.resolve = function (value) {
+  if (value instanceof Promise$4) return value;
 
   if (value === null) return NULL;
   if (value === undefined) return UNDEFINED;
@@ -2343,10 +3353,10 @@ core.resolve = function (value) {
     try {
       var then = value.then;
       if (typeof then === 'function') {
-        return new core(then.bind(value));
+        return new Promise$4(then.bind(value));
       }
     } catch (ex) {
-      return new core(function (resolve, reject) {
+      return new Promise$4(function (resolve, reject) {
         reject(ex);
       });
     }
@@ -2354,20 +3364,32 @@ core.resolve = function (value) {
   return valuePromise(value);
 };
 
-core.all = function (arr) {
-  var args = Array.prototype.slice.call(arr);
+var iterableToArray = function (iterable) {
+  if (typeof Array.from === 'function') {
+    // ES2015+, iterables exist
+    iterableToArray = Array.from;
+    return Array.from(iterable);
+  }
+
+  // ES5, only arrays and array-likes exist
+  iterableToArray = function (x) { return Array.prototype.slice.call(x); };
+  return Array.prototype.slice.call(iterable);
+};
+
+Promise$4.all = function (arr) {
+  var args = iterableToArray(arr);
 
-  return new core(function (resolve, reject) {
+  return new Promise$4(function (resolve, reject) {
     if (args.length === 0) return resolve([]);
     var remaining = args.length;
     function res(i, val) {
       if (val && (typeof val === 'object' || typeof val === 'function')) {
-        if (val instanceof core && val.then === core.prototype.then) {
-          while (val._83 === 3) {
-            val = val._18;
+        if (val instanceof Promise$4 && val.then === Promise$4.prototype.then) {
+          while (val._V === 3) {
+            val = val._W;
           }
-          if (val._83 === 1) return res(i, val._18);
-          if (val._83 === 2) reject(val._18);
+          if (val._V === 1) return res(i, val._W);
+          if (val._V === 2) reject(val._W);
           val.then(function (val) {
             res(i, val);
           }, reject);
@@ -2375,7 +3397,7 @@ core.all = function (arr) {
         } else {
           var then = val.then;
           if (typeof then === 'function') {
-            var p = new core(then.bind(val));
+            var p = new Promise$4(then.bind(val));
             p.then(function (val) {
               res(i, val);
             }, reject);
@@ -2394,26 +3416,27 @@ core.all = function (arr) {
   });
 };
 
-core.reject = function (value) {
-  return new core(function (resolve, reject) {
+Promise$4.reject = function (value) {
+  return new Promise$4(function (resolve, reject) {
     reject(value);
   });
 };
 
-core.race = function (values) {
-  return new core(function (resolve, reject) {
-    values.forEach(function(value){
-      core.resolve(value).then(resolve, reject);
+Promise$4.race = function (values) {
+  return new Promise$4(function (resolve, reject) {
+    iterableToArray(values).forEach(function(value){
+      Promise$4.resolve(value).then(resolve, reject);
     });
   });
 };
 
 /* Prototype Methods */
 
-core.prototype['catch'] = function (onRejected) {
+Promise$4.prototype['catch'] = function (onRejected) {
   return this.then(null, onRejected);
 };
 
+var rawAsap = raw;
 var freeTasks = [];
 
 /**
@@ -2426,8 +3449,8 @@ var freeTasks = [];
  * @param {{call}} task A callable object, typically a function that takes no
  * arguments.
  */
-var asap_1 = asap;
-function asap(task) {
+var asap_1 = asap$1;
+function asap$1(task) {
     var rawTask;
     if (freeTasks.length) {
         rawTask = freeTasks.pop();
@@ -2436,7 +3459,7 @@ function asap(task) {
     }
     rawTask.task = task;
     rawTask.domain = process.domain;
-    raw(rawTask);
+    rawAsap(rawTask);
 }
 
 function RawTask() {
@@ -2466,7 +3489,7 @@ RawTask.prototype.call = function () {
             // Ensure that flushing continues if an uncaught exception is
             // suppressed listening process.on("uncaughtException") or
             // domain.on("error").
-            raw.requestFlush();
+            rawAsap.requestFlush();
         }
         // If the task threw an error, we do not want to exit the domain here.
         // Exiting the domain would prevent the domain from catching the error.
@@ -2476,9 +3499,15 @@ RawTask.prototype.call = function () {
     }
 };
 
+// This file contains then/promise specific extensions that are only useful
+// for node.js interop
+
+var Promise$3 = core;
+var asap = asap_1;
+
 /* Static Functions */
 
-core.denodeify = function (fn, argumentCount) {
+Promise$3.denodeify = function (fn, argumentCount) {
   if (
     typeof argumentCount === 'number' && argumentCount !== Infinity
   ) {
@@ -2512,7 +3541,7 @@ function denodeifyWithCount(fn, argumentCount) {
     '});',
     '};'
   ].join('');
-  return Function(['Promise', 'fn'], body)(core, fn);
+  return Function(['Promise', 'fn'], body)(Promise$3, fn);
 }
 function denodeifyWithoutCount(fn) {
   var fnLength = Math.max(fn.length - 1, 3);
@@ -2558,10 +3587,10 @@ function denodeifyWithoutCount(fn) {
   return Function(
     ['Promise', 'fn'],
     body
-  )(core, fn);
+  )(Promise$3, fn);
 }
 
-core.nodeify = function (fn) {
+Promise$3.nodeify = function (fn) {
   return function () {
     var args = Array.prototype.slice.call(arguments);
     var callback =
@@ -2571,11 +3600,11 @@ core.nodeify = function (fn) {
       return fn.apply(this, arguments).nodeify(callback, ctx);
     } catch (ex) {
       if (callback === null || typeof callback == 'undefined') {
-        return new core(function (resolve, reject) {
+        return new Promise$3(function (resolve, reject) {
           reject(ex);
         });
       } else {
-        asap_1(function () {
+        asap(function () {
           callback.call(ctx, ex);
         });
       }
@@ -2583,76 +3612,77 @@ core.nodeify = function (fn) {
   }
 };
 
-core.prototype.nodeify = function (callback, ctx) {
+Promise$3.prototype.nodeify = function (callback, ctx) {
   if (typeof callback != 'function') return this;
 
   this.then(function (value) {
-    asap_1(function () {
+    asap(function () {
       callback.call(ctx, null, value);
     });
   }, function (err) {
-    asap_1(function () {
+    asap(function () {
       callback.call(ctx, err);
     });
   });
 };
 
-core.enableSynchronous = function () {
-  core.prototype.isPending = function() {
+var Promise$2 = core;
+Promise$2.enableSynchronous = function () {
+  Promise$2.prototype.isPending = function() {
     return this.getState() == 0;
   };
 
-  core.prototype.isFulfilled = function() {
+  Promise$2.prototype.isFulfilled = function() {
     return this.getState() == 1;
   };
 
-  core.prototype.isRejected = function() {
+  Promise$2.prototype.isRejected = function() {
     return this.getState() == 2;
   };
 
-  core.prototype.getValue = function () {
-    if (this._83 === 3) {
-      return this._18.getValue();
+  Promise$2.prototype.getValue = function () {
+    if (this._V === 3) {
+      return this._W.getValue();
     }
 
     if (!this.isFulfilled()) {
       throw new Error('Cannot get a value of an unfulfilled promise.');
     }
 
-    return this._18;
+    return this._W;
   };
 
-  core.prototype.getReason = function () {
-    if (this._83 === 3) {
-      return this._18.getReason();
+  Promise$2.prototype.getReason = function () {
+    if (this._V === 3) {
+      return this._W.getReason();
     }
 
     if (!this.isRejected()) {
       throw new Error('Cannot get a rejection reason of a non-rejected promise.');
     }
 
-    return this._18;
+    return this._W;
   };
 
-  core.prototype.getState = function () {
-    if (this._83 === 3) {
-      return this._18.getState();
+  Promise$2.prototype.getState = function () {
+    if (this._V === 3) {
+      return this._W.getState();
     }
-    if (this._83 === -1 || this._83 === -2) {
+    if (this._V === -1 || this._V === -2) {
       return 0;
     }
 
-    return this._83;
+    return this._V;
   };
 };
 
-core.disableSynchronous = function() {
-  core.prototype.isPending = undefined;
-  core.prototype.isFulfilled = undefined;
-  core.prototype.isRejected = undefined;
-  core.prototype.getValue = undefined;
-  core.prototype.getReason = undefined;
-  core.prototype.getState = undefined;
+Promise$2.disableSynchronous = function() {
+  Promise$2.prototype.isPending = undefined;
+  Promise$2.prototype.isFulfilled = undefined;
+  Promise$2.prototype.isRejected = undefined;
+  Promise$2.prototype.getValue = undefined;
+  Promise$2.prototype.getReason = undefined;
+  Promise$2.prototype.getState = undefined;
 };
 
 var lib = core;
@@ -2676,17 +3706,13 @@ var promise = lib;
  * limitations under the license.
  */
 
-
-
-
-
-
-
-
-
-
-
-
+const colors = safe.exports;
+const fs = fs__default;
+const http = http$1;
+const https = https$1;
+const program = commander.exports;
+const Promise$1 = promise;
+const vm = require$$10;
 
 const DEFAULT_USER_AGENT = 'amphtml-validator';
 
@@ -2716,8 +3742,8 @@ function isHttpOrHttpsUrl(url) {
  * @return {Promise<string>}
  */
 function readFromFile(name) {
-  return new promise(function(resolve, reject) {
-    fs__default.readFile(name, 'utf8', function(err, data) {
+  return new Promise$1(function(resolve, reject) {
+    fs.readFile(name, 'utf8', function(err, data) {
       if (err) {
         reject(err);
       } else {
@@ -2734,7 +3760,7 @@ function readFromFile(name) {
  * @return {Promise<string>}
  */
 function readFromReadable(name, readable) {
-  return new promise(function(resolve, reject) {
+  return new Promise$1(function(resolve, reject) {
     const chunks = [];
     readable.setEncoding('utf8');
     readable.on('data', function(chunk) {
@@ -2771,7 +3797,7 @@ function readFromStdin() {
  * @return {Promise<string>}
  */
 function readFromUrl(url, userAgent) {
-  return new promise(function(resolve, reject) {
+  return new Promise$1(function(resolve, reject) {
     const clientModule = hasPrefix(url, 'http://') ? http : https;
     const req = clientModule.request(url, function(response) {
       if (response.statusCode !== 200) {
@@ -2876,8 +3902,8 @@ function ValidationError() {
 
 /**
  * The validator instance is a proxy object to a precompiled
- * validator.js script - in practice the script was either downloaded
- * from 'https://cdn.ampproject.org/v0/validator.js' or read from a
+ * validator_wasm.js script - in practice the script was either downloaded
+ * from 'https://cdn.ampproject.org/v0/validator_wasm.js' or read from a
  * local file.
  * @param {string} scriptContents
  * @throws {!Error}
@@ -2898,10 +3924,23 @@ function Validator(scriptContents) {
   try {
     new vm.Script(scriptContents).runInContext(this.sandbox);
   } catch (error) {
-    throw new Error('Could not instantiate validator.js - ' + error.message);
+    throw new Error('Could not instantiate validator_wasm.js - ' +
+        error.message);
   }
 }
 
+/**
+ * Initialize the validator.
+ * @return {Promise<undefined>!}
+ */
+Validator.prototype.init = function() {
+  if (this.sandbox.amp.validator.init) {
+    return this.sandbox.amp.validator.init();
+  } else {
+    return Promise$1.resolve(undefined);
+  }
+};
+
 /**
  * Validates the provided inputString; the htmlFormat can be 'AMP' or
  * 'AMP4ADS'; it defaults to 'AMP' if not specified.
@@ -2939,7 +3978,7 @@ Validator.prototype.validateString = function(inputString, htmlFormat) {
 const instanceByValidatorJs = {};
 
 /**
- * Provided a URL or a filename from which to fetch the validator.js
+ * Provided a URL or a filename from which to fetch the validator_wasm.js
  * file, fetches, instantiates, and caches the validator instance
  * asynchronously.  If you prefer to implement your own fetching /
  * caching logic, you may want to consider newInstance() instead,
@@ -2952,10 +3991,10 @@ const instanceByValidatorJs = {};
  */
 function getInstance(opt_validatorJs, opt_userAgent) {
   const validatorJs =
-      opt_validatorJs || 'https://cdn.ampproject.org/v0/validator.js';
+      opt_validatorJs || 'https://cdn.ampproject.org/v0/validator_wasm.js';
   const userAgent = opt_userAgent || DEFAULT_USER_AGENT;
   if (instanceByValidatorJs.hasOwnProperty(validatorJs)) {
-    return promise.resolve(instanceByValidatorJs[validatorJs]);
+    return Promise$1.resolve(instanceByValidatorJs[validatorJs]);
   }
   const validatorJsPromise = isHttpOrHttpsUrl(validatorJs) ?
     readFromUrl(validatorJs, userAgent) :
@@ -2973,15 +4012,17 @@ function getInstance(opt_validatorJs, opt_userAgent) {
     }
     instanceByValidatorJs[validatorJs] = instance;
     return instance;
+  }).then(function(instance) {
+    return instance.init().then(() => instance);
   });
 }
-var getInstance_1 = getInstance;
+amphtmlValidator.getInstance = getInstance;
 
 /**
- * Provided the contents of the validator.js file, e.g. as downloaded from
- * 'https://cdn.ampproject.org/v0/validator.js', returns a new validator
+ * Provided the contents of the validator_wasm.js file, e.g. as downloaded from
+ * 'https://cdn.ampproject.org/v0/validator_wasm.js', returns a new validator
  * instance. The tradeoff between this function and getInstance() is that this
- * function is synchronous but requires the contents of the validator.js
+ * function is synchronous but requires the contents of the validator_wasm.js
  * file as a parameter, while getInstance is asynchronous, fetches files
  * from disk or the web, and caches them.
  *
@@ -2992,7 +4033,7 @@ var getInstance_1 = getInstance;
 function newInstance(validatorJsContents) {
   return new Validator(validatorJsContents);
 }
-var newInstance_1 = newInstance;
+amphtmlValidator.newInstance = newInstance;
 
 // A note on emitting output to the console and process exit status:
 // Node.js prior to 0.11.8 did not support process.exitCode
@@ -3014,13 +4055,13 @@ var newInstance_1 = newInstance;
 function logValidationResult(filename, validationResult, color) {
   if (validationResult.status === 'PASS') {
     process.stdout.write(
-        filename + ': ' + (color ? safe.green('PASS') : 'PASS') + '\n');
+        filename + ': ' + (color ? colors.green('PASS') : 'PASS') + '\n');
   }
   for (let ii = 0; ii < validationResult.errors.length; ii++) {
     const error = validationResult.errors[ii];
     let msg = filename + ':' + error.line + ':' + error.col + ' ';
     if (color) {
-      msg += (error.severity === 'ERROR' ? safe.red : safe.magenta)(
+      msg += (error.severity === 'ERROR' ? colors.red : colors.magenta)(
           error.message);
     } else {
       msg += error.message;
@@ -3037,7 +4078,7 @@ function logValidationResult(filename, validationResult, color) {
  * Main entry point into the command line tool.
  */
 function main() {
-  commander
+  program
       .usage(
           '[options] <fileOrUrlOrMinus...>\n\n' +
           '  Validates the files or urls provided as arguments. If "-" is\n' +
@@ -3048,7 +4089,7 @@ function main() {
               '  Latest published version by default, or\n' +
               '  dist/validator_minified.js (built with build.py)\n' +
               '  for development.',
-          'https://cdn.ampproject.org/v0/validator.js')
+          'https://cdn.ampproject.org/v0/validator_wasm.js')
       .option(
           '--user-agent <userAgent>', 'User agent string to use in requests.',
           DEFAULT_USER_AGENT)
@@ -3068,57 +4109,58 @@ function main() {
               '          message in validator.proto.',
           'color')
       .parse(process.argv);
-  if (commander.args.length === 0) {
-    commander.outputHelp();
+  const opts = program.opts();
+  if (opts.length === 0) {
+    program.outputHelp();
     process.exit(1);
   }
-  if (commander.html_format !== 'AMP' && commander.html_format !== 'AMP4ADS' &&
-      commander.html_format !== 'AMP4EMAIL') {
+  if (opts.html_format !== 'AMP' && opts.html_format !== 'AMP4ADS' &&
+      opts.html_format !== 'AMP4EMAIL') {
     process.stderr.write(
         '--html_format must be set to "AMP", "AMP4ADS", or "AMP4EMAIL".\n',
         function() {
           process.exit(1);
         });
   }
-  if (commander.format !== 'color' && commander.format !== 'text' &&
-      commander.format !== 'json') {
+  if (opts.format !== 'color' && opts.format !== 'text' &&
+      opts.format !== 'json') {
     process.stderr.write(
         '--format must be set to "color", "text", or "json".\n', function() {
           process.exit(1);
         });
   }
   const inputs = [];
-  for (let ii = 0; ii < commander.args.length; ii++) {
-    const item = commander.args[ii];
+  for (let ii = 0; ii < program.args.length; ii++) {
+    const item = program.args[ii];
     if (item === '-') {
       inputs.push(readFromStdin());
     } else if (isHttpOrHttpsUrl(item)) {
-      inputs.push(readFromUrl(item, commander.userAgent));
+      inputs.push(readFromUrl(item, opts.userAgent));
     } else {
       inputs.push(readFromFile(item));
     }
   }
-  getInstance(commander.validator_js, commander.userAgent)
+  getInstance(opts.validator_js, opts.userAgent)
       .then(function(validator) {
-        promise.all(inputs)
+        Promise$1.all(inputs)
             .then(function(resolvedInputs) {
               const jsonOut = {};
               let hasError = false;
               for (let ii = 0; ii < resolvedInputs.length; ii++) {
                 const validationResult = validator.validateString(
-                    resolvedInputs[ii], commander.html_format);
-                if (commander.format === 'json') {
-                  jsonOut[commander.args[ii]] = validationResult;
+                    resolvedInputs[ii], opts.html_format);
+                if (opts.format === 'json') {
+                  jsonOut[program.args[ii]] = validationResult;
                 } else {
                   logValidationResult(
-                      commander.args[ii], validationResult,
-                      commander.format === 'color' ? true : false);
+                      program.args[ii], validationResult,
+                      opts.format === 'color' ? true : false);
                 }
                 if (validationResult.status !== 'PASS') {
                   hasError = true;
                 }
               }
-              if (commander.format === 'json') {
+              if (opts.format === 'json') {
                 process.stdout.write(
                     JSON.stringify(jsonOut) + '\n', function() {
                       process.exit(hasError ? 1 : 0);
@@ -3135,7 +4177,7 @@ function main() {
             })
             .catch(function(error) {
               process.stderr.write(
-                  (commander.format == 'color' ? safe.red(error.message) :
+                  (opts.format == 'color' ? colors.red(error.message) :
                     error.message) +
                       '\n',
                   function() {
@@ -3145,7 +4187,7 @@ function main() {
       })
       .catch(function(error) {
         process.stderr.write(
-            (commander.format == 'color' ? safe.red(error.message) :
+            (opts.format == 'color' ? colors.red(error.message) :
               error.message) +
                 '\n',
             function() {
@@ -3154,13 +4196,7 @@ function main() {
       });
 }
 
-var main_1 = main;
-
-var amphtmlValidator = {
-	getInstance: getInstance_1,
-	newInstance: newInstance_1,
-	main: main_1
-};
+amphtmlValidator.main = main;
 
 /** @typedef {{ cwd?: string, port: number, host?: string, https: boolean, config: import('types/config').ValidatedConfig }} Options */
 /** @typedef {import('types/internal').SSRComponent} SSRComponent */
@@ -3246,14 +4282,17 @@ class Watcher extends EventEmitter {
 			}
 		};
 
-		/** @type {(req: import("http").IncomingMessage, res: import("http").ServerResponse) => void} */
-		let handler = (req, res) => {};
-
-		this.server = await get_server(this.https, vite_config, (req, res) => handler(req, res));
-
 		// don't warn on overriding defaults
 		const [modified_vite_config] = deep_merge(default_config, vite_config);
 
+		const kit_plugin = await create_plugin(this.config, this.dir, this.cwd, () => {
+			if (!this.manifest) {
+				throw new Error('Manifest is not available');
+			}
+
+			return this.manifest;
+		});
+
 		/** @type {[any, string[]]} */
 		const [merged_config, conflicts] = deep_merge(modified_vite_config, {
 			configFile: false,
@@ -3278,14 +4317,13 @@ class Watcher extends EventEmitter {
 					compilerOptions: {
 						hydratable: !!this.config.kit.hydrate
 					}
-				})
+				}),
+				kit_plugin
 			],
 			publicDir: this.config.kit.files.assets,
 			server: {
-				middlewareMode: true,
-				hmr: {
-					...(this.https ? { server: this.server, port: this.port } : {})
-				}
+				host: this.host,
+				https: this.https
 			},
 			base: this.config.kit.paths.assets.startsWith('/') ? `${this.config.kit.paths.assets}/` : '/'
 		});
@@ -3293,18 +4331,8 @@ class Watcher extends EventEmitter {
 		print_config_conflicts(conflicts, 'kit.vite.');
 
 		this.vite = await vite.createServer(merged_config);
-
-		const get_manifest = () => {
-			if (!this.manifest) {
-				throw new Error('Manifest is not available');
-			}
-
-			return this.manifest;
-		};
-
-		handler = await create_handler(this.vite, this.config, this.dir, this.cwd, get_manifest);
-
-		this.server.listen(this.port, this.host || '0.0.0.0');
+		remove_html_middlewares(this.vite.middlewares);
+		await this.vite.listen(this.port);
 	}
 
 	update() {
@@ -3351,7 +4379,7 @@ class Watcher extends EventEmitter {
 	}
 
 	close() {
-		if (!this.vite || !this.server || !this.cheapwatch) {
+		if (!this.vite || !this.cheapwatch) {
 			throw new Error('Cannot close server before it is initialized');
 		}
 
@@ -3359,7 +4387,6 @@ class Watcher extends EventEmitter {
 		this.closed = true;
 
 		this.vite.close();
-		this.server.close();
 		this.cheapwatch.close();
 	}
 }
@@ -3370,15 +4397,31 @@ function get_params(array) {
 	// src/routes/[x]/[y]/[z]/svelte, create a function
 	// that turns a RegExpExecArray into ({ x, y, z })
 
+	// input has already been decoded by decodeURI
+	// now handle the rest that decodeURIComponent would do
+	const d = /** @param {string} s */ (s) =>
+		s
+			.replace(/%23/g, '#')
+			.replace(/%3[Bb]/g, ';')
+			.replace(/%2[Cc]/g, ',')
+			.replace(/%2[Ff]/g, '/')
+			.replace(/%3[Ff]/g, '?')
+			.replace(/%3[Aa]/g, ':')
+			.replace(/%40/g, '@')
+			.replace(/%26/g, '&')
+			.replace(/%3[Dd]/g, '=')
+			.replace(/%2[Bb]/g, '+')
+			.replace(/%24/g, '$');
+
 	/** @param {RegExpExecArray} match */
 	const fn = (match) => {
 		/** @type {Record<string, string>} */
 		const params = {};
 		array.forEach((key, i) => {
 			if (key.startsWith('...')) {
-				params[key.slice(3)] = decodeURIComponent(match[i + 1] || '');
+				params[key.slice(3)] = d(match[i + 1] || '');
 			} else {
-				params[key] = decodeURIComponent(match[i + 1]);
+				params[key] = d(match[i + 1]);
 			}
 		});
 		return params;
@@ -3388,13 +4431,12 @@ function get_params(array) {
 }
 
 /**
- * @param {vite.ViteDevServer} vite
  * @param {import('types/config').ValidatedConfig} config
  * @param {string} dir
  * @param {string} cwd
  * @param {() => import('types/internal').SSRManifest} get_manifest
  */
-async function create_handler(vite, config, dir, cwd, get_manifest) {
+async function create_plugin(config, dir, cwd, get_manifest) {
 	/**
 	 * @type {amp_validator.Validator?}
 	 */
@@ -3414,11 +4456,14 @@ async function create_handler(vite, config, dir, cwd, get_manifest) {
 	};
 
 	/**
-	 * @param {import('http').IncomingMessage} req
-	 * @param {import('http').ServerResponse} res
+	 * @param {vite.ViteDevServer} vite
 	 */
-	return (req, res) => {
-		vite.middlewares(req, res, async () => {
+	function create_kit_middleware(vite) {
+		/**
+		 * Use a named function for debugging
+		 * @type {import('connect').NextHandleFunction}
+		 */
+		return async function svelteKitMiddleware(req, res) {
 			try {
 				if (!req.url || !req.method) throw new Error('Incomplete request');
 				if (req.url === '/favicon.ico') return not_found(res);
@@ -3479,8 +4524,9 @@ async function create_handler(vite, config, dir, cwd, get_manifest) {
 					return res.end(err.reason || 'Invalid request body');
 				}
 
-				const host = /** @type {string} */ (config.kit.host ||
-					req.headers[config.kit.hostHeader || 'host']);
+				const host = /** @type {string} */ (
+					config.kit.host || req.headers[config.kit.hostHeader || 'host']
+				);
 
 				const rendered = await respond(
 					{
@@ -3631,7 +4677,19 @@ async function create_handler(vite, config, dir, cwd, get_manifest) {
 				res.statusCode = 500;
 				res.end(error.stack);
 			}
-		});
+		};
+	}
+
+	return {
+		name: 'vite-plugin-svelte-kit',
+		/**
+		 * @param {import('vite').ViteDevServer} vite
+		 */
+		configureServer(vite) {
+			return () => {
+				vite.middlewares.use(create_kit_middleware(vite));
+			};
+		}
 	};
 }
 
@@ -3641,4 +4699,21 @@ function not_found(res) {
 	res.end('Not found');
 }
 
+/**
+ * @param {import('connect').Server} server
+ */
+function remove_html_middlewares(server) {
+	const html_middlewares = [
+		'viteIndexHtmlMiddleware',
+		'vite404Middleware',
+		'viteSpaFallbackMiddleware'
+	];
+	for (let i = server.stack.length - 1; i > 0; i--) {
+		// @ts-expect-error using internals until https://github.com/vitejs/vite/pull/4640 is merged
+		if (html_middlewares.includes(server.stack[i].handle.name)) {
+			server.stack.splice(i, 1);
+		}
+	}
+}
+
 export { dev };