1  'use strict';
   2  
   3  var assert = require('assert');
   4  
   5  class YError extends Error {
   6      constructor(msg) {
   7          super(msg || 'yargs error');
   8          this.name = 'YError';
   9          Error.captureStackTrace(this, YError);
  10      }
  11  }
  12  
  13  let previouslyVisitedConfigs = [];
  14  let shim;
  15  function applyExtends(config, cwd, mergeExtends, _shim) {
  16      shim = _shim;
  17      let defaultConfig = {};
  18      if (Object.prototype.hasOwnProperty.call(config, 'extends')) {
  19          if (typeof config.extends !== 'string')
  20              return defaultConfig;
  21          const isPath = /\.json|\..*rc$/.test(config.extends);
  22          let pathToDefault = null;
  23          if (!isPath) {
  24              try {
  25                  pathToDefault = require.resolve(config.extends);
  26              }
  27              catch (_err) {
  28                  return config;
  29              }
  30          }
  31          else {
  32              pathToDefault = getPathToDefaultConfig(cwd, config.extends);
  33          }
  34          checkForCircularExtends(pathToDefault);
  35          previouslyVisitedConfigs.push(pathToDefault);
  36          defaultConfig = isPath
  37              ? JSON.parse(shim.readFileSync(pathToDefault, 'utf8'))
  38              : require(config.extends);
  39          delete config.extends;
  40          defaultConfig = applyExtends(defaultConfig, shim.path.dirname(pathToDefault), mergeExtends, shim);
  41      }
  42      previouslyVisitedConfigs = [];
  43      return mergeExtends
  44          ? mergeDeep(defaultConfig, config)
  45          : Object.assign({}, defaultConfig, config);
  46  }
  47  function checkForCircularExtends(cfgPath) {
  48      if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {
  49          throw new YError(`Circular extended configurations: '${cfgPath}'.`);
  50      }
  51  }
  52  function getPathToDefaultConfig(cwd, pathToExtend) {
  53      return shim.path.resolve(cwd, pathToExtend);
  54  }
  55  function mergeDeep(config1, config2) {
  56      const target = {};
  57      function isObject(obj) {
  58          return obj && typeof obj === 'object' && !Array.isArray(obj);
  59      }
  60      Object.assign(target, config1);
  61      for (const key of Object.keys(config2)) {
  62          if (isObject(config2[key]) && isObject(target[key])) {
  63              target[key] = mergeDeep(config1[key], config2[key]);
  64          }
  65          else {
  66              target[key] = config2[key];
  67          }
  68      }
  69      return target;
  70  }
  71  
  72  function parseCommand(cmd) {
  73      const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, ' ');
  74      const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/);
  75      const bregex = /\.*[\][<>]/g;
  76      const firstCommand = splitCommand.shift();
  77      if (!firstCommand)
  78          throw new Error(`No command found in: ${cmd}`);
  79      const parsedCommand = {
  80          cmd: firstCommand.replace(bregex, ''),
  81          demanded: [],
  82          optional: [],
  83      };
  84      splitCommand.forEach((cmd, i) => {
  85          let variadic = false;
  86          cmd = cmd.replace(/\s/g, '');
  87          if (/\.+[\]>]/.test(cmd) && i === splitCommand.length - 1)
  88              variadic = true;
  89          if (/^\[/.test(cmd)) {
  90              parsedCommand.optional.push({
  91                  cmd: cmd.replace(bregex, '').split('|'),
  92                  variadic,
  93              });
  94          }
  95          else {
  96              parsedCommand.demanded.push({
  97                  cmd: cmd.replace(bregex, '').split('|'),
  98                  variadic,
  99              });
 100          }
 101      });
 102      return parsedCommand;
 103  }
 104  
 105  const positionName = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth'];
 106  function argsert(arg1, arg2, arg3) {
 107      function parseArgs() {
 108          return typeof arg1 === 'object'
 109              ? [{ demanded: [], optional: [] }, arg1, arg2]
 110              : [
 111                  parseCommand(`cmd ${arg1}`),
 112                  arg2,
 113                  arg3,
 114              ];
 115      }
 116      try {
 117          let position = 0;
 118          const [parsed, callerArguments, _length] = parseArgs();
 119          const args = [].slice.call(callerArguments);
 120          while (args.length && args[args.length - 1] === undefined)
 121              args.pop();
 122          const length = _length || args.length;
 123          if (length < parsed.demanded.length) {
 124              throw new YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`);
 125          }
 126          const totalCommands = parsed.demanded.length + parsed.optional.length;
 127          if (length > totalCommands) {
 128              throw new YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`);
 129          }
 130          parsed.demanded.forEach(demanded => {
 131              const arg = args.shift();
 132              const observedType = guessType(arg);
 133              const matchingTypes = demanded.cmd.filter(type => type === observedType || type === '*');
 134              if (matchingTypes.length === 0)
 135                  argumentTypeError(observedType, demanded.cmd, position);
 136              position += 1;
 137          });
 138          parsed.optional.forEach(optional => {
 139              if (args.length === 0)
 140                  return;
 141              const arg = args.shift();
 142              const observedType = guessType(arg);
 143              const matchingTypes = optional.cmd.filter(type => type === observedType || type === '*');
 144              if (matchingTypes.length === 0)
 145                  argumentTypeError(observedType, optional.cmd, position);
 146              position += 1;
 147          });
 148      }
 149      catch (err) {
 150          console.warn(err.stack);
 151      }
 152  }
 153  function guessType(arg) {
 154      if (Array.isArray(arg)) {
 155          return 'array';
 156      }
 157      else if (arg === null) {
 158          return 'null';
 159      }
 160      return typeof arg;
 161  }
 162  function argumentTypeError(observedType, allowedTypes, position) {
 163      throw new YError(`Invalid ${positionName[position] || 'manyith'} argument. Expected ${allowedTypes.join(' or ')} but received ${observedType}.`);
 164  }
 165  
 166  function isPromise(maybePromise) {
 167      return (!!maybePromise &&
 168          !!maybePromise.then &&
 169          typeof maybePromise.then === 'function');
 170  }
 171  
 172  function assertNotStrictEqual(actual, expected, shim, message) {
 173      shim.assert.notStrictEqual(actual, expected, message);
 174  }
 175  function assertSingleKey(actual, shim) {
 176      shim.assert.strictEqual(typeof actual, 'string');
 177  }
 178  function objectKeys(object) {
 179      return Object.keys(object);
 180  }
 181  
 182  function objFilter(original = {}, filter = () => true) {
 183      const obj = {};
 184      objectKeys(original).forEach(key => {
 185          if (filter(key, original[key])) {
 186              obj[key] = original[key];
 187          }
 188      });
 189      return obj;
 190  }
 191  
 192  function globalMiddlewareFactory(globalMiddleware, context) {
 193      return function (callback, applyBeforeValidation = false) {
 194          argsert('<array|function> [boolean]', [callback, applyBeforeValidation], arguments.length);
 195          if (Array.isArray(callback)) {
 196              for (let i = 0; i < callback.length; i++) {
 197                  if (typeof callback[i] !== 'function') {
 198                      throw Error('middleware must be a function');
 199                  }
 200                  callback[i].applyBeforeValidation = applyBeforeValidation;
 201              }
 202              Array.prototype.push.apply(globalMiddleware, callback);
 203          }
 204          else if (typeof callback === 'function') {
 205              callback.applyBeforeValidation = applyBeforeValidation;
 206              globalMiddleware.push(callback);
 207          }
 208          return context;
 209      };
 210  }
 211  function commandMiddlewareFactory(commandMiddleware) {
 212      if (!commandMiddleware)
 213          return [];
 214      return commandMiddleware.map(middleware => {
 215          middleware.applyBeforeValidation = false;
 216          return middleware;
 217      });
 218  }
 219  function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
 220      const beforeValidationError = new Error('middleware cannot return a promise when applyBeforeValidation is true');
 221      return middlewares.reduce((acc, middleware) => {
 222          if (middleware.applyBeforeValidation !== beforeValidation) {
 223              return acc;
 224          }
 225          if (isPromise(acc)) {
 226              return acc
 227                  .then(initialObj => Promise.all([
 228                  initialObj,
 229                  middleware(initialObj, yargs),
 230              ]))
 231                  .then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
 232          }
 233          else {
 234              const result = middleware(acc, yargs);
 235              if (beforeValidation && isPromise(result))
 236                  throw beforeValidationError;
 237              return isPromise(result)
 238                  ? result.then(middlewareObj => Object.assign(acc, middlewareObj))
 239                  : Object.assign(acc, result);
 240          }
 241      }, argv);
 242  }
 243  
 244  function getProcessArgvBinIndex() {
 245      if (isBundledElectronApp())
 246          return 0;
 247      return 1;
 248  }
 249  function isBundledElectronApp() {
 250      return isElectronApp() && !process.defaultApp;
 251  }
 252  function isElectronApp() {
 253      return !!process.versions.electron;
 254  }
 255  function hideBin(argv) {
 256      return argv.slice(getProcessArgvBinIndex() + 1);
 257  }
 258  function getProcessArgvBin() {
 259      return process.argv[getProcessArgvBinIndex()];
 260  }
 261  
 262  var processArgv = /*#__PURE__*/Object.freeze({
 263    __proto__: null,
 264    hideBin: hideBin,
 265    getProcessArgvBin: getProcessArgvBin
 266  });
 267  
 268  function whichModule(exported) {
 269      if (typeof require === 'undefined')
 270          return null;
 271      for (let i = 0, files = Object.keys(require.cache), mod; i < files.length; i++) {
 272          mod = require.cache[files[i]];
 273          if (mod.exports === exported)
 274              return mod;
 275      }
 276      return null;
 277  }
 278  
 279  const DEFAULT_MARKER = /(^\*)|(^\$0)/;
 280  function command(yargs, usage, validation, globalMiddleware = [], shim) {
 281      const self = {};
 282      let handlers = {};
 283      let aliasMap = {};
 284      let defaultCommand;
 285      self.addHandler = function addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {
 286          let aliases = [];
 287          const middlewares = commandMiddlewareFactory(commandMiddleware);
 288          handler = handler || (() => { });
 289          if (Array.isArray(cmd)) {
 290              if (isCommandAndAliases(cmd)) {
 291                  [cmd, ...aliases] = cmd;
 292              }
 293              else {
 294                  for (const command of cmd) {
 295                      self.addHandler(command);
 296                  }
 297              }
 298          }
 299          else if (isCommandHandlerDefinition(cmd)) {
 300              let command = Array.isArray(cmd.command) || typeof cmd.command === 'string'
 301                  ? cmd.command
 302                  : moduleName(cmd);
 303              if (cmd.aliases)
 304                  command = [].concat(command).concat(cmd.aliases);
 305              self.addHandler(command, extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
 306              return;
 307          }
 308          else if (isCommandBuilderDefinition(builder)) {
 309              self.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
 310              return;
 311          }
 312          if (typeof cmd === 'string') {
 313              const parsedCommand = parseCommand(cmd);
 314              aliases = aliases.map(alias => parseCommand(alias).cmd);
 315              let isDefault = false;
 316              const parsedAliases = [parsedCommand.cmd].concat(aliases).filter(c => {
 317                  if (DEFAULT_MARKER.test(c)) {
 318                      isDefault = true;
 319                      return false;
 320                  }
 321                  return true;
 322              });
 323              if (parsedAliases.length === 0 && isDefault)
 324                  parsedAliases.push('$0');
 325              if (isDefault) {
 326                  parsedCommand.cmd = parsedAliases[0];
 327                  aliases = parsedAliases.slice(1);
 328                  cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);
 329              }
 330              aliases.forEach(alias => {
 331                  aliasMap[alias] = parsedCommand.cmd;
 332              });
 333              if (description !== false) {
 334                  usage.command(cmd, description, isDefault, aliases, deprecated);
 335              }
 336              handlers[parsedCommand.cmd] = {
 337                  original: cmd,
 338                  description,
 339                  handler,
 340                  builder: builder || {},
 341                  middlewares,
 342                  deprecated,
 343                  demanded: parsedCommand.demanded,
 344                  optional: parsedCommand.optional,
 345              };
 346              if (isDefault)
 347                  defaultCommand = handlers[parsedCommand.cmd];
 348          }
 349      };
 350      self.addDirectory = function addDirectory(dir, context, req, callerFile, opts) {
 351          opts = opts || {};
 352          if (typeof opts.recurse !== 'boolean')
 353              opts.recurse = false;
 354          if (!Array.isArray(opts.extensions))
 355              opts.extensions = ['js'];
 356          const parentVisit = typeof opts.visit === 'function' ? opts.visit : (o) => o;
 357          opts.visit = function visit(obj, joined, filename) {
 358              const visited = parentVisit(obj, joined, filename);
 359              if (visited) {
 360                  if (~context.files.indexOf(joined))
 361                      return visited;
 362                  context.files.push(joined);
 363                  self.addHandler(visited);
 364              }
 365              return visited;
 366          };
 367          shim.requireDirectory({ require: req, filename: callerFile }, dir, opts);
 368      };
 369      function moduleName(obj) {
 370          const mod = whichModule(obj);
 371          if (!mod)
 372              throw new Error(`No command name given for module: ${shim.inspect(obj)}`);
 373          return commandFromFilename(mod.filename);
 374      }
 375      function commandFromFilename(filename) {
 376          return shim.path.basename(filename, shim.path.extname(filename));
 377      }
 378      function extractDesc({ describe, description, desc, }) {
 379          for (const test of [describe, description, desc]) {
 380              if (typeof test === 'string' || test === false)
 381                  return test;
 382              assertNotStrictEqual(test, true, shim);
 383          }
 384          return false;
 385      }
 386      self.getCommands = () => Object.keys(handlers).concat(Object.keys(aliasMap));
 387      self.getCommandHandlers = () => handlers;
 388      self.hasDefaultCommand = () => !!defaultCommand;
 389      self.runCommand = function runCommand(command, yargs, parsed, commandIndex) {
 390          let aliases = parsed.aliases;
 391          const commandHandler = handlers[command] || handlers[aliasMap[command]] || defaultCommand;
 392          const currentContext = yargs.getContext();
 393          let numFiles = currentContext.files.length;
 394          const parentCommands = currentContext.commands.slice();
 395          let innerArgv = parsed.argv;
 396          let positionalMap = {};
 397          if (command) {
 398              currentContext.commands.push(command);
 399              currentContext.fullCommands.push(commandHandler.original);
 400          }
 401          const builder = commandHandler.builder;
 402          if (isCommandBuilderCallback(builder)) {
 403              const builderOutput = builder(yargs.reset(parsed.aliases));
 404              const innerYargs = isYargsInstance(builderOutput) ? builderOutput : yargs;
 405              if (shouldUpdateUsage(innerYargs)) {
 406                  innerYargs
 407                      .getUsageInstance()
 408                      .usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
 409              }
 410              innerArgv = innerYargs._parseArgs(null, null, true, commandIndex);
 411              aliases = innerYargs.parsed.aliases;
 412          }
 413          else if (isCommandBuilderOptionDefinitions(builder)) {
 414              const innerYargs = yargs.reset(parsed.aliases);
 415              if (shouldUpdateUsage(innerYargs)) {
 416                  innerYargs
 417                      .getUsageInstance()
 418                      .usage(usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
 419              }
 420              Object.keys(commandHandler.builder).forEach(key => {
 421                  innerYargs.option(key, builder[key]);
 422              });
 423              innerArgv = innerYargs._parseArgs(null, null, true, commandIndex);
 424              aliases = innerYargs.parsed.aliases;
 425          }
 426          if (!yargs._hasOutput()) {
 427              positionalMap = populatePositionals(commandHandler, innerArgv, currentContext);
 428          }
 429          const middlewares = globalMiddleware
 430              .slice(0)
 431              .concat(commandHandler.middlewares);
 432          applyMiddleware(innerArgv, yargs, middlewares, true);
 433          if (!yargs._hasOutput()) {
 434              yargs._runValidation(innerArgv, aliases, positionalMap, yargs.parsed.error, !command);
 435          }
 436          if (commandHandler.handler && !yargs._hasOutput()) {
 437              yargs._setHasOutput();
 438              const populateDoubleDash = !!yargs.getOptions().configuration['populate--'];
 439              yargs._postProcess(innerArgv, populateDoubleDash);
 440              innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);
 441              let handlerResult;
 442              if (isPromise(innerArgv)) {
 443                  handlerResult = innerArgv.then(argv => commandHandler.handler(argv));
 444              }
 445              else {
 446                  handlerResult = commandHandler.handler(innerArgv);
 447              }
 448              const handlerFinishCommand = yargs.getHandlerFinishCommand();
 449              if (isPromise(handlerResult)) {
 450                  yargs.getUsageInstance().cacheHelpMessage();
 451                  handlerResult
 452                      .then(value => {
 453                      if (handlerFinishCommand) {
 454                          handlerFinishCommand(value);
 455                      }
 456                  })
 457                      .catch(error => {
 458                      try {
 459                          yargs.getUsageInstance().fail(null, error);
 460                      }
 461                      catch (err) {
 462                      }
 463                  })
 464                      .then(() => {
 465                      yargs.getUsageInstance().clearCachedHelpMessage();
 466                  });
 467              }
 468              else {
 469                  if (handlerFinishCommand) {
 470                      handlerFinishCommand(handlerResult);
 471                  }
 472              }
 473          }
 474          if (command) {
 475              currentContext.commands.pop();
 476              currentContext.fullCommands.pop();
 477          }
 478          numFiles = currentContext.files.length - numFiles;
 479          if (numFiles > 0)
 480              currentContext.files.splice(numFiles * -1, numFiles);
 481          return innerArgv;
 482      };
 483      function shouldUpdateUsage(yargs) {
 484          return (!yargs.getUsageInstance().getUsageDisabled() &&
 485              yargs.getUsageInstance().getUsage().length === 0);
 486      }
 487      function usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
 488          const c = DEFAULT_MARKER.test(commandHandler.original)
 489              ? commandHandler.original.replace(DEFAULT_MARKER, '').trim()
 490              : commandHandler.original;
 491          const pc = parentCommands.filter(c => {
 492              return !DEFAULT_MARKER.test(c);
 493          });
 494          pc.push(c);
 495          return `$0 ${pc.join(' ')}`;
 496      }
 497      self.runDefaultBuilderOn = function (yargs) {
 498          assertNotStrictEqual(defaultCommand, undefined, shim);
 499          if (shouldUpdateUsage(yargs)) {
 500              const commandString = DEFAULT_MARKER.test(defaultCommand.original)
 501                  ? defaultCommand.original
 502                  : defaultCommand.original.replace(/^[^[\]<>]*/, '$0 ');
 503              yargs.getUsageInstance().usage(commandString, defaultCommand.description);
 504          }
 505          const builder = defaultCommand.builder;
 506          if (isCommandBuilderCallback(builder)) {
 507              builder(yargs);
 508          }
 509          else if (!isCommandBuilderDefinition(builder)) {
 510              Object.keys(builder).forEach(key => {
 511                  yargs.option(key, builder[key]);
 512              });
 513          }
 514      };
 515      function populatePositionals(commandHandler, argv, context) {
 516          argv._ = argv._.slice(context.commands.length);
 517          const demanded = commandHandler.demanded.slice(0);
 518          const optional = commandHandler.optional.slice(0);
 519          const positionalMap = {};
 520          validation.positionalCount(demanded.length, argv._.length);
 521          while (demanded.length) {
 522              const demand = demanded.shift();
 523              populatePositional(demand, argv, positionalMap);
 524          }
 525          while (optional.length) {
 526              const maybe = optional.shift();
 527              populatePositional(maybe, argv, positionalMap);
 528          }
 529          argv._ = context.commands.concat(argv._.map(a => '' + a));
 530          postProcessPositionals(argv, positionalMap, self.cmdToParseOptions(commandHandler.original));
 531          return positionalMap;
 532      }
 533      function populatePositional(positional, argv, positionalMap) {
 534          const cmd = positional.cmd[0];
 535          if (positional.variadic) {
 536              positionalMap[cmd] = argv._.splice(0).map(String);
 537          }
 538          else {
 539              if (argv._.length)
 540                  positionalMap[cmd] = [String(argv._.shift())];
 541          }
 542      }
 543      function postProcessPositionals(argv, positionalMap, parseOptions) {
 544          const options = Object.assign({}, yargs.getOptions());
 545          options.default = Object.assign(parseOptions.default, options.default);
 546          for (const key of Object.keys(parseOptions.alias)) {
 547              options.alias[key] = (options.alias[key] || []).concat(parseOptions.alias[key]);
 548          }
 549          options.array = options.array.concat(parseOptions.array);
 550          options.config = {};
 551          const unparsed = [];
 552          Object.keys(positionalMap).forEach(key => {
 553              positionalMap[key].map(value => {
 554                  if (options.configuration['unknown-options-as-args'])
 555                      options.key[key] = true;
 556                  unparsed.push(`--${key}`);
 557                  unparsed.push(value);
 558              });
 559          });
 560          if (!unparsed.length)
 561              return;
 562          const config = Object.assign({}, options.configuration, {
 563              'populate--': true,
 564          });
 565          const parsed = shim.Parser.detailed(unparsed, Object.assign({}, options, {
 566              configuration: config,
 567          }));
 568          if (parsed.error) {
 569              yargs.getUsageInstance().fail(parsed.error.message, parsed.error);
 570          }
 571          else {
 572              const positionalKeys = Object.keys(positionalMap);
 573              Object.keys(positionalMap).forEach(key => {
 574                  positionalKeys.push(...parsed.aliases[key]);
 575              });
 576              Object.keys(parsed.argv).forEach(key => {
 577                  if (positionalKeys.indexOf(key) !== -1) {
 578                      if (!positionalMap[key])
 579                          positionalMap[key] = parsed.argv[key];
 580                      argv[key] = parsed.argv[key];
 581                  }
 582              });
 583          }
 584      }
 585      self.cmdToParseOptions = function (cmdString) {
 586          const parseOptions = {
 587              array: [],
 588              default: {},
 589              alias: {},
 590              demand: {},
 591          };
 592          const parsed = parseCommand(cmdString);
 593          parsed.demanded.forEach(d => {
 594              const [cmd, ...aliases] = d.cmd;
 595              if (d.variadic) {
 596                  parseOptions.array.push(cmd);
 597                  parseOptions.default[cmd] = [];
 598              }
 599              parseOptions.alias[cmd] = aliases;
 600              parseOptions.demand[cmd] = true;
 601          });
 602          parsed.optional.forEach(o => {
 603              const [cmd, ...aliases] = o.cmd;
 604              if (o.variadic) {
 605                  parseOptions.array.push(cmd);
 606                  parseOptions.default[cmd] = [];
 607              }
 608              parseOptions.alias[cmd] = aliases;
 609          });
 610          return parseOptions;
 611      };
 612      self.reset = () => {
 613          handlers = {};
 614          aliasMap = {};
 615          defaultCommand = undefined;
 616          return self;
 617      };
 618      const frozens = [];
 619      self.freeze = () => {
 620          frozens.push({
 621              handlers,
 622              aliasMap,
 623              defaultCommand,
 624          });
 625      };
 626      self.unfreeze = () => {
 627          const frozen = frozens.pop();
 628          assertNotStrictEqual(frozen, undefined, shim);
 629          ({ handlers, aliasMap, defaultCommand } = frozen);
 630      };
 631      return self;
 632  }
 633  function isCommandBuilderDefinition(builder) {
 634      return (typeof builder === 'object' &&
 635          !!builder.builder &&
 636          typeof builder.handler === 'function');
 637  }
 638  function isCommandAndAliases(cmd) {
 639      if (cmd.every(c => typeof c === 'string')) {
 640          return true;
 641      }
 642      else {
 643          return false;
 644      }
 645  }
 646  function isCommandBuilderCallback(builder) {
 647      return typeof builder === 'function';
 648  }
 649  function isCommandBuilderOptionDefinitions(builder) {
 650      return typeof builder === 'object';
 651  }
 652  function isCommandHandlerDefinition(cmd) {
 653      return typeof cmd === 'object' && !Array.isArray(cmd);
 654  }
 655  
 656  function setBlocking(blocking) {
 657      if (typeof process === 'undefined')
 658          return;
 659      [process.stdout, process.stderr].forEach(_stream => {
 660          const stream = _stream;
 661          if (stream._handle &&
 662              stream.isTTY &&
 663              typeof stream._handle.setBlocking === 'function') {
 664              stream._handle.setBlocking(blocking);
 665          }
 666      });
 667  }
 668  
 669  function usage(yargs, y18n, shim) {
 670      const __ = y18n.__;
 671      const self = {};
 672      const fails = [];
 673      self.failFn = function failFn(f) {
 674          fails.push(f);
 675      };
 676      let failMessage = null;
 677      let showHelpOnFail = true;
 678      self.showHelpOnFail = function showHelpOnFailFn(arg1 = true, arg2) {
 679          function parseFunctionArgs() {
 680              return typeof arg1 === 'string' ? [true, arg1] : [arg1, arg2];
 681          }
 682          const [enabled, message] = parseFunctionArgs();
 683          failMessage = message;
 684          showHelpOnFail = enabled;
 685          return self;
 686      };
 687      let failureOutput = false;
 688      self.fail = function fail(msg, err) {
 689          const logger = yargs._getLoggerInstance();
 690          if (fails.length) {
 691              for (let i = fails.length - 1; i >= 0; --i) {
 692                  fails[i](msg, err, self);
 693              }
 694          }
 695          else {
 696              if (yargs.getExitProcess())
 697                  setBlocking(true);
 698              if (!failureOutput) {
 699                  failureOutput = true;
 700                  if (showHelpOnFail) {
 701                      yargs.showHelp('error');
 702                      logger.error();
 703                  }
 704                  if (msg || err)
 705                      logger.error(msg || err);
 706                  if (failMessage) {
 707                      if (msg || err)
 708                          logger.error('');
 709                      logger.error(failMessage);
 710                  }
 711              }
 712              err = err || new YError(msg);
 713              if (yargs.getExitProcess()) {
 714                  return yargs.exit(1);
 715              }
 716              else if (yargs._hasParseCallback()) {
 717                  return yargs.exit(1, err);
 718              }
 719              else {
 720                  throw err;
 721              }
 722          }
 723      };
 724      let usages = [];
 725      let usageDisabled = false;
 726      self.usage = (msg, description) => {
 727          if (msg === null) {
 728              usageDisabled = true;
 729              usages = [];
 730              return self;
 731          }
 732          usageDisabled = false;
 733          usages.push([msg, description || '']);
 734          return self;
 735      };
 736      self.getUsage = () => {
 737          return usages;
 738      };
 739      self.getUsageDisabled = () => {
 740          return usageDisabled;
 741      };
 742      self.getPositionalGroupName = () => {
 743          return __('Positionals:');
 744      };
 745      let examples = [];
 746      self.example = (cmd, description) => {
 747          examples.push([cmd, description || '']);
 748      };
 749      let commands = [];
 750      self.command = function command(cmd, description, isDefault, aliases, deprecated = false) {
 751          if (isDefault) {
 752              commands = commands.map(cmdArray => {
 753                  cmdArray[2] = false;
 754                  return cmdArray;
 755              });
 756          }
 757          commands.push([cmd, description || '', isDefault, aliases, deprecated]);
 758      };
 759      self.getCommands = () => commands;
 760      let descriptions = {};
 761      self.describe = function describe(keyOrKeys, desc) {
 762          if (Array.isArray(keyOrKeys)) {
 763              keyOrKeys.forEach(k => {
 764                  self.describe(k, desc);
 765              });
 766          }
 767          else if (typeof keyOrKeys === 'object') {
 768              Object.keys(keyOrKeys).forEach(k => {
 769                  self.describe(k, keyOrKeys[k]);
 770              });
 771          }
 772          else {
 773              descriptions[keyOrKeys] = desc;
 774          }
 775      };
 776      self.getDescriptions = () => descriptions;
 777      let epilogs = [];
 778      self.epilog = msg => {
 779          epilogs.push(msg);
 780      };
 781      let wrapSet = false;
 782      let wrap;
 783      self.wrap = cols => {
 784          wrapSet = true;
 785          wrap = cols;
 786      };
 787      function getWrap() {
 788          if (!wrapSet) {
 789              wrap = windowWidth();
 790              wrapSet = true;
 791          }
 792          return wrap;
 793      }
 794      const deferY18nLookupPrefix = '__yargsString__:';
 795      self.deferY18nLookup = str => deferY18nLookupPrefix + str;
 796      self.help = function help() {
 797          if (cachedHelpMessage)
 798              return cachedHelpMessage;
 799          normalizeAliases();
 800          const base$0 = yargs.customScriptName
 801              ? yargs.$0
 802              : shim.path.basename(yargs.$0);
 803          const demandedOptions = yargs.getDemandedOptions();
 804          const demandedCommands = yargs.getDemandedCommands();
 805          const deprecatedOptions = yargs.getDeprecatedOptions();
 806          const groups = yargs.getGroups();
 807          const options = yargs.getOptions();
 808          let keys = [];
 809          keys = keys.concat(Object.keys(descriptions));
 810          keys = keys.concat(Object.keys(demandedOptions));
 811          keys = keys.concat(Object.keys(demandedCommands));
 812          keys = keys.concat(Object.keys(options.default));
 813          keys = keys.filter(filterHiddenOptions);
 814          keys = Object.keys(keys.reduce((acc, key) => {
 815              if (key !== '_')
 816                  acc[key] = true;
 817              return acc;
 818          }, {}));
 819          const theWrap = getWrap();
 820          const ui = shim.cliui({
 821              width: theWrap,
 822              wrap: !!theWrap,
 823          });
 824          if (!usageDisabled) {
 825              if (usages.length) {
 826                  usages.forEach(usage => {
 827                      ui.div(`${usage[0].replace(/\$0/g, base$0)}`);
 828                      if (usage[1]) {
 829                          ui.div({ text: `${usage[1]}`, padding: [1, 0, 0, 0] });
 830                      }
 831                  });
 832                  ui.div();
 833              }
 834              else if (commands.length) {
 835                  let u = null;
 836                  if (demandedCommands._) {
 837                      u = `${base$0} <${__('command')}>\n`;
 838                  }
 839                  else {
 840                      u = `${base$0} [${__('command')}]\n`;
 841                  }
 842                  ui.div(`${u}`);
 843              }
 844          }
 845          if (commands.length) {
 846              ui.div(__('Commands:'));
 847              const context = yargs.getContext();
 848              const parentCommands = context.commands.length
 849                  ? `${context.commands.join(' ')} `
 850                  : '';
 851              if (yargs.getParserConfiguration()['sort-commands'] === true) {
 852                  commands = commands.sort((a, b) => a[0].localeCompare(b[0]));
 853              }
 854              commands.forEach(command => {
 855                  const commandString = `${base$0} ${parentCommands}${command[0].replace(/^\$0 ?/, '')}`;
 856                  ui.span({
 857                      text: commandString,
 858                      padding: [0, 2, 0, 2],
 859                      width: maxWidth(commands, theWrap, `${base$0}${parentCommands}`) + 4,
 860                  }, { text: command[1] });
 861                  const hints = [];
 862                  if (command[2])
 863                      hints.push(`[${__('default')}]`);
 864                  if (command[3] && command[3].length) {
 865                      hints.push(`[${__('aliases:')} ${command[3].join(', ')}]`);
 866                  }
 867                  if (command[4]) {
 868                      if (typeof command[4] === 'string') {
 869                          hints.push(`[${__('deprecated: %s', command[4])}]`);
 870                      }
 871                      else {
 872                          hints.push(`[${__('deprecated')}]`);
 873                      }
 874                  }
 875                  if (hints.length) {
 876                      ui.div({
 877                          text: hints.join(' '),
 878                          padding: [0, 0, 0, 2],
 879                          align: 'right',
 880                      });
 881                  }
 882                  else {
 883                      ui.div();
 884                  }
 885              });
 886              ui.div();
 887          }
 888          const aliasKeys = (Object.keys(options.alias) || []).concat(Object.keys(yargs.parsed.newAliases) || []);
 889          keys = keys.filter(key => !yargs.parsed.newAliases[key] &&
 890              aliasKeys.every(alias => (options.alias[alias] || []).indexOf(key) === -1));
 891          const defaultGroup = __('Options:');
 892          if (!groups[defaultGroup])
 893              groups[defaultGroup] = [];
 894          addUngroupedKeys(keys, options.alias, groups, defaultGroup);
 895          const isLongSwitch = (sw) => /^--/.test(getText(sw));
 896          const displayedGroups = Object.keys(groups)
 897              .filter(groupName => groups[groupName].length > 0)
 898              .map(groupName => {
 899              const normalizedKeys = groups[groupName]
 900                  .filter(filterHiddenOptions)
 901                  .map(key => {
 902                  if (~aliasKeys.indexOf(key))
 903                      return key;
 904                  for (let i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== undefined; i++) {
 905                      if (~(options.alias[aliasKey] || []).indexOf(key))
 906                          return aliasKey;
 907                  }
 908                  return key;
 909              });
 910              return { groupName, normalizedKeys };
 911          })
 912              .filter(({ normalizedKeys }) => normalizedKeys.length > 0)
 913              .map(({ groupName, normalizedKeys }) => {
 914              const switches = normalizedKeys.reduce((acc, key) => {
 915                  acc[key] = [key]
 916                      .concat(options.alias[key] || [])
 917                      .map(sw => {
 918                      if (groupName === self.getPositionalGroupName())
 919                          return sw;
 920                      else {
 921                          return ((/^[0-9]$/.test(sw)
 922                              ? ~options.boolean.indexOf(key)
 923                                  ? '-'
 924                                  : '--'
 925                              : sw.length > 1
 926                                  ? '--'
 927                                  : '-') + sw);
 928                      }
 929                  })
 930                      .sort((sw1, sw2) => isLongSwitch(sw1) === isLongSwitch(sw2)
 931                      ? 0
 932                      : isLongSwitch(sw1)
 933                          ? 1
 934                          : -1)
 935                      .join(', ');
 936                  return acc;
 937              }, {});
 938              return { groupName, normalizedKeys, switches };
 939          });
 940          const shortSwitchesUsed = displayedGroups
 941              .filter(({ groupName }) => groupName !== self.getPositionalGroupName())
 942              .some(({ normalizedKeys, switches }) => !normalizedKeys.every(key => isLongSwitch(switches[key])));
 943          if (shortSwitchesUsed) {
 944              displayedGroups
 945                  .filter(({ groupName }) => groupName !== self.getPositionalGroupName())
 946                  .forEach(({ normalizedKeys, switches }) => {
 947                  normalizedKeys.forEach(key => {
 948                      if (isLongSwitch(switches[key])) {
 949                          switches[key] = addIndentation(switches[key], '-x, '.length);
 950                      }
 951                  });
 952              });
 953          }
 954          displayedGroups.forEach(({ groupName, normalizedKeys, switches }) => {
 955              ui.div(groupName);
 956              normalizedKeys.forEach(key => {
 957                  const kswitch = switches[key];
 958                  let desc = descriptions[key] || '';
 959                  let type = null;
 960                  if (~desc.lastIndexOf(deferY18nLookupPrefix))
 961                      desc = __(desc.substring(deferY18nLookupPrefix.length));
 962                  if (~options.boolean.indexOf(key))
 963                      type = `[${__('boolean')}]`;
 964                  if (~options.count.indexOf(key))
 965                      type = `[${__('count')}]`;
 966                  if (~options.string.indexOf(key))
 967                      type = `[${__('string')}]`;
 968                  if (~options.normalize.indexOf(key))
 969                      type = `[${__('string')}]`;
 970                  if (~options.array.indexOf(key))
 971                      type = `[${__('array')}]`;
 972                  if (~options.number.indexOf(key))
 973                      type = `[${__('number')}]`;
 974                  const deprecatedExtra = (deprecated) => typeof deprecated === 'string'
 975                      ? `[${__('deprecated: %s', deprecated)}]`
 976                      : `[${__('deprecated')}]`;
 977                  const extra = [
 978                      key in deprecatedOptions
 979                          ? deprecatedExtra(deprecatedOptions[key])
 980                          : null,
 981                      type,
 982                      key in demandedOptions ? `[${__('required')}]` : null,
 983                      options.choices && options.choices[key]
 984                          ? `[${__('choices:')} ${self.stringifiedValues(options.choices[key])}]`
 985                          : null,
 986                      defaultString(options.default[key], options.defaultDescription[key]),
 987                  ]
 988                      .filter(Boolean)
 989                      .join(' ');
 990                  ui.span({
 991                      text: getText(kswitch),
 992                      padding: [0, 2, 0, 2 + getIndentation(kswitch)],
 993                      width: maxWidth(switches, theWrap) + 4,
 994                  }, desc);
 995                  if (extra)
 996                      ui.div({ text: extra, padding: [0, 0, 0, 2], align: 'right' });
 997                  else
 998                      ui.div();
 999              });
1000              ui.div();
1001          });
1002          if (examples.length) {
1003              ui.div(__('Examples:'));
1004              examples.forEach(example => {
1005                  example[0] = example[0].replace(/\$0/g, base$0);
1006              });
1007              examples.forEach(example => {
1008                  if (example[1] === '') {
1009                      ui.div({
1010                          text: example[0],
1011                          padding: [0, 2, 0, 2],
1012                      });
1013                  }
1014                  else {
1015                      ui.div({
1016                          text: example[0],
1017                          padding: [0, 2, 0, 2],
1018                          width: maxWidth(examples, theWrap) + 4,
1019                      }, {
1020                          text: example[1],
1021                      });
1022                  }
1023              });
1024              ui.div();
1025          }
1026          if (epilogs.length > 0) {
1027              const e = epilogs
1028                  .map(epilog => epilog.replace(/\$0/g, base$0))
1029                  .join('\n');
1030              ui.div(`${e}\n`);
1031          }
1032          return ui.toString().replace(/\s*$/, '');
1033      };
1034      function maxWidth(table, theWrap, modifier) {
1035          let width = 0;
1036          if (!Array.isArray(table)) {
1037              table = Object.values(table).map(v => [v]);
1038          }
1039          table.forEach(v => {
1040              width = Math.max(shim.stringWidth(modifier ? `${modifier} ${getText(v[0])}` : getText(v[0])) + getIndentation(v[0]), width);
1041          });
1042          if (theWrap)
1043              width = Math.min(width, parseInt((theWrap * 0.5).toString(), 10));
1044          return width;
1045      }
1046      function normalizeAliases() {
1047          const demandedOptions = yargs.getDemandedOptions();
1048          const options = yargs.getOptions();
1049          (Object.keys(options.alias) || []).forEach(key => {
1050              options.alias[key].forEach(alias => {
1051                  if (descriptions[alias])
1052                      self.describe(key, descriptions[alias]);
1053                  if (alias in demandedOptions)
1054                      yargs.demandOption(key, demandedOptions[alias]);
1055                  if (~options.boolean.indexOf(alias))
1056                      yargs.boolean(key);
1057                  if (~options.count.indexOf(alias))
1058                      yargs.count(key);
1059                  if (~options.string.indexOf(alias))
1060                      yargs.string(key);
1061                  if (~options.normalize.indexOf(alias))
1062                      yargs.normalize(key);
1063                  if (~options.array.indexOf(alias))
1064                      yargs.array(key);
1065                  if (~options.number.indexOf(alias))
1066                      yargs.number(key);
1067              });
1068          });
1069      }
1070      let cachedHelpMessage;
1071      self.cacheHelpMessage = function () {
1072          cachedHelpMessage = this.help();
1073      };
1074      self.clearCachedHelpMessage = function () {
1075          cachedHelpMessage = undefined;
1076      };
1077      function addUngroupedKeys(keys, aliases, groups, defaultGroup) {
1078          let groupedKeys = [];
1079          let toCheck = null;
1080          Object.keys(groups).forEach(group => {
1081              groupedKeys = groupedKeys.concat(groups[group]);
1082          });
1083          keys.forEach(key => {
1084              toCheck = [key].concat(aliases[key]);
1085              if (!toCheck.some(k => groupedKeys.indexOf(k) !== -1)) {
1086                  groups[defaultGroup].push(key);
1087              }
1088          });
1089          return groupedKeys;
1090      }
1091      function filterHiddenOptions(key) {
1092          return (yargs.getOptions().hiddenOptions.indexOf(key) < 0 ||
1093              yargs.parsed.argv[yargs.getOptions().showHiddenOpt]);
1094      }
1095      self.showHelp = (level) => {
1096          const logger = yargs._getLoggerInstance();
1097          if (!level)
1098              level = 'error';
1099          const emit = typeof level === 'function' ? level : logger[level];
1100          emit(self.help());
1101      };
1102      self.functionDescription = fn => {
1103          const description = fn.name
1104              ? shim.Parser.decamelize(fn.name, '-')
1105              : __('generated-value');
1106          return ['(', description, ')'].join('');
1107      };
1108      self.stringifiedValues = function stringifiedValues(values, separator) {
1109          let string = '';
1110          const sep = separator || ', ';
1111          const array = [].concat(values);
1112          if (!values || !array.length)
1113              return string;
1114          array.forEach(value => {
1115              if (string.length)
1116                  string += sep;
1117              string += JSON.stringify(value);
1118          });
1119          return string;
1120      };
1121      function defaultString(value, defaultDescription) {
1122          let string = `[${__('default:')} `;
1123          if (value === undefined && !defaultDescription)
1124              return null;
1125          if (defaultDescription) {
1126              string += defaultDescription;
1127          }
1128          else {
1129              switch (typeof value) {
1130                  case 'string':
1131                      string += `"${value}"`;
1132                      break;
1133                  case 'object':
1134                      string += JSON.stringify(value);
1135                      break;
1136                  default:
1137                      string += value;
1138              }
1139          }
1140          return `${string}]`;
1141      }
1142      function windowWidth() {
1143          const maxWidth = 80;
1144          if (shim.process.stdColumns) {
1145              return Math.min(maxWidth, shim.process.stdColumns);
1146          }
1147          else {
1148              return maxWidth;
1149          }
1150      }
1151      let version = null;
1152      self.version = ver => {
1153          version = ver;
1154      };
1155      self.showVersion = () => {
1156          const logger = yargs._getLoggerInstance();
1157          logger.log(version);
1158      };
1159      self.reset = function reset(localLookup) {
1160          failMessage = null;
1161          failureOutput = false;
1162          usages = [];
1163          usageDisabled = false;
1164          epilogs = [];
1165          examples = [];
1166          commands = [];
1167          descriptions = objFilter(descriptions, k => !localLookup[k]);
1168          return self;
1169      };
1170      const frozens = [];
1171      self.freeze = function freeze() {
1172          frozens.push({
1173              failMessage,
1174              failureOutput,
1175              usages,
1176              usageDisabled,
1177              epilogs,
1178              examples,
1179              commands,
1180              descriptions,
1181          });
1182      };
1183      self.unfreeze = function unfreeze() {
1184          const frozen = frozens.pop();
1185          assertNotStrictEqual(frozen, undefined, shim);
1186          ({
1187              failMessage,
1188              failureOutput,
1189              usages,
1190              usageDisabled,
1191              epilogs,
1192              examples,
1193              commands,
1194              descriptions,
1195          } = frozen);
1196      };
1197      return self;
1198  }
1199  function isIndentedText(text) {
1200      return typeof text === 'object';
1201  }
1202  function addIndentation(text, indent) {
1203      return isIndentedText(text)
1204          ? { text: text.text, indentation: text.indentation + indent }
1205          : { text, indentation: indent };
1206  }
1207  function getIndentation(text) {
1208      return isIndentedText(text) ? text.indentation : 0;
1209  }
1210  function getText(text) {
1211      return isIndentedText(text) ? text.text : text;
1212  }
1213  
1214  const completionShTemplate = `###-begin-{{app_name}}-completions-###
1215  #
1216  # yargs command completion script
1217  #
1218  # Installation: {{app_path}} {{completion_command}} >> ~/.bashrc
1219  #    or {{app_path}} {{completion_command}} >> ~/.bash_profile on OSX.
1220  #
1221  _yargs_completions()
1222  {
1223      local cur_word args type_list
1224  
1225      cur_word="\${COMP_WORDS[COMP_CWORD]}"
1226      args=("\${COMP_WORDS[@]}")
1227  
1228      # ask yargs to generate completions.
1229      type_list=$({{app_path}} --get-yargs-completions "\${args[@]}")
1230  
1231      COMPREPLY=( $(compgen -W "\${type_list}" -- \${cur_word}) )
1232  
1233      # if no match was found, fall back to filename completion
1234      if [ \${#COMPREPLY[@]} -eq 0 ]; then
1235        COMPREPLY=()
1236      fi
1237  
1238      return 0
1239  }
1240  complete -o default -F _yargs_completions {{app_name}}
1241  ###-end-{{app_name}}-completions-###
1242  `;
1243  const completionZshTemplate = `###-begin-{{app_name}}-completions-###
1244  #
1245  # yargs command completion script
1246  #
1247  # Installation: {{app_path}} {{completion_command}} >> ~/.zshrc
1248  #    or {{app_path}} {{completion_command}} >> ~/.zsh_profile on OSX.
1249  #
1250  _{{app_name}}_yargs_completions()
1251  {
1252    local reply
1253    local si=$IFS
1254    IFS=$'\n' reply=($(COMP_CWORD="$((CURRENT-1))" COMP_LINE="$BUFFER" COMP_POINT="$CURSOR" {{app_path}} --get-yargs-completions "\${words[@]}"))
1255    IFS=$si
1256    _describe 'values' reply
1257  }
1258  compdef _{{app_name}}_yargs_completions {{app_name}}
1259  ###-end-{{app_name}}-completions-###
1260  `;
1261  
1262  function completion(yargs, usage, command, shim) {
1263      const self = {
1264          completionKey: 'get-yargs-completions',
1265      };
1266      let aliases;
1267      self.setParsed = function setParsed(parsed) {
1268          aliases = parsed.aliases;
1269      };
1270      const zshShell = (shim.getEnv('SHELL') && shim.getEnv('SHELL').indexOf('zsh') !== -1) ||
1271          (shim.getEnv('ZSH_NAME') && shim.getEnv('ZSH_NAME').indexOf('zsh') !== -1);
1272      self.getCompletion = function getCompletion(args, done) {
1273          const completions = [];
1274          const current = args.length ? args[args.length - 1] : '';
1275          const argv = yargs.parse(args, true);
1276          const parentCommands = yargs.getContext().commands;
1277          function runCompletionFunction(argv) {
1278              assertNotStrictEqual(completionFunction, null, shim);
1279              if (isSyncCompletionFunction(completionFunction)) {
1280                  const result = completionFunction(current, argv);
1281                  if (isPromise(result)) {
1282                      return result
1283                          .then(list => {
1284                          shim.process.nextTick(() => {
1285                              done(list);
1286                          });
1287                      })
1288                          .catch(err => {
1289                          shim.process.nextTick(() => {
1290                              throw err;
1291                          });
1292                      });
1293                  }
1294                  return done(result);
1295              }
1296              else {
1297                  return completionFunction(current, argv, completions => {
1298                      done(completions);
1299                  });
1300              }
1301          }
1302          if (completionFunction) {
1303              return isPromise(argv)
1304                  ? argv.then(runCompletionFunction)
1305                  : runCompletionFunction(argv);
1306          }
1307          const handlers = command.getCommandHandlers();
1308          for (let i = 0, ii = args.length; i < ii; ++i) {
1309              if (handlers[args[i]] && handlers[args[i]].builder) {
1310                  const builder = handlers[args[i]].builder;
1311                  if (isCommandBuilderCallback(builder)) {
1312                      const y = yargs.reset();
1313                      builder(y);
1314                      return y.argv;
1315                  }
1316              }
1317          }
1318          if (!current.match(/^-/) &&
1319              parentCommands[parentCommands.length - 1] !== current) {
1320              usage.getCommands().forEach(usageCommand => {
1321                  const commandName = parseCommand(usageCommand[0]).cmd;
1322                  if (args.indexOf(commandName) === -1) {
1323                      if (!zshShell) {
1324                          completions.push(commandName);
1325                      }
1326                      else {
1327                          const desc = usageCommand[1] || '';
1328                          completions.push(commandName.replace(/:/g, '\\:') + ':' + desc);
1329                      }
1330                  }
1331              });
1332          }
1333          if (current.match(/^-/) || (current === '' && completions.length === 0)) {
1334              const descs = usage.getDescriptions();
1335              const options = yargs.getOptions();
1336              Object.keys(options.key).forEach(key => {
1337                  const negable = !!options.configuration['boolean-negation'] &&
1338                      options.boolean.includes(key);
1339                  let keyAndAliases = [key].concat(aliases[key] || []);
1340                  if (negable)
1341                      keyAndAliases = keyAndAliases.concat(keyAndAliases.map(key => `no-${key}`));
1342                  function completeOptionKey(key) {
1343                      const notInArgs = keyAndAliases.every(val => args.indexOf(`--${val}`) === -1);
1344                      if (notInArgs) {
1345                          const startsByTwoDashes = (s) => /^--/.test(s);
1346                          const isShortOption = (s) => /^[^0-9]$/.test(s);
1347                          const dashes = !startsByTwoDashes(current) && isShortOption(key) ? '-' : '--';
1348                          if (!zshShell) {
1349                              completions.push(dashes + key);
1350                          }
1351                          else {
1352                              const desc = descs[key] || '';
1353                              completions.push(dashes +
1354                                  `${key.replace(/:/g, '\\:')}:${desc.replace('__yargsString__:', '')}`);
1355                          }
1356                      }
1357                  }
1358                  completeOptionKey(key);
1359                  if (negable && !!options.default[key])
1360                      completeOptionKey(`no-${key}`);
1361              });
1362          }
1363          done(completions);
1364      };
1365      self.generateCompletionScript = function generateCompletionScript($0, cmd) {
1366          let script = zshShell
1367              ? completionZshTemplate
1368              : completionShTemplate;
1369          const name = shim.path.basename($0);
1370          if ($0.match(/\.js$/))
1371              $0 = `./${$0}`;
1372          script = script.replace(/{{app_name}}/g, name);
1373          script = script.replace(/{{completion_command}}/g, cmd);
1374          return script.replace(/{{app_path}}/g, $0);
1375      };
1376      let completionFunction = null;
1377      self.registerFunction = fn => {
1378          completionFunction = fn;
1379      };
1380      return self;
1381  }
1382  function isSyncCompletionFunction(completionFunction) {
1383      return completionFunction.length < 3;
1384  }
1385  
1386  function levenshtein(a, b) {
1387      if (a.length === 0)
1388          return b.length;
1389      if (b.length === 0)
1390          return a.length;
1391      const matrix = [];
1392      let i;
1393      for (i = 0; i <= b.length; i++) {
1394          matrix[i] = [i];
1395      }
1396      let j;
1397      for (j = 0; j <= a.length; j++) {
1398          matrix[0][j] = j;
1399      }
1400      for (i = 1; i <= b.length; i++) {
1401          for (j = 1; j <= a.length; j++) {
1402              if (b.charAt(i - 1) === a.charAt(j - 1)) {
1403                  matrix[i][j] = matrix[i - 1][j - 1];
1404              }
1405              else {
1406                  matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
1407              }
1408          }
1409      }
1410      return matrix[b.length][a.length];
1411  }
1412  
1413  const specialKeys = ['$0', '--', '_'];
1414  function validation(yargs, usage, y18n, shim) {
1415      const __ = y18n.__;
1416      const __n = y18n.__n;
1417      const self = {};
1418      self.nonOptionCount = function nonOptionCount(argv) {
1419          const demandedCommands = yargs.getDemandedCommands();
1420          const positionalCount = argv._.length + (argv['--'] ? argv['--'].length : 0);
1421          const _s = positionalCount - yargs.getContext().commands.length;
1422          if (demandedCommands._ &&
1423              (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
1424              if (_s < demandedCommands._.min) {
1425                  if (demandedCommands._.minMsg !== undefined) {
1426                      usage.fail(demandedCommands._.minMsg
1427                          ? demandedCommands._.minMsg
1428                              .replace(/\$0/g, _s.toString())
1429                              .replace(/\$1/, demandedCommands._.min.toString())
1430                          : null);
1431                  }
1432                  else {
1433                      usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', _s, _s.toString(), demandedCommands._.min.toString()));
1434                  }
1435              }
1436              else if (_s > demandedCommands._.max) {
1437                  if (demandedCommands._.maxMsg !== undefined) {
1438                      usage.fail(demandedCommands._.maxMsg
1439                          ? demandedCommands._.maxMsg
1440                              .replace(/\$0/g, _s.toString())
1441                              .replace(/\$1/, demandedCommands._.max.toString())
1442                          : null);
1443                  }
1444                  else {
1445                      usage.fail(__n('Too many non-option arguments: got %s, maximum of %s', 'Too many non-option arguments: got %s, maximum of %s', _s, _s.toString(), demandedCommands._.max.toString()));
1446                  }
1447              }
1448          }
1449      };
1450      self.positionalCount = function positionalCount(required, observed) {
1451          if (observed < required) {
1452              usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', observed, observed + '', required + ''));
1453          }
1454      };
1455      self.requiredArguments = function requiredArguments(argv) {
1456          const demandedOptions = yargs.getDemandedOptions();
1457          let missing = null;
1458          for (const key of Object.keys(demandedOptions)) {
1459              if (!Object.prototype.hasOwnProperty.call(argv, key) ||
1460                  typeof argv[key] === 'undefined') {
1461                  missing = missing || {};
1462                  missing[key] = demandedOptions[key];
1463              }
1464          }
1465          if (missing) {
1466              const customMsgs = [];
1467              for (const key of Object.keys(missing)) {
1468                  const msg = missing[key];
1469                  if (msg && customMsgs.indexOf(msg) < 0) {
1470                      customMsgs.push(msg);
1471                  }
1472              }
1473              const customMsg = customMsgs.length ? `\n${customMsgs.join('\n')}` : '';
1474              usage.fail(__n('Missing required argument: %s', 'Missing required arguments: %s', Object.keys(missing).length, Object.keys(missing).join(', ') + customMsg));
1475          }
1476      };
1477      self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand, checkPositionals = true) {
1478          const commandKeys = yargs.getCommandInstance().getCommands();
1479          const unknown = [];
1480          const currentContext = yargs.getContext();
1481          Object.keys(argv).forEach(key => {
1482              if (specialKeys.indexOf(key) === -1 &&
1483                  !Object.prototype.hasOwnProperty.call(positionalMap, key) &&
1484                  !Object.prototype.hasOwnProperty.call(yargs._getParseContext(), key) &&
1485                  !self.isValidAndSomeAliasIsNotNew(key, aliases)) {
1486                  unknown.push(key);
1487              }
1488          });
1489          if (checkPositionals &&
1490              (currentContext.commands.length > 0 ||
1491                  commandKeys.length > 0 ||
1492                  isDefaultCommand)) {
1493              argv._.slice(currentContext.commands.length).forEach(key => {
1494                  if (commandKeys.indexOf('' + key) === -1) {
1495                      unknown.push('' + key);
1496                  }
1497              });
1498          }
1499          if (unknown.length > 0) {
1500              usage.fail(__n('Unknown argument: %s', 'Unknown arguments: %s', unknown.length, unknown.join(', ')));
1501          }
1502      };
1503      self.unknownCommands = function unknownCommands(argv) {
1504          const commandKeys = yargs.getCommandInstance().getCommands();
1505          const unknown = [];
1506          const currentContext = yargs.getContext();
1507          if (currentContext.commands.length > 0 || commandKeys.length > 0) {
1508              argv._.slice(currentContext.commands.length).forEach(key => {
1509                  if (commandKeys.indexOf('' + key) === -1) {
1510                      unknown.push('' + key);
1511                  }
1512              });
1513          }
1514          if (unknown.length > 0) {
1515              usage.fail(__n('Unknown command: %s', 'Unknown commands: %s', unknown.length, unknown.join(', ')));
1516              return true;
1517          }
1518          else {
1519              return false;
1520          }
1521      };
1522      self.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) {
1523          if (!Object.prototype.hasOwnProperty.call(aliases, key)) {
1524              return false;
1525          }
1526          const newAliases = yargs.parsed.newAliases;
1527          for (const a of [key, ...aliases[key]]) {
1528              if (!Object.prototype.hasOwnProperty.call(newAliases, a) ||
1529                  !newAliases[key]) {
1530                  return true;
1531              }
1532          }
1533          return false;
1534      };
1535      self.limitedChoices = function limitedChoices(argv) {
1536          const options = yargs.getOptions();
1537          const invalid = {};
1538          if (!Object.keys(options.choices).length)
1539              return;
1540          Object.keys(argv).forEach(key => {
1541              if (specialKeys.indexOf(key) === -1 &&
1542                  Object.prototype.hasOwnProperty.call(options.choices, key)) {
1543                  [].concat(argv[key]).forEach(value => {
1544                      if (options.choices[key].indexOf(value) === -1 &&
1545                          value !== undefined) {
1546                          invalid[key] = (invalid[key] || []).concat(value);
1547                      }
1548                  });
1549              }
1550          });
1551          const invalidKeys = Object.keys(invalid);
1552          if (!invalidKeys.length)
1553              return;
1554          let msg = __('Invalid values:');
1555          invalidKeys.forEach(key => {
1556              msg += `\n  ${__('Argument: %s, Given: %s, Choices: %s', key, usage.stringifiedValues(invalid[key]), usage.stringifiedValues(options.choices[key]))}`;
1557          });
1558          usage.fail(msg);
1559      };
1560      let checks = [];
1561      self.check = function check(f, global) {
1562          checks.push({
1563              func: f,
1564              global,
1565          });
1566      };
1567      self.customChecks = function customChecks(argv, aliases) {
1568          for (let i = 0, f; (f = checks[i]) !== undefined; i++) {
1569              const func = f.func;
1570              let result = null;
1571              try {
1572                  result = func(argv, aliases);
1573              }
1574              catch (err) {
1575                  usage.fail(err.message ? err.message : err, err);
1576                  continue;
1577              }
1578              if (!result) {
1579                  usage.fail(__('Argument check failed: %s', func.toString()));
1580              }
1581              else if (typeof result === 'string' || result instanceof Error) {
1582                  usage.fail(result.toString(), result);
1583              }
1584          }
1585      };
1586      let implied = {};
1587      self.implies = function implies(key, value) {
1588          argsert('<string|object> [array|number|string]', [key, value], arguments.length);
1589          if (typeof key === 'object') {
1590              Object.keys(key).forEach(k => {
1591                  self.implies(k, key[k]);
1592              });
1593          }
1594          else {
1595              yargs.global(key);
1596              if (!implied[key]) {
1597                  implied[key] = [];
1598              }
1599              if (Array.isArray(value)) {
1600                  value.forEach(i => self.implies(key, i));
1601              }
1602              else {
1603                  assertNotStrictEqual(value, undefined, shim);
1604                  implied[key].push(value);
1605              }
1606          }
1607      };
1608      self.getImplied = function getImplied() {
1609          return implied;
1610      };
1611      function keyExists(argv, val) {
1612          const num = Number(val);
1613          val = isNaN(num) ? val : num;
1614          if (typeof val === 'number') {
1615              val = argv._.length >= val;
1616          }
1617          else if (val.match(/^--no-.+/)) {
1618              val = val.match(/^--no-(.+)/)[1];
1619              val = !argv[val];
1620          }
1621          else {
1622              val = argv[val];
1623          }
1624          return val;
1625      }
1626      self.implications = function implications(argv) {
1627          const implyFail = [];
1628          Object.keys(implied).forEach(key => {
1629              const origKey = key;
1630              (implied[key] || []).forEach(value => {
1631                  let key = origKey;
1632                  const origValue = value;
1633                  key = keyExists(argv, key);
1634                  value = keyExists(argv, value);
1635                  if (key && !value) {
1636                      implyFail.push(` ${origKey} -> ${origValue}`);
1637                  }
1638              });
1639          });
1640          if (implyFail.length) {
1641              let msg = `${__('Implications failed:')}\n`;
1642              implyFail.forEach(value => {
1643                  msg += value;
1644              });
1645              usage.fail(msg);
1646          }
1647      };
1648      let conflicting = {};
1649      self.conflicts = function conflicts(key, value) {
1650          argsert('<string|object> [array|string]', [key, value], arguments.length);
1651          if (typeof key === 'object') {
1652              Object.keys(key).forEach(k => {
1653                  self.conflicts(k, key[k]);
1654              });
1655          }
1656          else {
1657              yargs.global(key);
1658              if (!conflicting[key]) {
1659                  conflicting[key] = [];
1660              }
1661              if (Array.isArray(value)) {
1662                  value.forEach(i => self.conflicts(key, i));
1663              }
1664              else {
1665                  conflicting[key].push(value);
1666              }
1667          }
1668      };
1669      self.getConflicting = () => conflicting;
1670      self.conflicting = function conflictingFn(argv) {
1671          Object.keys(argv).forEach(key => {
1672              if (conflicting[key]) {
1673                  conflicting[key].forEach(value => {
1674                      if (value && argv[key] !== undefined && argv[value] !== undefined) {
1675                          usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));
1676                      }
1677                  });
1678              }
1679          });
1680      };
1681      self.recommendCommands = function recommendCommands(cmd, potentialCommands) {
1682          const threshold = 3;
1683          potentialCommands = potentialCommands.sort((a, b) => b.length - a.length);
1684          let recommended = null;
1685          let bestDistance = Infinity;
1686          for (let i = 0, candidate; (candidate = potentialCommands[i]) !== undefined; i++) {
1687              const d = levenshtein(cmd, candidate);
1688              if (d <= threshold && d < bestDistance) {
1689                  bestDistance = d;
1690                  recommended = candidate;
1691              }
1692          }
1693          if (recommended)
1694              usage.fail(__('Did you mean %s?', recommended));
1695      };
1696      self.reset = function reset(localLookup) {
1697          implied = objFilter(implied, k => !localLookup[k]);
1698          conflicting = objFilter(conflicting, k => !localLookup[k]);
1699          checks = checks.filter(c => c.global);
1700          return self;
1701      };
1702      const frozens = [];
1703      self.freeze = function freeze() {
1704          frozens.push({
1705              implied,
1706              checks,
1707              conflicting,
1708          });
1709      };
1710      self.unfreeze = function unfreeze() {
1711          const frozen = frozens.pop();
1712          assertNotStrictEqual(frozen, undefined, shim);
1713          ({ implied, checks, conflicting } = frozen);
1714      };
1715      return self;
1716  }
1717  
1718  let shim$1;
1719  function YargsWithShim(_shim) {
1720      shim$1 = _shim;
1721      return Yargs;
1722  }
1723  function Yargs(processArgs = [], cwd = shim$1.process.cwd(), parentRequire) {
1724      const self = {};
1725      let command$1;
1726      let completion$1 = null;
1727      let groups = {};
1728      const globalMiddleware = [];
1729      let output = '';
1730      const preservedGroups = {};
1731      let usage$1;
1732      let validation$1;
1733      let handlerFinishCommand = null;
1734      const y18n = shim$1.y18n;
1735      self.middleware = globalMiddlewareFactory(globalMiddleware, self);
1736      self.scriptName = function (scriptName) {
1737          self.customScriptName = true;
1738          self.$0 = scriptName;
1739          return self;
1740      };
1741      let default$0;
1742      if (/\b(node|iojs|electron)(\.exe)?$/.test(shim$1.process.argv()[0])) {
1743          default$0 = shim$1.process.argv().slice(1, 2);
1744      }
1745      else {
1746          default$0 = shim$1.process.argv().slice(0, 1);
1747      }
1748      self.$0 = default$0
1749          .map(x => {
1750          const b = rebase(cwd, x);
1751          return x.match(/^(\/|([a-zA-Z]:)?\\)/) && b.length < x.length ? b : x;
1752      })
1753          .join(' ')
1754          .trim();
1755      if (shim$1.getEnv('_') && shim$1.getProcessArgvBin() === shim$1.getEnv('_')) {
1756          self.$0 = shim$1
1757              .getEnv('_')
1758              .replace(`${shim$1.path.dirname(shim$1.process.execPath())}/`, '');
1759      }
1760      const context = { resets: -1, commands: [], fullCommands: [], files: [] };
1761      self.getContext = () => context;
1762      let hasOutput = false;
1763      let exitError = null;
1764      self.exit = (code, err) => {
1765          hasOutput = true;
1766          exitError = err;
1767          if (exitProcess)
1768              shim$1.process.exit(code);
1769      };
1770      let completionCommand = null;
1771      self.completion = function (cmd, desc, fn) {
1772          argsert('[string] [string|boolean|function] [function]', [cmd, desc, fn], arguments.length);
1773          if (typeof desc === 'function') {
1774              fn = desc;
1775              desc = undefined;
1776          }
1777          completionCommand = cmd || completionCommand || 'completion';
1778          if (!desc && desc !== false) {
1779              desc = 'generate completion script';
1780          }
1781          self.command(completionCommand, desc);
1782          if (fn)
1783              completion$1.registerFunction(fn);
1784          return self;
1785      };
1786      let options;
1787      self.resetOptions = self.reset = function resetOptions(aliases = {}) {
1788          context.resets++;
1789          options = options || {};
1790          const tmpOptions = {};
1791          tmpOptions.local = options.local ? options.local : [];
1792          tmpOptions.configObjects = options.configObjects
1793              ? options.configObjects
1794              : [];
1795          const localLookup = {};
1796          tmpOptions.local.forEach(l => {
1797              localLookup[l] = true;
1798              (aliases[l] || []).forEach(a => {
1799                  localLookup[a] = true;
1800              });
1801          });
1802          Object.assign(preservedGroups, Object.keys(groups).reduce((acc, groupName) => {
1803              const keys = groups[groupName].filter(key => !(key in localLookup));
1804              if (keys.length > 0) {
1805                  acc[groupName] = keys;
1806              }
1807              return acc;
1808          }, {}));
1809          groups = {};
1810          const arrayOptions = [
1811              'array',
1812              'boolean',
1813              'string',
1814              'skipValidation',
1815              'count',
1816              'normalize',
1817              'number',
1818              'hiddenOptions',
1819          ];
1820          const objectOptions = [
1821              'narg',
1822              'key',
1823              'alias',
1824              'default',
1825              'defaultDescription',
1826              'config',
1827              'choices',
1828              'demandedOptions',
1829              'demandedCommands',
1830              'coerce',
1831              'deprecatedOptions',
1832          ];
1833          arrayOptions.forEach(k => {
1834              tmpOptions[k] = (options[k] || []).filter((k) => !localLookup[k]);
1835          });
1836          objectOptions.forEach((k) => {
1837              tmpOptions[k] = objFilter(options[k], k => !localLookup[k]);
1838          });
1839          tmpOptions.envPrefix = options.envPrefix;
1840          options = tmpOptions;
1841          usage$1 = usage$1 ? usage$1.reset(localLookup) : usage(self, y18n, shim$1);
1842          validation$1 = validation$1
1843              ? validation$1.reset(localLookup)
1844              : validation(self, usage$1, y18n, shim$1);
1845          command$1 = command$1
1846              ? command$1.reset()
1847              : command(self, usage$1, validation$1, globalMiddleware, shim$1);
1848          if (!completion$1)
1849              completion$1 = completion(self, usage$1, command$1, shim$1);
1850          completionCommand = null;
1851          output = '';
1852          exitError = null;
1853          hasOutput = false;
1854          self.parsed = false;
1855          return self;
1856      };
1857      self.resetOptions();
1858      const frozens = [];
1859      function freeze() {
1860          frozens.push({
1861              options,
1862              configObjects: options.configObjects.slice(0),
1863              exitProcess,
1864              groups,
1865              strict,
1866              strictCommands,
1867              strictOptions,
1868              completionCommand,
1869              output,
1870              exitError,
1871              hasOutput,
1872              parsed: self.parsed,
1873              parseFn,
1874              parseContext,
1875              handlerFinishCommand,
1876          });
1877          usage$1.freeze();
1878          validation$1.freeze();
1879          command$1.freeze();
1880      }
1881      function unfreeze() {
1882          const frozen = frozens.pop();
1883          assertNotStrictEqual(frozen, undefined, shim$1);
1884          let configObjects;
1885          ({
1886              options,
1887              configObjects,
1888              exitProcess,
1889              groups,
1890              output,
1891              exitError,
1892              hasOutput,
1893              parsed: self.parsed,
1894              strict,
1895              strictCommands,
1896              strictOptions,
1897              completionCommand,
1898              parseFn,
1899              parseContext,
1900              handlerFinishCommand,
1901          } = frozen);
1902          options.configObjects = configObjects;
1903          usage$1.unfreeze();
1904          validation$1.unfreeze();
1905          command$1.unfreeze();
1906      }
1907      self.boolean = function (keys) {
1908          argsert('<array|string>', [keys], arguments.length);
1909          populateParserHintArray('boolean', keys);
1910          return self;
1911      };
1912      self.array = function (keys) {
1913          argsert('<array|string>', [keys], arguments.length);
1914          populateParserHintArray('array', keys);
1915          return self;
1916      };
1917      self.number = function (keys) {
1918          argsert('<array|string>', [keys], arguments.length);
1919          populateParserHintArray('number', keys);
1920          return self;
1921      };
1922      self.normalize = function (keys) {
1923          argsert('<array|string>', [keys], arguments.length);
1924          populateParserHintArray('normalize', keys);
1925          return self;
1926      };
1927      self.count = function (keys) {
1928          argsert('<array|string>', [keys], arguments.length);
1929          populateParserHintArray('count', keys);
1930          return self;
1931      };
1932      self.string = function (keys) {
1933          argsert('<array|string>', [keys], arguments.length);
1934          populateParserHintArray('string', keys);
1935          return self;
1936      };
1937      self.requiresArg = function (keys) {
1938          argsert('<array|string|object> [number]', [keys], arguments.length);
1939          if (typeof keys === 'string' && options.narg[keys]) {
1940              return self;
1941          }
1942          else {
1943              populateParserHintSingleValueDictionary(self.requiresArg, 'narg', keys, NaN);
1944          }
1945          return self;
1946      };
1947      self.skipValidation = function (keys) {
1948          argsert('<array|string>', [keys], arguments.length);
1949          populateParserHintArray('skipValidation', keys);
1950          return self;
1951      };
1952      function populateParserHintArray(type, keys) {
1953          keys = [].concat(keys);
1954          keys.forEach(key => {
1955              key = sanitizeKey(key);
1956              options[type].push(key);
1957          });
1958      }
1959      self.nargs = function (key, value) {
1960          argsert('<string|object|array> [number]', [key, value], arguments.length);
1961          populateParserHintSingleValueDictionary(self.nargs, 'narg', key, value);
1962          return self;
1963      };
1964      self.choices = function (key, value) {
1965          argsert('<object|string|array> [string|array]', [key, value], arguments.length);
1966          populateParserHintArrayDictionary(self.choices, 'choices', key, value);
1967          return self;
1968      };
1969      self.alias = function (key, value) {
1970          argsert('<object|string|array> [string|array]', [key, value], arguments.length);
1971          populateParserHintArrayDictionary(self.alias, 'alias', key, value);
1972          return self;
1973      };
1974      self.default = self.defaults = function (key, value, defaultDescription) {
1975          argsert('<object|string|array> [*] [string]', [key, value, defaultDescription], arguments.length);
1976          if (defaultDescription) {
1977              assertSingleKey(key, shim$1);
1978              options.defaultDescription[key] = defaultDescription;
1979          }
1980          if (typeof value === 'function') {
1981              assertSingleKey(key, shim$1);
1982              if (!options.defaultDescription[key])
1983                  options.defaultDescription[key] = usage$1.functionDescription(value);
1984              value = value.call();
1985          }
1986          populateParserHintSingleValueDictionary(self.default, 'default', key, value);
1987          return self;
1988      };
1989      self.describe = function (key, desc) {
1990          argsert('<object|string|array> [string]', [key, desc], arguments.length);
1991          setKey(key, true);
1992          usage$1.describe(key, desc);
1993          return self;
1994      };
1995      function setKey(key, set) {
1996          populateParserHintSingleValueDictionary(setKey, 'key', key, set);
1997          return self;
1998      }
1999      function demandOption(keys, msg) {
2000          argsert('<object|string|array> [string]', [keys, msg], arguments.length);
2001          populateParserHintSingleValueDictionary(self.demandOption, 'demandedOptions', keys, msg);
2002          return self;
2003      }
2004      self.demandOption = demandOption;
2005      self.coerce = function (keys, value) {
2006          argsert('<object|string|array> [function]', [keys, value], arguments.length);
2007          populateParserHintSingleValueDictionary(self.coerce, 'coerce', keys, value);
2008          return self;
2009      };
2010      function populateParserHintSingleValueDictionary(builder, type, key, value) {
2011          populateParserHintDictionary(builder, type, key, value, (type, key, value) => {
2012              options[type][key] = value;
2013          });
2014      }
2015      function populateParserHintArrayDictionary(builder, type, key, value) {
2016          populateParserHintDictionary(builder, type, key, value, (type, key, value) => {
2017              options[type][key] = (options[type][key] || []).concat(value);
2018          });
2019      }
2020      function populateParserHintDictionary(builder, type, key, value, singleKeyHandler) {
2021          if (Array.isArray(key)) {
2022              key.forEach(k => {
2023                  builder(k, value);
2024              });
2025          }
2026          else if (((key) => typeof key === 'object')(key)) {
2027              for (const k of objectKeys(key)) {
2028                  builder(k, key[k]);
2029              }
2030          }
2031          else {
2032              singleKeyHandler(type, sanitizeKey(key), value);
2033          }
2034      }
2035      function sanitizeKey(key) {
2036          if (key === '__proto__')
2037              return '___proto___';
2038          return key;
2039      }
2040      function deleteFromParserHintObject(optionKey) {
2041          objectKeys(options).forEach((hintKey) => {
2042              if (((key) => key === 'configObjects')(hintKey))
2043                  return;
2044              const hint = options[hintKey];
2045              if (Array.isArray(hint)) {
2046                  if (~hint.indexOf(optionKey))
2047                      hint.splice(hint.indexOf(optionKey), 1);
2048              }
2049              else if (typeof hint === 'object') {
2050                  delete hint[optionKey];
2051              }
2052          });
2053          delete usage$1.getDescriptions()[optionKey];
2054      }
2055      self.config = function config(key = 'config', msg, parseFn) {
2056          argsert('[object|string] [string|function] [function]', [key, msg, parseFn], arguments.length);
2057          if (typeof key === 'object' && !Array.isArray(key)) {
2058              key = applyExtends(key, cwd, self.getParserConfiguration()['deep-merge-config'] || false, shim$1);
2059              options.configObjects = (options.configObjects || []).concat(key);
2060              return self;
2061          }
2062          if (typeof msg === 'function') {
2063              parseFn = msg;
2064              msg = undefined;
2065          }
2066          self.describe(key, msg || usage$1.deferY18nLookup('Path to JSON config file'));
2067          (Array.isArray(key) ? key : [key]).forEach(k => {
2068              options.config[k] = parseFn || true;
2069          });
2070          return self;
2071      };
2072      self.example = function (cmd, description) {
2073          argsert('<string|array> [string]', [cmd, description], arguments.length);
2074          if (Array.isArray(cmd)) {
2075              cmd.forEach(exampleParams => self.example(...exampleParams));
2076          }
2077          else {
2078              usage$1.example(cmd, description);
2079          }
2080          return self;
2081      };
2082      self.command = function (cmd, description, builder, handler, middlewares, deprecated) {
2083          argsert('<string|array|object> [string|boolean] [function|object] [function] [array] [boolean|string]', [cmd, description, builder, handler, middlewares, deprecated], arguments.length);
2084          command$1.addHandler(cmd, description, builder, handler, middlewares, deprecated);
2085          return self;
2086      };
2087      self.commandDir = function (dir, opts) {
2088          argsert('<string> [object]', [dir, opts], arguments.length);
2089          const req = parentRequire || shim$1.require;
2090          command$1.addDirectory(dir, self.getContext(), req, shim$1.getCallerFile(), opts);
2091          return self;
2092      };
2093      self.demand = self.required = self.require = function demand(keys, max, msg) {
2094          if (Array.isArray(max)) {
2095              max.forEach(key => {
2096                  assertNotStrictEqual(msg, true, shim$1);
2097                  demandOption(key, msg);
2098              });
2099              max = Infinity;
2100          }
2101          else if (typeof max !== 'number') {
2102              msg = max;
2103              max = Infinity;
2104          }
2105          if (typeof keys === 'number') {
2106              assertNotStrictEqual(msg, true, shim$1);
2107              self.demandCommand(keys, max, msg, msg);
2108          }
2109          else if (Array.isArray(keys)) {
2110              keys.forEach(key => {
2111                  assertNotStrictEqual(msg, true, shim$1);
2112                  demandOption(key, msg);
2113              });
2114          }
2115          else {
2116              if (typeof msg === 'string') {
2117                  demandOption(keys, msg);
2118              }
2119              else if (msg === true || typeof msg === 'undefined') {
2120                  demandOption(keys);
2121              }
2122          }
2123          return self;
2124      };
2125      self.demandCommand = function demandCommand(min = 1, max, minMsg, maxMsg) {
2126          argsert('[number] [number|string] [string|null|undefined] [string|null|undefined]', [min, max, minMsg, maxMsg], arguments.length);
2127          if (typeof max !== 'number') {
2128              minMsg = max;
2129              max = Infinity;
2130          }
2131          self.global('_', false);
2132          options.demandedCommands._ = {
2133              min,
2134              max,
2135              minMsg,
2136              maxMsg,
2137          };
2138          return self;
2139      };
2140      self.getDemandedOptions = () => {
2141          argsert([], 0);
2142          return options.demandedOptions;
2143      };
2144      self.getDemandedCommands = () => {
2145          argsert([], 0);
2146          return options.demandedCommands;
2147      };
2148      self.deprecateOption = function deprecateOption(option, message) {
2149          argsert('<string> [string|boolean]', [option, message], arguments.length);
2150          options.deprecatedOptions[option] = message;
2151          return self;
2152      };
2153      self.getDeprecatedOptions = () => {
2154          argsert([], 0);
2155          return options.deprecatedOptions;
2156      };
2157      self.implies = function (key, value) {
2158          argsert('<string|object> [number|string|array]', [key, value], arguments.length);
2159          validation$1.implies(key, value);
2160          return self;
2161      };
2162      self.conflicts = function (key1, key2) {
2163          argsert('<string|object> [string|array]', [key1, key2], arguments.length);
2164          validation$1.conflicts(key1, key2);
2165          return self;
2166      };
2167      self.usage = function (msg, description, builder, handler) {
2168          argsert('<string|null|undefined> [string|boolean] [function|object] [function]', [msg, description, builder, handler], arguments.length);
2169          if (description !== undefined) {
2170              assertNotStrictEqual(msg, null, shim$1);
2171              if ((msg || '').match(/^\$0( |$)/)) {
2172                  return self.command(msg, description, builder, handler);
2173              }
2174              else {
2175                  throw new YError('.usage() description must start with $0 if being used as alias for .command()');
2176              }
2177          }
2178          else {
2179              usage$1.usage(msg);
2180              return self;
2181          }
2182      };
2183      self.epilogue = self.epilog = function (msg) {
2184          argsert('<string>', [msg], arguments.length);
2185          usage$1.epilog(msg);
2186          return self;
2187      };
2188      self.fail = function (f) {
2189          argsert('<function>', [f], arguments.length);
2190          usage$1.failFn(f);
2191          return self;
2192      };
2193      self.onFinishCommand = function (f) {
2194          argsert('<function>', [f], arguments.length);
2195          handlerFinishCommand = f;
2196          return self;
2197      };
2198      self.getHandlerFinishCommand = () => handlerFinishCommand;
2199      self.check = function (f, _global) {
2200          argsert('<function> [boolean]', [f, _global], arguments.length);
2201          validation$1.check(f, _global !== false);
2202          return self;
2203      };
2204      self.global = function global(globals, global) {
2205          argsert('<string|array> [boolean]', [globals, global], arguments.length);
2206          globals = [].concat(globals);
2207          if (global !== false) {
2208              options.local = options.local.filter(l => globals.indexOf(l) === -1);
2209          }
2210          else {
2211              globals.forEach(g => {
2212                  if (options.local.indexOf(g) === -1)
2213                      options.local.push(g);
2214              });
2215          }
2216          return self;
2217      };
2218      self.pkgConf = function pkgConf(key, rootPath) {
2219          argsert('<string> [string]', [key, rootPath], arguments.length);
2220          let conf = null;
2221          const obj = pkgUp(rootPath || cwd);
2222          if (obj[key] && typeof obj[key] === 'object') {
2223              conf = applyExtends(obj[key], rootPath || cwd, self.getParserConfiguration()['deep-merge-config'] || false, shim$1);
2224              options.configObjects = (options.configObjects || []).concat(conf);
2225          }
2226          return self;
2227      };
2228      const pkgs = {};
2229      function pkgUp(rootPath) {
2230          const npath = rootPath || '*';
2231          if (pkgs[npath])
2232              return pkgs[npath];
2233          let obj = {};
2234          try {
2235              let startDir = rootPath || shim$1.mainFilename;
2236              if (!rootPath && shim$1.path.extname(startDir)) {
2237                  startDir = shim$1.path.dirname(startDir);
2238              }
2239              const pkgJsonPath = shim$1.findUp(startDir, (dir, names) => {
2240                  if (names.includes('package.json')) {
2241                      return 'package.json';
2242                  }
2243                  else {
2244                      return undefined;
2245                  }
2246              });
2247              assertNotStrictEqual(pkgJsonPath, undefined, shim$1);
2248              obj = JSON.parse(shim$1.readFileSync(pkgJsonPath, 'utf8'));
2249          }
2250          catch (_noop) { }
2251          pkgs[npath] = obj || {};
2252          return pkgs[npath];
2253      }
2254      let parseFn = null;
2255      let parseContext = null;
2256      self.parse = function parse(args, shortCircuit, _parseFn) {
2257          argsert('[string|array] [function|boolean|object] [function]', [args, shortCircuit, _parseFn], arguments.length);
2258          freeze();
2259          if (typeof args === 'undefined') {
2260              const argv = self._parseArgs(processArgs);
2261              const tmpParsed = self.parsed;
2262              unfreeze();
2263              self.parsed = tmpParsed;
2264              return argv;
2265          }
2266          if (typeof shortCircuit === 'object') {
2267              parseContext = shortCircuit;
2268              shortCircuit = _parseFn;
2269          }
2270          if (typeof shortCircuit === 'function') {
2271              parseFn = shortCircuit;
2272              shortCircuit = false;
2273          }
2274          if (!shortCircuit)
2275              processArgs = args;
2276          if (parseFn)
2277              exitProcess = false;
2278          const parsed = self._parseArgs(args, !!shortCircuit);
2279          completion$1.setParsed(self.parsed);
2280          if (parseFn)
2281              parseFn(exitError, parsed, output);
2282          unfreeze();
2283          return parsed;
2284      };
2285      self._getParseContext = () => parseContext || {};
2286      self._hasParseCallback = () => !!parseFn;
2287      self.option = self.options = function option(key, opt) {
2288          argsert('<string|object> [object]', [key, opt], arguments.length);
2289          if (typeof key === 'object') {
2290              Object.keys(key).forEach(k => {
2291                  self.options(k, key[k]);
2292              });
2293          }
2294          else {
2295              if (typeof opt !== 'object') {
2296                  opt = {};
2297              }
2298              options.key[key] = true;
2299              if (opt.alias)
2300                  self.alias(key, opt.alias);
2301              const deprecate = opt.deprecate || opt.deprecated;
2302              if (deprecate) {
2303                  self.deprecateOption(key, deprecate);
2304              }
2305              const demand = opt.demand || opt.required || opt.require;
2306              if (demand) {
2307                  self.demand(key, demand);
2308              }
2309              if (opt.demandOption) {
2310                  self.demandOption(key, typeof opt.demandOption === 'string' ? opt.demandOption : undefined);
2311              }
2312              if (opt.conflicts) {
2313                  self.conflicts(key, opt.conflicts);
2314              }
2315              if ('default' in opt) {
2316                  self.default(key, opt.default);
2317              }
2318              if (opt.implies !== undefined) {
2319                  self.implies(key, opt.implies);
2320              }
2321              if (opt.nargs !== undefined) {
2322                  self.nargs(key, opt.nargs);
2323              }
2324              if (opt.config) {
2325                  self.config(key, opt.configParser);
2326              }
2327              if (opt.normalize) {
2328                  self.normalize(key);
2329              }
2330              if (opt.choices) {
2331                  self.choices(key, opt.choices);
2332              }
2333              if (opt.coerce) {
2334                  self.coerce(key, opt.coerce);
2335              }
2336              if (opt.group) {
2337                  self.group(key, opt.group);
2338              }
2339              if (opt.boolean || opt.type === 'boolean') {
2340                  self.boolean(key);
2341                  if (opt.alias)
2342                      self.boolean(opt.alias);
2343              }
2344              if (opt.array || opt.type === 'array') {
2345                  self.array(key);
2346                  if (opt.alias)
2347                      self.array(opt.alias);
2348              }
2349              if (opt.number || opt.type === 'number') {
2350                  self.number(key);
2351                  if (opt.alias)
2352                      self.number(opt.alias);
2353              }
2354              if (opt.string || opt.type === 'string') {
2355                  self.string(key);
2356                  if (opt.alias)
2357                      self.string(opt.alias);
2358              }
2359              if (opt.count || opt.type === 'count') {
2360                  self.count(key);
2361              }
2362              if (typeof opt.global === 'boolean') {
2363                  self.global(key, opt.global);
2364              }
2365              if (opt.defaultDescription) {
2366                  options.defaultDescription[key] = opt.defaultDescription;
2367              }
2368              if (opt.skipValidation) {
2369                  self.skipValidation(key);
2370              }
2371              const desc = opt.describe || opt.description || opt.desc;
2372              self.describe(key, desc);
2373              if (opt.hidden) {
2374                  self.hide(key);
2375              }
2376              if (opt.requiresArg) {
2377                  self.requiresArg(key);
2378              }
2379          }
2380          return self;
2381      };
2382      self.getOptions = () => options;
2383      self.positional = function (key, opts) {
2384          argsert('<string> <object>', [key, opts], arguments.length);
2385          if (context.resets === 0) {
2386              throw new YError(".positional() can only be called in a command's builder function");
2387          }
2388          const supportedOpts = [
2389              'default',
2390              'defaultDescription',
2391              'implies',
2392              'normalize',
2393              'choices',
2394              'conflicts',
2395              'coerce',
2396              'type',
2397              'describe',
2398              'desc',
2399              'description',
2400              'alias',
2401          ];
2402          opts = objFilter(opts, (k, v) => {
2403              let accept = supportedOpts.indexOf(k) !== -1;
2404              if (k === 'type' && ['string', 'number', 'boolean'].indexOf(v) === -1)
2405                  accept = false;
2406              return accept;
2407          });
2408          const fullCommand = context.fullCommands[context.fullCommands.length - 1];
2409          const parseOptions = fullCommand
2410              ? command$1.cmdToParseOptions(fullCommand)
2411              : {
2412                  array: [],
2413                  alias: {},
2414                  default: {},
2415                  demand: {},
2416              };
2417          objectKeys(parseOptions).forEach(pk => {
2418              const parseOption = parseOptions[pk];
2419              if (Array.isArray(parseOption)) {
2420                  if (parseOption.indexOf(key) !== -1)
2421                      opts[pk] = true;
2422              }
2423              else {
2424                  if (parseOption[key] && !(pk in opts))
2425                      opts[pk] = parseOption[key];
2426              }
2427          });
2428          self.group(key, usage$1.getPositionalGroupName());
2429          return self.option(key, opts);
2430      };
2431      self.group = function group(opts, groupName) {
2432          argsert('<string|array> <string>', [opts, groupName], arguments.length);
2433          const existing = preservedGroups[groupName] || groups[groupName];
2434          if (preservedGroups[groupName]) {
2435              delete preservedGroups[groupName];
2436          }
2437          const seen = {};
2438          groups[groupName] = (existing || []).concat(opts).filter(key => {
2439              if (seen[key])
2440                  return false;
2441              return (seen[key] = true);
2442          });
2443          return self;
2444      };
2445      self.getGroups = () => Object.assign({}, groups, preservedGroups);
2446      self.env = function (prefix) {
2447          argsert('[string|boolean]', [prefix], arguments.length);
2448          if (prefix === false)
2449              delete options.envPrefix;
2450          else
2451              options.envPrefix = prefix || '';
2452          return self;
2453      };
2454      self.wrap = function (cols) {
2455          argsert('<number|null|undefined>', [cols], arguments.length);
2456          usage$1.wrap(cols);
2457          return self;
2458      };
2459      let strict = false;
2460      self.strict = function (enabled) {
2461          argsert('[boolean]', [enabled], arguments.length);
2462          strict = enabled !== false;
2463          return self;
2464      };
2465      self.getStrict = () => strict;
2466      let strictCommands = false;
2467      self.strictCommands = function (enabled) {
2468          argsert('[boolean]', [enabled], arguments.length);
2469          strictCommands = enabled !== false;
2470          return self;
2471      };
2472      self.getStrictCommands = () => strictCommands;
2473      let strictOptions = false;
2474      self.strictOptions = function (enabled) {
2475          argsert('[boolean]', [enabled], arguments.length);
2476          strictOptions = enabled !== false;
2477          return self;
2478      };
2479      self.getStrictOptions = () => strictOptions;
2480      let parserConfig = {};
2481      self.parserConfiguration = function parserConfiguration(config) {
2482          argsert('<object>', [config], arguments.length);
2483          parserConfig = config;
2484          return self;
2485      };
2486      self.getParserConfiguration = () => parserConfig;
2487      self.showHelp = function (level) {
2488          argsert('[string|function]', [level], arguments.length);
2489          if (!self.parsed)
2490              self._parseArgs(processArgs);
2491          if (command$1.hasDefaultCommand()) {
2492              context.resets++;
2493              command$1.runDefaultBuilderOn(self);
2494          }
2495          usage$1.showHelp(level);
2496          return self;
2497      };
2498      let versionOpt = null;
2499      self.version = function version(opt, msg, ver) {
2500          const defaultVersionOpt = 'version';
2501          argsert('[boolean|string] [string] [string]', [opt, msg, ver], arguments.length);
2502          if (versionOpt) {
2503              deleteFromParserHintObject(versionOpt);
2504              usage$1.version(undefined);
2505              versionOpt = null;
2506          }
2507          if (arguments.length === 0) {
2508              ver = guessVersion();
2509              opt = defaultVersionOpt;
2510          }
2511          else if (arguments.length === 1) {
2512              if (opt === false) {
2513                  return self;
2514              }
2515              ver = opt;
2516              opt = defaultVersionOpt;
2517          }
2518          else if (arguments.length === 2) {
2519              ver = msg;
2520              msg = undefined;
2521          }
2522          versionOpt = typeof opt === 'string' ? opt : defaultVersionOpt;
2523          msg = msg || usage$1.deferY18nLookup('Show version number');
2524          usage$1.version(ver || undefined);
2525          self.boolean(versionOpt);
2526          self.describe(versionOpt, msg);
2527          return self;
2528      };
2529      function guessVersion() {
2530          const obj = pkgUp();
2531          return obj.version || 'unknown';
2532      }
2533      let helpOpt = null;
2534      self.addHelpOpt = self.help = function addHelpOpt(opt, msg) {
2535          const defaultHelpOpt = 'help';
2536          argsert('[string|boolean] [string]', [opt, msg], arguments.length);
2537          if (helpOpt) {
2538              deleteFromParserHintObject(helpOpt);
2539              helpOpt = null;
2540          }
2541          if (arguments.length === 1) {
2542              if (opt === false)
2543                  return self;
2544          }
2545          helpOpt = typeof opt === 'string' ? opt : defaultHelpOpt;
2546          self.boolean(helpOpt);
2547          self.describe(helpOpt, msg || usage$1.deferY18nLookup('Show help'));
2548          return self;
2549      };
2550      const defaultShowHiddenOpt = 'show-hidden';
2551      options.showHiddenOpt = defaultShowHiddenOpt;
2552      self.addShowHiddenOpt = self.showHidden = function addShowHiddenOpt(opt, msg) {
2553          argsert('[string|boolean] [string]', [opt, msg], arguments.length);
2554          if (arguments.length === 1) {
2555              if (opt === false)
2556                  return self;
2557          }
2558          const showHiddenOpt = typeof opt === 'string' ? opt : defaultShowHiddenOpt;
2559          self.boolean(showHiddenOpt);
2560          self.describe(showHiddenOpt, msg || usage$1.deferY18nLookup('Show hidden options'));
2561          options.showHiddenOpt = showHiddenOpt;
2562          return self;
2563      };
2564      self.hide = function hide(key) {
2565          argsert('<string>', [key], arguments.length);
2566          options.hiddenOptions.push(key);
2567          return self;
2568      };
2569      self.showHelpOnFail = function showHelpOnFail(enabled, message) {
2570          argsert('[boolean|string] [string]', [enabled, message], arguments.length);
2571          usage$1.showHelpOnFail(enabled, message);
2572          return self;
2573      };
2574      let exitProcess = true;
2575      self.exitProcess = function (enabled = true) {
2576          argsert('[boolean]', [enabled], arguments.length);
2577          exitProcess = enabled;
2578          return self;
2579      };
2580      self.getExitProcess = () => exitProcess;
2581      self.showCompletionScript = function ($0, cmd) {
2582          argsert('[string] [string]', [$0, cmd], arguments.length);
2583          $0 = $0 || self.$0;
2584          _logger.log(completion$1.generateCompletionScript($0, cmd || completionCommand || 'completion'));
2585          return self;
2586      };
2587      self.getCompletion = function (args, done) {
2588          argsert('<array> <function>', [args, done], arguments.length);
2589          completion$1.getCompletion(args, done);
2590      };
2591      self.locale = function (locale) {
2592          argsert('[string]', [locale], arguments.length);
2593          if (!locale) {
2594              guessLocale();
2595              return y18n.getLocale();
2596          }
2597          detectLocale = false;
2598          y18n.setLocale(locale);
2599          return self;
2600      };
2601      self.updateStrings = self.updateLocale = function (obj) {
2602          argsert('<object>', [obj], arguments.length);
2603          detectLocale = false;
2604          y18n.updateLocale(obj);
2605          return self;
2606      };
2607      let detectLocale = true;
2608      self.detectLocale = function (detect) {
2609          argsert('<boolean>', [detect], arguments.length);
2610          detectLocale = detect;
2611          return self;
2612      };
2613      self.getDetectLocale = () => detectLocale;
2614      const _logger = {
2615          log(...args) {
2616              if (!self._hasParseCallback())
2617                  console.log(...args);
2618              hasOutput = true;
2619              if (output.length)
2620                  output += '\n';
2621              output += args.join(' ');
2622          },
2623          error(...args) {
2624              if (!self._hasParseCallback())
2625                  console.error(...args);
2626              hasOutput = true;
2627              if (output.length)
2628                  output += '\n';
2629              output += args.join(' ');
2630          },
2631      };
2632      self._getLoggerInstance = () => _logger;
2633      self._hasOutput = () => hasOutput;
2634      self._setHasOutput = () => {
2635          hasOutput = true;
2636      };
2637      let recommendCommands;
2638      self.recommendCommands = function (recommend = true) {
2639          argsert('[boolean]', [recommend], arguments.length);
2640          recommendCommands = recommend;
2641          return self;
2642      };
2643      self.getUsageInstance = () => usage$1;
2644      self.getValidationInstance = () => validation$1;
2645      self.getCommandInstance = () => command$1;
2646      self.terminalWidth = () => {
2647          argsert([], 0);
2648          return shim$1.process.stdColumns;
2649      };
2650      Object.defineProperty(self, 'argv', {
2651          get: () => self._parseArgs(processArgs),
2652          enumerable: true,
2653      });
2654      self._parseArgs = function parseArgs(args, shortCircuit, _calledFromCommand, commandIndex) {
2655          let skipValidation = !!_calledFromCommand;
2656          args = args || processArgs;
2657          options.__ = y18n.__;
2658          options.configuration = self.getParserConfiguration();
2659          const populateDoubleDash = !!options.configuration['populate--'];
2660          const config = Object.assign({}, options.configuration, {
2661              'populate--': true,
2662          });
2663          const parsed = shim$1.Parser.detailed(args, Object.assign({}, options, {
2664              configuration: Object.assign({ 'parse-positional-numbers': false }, config),
2665          }));
2666          let argv = parsed.argv;
2667          if (parseContext)
2668              argv = Object.assign({}, argv, parseContext);
2669          const aliases = parsed.aliases;
2670          argv.$0 = self.$0;
2671          self.parsed = parsed;
2672          try {
2673              guessLocale();
2674              if (shortCircuit) {
2675                  return self._postProcess(argv, populateDoubleDash, _calledFromCommand);
2676              }
2677              if (helpOpt) {
2678                  const helpCmds = [helpOpt]
2679                      .concat(aliases[helpOpt] || [])
2680                      .filter(k => k.length > 1);
2681                  if (~helpCmds.indexOf('' + argv._[argv._.length - 1])) {
2682                      argv._.pop();
2683                      argv[helpOpt] = true;
2684                  }
2685              }
2686              const handlerKeys = command$1.getCommands();
2687              const requestCompletions = completion$1.completionKey in argv;
2688              const skipRecommendation = argv[helpOpt] || requestCompletions;
2689              const skipDefaultCommand = skipRecommendation &&
2690                  (handlerKeys.length > 1 || handlerKeys[0] !== '$0');
2691              if (argv._.length) {
2692                  if (handlerKeys.length) {
2693                      let firstUnknownCommand;
2694                      for (let i = commandIndex || 0, cmd; argv._[i] !== undefined; i++) {
2695                          cmd = String(argv._[i]);
2696                          if (~handlerKeys.indexOf(cmd) && cmd !== completionCommand) {
2697                              const innerArgv = command$1.runCommand(cmd, self, parsed, i + 1);
2698                              return self._postProcess(innerArgv, populateDoubleDash);
2699                          }
2700                          else if (!firstUnknownCommand && cmd !== completionCommand) {
2701                              firstUnknownCommand = cmd;
2702                              break;
2703                          }
2704                      }
2705                      if (command$1.hasDefaultCommand() && !skipDefaultCommand) {
2706                          const innerArgv = command$1.runCommand(null, self, parsed);
2707                          return self._postProcess(innerArgv, populateDoubleDash);
2708                      }
2709                      if (recommendCommands && firstUnknownCommand && !skipRecommendation) {
2710                          validation$1.recommendCommands(firstUnknownCommand, handlerKeys);
2711                      }
2712                  }
2713                  if (completionCommand &&
2714                      ~argv._.indexOf(completionCommand) &&
2715                      !requestCompletions) {
2716                      if (exitProcess)
2717                          setBlocking(true);
2718                      self.showCompletionScript();
2719                      self.exit(0);
2720                  }
2721              }
2722              else if (command$1.hasDefaultCommand() && !skipDefaultCommand) {
2723                  const innerArgv = command$1.runCommand(null, self, parsed);
2724                  return self._postProcess(innerArgv, populateDoubleDash);
2725              }
2726              if (requestCompletions) {
2727                  if (exitProcess)
2728                      setBlocking(true);
2729                  args = [].concat(args);
2730                  const completionArgs = args.slice(args.indexOf(`--${completion$1.completionKey}`) + 1);
2731                  completion$1.getCompletion(completionArgs, completions => {
2732                      (completions || []).forEach(completion => {
2733                          _logger.log(completion);
2734                      });
2735                      self.exit(0);
2736                  });
2737                  return self._postProcess(argv, !populateDoubleDash, _calledFromCommand);
2738              }
2739              if (!hasOutput) {
2740                  Object.keys(argv).forEach(key => {
2741                      if (key === helpOpt && argv[key]) {
2742                          if (exitProcess)
2743                              setBlocking(true);
2744                          skipValidation = true;
2745                          self.showHelp('log');
2746                          self.exit(0);
2747                      }
2748                      else if (key === versionOpt && argv[key]) {
2749                          if (exitProcess)
2750                              setBlocking(true);
2751                          skipValidation = true;
2752                          usage$1.showVersion();
2753                          self.exit(0);
2754                      }
2755                  });
2756              }
2757              if (!skipValidation && options.skipValidation.length > 0) {
2758                  skipValidation = Object.keys(argv).some(key => options.skipValidation.indexOf(key) >= 0 && argv[key] === true);
2759              }
2760              if (!skipValidation) {
2761                  if (parsed.error)
2762                      throw new YError(parsed.error.message);
2763                  if (!requestCompletions) {
2764                      self._runValidation(argv, aliases, {}, parsed.error);
2765                  }
2766              }
2767          }
2768          catch (err) {
2769              if (err instanceof YError)
2770                  usage$1.fail(err.message, err);
2771              else
2772                  throw err;
2773          }
2774          return self._postProcess(argv, populateDoubleDash, _calledFromCommand);
2775      };
2776      self._postProcess = function (argv, populateDoubleDash, calledFromCommand = false) {
2777          if (isPromise(argv))
2778              return argv;
2779          if (calledFromCommand)
2780              return argv;
2781          if (!populateDoubleDash) {
2782              argv = self._copyDoubleDash(argv);
2783          }
2784          const parsePositionalNumbers = self.getParserConfiguration()['parse-positional-numbers'] ||
2785              self.getParserConfiguration()['parse-positional-numbers'] === undefined;
2786          if (parsePositionalNumbers) {
2787              argv = self._parsePositionalNumbers(argv);
2788          }
2789          return argv;
2790      };
2791      self._copyDoubleDash = function (argv) {
2792          if (!argv._ || !argv['--'])
2793              return argv;
2794          argv._.push.apply(argv._, argv['--']);
2795          try {
2796              delete argv['--'];
2797          }
2798          catch (_err) { }
2799          return argv;
2800      };
2801      self._parsePositionalNumbers = function (argv) {
2802          const args = argv['--'] ? argv['--'] : argv._;
2803          for (let i = 0, arg; (arg = args[i]) !== undefined; i++) {
2804              if (shim$1.Parser.looksLikeNumber(arg) &&
2805                  Number.isSafeInteger(Math.floor(parseFloat(`${arg}`)))) {
2806                  args[i] = Number(arg);
2807              }
2808          }
2809          return argv;
2810      };
2811      self._runValidation = function runValidation(argv, aliases, positionalMap, parseErrors, isDefaultCommand = false) {
2812          if (parseErrors)
2813              throw new YError(parseErrors.message);
2814          validation$1.nonOptionCount(argv);
2815          validation$1.requiredArguments(argv);
2816          let failedStrictCommands = false;
2817          if (strictCommands) {
2818              failedStrictCommands = validation$1.unknownCommands(argv);
2819          }
2820          if (strict && !failedStrictCommands) {
2821              validation$1.unknownArguments(argv, aliases, positionalMap, isDefaultCommand);
2822          }
2823          else if (strictOptions) {
2824              validation$1.unknownArguments(argv, aliases, {}, false, false);
2825          }
2826          validation$1.customChecks(argv, aliases);
2827          validation$1.limitedChoices(argv);
2828          validation$1.implications(argv);
2829          validation$1.conflicting(argv);
2830      };
2831      function guessLocale() {
2832          if (!detectLocale)
2833              return;
2834          const locale = shim$1.getEnv('LC_ALL') ||
2835              shim$1.getEnv('LC_MESSAGES') ||
2836              shim$1.getEnv('LANG') ||
2837              shim$1.getEnv('LANGUAGE') ||
2838              'en_US';
2839          self.locale(locale.replace(/[.:].*/, ''));
2840      }
2841      self.help();
2842      self.version();
2843      return self;
2844  }
2845  const rebase = (base, dir) => shim$1.path.relative(base, dir);
2846  function isYargsInstance(y) {
2847      return !!y && typeof y._parseArgs === 'function';
2848  }
2849  
2850  var _a, _b;
2851  const { readFileSync } = require('fs');
2852  const { inspect } = require('util');
2853  const { resolve } = require('path');
2854  const y18n = require('y18n');
2855  const Parser = require('yargs-parser');
2856  var cjsPlatformShim = {
2857      assert: {
2858          notStrictEqual: assert.notStrictEqual,
2859          strictEqual: assert.strictEqual,
2860      },
2861      cliui: require('cliui'),
2862      findUp: require('escalade/sync'),
2863      getEnv: (key) => {
2864          return process.env[key];
2865      },
2866      getCallerFile: require('get-caller-file'),
2867      getProcessArgvBin: getProcessArgvBin,
2868      inspect,
2869      mainFilename: (_b = (_a = require === null || require === void 0 ? void 0 : require.main) === null || _a === void 0 ? void 0 : _a.filename) !== null && _b !== void 0 ? _b : process.cwd(),
2870      Parser,
2871      path: require('path'),
2872      process: {
2873          argv: () => process.argv,
2874          cwd: process.cwd,
2875          execPath: () => process.execPath,
2876          exit: (code) => {
2877              process.exit(code);
2878          },
2879          nextTick: process.nextTick,
2880          stdColumns: typeof process.stdout.columns !== 'undefined'
2881              ? process.stdout.columns
2882              : null,
2883      },
2884      readFileSync,
2885      require: require,
2886      requireDirectory: require('require-directory'),
2887      stringWidth: require('string-width'),
2888      y18n: y18n({
2889          directory: resolve(__dirname, '../locales'),
2890          updateFiles: false,
2891      }),
2892  };
2893  
2894  const minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION
2895      ? Number(process.env.YARGS_MIN_NODE_VERSION)
2896      : 10;
2897  if (process && process.version) {
2898      const major = Number(process.version.match(/v([^.]+)/)[1]);
2899      if (major < minNodeVersion) {
2900          throw Error(`yargs supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs#supported-nodejs-versions`);
2901      }
2902  }
2903  const Parser$1 = require('yargs-parser');
2904  const Yargs$1 = YargsWithShim(cjsPlatformShim);
2905  var cjs = {
2906      applyExtends,
2907      cjsPlatformShim,
2908      Yargs: Yargs$1,
2909      argsert,
2910      globalMiddlewareFactory,
2911      isPromise,
2912      objFilter,
2913      parseCommand,
2914      Parser: Parser$1,
2915      processArgv,
2916      rebase,
2917      YError,
2918  };
2919  
2920  module.exports = cjs;