typescript-language-server 4.3.1 → 4.3.3

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;
+  }
+  addHelpCommand(helpCommand, deprecatedDescription) {
+    if (typeof helpCommand !== 'object') {
+      this.helpCommand(helpCommand, deprecatedDescription);
+      return this;
     }
+    this._addImplicitHelpCommand = true;
+    this._helpCommand = helpCommand;
     return this;
   }
-  _hasImplicitHelpCommand() {
-    if (this._addImplicitHelpCommand === undefined) {
-      return this.commands.length && !this._actionHandler && !this._findCommand('help');
+  _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 this._addImplicitHelpCommand;
+    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;
@@ -17645,14 +17704,24 @@ class LspDocuments {
 
 const file = 'file';
 
+const untitled = 'untitled';
+
 const git = 'git';
 
 const github = 'github';
 
 const azurerepos = 'azurerepos';
 
+const buffer = 'buffer';
+
+const zipfile = 'zipfile';
+
 const vsls = 'vsls';
 
+function getSemanticSupportedSchemes() {
+  return [ file, untitled, buffer, zipfile ];
+}
+
 const disabledSchemes = new Set([ git, vsls, github, azurerepos ]);
 
 var TypeScriptServerPlugin;
@@ -18866,6 +18935,20 @@ class Tracer {
   }
 }
 
+class ZipfileURI extends URI {
+  constructor(uri, components) {
+    super(components);
+    this._originalUri = uri;
+  }
+  toString(_skipEncoding = false) {
+    return this._originalUri;
+  }
+  static parse(value, _strict = false) {
+    const uri = URI.parse(value, _strict);
+    return new ZipfileURI(value, uri);
+  }
+}
+
 var ServerState;
 
 (function(ServerState) {
@@ -18937,11 +19020,18 @@ class ServerInitializingIndicator {
   }
 }
 
+const emptyAuthority = 'ts-nul-authority';
+
+const inMemoryResourcePrefix = '^';
+
+const RE_IN_MEMORY_FILEPATH = /^\^\/([^/]+)\/([^/]*)\/(.+)$/;
+
 class TsClient {
   constructor(onCaseInsensitiveFileSystem, logger, lspClient) {
     this.apiVersion = API.defaultVersion;
     this.typescriptVersionSource = 'bundled';
     this.serverState = ServerState.None;
+    this.isNeovimHost = false;
     this.workspaceFolders = [];
     this.useSyntaxServer = 2;
     this.pluginManager = new PluginManager;
@@ -18967,7 +19057,7 @@ class TsClient {
     return this.documents.files[0] || this.workspaceFolders[0]?.uri.fsPath;
   }
   toTsFilePath(stringUri) {
-    if (stringUri.startsWith('zipfile:')) {
+    if (this.isNeovimHost && stringUri.startsWith('zipfile:')) {
       return stringUri;
     }
     const resource = URI.parse(stringUri);
@@ -18977,7 +19067,7 @@ class TsClient {
     if (resource.scheme === file) {
       return resource.fsPath;
     }
-    return undefined;
+    return inMemoryResourcePrefix + '/' + resource.scheme + '/' + (resource.authority || emptyAuthority) + (resource.path.startsWith('/') ? resource.path : '/' + resource.path) + (resource.fragment ? '#' + resource.fragment : '');
   }
   toOpenDocument(textDocumentUri, options = {}) {
     const filepath = this.toTsFilePath(textDocumentUri);
@@ -18998,13 +19088,25 @@ class TsClient {
     return this.documents.hasPendingDiagnostics(resource);
   }
   toResource(filepath) {
-    if (filepath.startsWith('zipfile:')) {
-      return URI.parse(filepath);
+    if (this.isNeovimHost && filepath.startsWith('zipfile:')) {
+      return ZipfileURI.parse(filepath);
+    }
+    if (filepath.startsWith(inMemoryResourcePrefix)) {
+      const parts = filepath.match(RE_IN_MEMORY_FILEPATH);
+      if (parts) {
+        const resource = URI.parse(parts[1] + '://' + (parts[2] === emptyAuthority ? '' : parts[2]) + '/' + parts[3]);
+        const tsFilepath = this.toTsFilePath(resource.toString());
+        const document = tsFilepath && this.documents.get(tsFilepath);
+        return document ? document.uri : resource;
+      }
     }
     const fileUri = URI.file(filepath);
     const document = this.documents.get(fileUri.fsPath);
     return document ? document.uri : fileUri;
   }
+  toResourceUri(filepath) {
+    return this.toResource(filepath).toString();
+  }
   getWorkspaceRootForResource(resource) {
     for (const root of this.workspaceFolders.sort(((a, b) => a.uri.fsPath.length - b.uri.fsPath.length))) {
       if (root.uri.scheme === resource.scheme && root.uri.authority === resource.authority) {
@@ -19031,7 +19133,7 @@ class TsClient {
     switch (capability) {
      case ClientCapability.Semantic:
       {
-        return [ 'file', 'untitled' ].includes(resource.scheme);
+        return getSemanticSupportedSchemes().includes(resource.scheme);
       }
 
      case ClientCapability.Syntax:
@@ -19052,6 +19154,7 @@ class TsClient {
   start(workspaceRoot, options) {
     this.apiVersion = options.typescriptVersion.version || API.defaultVersion;
     this.typescriptVersionSource = options.typescriptVersion.source;
+    this.isNeovimHost = options.hostInfo === 'neovim';
     this.tracer = new Tracer(this.tsserverLogger, options.trace);
     this.workspaceFolders = workspaceRoot ? [ {
       uri: URI.file(workspaceRoot)
@@ -19391,9 +19494,9 @@ var Location;
 })(Location || (Location = {}));
 
 function toLocation(fileSpan, client) {
-  const uri = client.toResource(fileSpan.file);
+  const uri = client.toResourceUri(fileSpan.file);
   return {
-    uri: uri.toString(),
+    uri: uri,
     range: {
       start: Position.fromLocation(fileSpan.start),
       end: Position.fromLocation(fileSpan.end)
@@ -19505,11 +19608,11 @@ function toTextEdit(edit) {
 }
 
 function toTextDocumentEdit(change, client) {
-  const uri = client.toResource(change.fileName);
-  const document = client.toOpenDocument(uri.toString());
+  const uri = client.toResourceUri(change.fileName);
+  const document = client.toOpenDocument(uri);
   return {
     textDocument: {
-      uri: uri.toString(),
+      uri: uri,
       version: document?.version ?? null
     },
     edits: change.textChanges.map((c => toTextEdit(c)))
@@ -19551,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();
   }
@@ -19607,7 +19713,7 @@ class DiagnosticEventQueue {
     if (this.ignoredDiagnosticCodes.size) {
       diagnostics = diagnostics.filter((diagnostic => !this.isDiagnosticIgnored(diagnostic)));
     }
-    const uri = this.client.toResource(file).toString();
+    const uri = this.client.toResourceUri(file);
     const diagnosticsForFile = this.diagnostics.get(uri) || new FileDiagnostics(uri, this.publishDiagnostics, this.client, this.features);
     diagnosticsForFile.update(kind, diagnostics);
     this.diagnostics.set(uri, diagnosticsForFile);
@@ -19616,17 +19722,17 @@ class DiagnosticEventQueue {
     this.ignoredDiagnosticCodes = new Set(ignoredCodes);
   }
   getDiagnosticsForFile(file) {
-    const uri = this.client.toResource(file).toString();
+    const uri = this.client.toResourceUri(file);
     return this.diagnostics.get(uri)?.getDiagnostics() || [];
   }
   onDidCloseFile(file) {
-    const uri = this.client.toResource(file).toString();
+    const uri = this.client.toResourceUri(file);
     const diagnosticsForFile = this.diagnostics.get(uri);
     diagnosticsForFile?.onDidClose();
     this.diagnostics.delete(uri);
   }
   async waitForDiagnosticsForTesting(file) {
-    const uri = this.client.toResource(file).toString();
+    const uri = this.client.toResourceUri(file);
     let diagnosticsForFile = this.diagnostics.get(uri);
     if (diagnosticsForFile) {
       diagnosticsForFile.onDidClose();
@@ -19656,7 +19762,7 @@ class SourceDefinitionCommand {
       lspClient.showErrorMessage('Go to Source Definition failed. No resource provided.');
       return;
     }
-    const document = client.toOpenDocument(client.toResource(file).toString());
+    const document = client.toOpenDocument(client.toResourceUri(file));
     if (!document) {
       lspClient.showErrorMessage('Go to Source Definition failed. File not opened in the editor.');
       return;
@@ -20741,7 +20847,7 @@ function fromProtocolCallHierarchyItem(item, client, workspaceRoot) {
     kind: fromProtocolScriptElementKind(item.kind),
     name: name,
     detail: detail,
-    uri: client.toResource(item.file).toString(),
+    uri: client.toResourceUri(item.file),
     range: Range.fromTextSpan(item.span),
     selectionRange: Range.fromTextSpan(item.selectionSpan)
   };
@@ -21510,7 +21616,7 @@ class TypeScriptImplementationsCodeLensProvider extends TypeScriptBaseCodeLensPr
       codeLens.command = response.type === 'cancelled' ? TypeScriptBaseCodeLensProvider.cancelledCommand : TypeScriptBaseCodeLensProvider.errorCommand;
       return codeLens;
     }
-    const locations = response.body.map((reference => main$2.Location.create(this.client.toResource(reference.file).toString(), reference.start.line === reference.end.line ? Range.fromTextSpan(reference) : main$2.Range.create(Position.fromLocation(reference.start), main$2.Position.create(reference.start.line, 0))))).filter((location => !(location.uri.toString() === codeLens.data.uri && location.range.start.line === codeLens.range.start.line && location.range.start.character === codeLens.range.start.character)));
+    const locations = response.body.map((reference => main$2.Location.create(this.client.toResourceUri(reference.file), reference.start.line === reference.end.line ? Range.fromTextSpan(reference) : main$2.Range.create(Position.fromLocation(reference.start), main$2.Position.create(reference.start.line, 0))))).filter((location => !(location.uri.toString() === codeLens.data.uri && location.range.start.line === codeLens.range.start.line && location.range.start.character === codeLens.range.start.character)));
     codeLens.command = this.getCommand(locations, codeLens);
     return codeLens;
   }
@@ -21565,7 +21671,7 @@ class TypeScriptReferencesCodeLensProvider extends TypeScriptBaseCodeLensProvide
       codeLens.command = response.type === 'cancelled' ? TypeScriptBaseCodeLensProvider.cancelledCommand : TypeScriptBaseCodeLensProvider.errorCommand;
       return codeLens;
     }
-    const locations = response.body.refs.filter((reference => !reference.isDefinition)).map((reference => Location.fromTextSpan(this.client.toResource(reference.file).toString(), reference)));
+    const locations = response.body.refs.filter((reference => !reference.isDefinition)).map((reference => Location.fromTextSpan(this.client.toResourceUri(reference.file), reference)));
     codeLens.command = {
       title: this.getCodeLensLabel(locations),
       command: locations.length ? 'editor.action.showReferences' : '',
@@ -22387,6 +22493,7 @@ class LspServer {
       disableAutomaticTypingAcquisition: disableAutomaticTypingAcquisition,
       maxTsServerMemory: maxTsServerMemory,
       npmLocation: npmLocation,
+      hostInfo: hostInfo,
       locale: locale,
       plugins: plugins || [],
       onEvent: this.onTsEvent.bind(this),
@@ -22708,7 +22815,7 @@ class LspServer {
   }
   async completionResolve(item, token) {
     item.data = item.data?.cacheId !== undefined ? this.completionDataCache.get(item.data.cacheId) : item.data;
-    const uri = this.tsClient.toResource(item.data.file).toString();
+    const uri = this.tsClient.toResourceUri(item.data.file);
     const document = item.data?.file ? this.tsClient.toOpenDocument(uri) : undefined;
     if (!document) {
       return item;
@@ -22781,7 +22888,7 @@ class LspServer {
     }
     const changes = {};
     result.locs.forEach((spanGroup => {
-      const uri = this.tsClient.toResource(spanGroup.file).toString();
+      const uri = this.tsClient.toResourceUri(spanGroup.file);
       const textEdits = changes[uri] || (changes[uri] = []);
       spanGroup.locs.forEach((textSpan => {
         textEdits.push({
@@ -22977,7 +23084,7 @@ class LspServer {
       if (renameLocation) {
         await this.options.lspClient.rename({
           textDocument: {
-            uri: this.tsClient.toResource(args.file).toString()
+            uri: this.tsClient.toResourceUri(args.file)
           },
           position: Position.fromLocation(renameLocation)
         });
@@ -22987,7 +23094,7 @@ class LspServer {
       this.tsClient.configurePlugin(pluginName, configuration);
     } else if (params.command === Commands.ORGANIZE_IMPORTS && params.arguments) {
       const file = params.arguments[0];
-      const uri = this.tsClient.toResource(file).toString();
+      const uri = this.tsClient.toResourceUri(file);
       const document = this.tsClient.toOpenDocument(uri);
       if (!document) {
         return;
@@ -23044,7 +23151,7 @@ class LspServer {
     }
     const changes = {};
     for (const edit of edits) {
-      changes[this.tsClient.toResource(edit.fileName).toString()] = edit.textChanges.map(toTextEdit);
+      changes[this.tsClient.toResourceUri(edit.fileName)] = edit.textChanges.map(toTextEdit);
     }
     const {applied: applied} = await this.options.lspClient.applyWorkspaceEdit({
       edit: {
@@ -23058,7 +23165,7 @@ class LspServer {
     for (const rename of params.files) {
       const codeEdits = await this.getEditsForFileRename(rename.oldUri, rename.newUri, token);
       for (const codeEdit of codeEdits) {
-        const uri = this.tsClient.toResource(codeEdit.fileName).toString();
+        const uri = this.tsClient.toResourceUri(codeEdit.fileName);
         const textEdits = changes[uri] || (changes[uri] = []);
         textEdits.push(...codeEdit.textChanges.map(toTextEdit));
       }
@@ -23134,7 +23241,7 @@ class LspServer {
     }
     return response.body.map((item => ({
       location: {
-        uri: this.tsClient.toResource(item.file).toString(),
+        uri: this.tsClient.toResourceUri(item.file),
         range: {
           start: Position.fromLocation(item.start),
           end: Position.fromLocation(item.end)