typescript-language-server 4.3.2 → 4.3.4

package/lib/cli.mjs

@@ -55,15 +55,13 @@ function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var commander$1 = {
-  exports: {}
-};
+var commander = {};
 
 var argument = {};
 
 var error$2 = {};
 
-let CommanderError$2 = class CommanderError extends Error {
+let CommanderError$3 = class CommanderError extends Error {
   constructor(exitCode, code, message) {
     super(message);
     Error.captureStackTrace(this, this.constructor);
@@ -74,7 +72,7 @@ let CommanderError$2 = class CommanderError extends Error {
   }
 };
 
-let InvalidArgumentError$3 = class InvalidArgumentError extends CommanderError$2 {
+let InvalidArgumentError$4 = class InvalidArgumentError extends CommanderError$3 {
   constructor(message) {
     super(1, 'commander.invalidArgument', message);
     Error.captureStackTrace(this, this.constructor);
@@ -82,13 +80,13 @@ let InvalidArgumentError$3 = class InvalidArgumentError extends CommanderError$2
   }
 };
 
-error$2.CommanderError = CommanderError$2;
+error$2.CommanderError = CommanderError$3;
 
-error$2.InvalidArgumentError = InvalidArgumentError$3;
+error$2.InvalidArgumentError = InvalidArgumentError$4;
 
-const {InvalidArgumentError: InvalidArgumentError$2} = error$2;
+const {InvalidArgumentError: InvalidArgumentError$3} = error$2;
 
-let Argument$2 = class Argument {
+let Argument$3 = class Argument {
   constructor(name, description) {
     this.description = description || '';
     this.variadic = false;
@@ -139,7 +137,7 @@ let Argument$2 = class Argument {
     this.argChoices = values.slice();
     this.parseArg = (arg, previous) => {
       if (!this.argChoices.includes(arg)) {
-        throw new InvalidArgumentError$2(`Allowed choices are ${this.argChoices.join(', ')}.`);
+        throw new InvalidArgumentError$3(`Allowed choices are ${this.argChoices.join(', ')}.`);
       }
       if (this.variadic) {
         return this._concatValue(arg, previous);
@@ -163,7 +161,7 @@ function humanReadableArgName$2(arg) {
   return arg.required ? '<' + nameOutput + '>' : '[' + nameOutput + ']';
 }
 
-argument.Argument = Argument$2;
+argument.Argument = Argument$3;
 
 argument.humanReadableArgName = humanReadableArgName$2;
 
@@ -173,7 +171,7 @@ var help = {};
 
 const {humanReadableArgName: humanReadableArgName$1} = argument;
 
-let Help$2 = class Help {
+let Help$3 = class Help {
   constructor() {
     this.helpWidth = undefined;
     this.sortSubcommands = false;
@@ -182,11 +180,8 @@ let Help$2 = class Help {
   }
   visibleCommands(cmd) {
     const visibleCommands = cmd.commands.filter((cmd => !cmd._hidden));
-    if (cmd._hasImplicitHelpCommand()) {
-      const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
-      const helpCommand = cmd.createCommand(helpName).helpOption(false);
-      helpCommand.description(cmd._helpCommandDescription);
-      if (helpArgs) helpCommand.arguments(helpArgs);
+    const helpCommand = cmd._getHelpCommand();
+    if (helpCommand && !helpCommand._hidden) {
       visibleCommands.push(helpCommand);
     }
     if (this.sortSubcommands) {
@@ -200,18 +195,17 @@ let Help$2 = class Help {
   }
   visibleOptions(cmd) {
     const visibleOptions = cmd.options.filter((option => !option.hidden));
-    const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
-    const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
-    if (showShortHelpFlag || showLongHelpFlag) {
-      let helpOption;
-      if (!showShortHelpFlag) {
-        helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
-      } else if (!showLongHelpFlag) {
-        helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
-      } else {
-        helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
+    const helpOption = cmd._getHelpOption();
+    if (helpOption && !helpOption.hidden) {
+      const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+      const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+      if (!removeShort && !removeLong) {
+        visibleOptions.push(helpOption);
+      } else if (helpOption.long && !removeLong) {
+        visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
+      } else if (helpOption.short && !removeShort) {
+        visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
       }
-      visibleOptions.push(helpOption);
     }
     if (this.sortOptions) {
       visibleOptions.sort(this.compareOptions);
@@ -382,13 +376,13 @@ let Help$2 = class Help {
   }
 };
 
-help.Help = Help$2;
+help.Help = Help$3;
 
 var option = {};
 
-const {InvalidArgumentError: InvalidArgumentError$1} = error$2;
+const {InvalidArgumentError: InvalidArgumentError$2} = error$2;
 
-let Option$2 = class Option {
+let Option$3 = class Option {
   constructor(flags, description) {
     this.flags = flags;
     this.description = description || '';
@@ -396,7 +390,7 @@ let Option$2 = class Option {
     this.optional = flags.includes('[');
     this.variadic = /\w\.\.\.[>\]]$/.test(flags);
     this.mandatory = false;
-    const optionFlags = splitOptionFlags$1(flags);
+    const optionFlags = splitOptionFlags(flags);
     this.short = optionFlags.shortFlag;
     this.long = optionFlags.longFlag;
     this.negate = false;
@@ -462,7 +456,7 @@ let Option$2 = class Option {
     this.argChoices = values.slice();
     this.parseArg = (arg, previous) => {
       if (!this.argChoices.includes(arg)) {
-        throw new InvalidArgumentError$1(`Allowed choices are ${this.argChoices.join(', ')}.`);
+        throw new InvalidArgumentError$2(`Allowed choices are ${this.argChoices.join(', ')}.`);
       }
       if (this.variadic) {
         return this._concatValue(arg, previous);
@@ -519,7 +513,7 @@ function camelcase(str) {
   return str.split('-').reduce(((str, word) => str + word[0].toUpperCase() + word.slice(1)));
 }
 
-function splitOptionFlags$1(flags) {
+function splitOptionFlags(flags) {
   let shortFlag;
   let longFlag;
   const flagParts = flags.split(/[ |,]+/);
@@ -535,9 +529,7 @@ function splitOptionFlags$1(flags) {
   };
 }
 
-option.Option = Option$2;
-
-option.splitOptionFlags = splitOptionFlags$1;
+option.Option = Option$3;
 
 option.DualOptions = DualOptions$1;
 
@@ -621,17 +613,17 @@ const fs$k = require$$0$1;
 
 const process$1 = require$$4;
 
-const {Argument: Argument$1, humanReadableArgName: humanReadableArgName} = argument;
+const {Argument: Argument$2, humanReadableArgName: humanReadableArgName} = argument;
 
-const {CommanderError: CommanderError$1} = error$2;
+const {CommanderError: CommanderError$2} = error$2;
 
-const {Help: Help$1} = help;
+const {Help: Help$2} = help;
 
-const {Option: Option$1, splitOptionFlags: splitOptionFlags, DualOptions: DualOptions} = option;
+const {Option: Option$2, DualOptions: DualOptions} = option;
 
 const {suggestSimilar: suggestSimilar} = suggestSimilar$2;
 
-let Command$1 = class Command extends EventEmitter {
+let Command$2 = class Command extends EventEmitter {
   constructor(name) {
     super();
     this.commands = [];
@@ -673,27 +665,15 @@ let Command$1 = class Command extends EventEmitter {
       outputError: (str, write) => write(str)
     };
     this._hidden = false;
-    this._hasHelpOption = true;
-    this._helpFlags = '-h, --help';
-    this._helpDescription = 'display help for command';
-    this._helpShortFlag = '-h';
-    this._helpLongFlag = '--help';
+    this._helpOption = undefined;
     this._addImplicitHelpCommand = undefined;
-    this._helpCommandName = 'help';
-    this._helpCommandnameAndArgs = 'help [command]';
-    this._helpCommandDescription = 'display help for command';
+    this._helpCommand = undefined;
     this._helpConfiguration = {};
   }
   copyInheritedSettings(sourceCommand) {
     this._outputConfiguration = sourceCommand._outputConfiguration;
-    this._hasHelpOption = sourceCommand._hasHelpOption;
-    this._helpFlags = sourceCommand._helpFlags;
-    this._helpDescription = sourceCommand._helpDescription;
-    this._helpShortFlag = sourceCommand._helpShortFlag;
-    this._helpLongFlag = sourceCommand._helpLongFlag;
-    this._helpCommandName = sourceCommand._helpCommandName;
-    this._helpCommandnameAndArgs = sourceCommand._helpCommandnameAndArgs;
-    this._helpCommandDescription = sourceCommand._helpCommandDescription;
+    this._helpOption = sourceCommand._helpOption;
+    this._helpCommand = sourceCommand._helpCommand;
     this._helpConfiguration = sourceCommand._helpConfiguration;
     this._exitCallback = sourceCommand._exitCallback;
     this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
@@ -729,7 +709,7 @@ let Command$1 = class Command extends EventEmitter {
     cmd._hidden = !!(opts.noHelp || opts.hidden);
     cmd._executableFile = opts.executableFile || null;
     if (args) cmd.arguments(args);
-    this.commands.push(cmd);
+    this._registerCommand(cmd);
     cmd.parent = this;
     cmd.copyInheritedSettings(this);
     if (desc) return this;
@@ -739,7 +719,7 @@ let Command$1 = class Command extends EventEmitter {
     return new Command(name);
   }
   createHelp() {
-    return Object.assign(new Help$1, this.configureHelp());
+    return Object.assign(new Help$2, this.configureHelp());
   }
   configureHelp(configuration) {
     if (configuration === undefined) return this._helpConfiguration;
@@ -767,12 +747,13 @@ let Command$1 = class Command extends EventEmitter {
     opts = opts || {};
     if (opts.isDefault) this._defaultCommandName = cmd._name;
     if (opts.noHelp || opts.hidden) cmd._hidden = true;
-    this.commands.push(cmd);
+    this._registerCommand(cmd);
     cmd.parent = this;
+    cmd._checkForBrokenPassThrough();
     return this;
   }
   createArgument(name, description) {
-    return new Argument$1(name, description);
+    return new Argument$2(name, description);
   }
   argument(name, description, fn, defaultValue) {
     const argument = this.createArgument(name, description);
@@ -801,24 +782,40 @@ let Command$1 = class Command extends EventEmitter {
     this.registeredArguments.push(argument);
     return this;
   }
-  addHelpCommand(enableOrNameAndArgs, description) {
-    if (enableOrNameAndArgs === false) {
-      this._addImplicitHelpCommand = false;
-    } else {
-      this._addImplicitHelpCommand = true;
-      if (typeof enableOrNameAndArgs === 'string') {
-        this._helpCommandName = enableOrNameAndArgs.split(' ')[0];
-        this._helpCommandnameAndArgs = enableOrNameAndArgs;
-      }
-      this._helpCommandDescription = description || this._helpCommandDescription;
+  helpCommand(enableOrNameAndArgs, description) {
+    if (typeof enableOrNameAndArgs === 'boolean') {
+      this._addImplicitHelpCommand = enableOrNameAndArgs;
+      return this;
     }
+    enableOrNameAndArgs = enableOrNameAndArgs ?? 'help [command]';
+    const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
+    const helpDescription = description ?? 'display help for command';
+    const helpCommand = this.createCommand(helpName);
+    helpCommand.helpOption(false);
+    if (helpArgs) helpCommand.arguments(helpArgs);
+    if (helpDescription) helpCommand.description(helpDescription);
+    this._addImplicitHelpCommand = true;
+    this._helpCommand = helpCommand;
     return this;
   }
-  _hasImplicitHelpCommand() {
-    if (this._addImplicitHelpCommand === undefined) {
-      return this.commands.length && !this._actionHandler && !this._findCommand('help');
+  addHelpCommand(helpCommand, deprecatedDescription) {
+    if (typeof helpCommand !== 'object') {
+      this.helpCommand(helpCommand, deprecatedDescription);
+      return this;
     }
-    return this._addImplicitHelpCommand;
+    this._addImplicitHelpCommand = true;
+    this._helpCommand = helpCommand;
+    return this;
+  }
+  _getHelpCommand() {
+    const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand('help'));
+    if (hasImplicitHelpCommand) {
+      if (this._helpCommand === undefined) {
+        this.helpCommand(undefined, undefined);
+      }
+      return this._helpCommand;
+    }
+    return null;
   }
   hook(event, listener) {
     const allowedValues = [ 'preSubcommand', 'preAction', 'postAction' ];
@@ -846,7 +843,7 @@ let Command$1 = class Command extends EventEmitter {
   }
   _exit(exitCode, code, message) {
     if (this._exitCallback) {
-      this._exitCallback(new CommanderError$1(exitCode, code, message));
+      this._exitCallback(new CommanderError$2(exitCode, code, message));
     }
     process$1.exit(exitCode);
   }
@@ -866,7 +863,7 @@ let Command$1 = class Command extends EventEmitter {
     return this;
   }
   createOption(flags, description) {
-    return new Option$1(flags, description);
+    return new Option$2(flags, description);
   }
   _callParseArg(target, value, previous, invalidArgumentMessage) {
     try {
@@ -882,7 +879,26 @@ let Command$1 = class Command extends EventEmitter {
       throw err;
     }
   }
+  _registerOption(option) {
+    const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
+    if (matchingOption) {
+      const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
+      throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'\n-  already used by option '${matchingOption.flags}'`);
+    }
+    this.options.push(option);
+  }
+  _registerCommand(command) {
+    const knownBy = cmd => [ cmd.name() ].concat(cmd.aliases());
+    const alreadyUsed = knownBy(command).find((name => this._findCommand(name)));
+    if (alreadyUsed) {
+      const existingCmd = knownBy(this._findCommand(alreadyUsed)).join('|');
+      const newCmd = knownBy(command).join('|');
+      throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
+    }
+    this.commands.push(command);
+  }
   addOption(option) {
+    this._registerOption(option);
     const oname = option.name();
     const name = option.attributeName();
     if (option.negate) {
@@ -893,7 +909,6 @@ let Command$1 = class Command extends EventEmitter {
     } else if (option.defaultValue !== undefined) {
       this.setOptionValueWithSource(name, option.defaultValue, 'default');
     }
-    this.options.push(option);
     const handleOptionValue = (val, invalidValueMessage, valueSource) => {
       if (val == null && option.presetArg !== undefined) {
         val = option.presetArg;
@@ -928,7 +943,7 @@ let Command$1 = class Command extends EventEmitter {
     return this;
   }
   _optionEx(config, flags, description, fn, defaultValue) {
-    if (typeof flags === 'object' && flags instanceof Option$1) {
+    if (typeof flags === 'object' && flags instanceof Option$2) {
       throw new Error('To add an Option object use addOption() instead of option() or requiredOption()');
     }
     const option = this.createOption(flags, description);
@@ -973,15 +988,21 @@ let Command$1 = class Command extends EventEmitter {
   }
   passThroughOptions(passThrough = true) {
     this._passThroughOptions = !!passThrough;
-    if (!!this.parent && passThrough && !this.parent._enablePositionalOptions) {
-      throw new Error('passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)');
-    }
+    this._checkForBrokenPassThrough();
     return this;
   }
+  _checkForBrokenPassThrough() {
+    if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
+      throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
+    }
+  }
   storeOptionsAsProperties(storeAsProperties = true) {
     if (this.options.length) {
       throw new Error('call .storeOptionsAsProperties() before adding options');
     }
+    if (Object.keys(this._optionValues).length) {
+      throw new Error('call .storeOptionsAsProperties() before setting option values');
+    }
     this._storeOptionsAsProperties = !!storeAsProperties;
     return this;
   }
@@ -1132,13 +1153,14 @@ let Command$1 = class Command extends EventEmitter {
       }));
     }
     const exitCallback = this._exitCallback;
-    if (!exitCallback) {
-      proc.on('close', process$1.exit.bind(process$1));
-    } else {
-      proc.on('close', (() => {
-        exitCallback(new CommanderError$1(process$1.exitCode || 0, 'commander.executeSubCommandAsync', '(close)'));
-      }));
-    }
+    proc.on('close', ((code, _signal) => {
+      code = code ?? 1;
+      if (!exitCallback) {
+        process$1.exit(code);
+      } else {
+        exitCallback(new CommanderError$2(code, 'commander.executeSubCommandAsync', '(close)'));
+      }
+    }));
     proc.on('error', (err => {
       if (err.code === 'ENOENT') {
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';
@@ -1150,7 +1172,7 @@ let Command$1 = class Command extends EventEmitter {
       if (!exitCallback) {
         process$1.exit(1);
       } else {
-        const wrappedError = new CommanderError$1(1, 'commander.executeSubCommandAsync', '(error)');
+        const wrappedError = new CommanderError$2(1, 'commander.executeSubCommandAsync', '(error)');
         wrappedError.nestedError = err;
         exitCallback(wrappedError);
       }
@@ -1181,7 +1203,7 @@ let Command$1 = class Command extends EventEmitter {
     if (subCommand && !subCommand._executableHandler) {
       subCommand.help();
     }
-    return this._dispatchSubcommand(subcommandName, [], [ this._helpLongFlag || this._helpShortFlag ]);
+    return this._dispatchSubcommand(subcommandName, [], [ this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? '--help' ]);
   }
   _checkNumberOfArguments() {
     this.registeredArguments.forEach(((arg, i) => {
@@ -1272,11 +1294,11 @@ let Command$1 = class Command extends EventEmitter {
     if (operands && this._findCommand(operands[0])) {
       return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
     }
-    if (this._hasImplicitHelpCommand() && operands[0] === this._helpCommandName) {
+    if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
       return this._dispatchHelpCommand(operands[1]);
     }
     if (this._defaultCommandName) {
-      outputHelpIfRequested(this, unknown);
+      this._outputHelpIfRequested(unknown);
       return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
     }
     if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
@@ -1284,7 +1306,7 @@ let Command$1 = class Command extends EventEmitter {
         error: true
       });
     }
-    outputHelpIfRequested(this, parsed.unknown);
+    this._outputHelpIfRequested(parsed.unknown);
     this._checkForMissingMandatoryOptions();
     this._checkForConflictingOptions();
     const checkForUnknownOptions = () => {
@@ -1439,7 +1461,7 @@ let Command$1 = class Command extends EventEmitter {
           operands.push(arg);
           if (args.length > 0) unknown.push(...args);
           break;
-        } else if (arg === this._helpCommandName && this._hasImplicitHelpCommand()) {
+        } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
           operands.push(arg);
           if (args.length > 0) operands.push(...args);
           break;
@@ -1608,7 +1630,7 @@ let Command$1 = class Command extends EventEmitter {
     description = description || 'output the version number';
     const versionOption = this.createOption(flags, description);
     this._versionOptionName = versionOption.attributeName();
-    this.options.push(versionOption);
+    this._registerOption(versionOption);
     this.on('option:' + versionOption.name(), (() => {
       this._outputConfiguration.writeOut(`${str}\n`);
       this._exit(0, 'commander.version', str);
@@ -1635,6 +1657,11 @@ let Command$1 = class Command extends EventEmitter {
       command = this.commands[this.commands.length - 1];
     }
     if (alias === command._name) throw new Error('Command alias can\'t be the same as its name');
+    const matchingCommand = this.parent?._findCommand(alias);
+    if (matchingCommand) {
+      const existingCmd = [ matchingCommand.name() ].concat(matchingCommand.aliases()).join('|');
+      throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
+    }
     command._aliases.push(alias);
     return this;
   }
@@ -1647,7 +1674,7 @@ let Command$1 = class Command extends EventEmitter {
     if (str === undefined) {
       if (this._usage) return this._usage;
       const args = this.registeredArguments.map((arg => humanReadableArgName(arg)));
-      return [].concat(this.options.length || this._hasHelpOption ? '[options]' : [], this.commands.length ? '[command]' : [], this.registeredArguments.length ? args : []).join(' ');
+      return [].concat(this.options.length || this._helpOption !== null ? '[options]' : [], this.commands.length ? '[command]' : [], this.registeredArguments.length ? args : []).join(' ');
     }
     this._usage = str;
     return this;
@@ -1705,22 +1732,34 @@ let Command$1 = class Command extends EventEmitter {
       }
     }
     context.write(helpInformation);
-    if (this._helpLongFlag) {
-      this.emit(this._helpLongFlag);
+    if (this._getHelpOption()?.long) {
+      this.emit(this._getHelpOption().long);
     }
     this.emit('afterHelp', context);
     this._getCommandAndAncestors().forEach((command => command.emit('afterAllHelp', context)));
   }
   helpOption(flags, description) {
     if (typeof flags === 'boolean') {
-      this._hasHelpOption = flags;
+      if (flags) {
+        this._helpOption = this._helpOption ?? undefined;
+      } else {
+        this._helpOption = null;
+      }
       return this;
     }
-    this._helpFlags = flags || this._helpFlags;
-    this._helpDescription = description || this._helpDescription;
-    const helpFlags = splitOptionFlags(this._helpFlags);
-    this._helpShortFlag = helpFlags.shortFlag;
-    this._helpLongFlag = helpFlags.longFlag;
+    flags = flags ?? '-h, --help';
+    description = description ?? 'display help for command';
+    this._helpOption = this.createOption(flags, description);
+    return this;
+  }
+  _getHelpOption() {
+    if (this._helpOption === undefined) {
+      this.helpOption(undefined, undefined);
+    }
+    return this._helpOption;
+  }
+  addHelpOption(option) {
+    this._helpOption = option;
     return this;
   }
   help(contextOptions) {
@@ -1753,15 +1792,15 @@ let Command$1 = class Command extends EventEmitter {
     }));
     return this;
   }
-};
-
-function outputHelpIfRequested(cmd, args) {
-  const helpOption = cmd._hasHelpOption && args.find((arg => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag));
-  if (helpOption) {
-    cmd.outputHelp();
-    cmd._exit(0, 'commander.helpDisplayed', '(outputHelp)');
+  _outputHelpIfRequested(args) {
+    const helpOption = this._getHelpOption();
+    const helpRequested = helpOption && args.find((arg => helpOption.is(arg)));
+    if (helpRequested) {
+      this.outputHelp();
+      this._exit(0, 'commander.helpDisplayed', '(outputHelp)');
+    }
   }
-}
+};
 
 function incrementNodeInspectorPort(args) {
   return args.map((arg => {
@@ -1793,28 +1832,39 @@ function incrementNodeInspectorPort(args) {
   }));
 }
 
-command.Command = Command$1;
+command.Command = Command$2;
 
-(function(module, exports) {
-  const {Argument: Argument} = argument;
-  const {Command: Command} = command;
-  const {CommanderError: CommanderError, InvalidArgumentError: InvalidArgumentError} = error$2;
-  const {Help: Help} = help;
-  const {Option: Option} = option;
-  exports = module.exports = new Command;
-  exports.program = exports;
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-})(commander$1, commander$1.exports);
-
-var commanderExports = commander$1.exports;
-
-const commander = getDefaultExportFromCjs(commanderExports);
+const {Argument: Argument$1} = argument;
+
+const {Command: Command$1} = command;
+
+const {CommanderError: CommanderError$1, InvalidArgumentError: InvalidArgumentError$1} = error$2;
+
+const {Help: Help$1} = help;
+
+const {Option: Option$1} = option;
+
+commander.program = new Command$1;
+
+commander.createCommand = name => new Command$1(name);
+
+commander.createOption = (flags, description) => new Option$1(flags, description);
+
+commander.createArgument = (name, description) => new Argument$1(name, description);
+
+commander.Command = Command$1;
+
+commander.Option = Option$1;
+
+commander.Argument = Argument$1;
+
+commander.Help = Help$1;
+
+commander.CommanderError = CommanderError$1;
+
+commander.InvalidArgumentError = InvalidArgumentError$1;
+
+commander.InvalidOptionArgumentError = InvalidArgumentError$1;
 
 const {program: program$1, createCommand: createCommand, createArgument: createArgument, createOption: createOption, CommanderError: CommanderError, InvalidArgumentError: InvalidArgumentError, InvalidOptionArgumentError: InvalidOptionArgumentError, Command: Command, Argument: Argument, Option: Option, Help: Help} = commander;
 
@@ -14697,8 +14747,11 @@ var debug_1 = debug$1;
   createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);
   createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
   createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-  createToken('COERCE', `${'(^|[^\\d])' + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:$|[^\\d])`);
+  createToken('COERCEPLAIN', `${'(^|[^\\d])' + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+  createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+  createToken('COERCEFULL', src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?` + `(?:${src[t.BUILD]})?` + `(?:$|[^\\d])`);
   createToken('COERCERTL', src[t.COERCE], true);
+  createToken('COERCERTLFULL', src[t.COERCEFULL], true);
   createToken('LONETILDE', '(?:~>?)');
   createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
   exports.tildeTrimReplace = '$1~';
@@ -15282,21 +15335,27 @@ const coerce$1 = (version, options) => {
   options = options || {};
   let match = null;
   if (!options.rtl) {
-    match = version.match(re[t.COERCE]);
+    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
   } else {
+    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
     let next;
-    while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+    while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
       if (!match || next.index + next[0].length !== match.index + match[0].length) {
         match = next;
       }
-      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
     }
-    re[t.COERCERTL].lastIndex = -1;
+    coerceRtlRegex.lastIndex = -1;
   }
   if (match === null) {
     return null;
   }
-  return parse$1(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options);
+  const major = match[2];
+  const minor = match[3] || '0';
+  const patch = match[4] || '0';
+  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : '';
+  const build = options.includePrerelease && match[6] ? `+${match[6]}` : '';
+  return parse$1(`${major}.${minor}.${patch}${prerelease}${build}`, options);
 };
 
 var coerce_1 = coerce$1;
@@ -19595,6 +19654,9 @@ class FileDiagnostics {
     this.firePublishDiagnostics = pDebounce((() => this.publishDiagnostics()), 50);
   }
   update(kind, diagnostics) {
+    if (this.diagnosticsPerKind.get(kind)?.length === 0 && diagnostics.length === 0) {
+      return;
+    }
     this.diagnosticsPerKind.set(kind, diagnostics);
     this.firePublishDiagnostics();
   }
@@ -19794,7 +19856,7 @@ function getTagBodyText(tag, filePathConverter) {
     if (/^\s*[~`]{3}/m.test(text)) {
       return text;
     }
-    return '```\n' + text + '\n```';
+    return '```typescript\n' + text + '\n```';
   }
   const text = convertLinkTags(tag.text, filePathConverter);
   switch (tag.name) {