typescript-language-server 4.4.1 → 5.0.1

package/lib/cli.mjs

@@ -116,7 +116,7 @@ function requireArgument() {
         this._name = name;
         break;
       }
-      if (this._name.length > 3 && this._name.slice(-3) === '...') {
+      if (this._name.endsWith('...')) {
         this.variadic = true;
         this._name = this._name.slice(0, -3);
       }
@@ -124,11 +124,12 @@ function requireArgument() {
     name() {
       return this._name;
     }
-    _concatValue(value, previous) {
+    _collectValue(value, previous) {
       if (previous === this.defaultValue || !Array.isArray(previous)) {
         return [ value ];
       }
-      return previous.concat(value);
+      previous.push(value);
+      return previous;
     }
     default(value, description) {
       this.defaultValue = value;
@@ -146,7 +147,7 @@ function requireArgument() {
           throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(', ')}.`);
         }
         if (this.variadic) {
-          return this._concatValue(arg, previous);
+          return this._collectValue(arg, previous);
         }
         return arg;
       };
@@ -183,10 +184,14 @@ function requireHelp() {
   class Help {
     constructor() {
       this.helpWidth = undefined;
+      this.minWidthToWrap = 40;
       this.sortSubcommands = false;
       this.sortOptions = false;
       this.showGlobalOptions = false;
     }
+    prepareContext(contextOptions) {
+      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+    }
     visibleCommands(cmd) {
       const visibleCommands = cmd.commands.filter(cmd => !cmd._hidden);
       const helpCommand = cmd._getHelpCommand();
@@ -255,16 +260,16 @@ function requireHelp() {
       return argument.name();
     }
     longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => Math.max(max, helper.subcommandTerm(command).length), 0);
+      return helper.visibleCommands(cmd).reduce((max, command) => Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command)))), 0);
     }
     longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => Math.max(max, helper.optionTerm(option).length), 0);
+      return helper.visibleOptions(cmd).reduce((max, option) => Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option)))), 0);
     }
     longestGlobalOptionTermLength(cmd, helper) {
-      return helper.visibleGlobalOptions(cmd).reduce((max, option) => Math.max(max, helper.optionTerm(option).length), 0);
+      return helper.visibleGlobalOptions(cmd).reduce((max, option) => Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option)))), 0);
     }
     longestArgumentTermLength(cmd, helper) {
-      return helper.visibleArguments(cmd).reduce((max, argument) => Math.max(max, helper.argumentTerm(argument).length), 0);
+      return helper.visibleArguments(cmd).reduce((max, argument) => Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument)))), 0);
     }
     commandUsage(cmd) {
       let cmdName = cmd._name;
@@ -301,7 +306,11 @@ function requireHelp() {
         extraInfo.push(`env: ${option.envVar}`);
       }
       if (extraInfo.length > 0) {
-        return `${option.description} (${extraInfo.join(', ')})`;
+        const extraDescription = `(${extraInfo.join(', ')})`;
+        if (option.description) {
+          return `${option.description} ${extraDescription}`;
+        }
+        return extraDescription;
       }
       return option.description;
     }
@@ -314,77 +323,175 @@ function requireHelp() {
         extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
       }
       if (extraInfo.length > 0) {
-        const extraDescripton = `(${extraInfo.join(', ')})`;
+        const extraDescription = `(${extraInfo.join(', ')})`;
         if (argument.description) {
-          return `${argument.description} ${extraDescripton}`;
+          return `${argument.description} ${extraDescription}`;
         }
-        return extraDescripton;
+        return extraDescription;
       }
       return argument.description;
     }
+    formatItemList(heading, items, helper) {
+      if (items.length === 0) return [];
+      return [ helper.styleTitle(heading), ...items, '' ];
+    }
+    groupItems(unsortedItems, visibleItems, getGroup) {
+      const result = new Map;
+      unsortedItems.forEach(item => {
+        const group = getGroup(item);
+        if (!result.has(group)) result.set(group, []);
+      });
+      visibleItems.forEach(item => {
+        const group = getGroup(item);
+        if (!result.has(group)) {
+          result.set(group, []);
+        }
+        result.get(group).push(item);
+      });
+      return result;
+    }
     formatHelp(cmd, helper) {
       const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth || 80;
-      const itemIndentWidth = 2;
-      const itemSeparatorWidth = 2;
-      function formatItem(term, description) {
-        if (description) {
-          const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-          return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-        }
-        return term;
+      const helpWidth = helper.helpWidth ?? 80;
+      function callFormatItem(term, description) {
+        return helper.formatItem(term, termWidth, description, helper);
       }
-      function formatList(textArray) {
-        return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
-      }
-      let output = [ `Usage: ${helper.commandUsage(cmd)}`, '' ];
+      let output = [ `${helper.styleTitle('Usage:')} ${helper.styleUsage(helper.commandUsage(cmd))}`, '' ];
       const commandDescription = helper.commandDescription(cmd);
       if (commandDescription.length > 0) {
-        output = output.concat([ helper.wrap(commandDescription, helpWidth, 0), '' ]);
-      }
-      const argumentList = helper.visibleArguments(cmd).map(argument => formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument)));
-      if (argumentList.length > 0) {
-        output = output.concat([ 'Arguments:', formatList(argumentList), '' ]);
-      }
-      const optionList = helper.visibleOptions(cmd).map(option => formatItem(helper.optionTerm(option), helper.optionDescription(option)));
-      if (optionList.length > 0) {
-        output = output.concat([ 'Options:', formatList(optionList), '' ]);
-      }
-      if (this.showGlobalOptions) {
-        const globalOptionList = helper.visibleGlobalOptions(cmd).map(option => formatItem(helper.optionTerm(option), helper.optionDescription(option)));
-        if (globalOptionList.length > 0) {
-          output = output.concat([ 'Global Options:', formatList(globalOptionList), '' ]);
-        }
-      }
-      const commandList = helper.visibleCommands(cmd).map(cmd => formatItem(helper.subcommandTerm(cmd), helper.subcommandDescription(cmd)));
-      if (commandList.length > 0) {
-        output = output.concat([ 'Commands:', formatList(commandList), '' ]);
-      }
+        output = output.concat([ helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth), '' ]);
+      }
+      const argumentList = helper.visibleArguments(cmd).map(argument => callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument))));
+      output = output.concat(this.formatItemList('Arguments:', argumentList, helper));
+      const optionGroups = this.groupItems(cmd.options, helper.visibleOptions(cmd), option => option.helpGroupHeading ?? 'Options:');
+      optionGroups.forEach((options, group) => {
+        const optionList = options.map(option => callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option))));
+        output = output.concat(this.formatItemList(group, optionList, helper));
+      });
+      if (helper.showGlobalOptions) {
+        const globalOptionList = helper.visibleGlobalOptions(cmd).map(option => callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option))));
+        output = output.concat(this.formatItemList('Global Options:', globalOptionList, helper));
+      }
+      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), sub => sub.helpGroup() || 'Commands:');
+      commandGroups.forEach((commands, group) => {
+        const commandList = commands.map(sub => callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub)), helper.styleSubcommandDescription(helper.subcommandDescription(sub))));
+        output = output.concat(this.formatItemList(group, commandList, helper));
+      });
       return output.join('\n');
     }
+    displayWidth(str) {
+      return stripColor(str).length;
+    }
+    styleTitle(str) {
+      return str;
+    }
+    styleUsage(str) {
+      return str.split(' ').map(word => {
+        if (word === '[options]') return this.styleOptionText(word);
+        if (word === '[command]') return this.styleSubcommandText(word);
+        if (word[0] === '[' || word[0] === '<') return this.styleArgumentText(word);
+        return this.styleCommandText(word);
+      }).join(' ');
+    }
+    styleCommandDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleOptionDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleSubcommandDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleArgumentDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleDescriptionText(str) {
+      return str;
+    }
+    styleOptionTerm(str) {
+      return this.styleOptionText(str);
+    }
+    styleSubcommandTerm(str) {
+      return str.split(' ').map(word => {
+        if (word === '[options]') return this.styleOptionText(word);
+        if (word[0] === '[' || word[0] === '<') return this.styleArgumentText(word);
+        return this.styleSubcommandText(word);
+      }).join(' ');
+    }
+    styleArgumentTerm(str) {
+      return this.styleArgumentText(str);
+    }
+    styleOptionText(str) {
+      return str;
+    }
+    styleArgumentText(str) {
+      return str;
+    }
+    styleSubcommandText(str) {
+      return str;
+    }
+    styleCommandText(str) {
+      return str;
+    }
     padWidth(cmd, helper) {
       return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
     }
-    wrap(str, width, indent, minColumnWidth = 40) {
-      const indents = ' \\f\\t\\v   -   　\ufeff';
-      const manualIndent = new RegExp(`[\\n][${indents}]+`);
-      if (str.match(manualIndent)) return str;
-      const columnWidth = width - indent;
-      if (columnWidth < minColumnWidth) return str;
-      const leadingStr = str.slice(0, indent);
-      const columnText = str.slice(indent).replace('\r\n', '\n');
-      const indentString = ' '.repeat(indent);
-      const zeroWidthSpace = '​';
-      const breaks = `\\s${zeroWidthSpace}`;
-      const regex = new RegExp(`\n|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, 'g');
-      const lines = columnText.match(regex) || [];
-      return leadingStr + lines.map((line, i) => {
-        if (line === '\n') return '';
-        return (i > 0 ? indentString : '') + line.trimEnd();
-      }).join('\n');
+    preformatted(str) {
+      return /\n[^\S\r\n]/.test(str);
+    }
+    formatItem(term, termWidth, description, helper) {
+      const itemIndent = 2;
+      const itemIndentStr = ' '.repeat(itemIndent);
+      if (!description) return itemIndentStr + term;
+      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
+      const spacerWidth = 2;
+      const helpWidth = this.helpWidth ?? 80;
+      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+      let formattedDescription;
+      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
+        formattedDescription = description;
+      } else {
+        const wrappedDescription = helper.boxWrap(description, remainingWidth);
+        formattedDescription = wrappedDescription.replace(/\n/g, '\n' + ' '.repeat(termWidth + spacerWidth));
+      }
+      return itemIndentStr + paddedTerm + ' '.repeat(spacerWidth) + formattedDescription.replace(/\n/g, `\n${itemIndentStr}`);
+    }
+    boxWrap(str, width) {
+      if (width < this.minWidthToWrap) return str;
+      const rawLines = str.split(/\r\n|\n/);
+      const chunkPattern = /[\s]*[^\s]+/g;
+      const wrappedLines = [];
+      rawLines.forEach(line => {
+        const chunks = line.match(chunkPattern);
+        if (chunks === null) {
+          wrappedLines.push('');
+          return;
+        }
+        let sumChunks = [ chunks.shift() ];
+        let sumWidth = this.displayWidth(sumChunks[0]);
+        chunks.forEach(chunk => {
+          const visibleWidth = this.displayWidth(chunk);
+          if (sumWidth + visibleWidth <= width) {
+            sumChunks.push(chunk);
+            sumWidth += visibleWidth;
+            return;
+          }
+          wrappedLines.push(sumChunks.join(''));
+          const nextChunk = chunk.trimStart();
+          sumChunks = [ nextChunk ];
+          sumWidth = this.displayWidth(nextChunk);
+        });
+        wrappedLines.push(sumChunks.join(''));
+      });
+      return wrappedLines.join('\n');
     }
   }
+  function stripColor(str) {
+    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+    return str.replace(sgrPattern, '');
+  }
   help.Help = Help;
+  help.stripColor = stripColor;
   return help;
 }
 
@@ -420,6 +527,7 @@ function requireOption() {
       this.argChoices = undefined;
       this.conflictsWith = [];
       this.implied = undefined;
+      this.helpGroupHeading = undefined;
     }
     default(value, description) {
       this.defaultValue = value;
@@ -460,11 +568,12 @@ function requireOption() {
       this.hidden = !!hide;
       return this;
     }
-    _concatValue(value, previous) {
+    _collectValue(value, previous) {
       if (previous === this.defaultValue || !Array.isArray(previous)) {
         return [ value ];
       }
-      return previous.concat(value);
+      previous.push(value);
+      return previous;
     }
     choices(values) {
       this.argChoices = values.slice();
@@ -473,7 +582,7 @@ function requireOption() {
           throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(', ')}.`);
         }
         if (this.variadic) {
-          return this._concatValue(arg, previous);
+          return this._collectValue(arg, previous);
         }
         return arg;
       };
@@ -486,7 +595,14 @@ function requireOption() {
       return this.short.replace(/^-/, '');
     }
     attributeName() {
-      return camelcase(this.name().replace(/^no-/, ''));
+      if (this.negate) {
+        return camelcase(this.name().replace(/^no-/, ''));
+      }
+      return camelcase(this.name());
+    }
+    helpGroup(heading) {
+      this.helpGroupHeading = heading;
+      return this;
     }
     is(arg) {
       return this.short === arg || this.long === arg;
@@ -527,13 +643,25 @@ function requireOption() {
   function splitOptionFlags(flags) {
     let shortFlag;
     let longFlag;
-    const flagParts = flags.split(/[ |,]+/);
-    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1])) shortFlag = flagParts.shift();
-    longFlag = flagParts.shift();
-    if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+    const shortFlagExp = /^-[^-]$/;
+    const longFlagExp = /^--[^-]/;
+    const flagParts = flags.split(/[ |,]+/).concat('guard');
+    if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
+    if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
+    if (!shortFlag && shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
+    if (!shortFlag && longFlagExp.test(flagParts[0])) {
       shortFlag = longFlag;
-      longFlag = undefined;
+      longFlag = flagParts.shift();
+    }
+    if (flagParts[0].startsWith('-')) {
+      const unsupportedFlag = flagParts[0];
+      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+      if (/^-[^-][^-]/.test(unsupportedFlag)) throw new Error(`${baseError}\n- a short flag is a single dash and a single character\n  - either use a single dash and a single character (for a short flag)\n  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
+      if (shortFlagExp.test(unsupportedFlag)) throw new Error(`${baseError}\n- too many short flags`);
+      if (longFlagExp.test(unsupportedFlag)) throw new Error(`${baseError}\n- too many long flags`);
+      throw new Error(`${baseError}\n- unrecognised flag format`);
     }
+    if (shortFlag === undefined && longFlag === undefined) throw new Error(`option creation failed due to no flags found in '${flags}'.`);
     return {
       shortFlag: shortFlag,
       longFlag: longFlag
@@ -630,7 +758,7 @@ function requireCommand() {
   const process = process$1;
   const {Argument: Argument, humanReadableArgName: humanReadableArgName} = requireArgument();
   const {CommanderError: CommanderError} = requireError();
-  const {Help: Help} = requireHelp();
+  const {Help: Help, stripColor: stripColor} = requireHelp();
   const {Option: Option, DualOptions: DualOptions} = requireOption();
   const {suggestSimilar: suggestSimilar} = requireSuggestSimilar();
   class Command extends EventEmitter {
@@ -640,7 +768,7 @@ function requireCommand() {
       this.options = [];
       this.parent = null;
       this._allowUnknownOption = false;
-      this._allowExcessArguments = true;
+      this._allowExcessArguments = false;
       this.registeredArguments = [];
       this._args = this.registeredArguments;
       this.args = [];
@@ -667,18 +795,25 @@ function requireCommand() {
       this._lifeCycleHooks = {};
       this._showHelpAfterError = false;
       this._showSuggestionAfterError = true;
+      this._savedState = null;
       this._outputConfiguration = {
         writeOut: str => process.stdout.write(str),
         writeErr: str => process.stderr.write(str),
+        outputError: (str, write) => write(str),
         getOutHelpWidth: () => process.stdout.isTTY ? process.stdout.columns : undefined,
         getErrHelpWidth: () => process.stderr.isTTY ? process.stderr.columns : undefined,
-        outputError: (str, write) => write(str)
+        getOutHasColors: () => useColor() ?? (process.stdout.isTTY && process.stdout.hasColors?.()),
+        getErrHasColors: () => useColor() ?? (process.stderr.isTTY && process.stderr.hasColors?.()),
+        stripColor: str => stripColor(str)
       };
       this._hidden = false;
       this._helpOption = undefined;
       this._addImplicitHelpCommand = undefined;
       this._helpCommand = undefined;
       this._helpConfiguration = {};
+      this._helpGroupHeading = undefined;
+      this._defaultCommandGroup = undefined;
+      this._defaultOptionGroup = undefined;
     }
     copyInheritedSettings(sourceCommand) {
       this._outputConfiguration = sourceCommand._outputConfiguration;
@@ -738,7 +873,10 @@ function requireCommand() {
     }
     configureOutput(configuration) {
       if (configuration === undefined) return this._outputConfiguration;
-      Object.assign(this._outputConfiguration, configuration);
+      this._outputConfiguration = {
+        ...this._outputConfiguration,
+        ...configuration
+      };
       return this;
     }
     showHelpAfterError(displayHelp = true) {
@@ -765,12 +903,12 @@ function requireCommand() {
     createArgument(name, description) {
       return new Argument(name, description);
     }
-    argument(name, description, fn, defaultValue) {
+    argument(name, description, parseArg, defaultValue) {
       const argument = this.createArgument(name, description);
-      if (typeof fn === 'function') {
-        argument.default(defaultValue).argParser(fn);
+      if (typeof parseArg === 'function') {
+        argument.default(defaultValue).argParser(parseArg);
       } else {
-        argument.default(fn);
+        argument.default(parseArg);
       }
       this.addArgument(argument);
       return this;
@@ -783,7 +921,7 @@ function requireCommand() {
     }
     addArgument(argument) {
       const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument && previousArgument.variadic) {
+      if (previousArgument?.variadic) {
         throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
       }
       if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
@@ -795,10 +933,13 @@ function requireCommand() {
     helpCommand(enableOrNameAndArgs, description) {
       if (typeof enableOrNameAndArgs === 'boolean') {
         this._addImplicitHelpCommand = enableOrNameAndArgs;
+        if (enableOrNameAndArgs && this._defaultCommandGroup) {
+          this._initCommandGroup(this._getHelpCommand());
+        }
         return this;
       }
-      enableOrNameAndArgs = enableOrNameAndArgs ?? 'help [command]';
-      const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
+      const nameAndArgs = enableOrNameAndArgs ?? 'help [command]';
+      const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
       const helpDescription = description ?? 'display help for command';
       const helpCommand = this.createCommand(helpName);
       helpCommand.helpOption(false);
@@ -806,6 +947,7 @@ function requireCommand() {
       if (helpDescription) helpCommand.description(helpDescription);
       this._addImplicitHelpCommand = true;
       this._helpCommand = helpCommand;
+      if (enableOrNameAndArgs || description) this._initCommandGroup(helpCommand);
       return this;
     }
     addHelpCommand(helpCommand, deprecatedDescription) {
@@ -815,6 +957,7 @@ function requireCommand() {
       }
       this._addImplicitHelpCommand = true;
       this._helpCommand = helpCommand;
+      this._initCommandGroup(helpCommand);
       return this;
     }
     _getHelpCommand() {
@@ -895,6 +1038,7 @@ function requireCommand() {
         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._initOptionGroup(option);
       this.options.push(option);
     }
     _registerCommand(command) {
@@ -905,6 +1049,7 @@ function requireCommand() {
         const newCmd = knownBy(command).join('|');
         throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
       }
+      this._initCommandGroup(command);
       this.commands.push(command);
     }
     addOption(option) {
@@ -927,7 +1072,7 @@ function requireCommand() {
         if (val !== null && option.parseArg) {
           val = this._callParseArg(option, val, oldValue, invalidValueMessage);
         } else if (val !== null && option.variadic) {
-          val = option._concatValue(val, oldValue);
+          val = option._collectValue(val, oldValue);
         }
         if (val == null) {
           if (option.negate) {
@@ -1097,15 +1242,55 @@ function requireCommand() {
       return userArgs;
     }
     parse(argv, parseOptions) {
+      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       this._parseCommand([], userArgs);
       return this;
     }
     async parseAsync(argv, parseOptions) {
+      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       await this._parseCommand([], userArgs);
       return this;
     }
+    _prepareForParse() {
+      if (this._savedState === null) {
+        this.saveStateBeforeParse();
+      } else {
+        this.restoreStateBeforeParse();
+      }
+    }
+    saveStateBeforeParse() {
+      this._savedState = {
+        _name: this._name,
+        _optionValues: {
+          ...this._optionValues
+        },
+        _optionValueSources: {
+          ...this._optionValueSources
+        }
+      };
+    }
+    restoreStateBeforeParse() {
+      if (this._storeOptionsAsProperties) throw new Error(`Can not call parse again when storeOptionsAsProperties is true.\n- either make a new Command for each call to parse, or stop storing options as properties`);
+      this._name = this._savedState._name;
+      this._scriptPath = null;
+      this.rawArgs = [];
+      this._optionValues = {
+        ...this._savedState._optionValues
+      };
+      this._optionValueSources = {
+        ...this._savedState._optionValueSources
+      };
+      this.args = [];
+      this.processedArgs = [];
+    }
+    _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
+      if (fs.existsSync(executableFile)) return;
+      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';
+      const executableMissing = `'${executableFile}' does not exist\n - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead\n - if the default executable name is not suitable, use the executableFile option to supply a custom name or path\n - ${executableDirMessage}`;
+      throw new Error(executableMissing);
+    }
     _executeSubCommand(subcommand, args) {
       args = args.slice();
       let launchWithNode = false;
@@ -1126,7 +1311,7 @@ function requireCommand() {
         let resolvedScriptPath;
         try {
           resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch (err) {
+        } catch {
           resolvedScriptPath = this._scriptPath;
         }
         executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
@@ -1156,6 +1341,7 @@ function requireCommand() {
           });
         }
       } else {
+        this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         args.unshift(executableFile);
         args = incrementNodeInspectorPort(process.execArgv).concat(args);
         proc = childProcess.spawn(process.execPath, args, {
@@ -1183,9 +1369,7 @@ function requireCommand() {
       });
       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';
-          const executableMissing = `'${executableFile}' does not exist\n - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead\n - if the default executable name is not suitable, use the executableFile option to supply a custom name or path\n - ${executableDirMessage}`;
-          throw new Error(executableMissing);
+          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         } else if (err.code === 'EACCES') {
           throw new Error(`'${executableFile}' not executable`);
         }
@@ -1204,6 +1388,7 @@ function requireCommand() {
       if (!subCommand) this.help({
         error: true
       });
+      subCommand._prepareForParse();
       let promiseChain;
       promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, 'preSubcommand');
       promiseChain = this._chainOrCall(promiseChain, () => {
@@ -1271,7 +1456,7 @@ function requireCommand() {
       this.processedArgs = processedArgs;
     }
     _chainOrCall(promise, fn) {
-      if (promise && promise.then && typeof promise.then === 'function') {
+      if (promise?.then && typeof promise.then === 'function') {
         return promise.then(() => fn());
       }
       return fn();
@@ -1349,7 +1534,7 @@ function requireCommand() {
         promiseChain = this._chainOrCallHooks(promiseChain, 'postAction');
         return promiseChain;
       }
-      if (this.parent && this.parent.listenerCount(commandEvent)) {
+      if (this.parent?.listenerCount(commandEvent)) {
         checkForUnknownOptions();
         this._processArguments();
         this.parent.emit(commandEvent, operands, unknown);
@@ -1412,23 +1597,29 @@ function requireCommand() {
         cmd._checkForConflictingLocalOptions();
       });
     }
-    parseOptions(argv) {
+    parseOptions(args) {
       const operands = [];
       const unknown = [];
       let dest = operands;
-      const args = argv.slice();
       function maybeOption(arg) {
         return arg.length > 1 && arg[0] === '-';
       }
+      const negativeNumberArg = arg => {
+        if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg)) return false;
+        return !this._getCommandAndAncestors().some(cmd => cmd.options.map(opt => opt.short).some(short => /^-\d$/.test(short)));
+      };
       let activeVariadicOption = null;
-      while (args.length) {
-        const arg = args.shift();
+      let activeGroup = null;
+      let i = 0;
+      while (i < args.length || activeGroup) {
+        const arg = activeGroup ?? args[i++];
+        activeGroup = null;
         if (arg === '--') {
           if (dest === unknown) dest.push(arg);
-          dest.push(...args);
+          dest.push(...args.slice(i));
           break;
         }
-        if (activeVariadicOption && !maybeOption(arg)) {
+        if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
           this.emit(`option:${activeVariadicOption.name()}`, arg);
           continue;
         }
@@ -1437,13 +1628,13 @@ function requireCommand() {
           const option = this._findOption(arg);
           if (option) {
             if (option.required) {
-              const value = args.shift();
+              const value = args[i++];
               if (value === undefined) this.optionMissingArgument(option);
               this.emit(`option:${option.name()}`, value);
             } else if (option.optional) {
               let value = null;
-              if (args.length > 0 && !maybeOption(args[0])) {
-                value = args.shift();
+              if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
+                value = args[i++];
               }
               this.emit(`option:${option.name()}`, value);
             } else {
@@ -1460,7 +1651,7 @@ function requireCommand() {
               this.emit(`option:${option.name()}`, arg.slice(2));
             } else {
               this.emit(`option:${option.name()}`);
-              args.unshift(`-${arg.slice(2)}`);
+              activeGroup = `-${arg.slice(2)}`;
             }
             continue;
           }
@@ -1473,27 +1664,24 @@ function requireCommand() {
             continue;
           }
         }
-        if (maybeOption(arg)) {
+        if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
           dest = unknown;
         }
         if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
           if (this._findCommand(arg)) {
             operands.push(arg);
-            if (args.length > 0) unknown.push(...args);
+            unknown.push(...args.slice(i));
             break;
           } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg);
-            if (args.length > 0) operands.push(...args);
+            operands.push(arg, ...args.slice(i));
             break;
           } else if (this._defaultCommandName) {
-            unknown.push(arg);
-            if (args.length > 0) unknown.push(...args);
+            unknown.push(arg, ...args.slice(i));
             break;
           }
         }
         if (this._passThroughOptions) {
-          dest.push(arg);
-          if (args.length > 0) dest.push(...args);
+          dest.push(arg, ...args.slice(i));
           break;
         }
         dest.push(arg);
@@ -1704,6 +1892,27 @@ function requireCommand() {
       this._name = str;
       return this;
     }
+    helpGroup(heading) {
+      if (heading === undefined) return this._helpGroupHeading ?? '';
+      this._helpGroupHeading = heading;
+      return this;
+    }
+    commandsGroup(heading) {
+      if (heading === undefined) return this._defaultCommandGroup ?? '';
+      this._defaultCommandGroup = heading;
+      return this;
+    }
+    optionsGroup(heading) {
+      if (heading === undefined) return this._defaultOptionGroup ?? '';
+      this._defaultOptionGroup = heading;
+      return this;
+    }
+    _initOptionGroup(option) {
+      if (this._defaultOptionGroup && !option.helpGroupHeading) option.helpGroup(this._defaultOptionGroup);
+    }
+    _initCommandGroup(cmd) {
+      if (this._defaultCommandGroup && !cmd.helpGroup()) cmd.helpGroup(this._defaultCommandGroup);
+    }
     nameFromFilename(filename) {
       this._name = path.basename(filename, path.extname(filename));
       return this;
@@ -1715,25 +1924,41 @@ function requireCommand() {
     }
     helpInformation(contextOptions) {
       const helper = this.createHelp();
-      if (helper.helpWidth === undefined) {
-        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
-      }
-      return helper.formatHelp(this, helper);
+      const context = this._getOutputContext(contextOptions);
+      helper.prepareContext({
+        error: context.error,
+        helpWidth: context.helpWidth,
+        outputHasColors: context.hasColors
+      });
+      const text = helper.formatHelp(this, helper);
+      if (context.hasColors) return text;
+      return this._outputConfiguration.stripColor(text);
     }
-    _getHelpContext(contextOptions) {
+    _getOutputContext(contextOptions) {
       contextOptions = contextOptions || {};
-      const context = {
-        error: !!contextOptions.error
-      };
-      let write;
-      if (context.error) {
-        write = arg => this._outputConfiguration.writeErr(arg);
+      const error = !!contextOptions.error;
+      let baseWrite;
+      let hasColors;
+      let helpWidth;
+      if (error) {
+        baseWrite = str => this._outputConfiguration.writeErr(str);
+        hasColors = this._outputConfiguration.getErrHasColors();
+        helpWidth = this._outputConfiguration.getErrHelpWidth();
       } else {
-        write = arg => this._outputConfiguration.writeOut(arg);
+        baseWrite = str => this._outputConfiguration.writeOut(str);
+        hasColors = this._outputConfiguration.getOutHasColors();
+        helpWidth = this._outputConfiguration.getOutHelpWidth();
       }
-      context.write = contextOptions.write || write;
-      context.command = this;
-      return context;
+      const write = str => {
+        if (!hasColors) str = this._outputConfiguration.stripColor(str);
+        return baseWrite(str);
+      };
+      return {
+        error: error,
+        write: write,
+        hasColors: hasColors,
+        helpWidth: helpWidth
+      };
     }
     outputHelp(contextOptions) {
       let deprecatedCallback;
@@ -1741,35 +1966,44 @@ function requireCommand() {
         deprecatedCallback = contextOptions;
         contextOptions = undefined;
       }
-      const context = this._getHelpContext(contextOptions);
-      this._getCommandAndAncestors().reverse().forEach(command => command.emit('beforeAllHelp', context));
-      this.emit('beforeHelp', context);
-      let helpInformation = this.helpInformation(context);
+      const outputContext = this._getOutputContext(contextOptions);
+      const eventContext = {
+        error: outputContext.error,
+        write: outputContext.write,
+        command: this
+      };
+      this._getCommandAndAncestors().reverse().forEach(command => command.emit('beforeAllHelp', eventContext));
+      this.emit('beforeHelp', eventContext);
+      let helpInformation = this.helpInformation({
+        error: outputContext.error
+      });
       if (deprecatedCallback) {
         helpInformation = deprecatedCallback(helpInformation);
         if (typeof helpInformation !== 'string' && !Buffer.isBuffer(helpInformation)) {
           throw new Error('outputHelp callback must return a string or a Buffer');
         }
       }
-      context.write(helpInformation);
+      outputContext.write(helpInformation);
       if (this._getHelpOption()?.long) {
         this.emit(this._getHelpOption().long);
       }
-      this.emit('afterHelp', context);
-      this._getCommandAndAncestors().forEach(command => command.emit('afterAllHelp', context));
+      this.emit('afterHelp', eventContext);
+      this._getCommandAndAncestors().forEach(command => command.emit('afterAllHelp', eventContext));
     }
     helpOption(flags, description) {
       if (typeof flags === 'boolean') {
         if (flags) {
-          this._helpOption = this._helpOption ?? undefined;
+          if (this._helpOption === null) this._helpOption = undefined;
+          if (this._defaultOptionGroup) {
+            this._initOptionGroup(this._getHelpOption());
+          }
         } else {
           this._helpOption = null;
         }
         return this;
       }
-      flags = flags ?? '-h, --help';
-      description = description ?? 'display help for command';
-      this._helpOption = this.createOption(flags, description);
+      this._helpOption = this.createOption(flags ?? '-h, --help', description ?? 'display help for command');
+      if (flags || description) this._initOptionGroup(this._helpOption);
       return this;
     }
     _getHelpOption() {
@@ -1780,11 +2014,12 @@ function requireCommand() {
     }
     addHelpOption(option) {
       this._helpOption = option;
+      this._initOptionGroup(option);
       return this;
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = process.exitCode || 0;
+      let exitCode = Number(process.exitCode ?? 0);
       if (exitCode === 0 && contextOptions && typeof contextOptions !== 'function' && contextOptions.error) {
         exitCode = 1;
       }
@@ -1850,7 +2085,13 @@ function requireCommand() {
       return arg;
     });
   }
+  function useColor() {
+    if (process.env.NO_COLOR || process.env.FORCE_COLOR === '0' || process.env.FORCE_COLOR === 'false') return false;
+    if (process.env.FORCE_COLOR || process.env.CLICOLOR_FORCE !== undefined) return true;
+    return undefined;
+  }
   command.Command = Command;
+  command.useColor = useColor;
   return command;
 }
 
@@ -12728,7 +12969,7 @@ function requireStat() {
     return checkParentPathsSync(src, srcStat, destParent, funcName);
   }
   function areIdentical(srcStat, destStat) {
-    return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+    return destStat.ino !== undefined && destStat.dev !== undefined && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
   }
   function isSrcSubdir(src, dest) {
     const srcArr = path.resolve(src).split(path.sep).filter(i => i);
@@ -12749,6 +12990,28 @@ function requireStat() {
   return stat;
 }
 
+var async;
+
+var hasRequiredAsync;
+
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  async function asyncIteratorConcurrentProcess(iterator, fn) {
+    const promises = [];
+    for await (const item of iterator) {
+      promises.push(fn(item).then(() => null, err => err ?? new Error('unknown error')));
+    }
+    await Promise.all(promises.map(promise => promise.then(possibleErr => {
+      if (possibleErr !== null) throw possibleErr;
+    })));
+  }
+  async = {
+    asyncIteratorConcurrentProcess: asyncIteratorConcurrentProcess
+  };
+  return async;
+}
+
 var copy_1;
 
 var hasRequiredCopy$1;
@@ -12762,6 +13025,7 @@ function requireCopy$1() {
   const {pathExists: pathExists} = requirePathExists();
   const {utimesMillis: utimesMillis} = requireUtimes();
   const stat = requireStat();
+  const {asyncIteratorConcurrentProcess: asyncIteratorConcurrentProcess} = requireAsync();
   async function copy(src, dest, opts = {}) {
     if (typeof opts === 'function') {
       opts = {
@@ -12829,17 +13093,15 @@ function requireCopy$1() {
     if (!destStat) {
       await fs.mkdir(dest);
     }
-    const promises = [];
-    for await (const item of await fs.opendir(src)) {
+    await asyncIteratorConcurrentProcess(await fs.opendir(src), async item => {
       const srcItem = path.join(src, item.name);
       const destItem = path.join(dest, item.name);
-      promises.push(runFilter(srcItem, destItem, opts).then(include => {
-        if (include) {
-          return stat.checkPaths(srcItem, destItem, 'copy', opts).then(({destStat: destStat}) => getStatsAndPerformCopy(destStat, srcItem, destItem, opts));
-        }
-      }));
-    }
-    await Promise.all(promises);
+      const include = await runFilter(srcItem, destItem, opts);
+      if (include) {
+        const {destStat: destStat} = await stat.checkPaths(srcItem, destItem, 'copy', opts);
+        await getStatsAndPerformCopy(destStat, srcItem, destItem, opts);
+      }
+    });
     if (!destStat) {
       await fs.chmod(dest, srcStat.mode);
     }
@@ -13431,12 +13693,12 @@ function requireUtils() {
   return utils;
 }
 
-var jsonfile_1;
+var jsonfile$1;
 
 var hasRequiredJsonfile$1;
 
 function requireJsonfile$1() {
-  if (hasRequiredJsonfile$1) return jsonfile_1;
+  if (hasRequiredJsonfile$1) return jsonfile$1;
   hasRequiredJsonfile$1 = 1;
   let _fs;
   try {
@@ -13502,14 +13764,13 @@ function requireJsonfile$1() {
     const str = stringify(obj, options);
     return fs.writeFileSync(file, str, options);
   }
-  const jsonfile = {
+  jsonfile$1 = {
     readFile: readFile,
     readFileSync: readFileSync,
     writeFile: writeFile,
     writeFileSync: writeFileSync
   };
-  jsonfile_1 = jsonfile;
-  return jsonfile_1;
+  return jsonfile$1;
 }
 
 var jsonfile;
@@ -16908,6 +17169,8 @@ API.v500 = API.fromSimpleString('5.0.0');
 
 API.v510 = API.fromSimpleString('5.1.0');
 
+API.v520 = API.fromSimpleString('5.2.0');
+
 API.v540 = API.fromSimpleString('5.4.0');
 
 function equals$1(a, b, itemEquals = (a, b) => a === b) {
@@ -17949,7 +18212,7 @@ class SingleTsServer {
   tryCancelRequest(seq, command) {
     try {
       if (this._requestQueue.tryDeletePendingRequest(seq)) {
-        this.logTrace(`Canceled request with sequence number ${seq}`);
+        this.logTrace(`Canceled pending request with sequence number ${seq}`);
         return true;
       }
       if (this._requestCanceller.tryCancelOngoingRequest(seq)) {
@@ -19063,7 +19326,8 @@ class TsClient {
       executions[0].catch(err => this.fatalError(command, err));
     }
     if (command === CommandTypes.UpdateOpen) {
-      Promise.all(executions).then(() => {
+      const executionsWithResults = executions.filter(e => e !== undefined);
+      Promise.all(executionsWithResults).then(() => {
         this.loadingIndicator.reset();
       });
     }
@@ -19133,30 +19397,73 @@ class TsClient {
   }
 }
 
-const pDebounce = (fn, wait, options = {}) => {
+const pDebounce = (function_, wait, options = {}) => {
   if (!Number.isFinite(wait)) {
     throw new TypeError('Expected `wait` to be a finite number');
   }
   let leadingValue;
   let timeout;
   let resolveList = [];
+  let rejectList = [];
+  const onAbort = () => {
+    clearTimeout(timeout);
+    timeout = null;
+    try {
+      options.signal?.throwIfAborted();
+    } catch (error) {
+      for (const reject of rejectList) {
+        reject(error);
+      }
+      resolveList = [];
+      rejectList = [];
+    }
+  };
   return function(...arguments_) {
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
+      try {
+        options.signal?.throwIfAborted();
+      } catch (error) {
+        reject(error);
+        return;
+      }
       const shouldCallNow = options.before && !timeout;
       clearTimeout(timeout);
-      timeout = setTimeout(() => {
+      timeout = setTimeout(async () => {
         timeout = null;
-        const result = options.before ? leadingValue : fn.apply(this, arguments_);
-        for (resolve of resolveList) {
-          resolve(result);
-        }
+        const currentResolveList = resolveList;
+        const currentRejectList = rejectList;
         resolveList = [];
+        rejectList = [];
+        try {
+          const result = options.before ? leadingValue : await function_.apply(this, arguments_);
+          for (const resolveFunction of currentResolveList) {
+            resolveFunction(result);
+          }
+        } catch (error) {
+          for (const rejectFunction of currentRejectList) {
+            rejectFunction(error);
+          }
+        }
+        leadingValue = undefined;
+        options.signal?.removeEventListener('abort', onAbort);
       }, wait);
       if (shouldCallNow) {
-        leadingValue = fn.apply(this, arguments_);
-        resolve(leadingValue);
+        (async () => {
+          try {
+            leadingValue = await function_.apply(this, arguments_);
+            resolve(leadingValue);
+          } catch (error) {
+            reject(error);
+          }
+        })();
       } else {
         resolveList.push(resolve);
+        rejectList.push(reject);
+        if (options.signal && resolveList.length === 1) {
+          options.signal.addEventListener('abort', onAbort, {
+            once: true
+          });
+        }
       }
     });
   };
@@ -19499,7 +19806,7 @@ class FileDiagnostics {
   }
 }
 
-class DiagnosticEventQueue {
+class DiagnosticsManager {
   constructor(publishDiagnostics, client, features, logger) {
     this.publishDiagnostics = publishDiagnostics;
     this.client = client;
@@ -19616,8 +19923,6 @@ class TSServerRequestCommand {
 TSServerRequestCommand.id = 'typescript.tsserverRequest';
 
 const Commands = {
-  APPLY_WORKSPACE_EDIT: '_typescript.applyWorkspaceEdit',
-  APPLY_CODE_ACTION: '_typescript.applyCodeAction',
   APPLY_REFACTORING: '_typescript.applyRefactoring',
   CONFIGURE_PLUGIN: '_typescript.configurePlugin',
   ORGANIZE_IMPORTS: '_typescript.organizeImports',
@@ -20440,43 +20745,41 @@ function toTsTriggerReason(context) {
   }
 }
 
-function provideQuickFix(response, client) {
-  if (!response?.body) {
-    return [];
-  }
-  return response.body.map(fix => mainExports$2.CodeAction.create(fix.description, {
-    title: fix.description,
-    command: Commands.APPLY_WORKSPACE_EDIT,
-    arguments: [ {
-      documentChanges: fix.changes.map(c => toTextDocumentEdit(c, client))
-    } ]
-  }, mainExports$2.CodeActionKind.QuickFix));
-}
+var CodeActionKind$1;
 
-function provideRefactors(response, args, features) {
-  if (!response?.body) {
-    return [];
-  }
+(function(CodeActionKind) {
+  CodeActionKind.RefactorMove = 'refactor.move';
+})(CodeActionKind$1 || (CodeActionKind$1 = {}));
+
+function provideRefactors(refactors, args, features) {
   const actions = [];
-  for (const info of response.body) {
-    if (info.inlineable === false) {
-      actions.push(asSelectRefactoring(info, args));
+  for (const refactor of refactors) {
+    if (refactor.inlineable === false) {
+      actions.push(asSelectRefactoring(refactor, args));
     } else {
-      const relevantActions = features.codeActionDisabledSupport ? info.actions : info.actions.filter(action => !action.notApplicableReason);
+      const relevantActions = refactor.actions.filter(action => {
+        if (action.notApplicableReason && !features.codeActionDisabledSupport) {
+          return false;
+        }
+        if (action.isInteractive && (!features.moveToFileCodeActionSupport || action.name !== 'Move to file')) {
+          return false;
+        }
+        return true;
+      });
       for (const action of relevantActions) {
-        actions.push(asApplyRefactoring(action, info, args));
+        actions.push(asApplyRefactoring(action, refactor, args));
       }
     }
   }
   return actions;
 }
 
-function asSelectRefactoring(info, args) {
-  return mainExports$2.CodeAction.create(info.description, mainExports$2.Command.create(info.description, Commands.SELECT_REFACTORING, info, args), mainExports$2.CodeActionKind.Refactor);
+function asSelectRefactoring(refactor, args) {
+  return mainExports$2.CodeAction.create(refactor.description, mainExports$2.Command.create(refactor.description, Commands.SELECT_REFACTORING, refactor, args), mainExports$2.CodeActionKind.Refactor);
 }
 
-function asApplyRefactoring(action, info, args) {
-  const codeAction = mainExports$2.CodeAction.create(action.description, asKind(info));
+function asApplyRefactoring(action, refactor, args) {
+  const codeAction = mainExports$2.CodeAction.create(action.description, asKind(action));
   if (action.notApplicableReason) {
     codeAction.disabled = {
       reason: action.notApplicableReason
@@ -20484,20 +20787,46 @@ function asApplyRefactoring(action, info, args) {
   } else {
     codeAction.command = mainExports$2.Command.create(action.description, Commands.APPLY_REFACTORING, {
       ...args,
-      refactor: info.name,
+      refactor: refactor.name,
       action: action.name
     });
   }
   return codeAction;
 }
 
-function asKind(refactor) {
-  if (refactor.name.startsWith('function_')) {
+function asKind(action) {
+  if (action.kind) {
+    return action.kind;
+  }
+  if (action.name.startsWith('function_')) {
     return `${mainExports$2.CodeActionKind.RefactorExtract}.function`;
-  } else if (refactor.name.startsWith('constant_')) {
+  }
+  if (action.name.startsWith('constant_')) {
     return `${mainExports$2.CodeActionKind.RefactorExtract}.constant`;
-  } else if (refactor.name.startsWith('Move')) {
-    return `${mainExports$2.CodeActionKind.Refactor}.move`;
+  }
+  if (action.name.startsWith('Extract to type alias')) {
+    return `${mainExports$2.CodeActionKind.RefactorExtract}.type`;
+  }
+  if (action.name.startsWith('Extract to interface')) {
+    return `${mainExports$2.CodeActionKind.RefactorExtract}.interface`;
+  }
+  if (action.name.startsWith('Move to file')) {
+    return `${CodeActionKind$1.RefactorMove}.file`;
+  }
+  if (action.name.startsWith('Move to a new file')) {
+    return `${CodeActionKind$1.RefactorMove}.newFile`;
+  }
+  if (action.name.startsWith('Convert namespace import') || action.name.startsWith('Convert named imports')) {
+    return `${mainExports$2.CodeActionKind.RefactorRewrite}.import`;
+  }
+  if (action.name.startsWith('Convert default export') || action.name.startsWith('Convert named export')) {
+    return `${mainExports$2.CodeActionKind.RefactorRewrite}.export`;
+  }
+  if (action.name.startsWith('Convert parameters to destructured object')) {
+    return `${mainExports$2.CodeActionKind.RefactorRewrite}.parameters.toDestructured`;
+  }
+  if (action.name.startsWith('Generate \'get\' and \'set\' accessors')) {
+    return `${mainExports$2.CodeActionKind.RefactorRewrite}.property.generateAccessors`;
   }
   return mainExports$2.CodeActionKind.Refactor;
 }
@@ -21161,235 +21490,54 @@ class FileConfigurationManager {
   }
 }
 
-const variableDeclaredButNeverUsed = new Set([ 6196, 6133 ]);
-
-const unreachableCode$1 = new Set([ 7027 ]);
-
-const incorrectlyImplementsInterface = new Set([ 2420 ]);
-
-const cannotFindName = new Set([ 2552, 2304 ]);
-
-const asyncOnlyAllowedInAsyncFunctions = new Set([ 1308 ]);
-
-const awaitInSyncFunction = 'fixAwaitInSyncFunction';
-
-const classIncorrectlyImplementsInterface = 'fixClassIncorrectlyImplementsInterface';
-
-const unreachableCode = 'fixUnreachableCode';
+function escapeRegExp(text) {
+  return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+}
 
-const unusedIdentifier = 'unusedIdentifier';
+var CodeLensType;
 
-const fixImport = 'import';
+(function(CodeLensType) {
+  CodeLensType[CodeLensType['Reference'] = 0] = 'Reference';
+  CodeLensType[CodeLensType['Implementation'] = 1] = 'Implementation';
+})(CodeLensType || (CodeLensType = {}));
 
-async function buildIndividualFixes(fixes, client, file, diagnostics) {
-  const edits = [];
-  for (const diagnostic of diagnostics) {
-    for (const {codes: codes, fixName: fixName} of fixes) {
-      if (!codes.has(diagnostic.code)) {
-        continue;
-      }
-      const args = {
-        ...Range.toFileRangeRequestArgs(file, diagnostic.range),
-        errorCodes: [ +diagnostic.code ]
-      };
-      const response = await client.execute(CommandTypes.GetCodeFixes, args);
-      if (response.type !== 'response') {
-        continue;
-      }
-      const fix = response.body?.find(fix => fix.fixName === fixName);
-      if (fix) {
-        edits.push(...fix.changes.map(change => toTextDocumentEdit(change, client)));
-        break;
-      }
+class TypeScriptBaseCodeLensProvider {
+  constructor(client, cachedResponse, fileConfigurationManager) {
+    this.client = client;
+    this.cachedResponse = cachedResponse;
+    this.fileConfigurationManager = fileConfigurationManager;
+  }
+  async provideCodeLenses(document, token) {
+    const configuration = this.fileConfigurationManager.getWorkspacePreferencesForFile(document);
+    if (this.type === CodeLensType.Implementation && !configuration.implementationsCodeLens?.enabled || this.type === CodeLensType.Reference && !configuration.referencesCodeLens?.enabled) {
+      return [];
+    }
+    const response = await this.cachedResponse.execute(document, () => this.client.execute(CommandTypes.NavTree, {
+      file: document.filepath
+    }, token));
+    if (response.type !== 'response') {
+      return [];
     }
+    const referenceableSpans = [];
+    response.body?.childItems?.forEach(item => this.walkNavTree(document, item, undefined, referenceableSpans));
+    return referenceableSpans.map(span => mainExports.CodeLens.create(span, {
+      uri: document.uri.toString(),
+      type: this.type
+    }));
   }
-  return edits;
-}
-
-async function buildCombinedFix(fixes, client, file, diagnostics) {
-  const edits = [];
-  for (const diagnostic of diagnostics) {
-    for (const {codes: codes, fixName: fixName} of fixes) {
-      if (!codes.has(diagnostic.code)) {
-        continue;
-      }
-      const args = {
-        ...Range.toFileRangeRequestArgs(file, diagnostic.range),
-        errorCodes: [ +diagnostic.code ]
-      };
-      const response = await client.execute(CommandTypes.GetCodeFixes, args);
-      if (response.type !== 'response' || !response.body?.length) {
-        continue;
-      }
-      const fix = response.body?.find(fix => fix.fixName === fixName);
-      if (!fix) {
-        continue;
-      }
-      if (!fix.fixId) {
-        edits.push(...fix.changes.map(change => toTextDocumentEdit(change, client)));
-        return edits;
-      }
-      const combinedArgs = {
-        scope: {
-          type: 'file',
-          args: {
-            file: file
-          }
-        },
-        fixId: fix.fixId
-      };
-      const combinedResponse = await client.execute(CommandTypes.GetCombinedCodeFix, combinedArgs);
-      if (combinedResponse.type !== 'response' || !combinedResponse.body) {
-        return edits;
-      }
-      edits.push(...combinedResponse.body.changes.map(change => toTextDocumentEdit(change, client)));
-      return edits;
+  walkNavTree(document, item, parent, results) {
+    const range = this.extractSymbol(document, item, parent);
+    if (range) {
+      results.push(range);
     }
+    item.childItems?.forEach(child => this.walkNavTree(document, child, item, results));
   }
-  return edits;
 }
 
-class SourceAction {}
-
-class SourceFixAll extends SourceAction {
-  constructor() {
-    super(...arguments);
-    this.title = 'Fix all';
-  }
-  async build(client, file, diagnostics) {
-    const edits = [];
-    edits.push(...await buildIndividualFixes([ {
-      codes: incorrectlyImplementsInterface,
-      fixName: classIncorrectlyImplementsInterface
-    }, {
-      codes: asyncOnlyAllowedInAsyncFunctions,
-      fixName: awaitInSyncFunction
-    } ], client, file, diagnostics));
-    edits.push(...await buildCombinedFix([ {
-      codes: unreachableCode$1,
-      fixName: unreachableCode
-    } ], client, file, diagnostics));
-    if (!edits.length) {
-      return null;
-    }
-    return mainExports$2.CodeAction.create(this.title, {
-      documentChanges: edits
-    }, SourceFixAll.kind.value);
-  }
-}
-
-SourceFixAll.kind = CodeActionKind.SourceFixAllTs;
-
-class SourceRemoveUnused extends SourceAction {
-  constructor() {
-    super(...arguments);
-    this.title = 'Remove all unused code';
-  }
-  async build(client, file, diagnostics) {
-    const edits = await buildCombinedFix([ {
-      codes: variableDeclaredButNeverUsed,
-      fixName: unusedIdentifier
-    } ], client, file, diagnostics);
-    if (!edits.length) {
-      return null;
-    }
-    return mainExports$2.CodeAction.create(this.title, {
-      documentChanges: edits
-    }, SourceRemoveUnused.kind.value);
-  }
-}
-
-SourceRemoveUnused.kind = CodeActionKind.SourceRemoveUnusedTs;
-
-class SourceAddMissingImports extends SourceAction {
-  constructor() {
-    super(...arguments);
-    this.title = 'Add all missing imports';
-  }
-  async build(client, file, diagnostics) {
-    const edits = await buildCombinedFix([ {
-      codes: cannotFindName,
-      fixName: fixImport
-    } ], client, file, diagnostics);
-    if (!edits.length) {
-      return null;
-    }
-    return mainExports$2.CodeAction.create(this.title, {
-      documentChanges: edits
-    }, SourceAddMissingImports.kind.value);
-  }
-}
-
-SourceAddMissingImports.kind = CodeActionKind.SourceAddMissingImportsTs;
-
-class TypeScriptAutoFixProvider {
-  static get kinds() {
-    return TypeScriptAutoFixProvider.kindProviders.map(provider => provider.kind);
-  }
-  constructor(client) {
-    this.client = client;
-  }
-  async provideCodeActions(kinds, file, diagnostics) {
-    const results = [];
-    for (const provider of TypeScriptAutoFixProvider.kindProviders) {
-      if (kinds.some(kind => kind.contains(provider.kind))) {
-        results.push((new provider).build(this.client, file, diagnostics));
-      }
-    }
-    return (await Promise.all(results)).flatMap(result => result || []);
-  }
-}
-
-TypeScriptAutoFixProvider.kindProviders = [ SourceFixAll, SourceRemoveUnused, SourceAddMissingImports ];
-
-function escapeRegExp(text) {
-  return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-}
-
-var CodeLensType;
-
-(function(CodeLensType) {
-  CodeLensType[CodeLensType['Reference'] = 0] = 'Reference';
-  CodeLensType[CodeLensType['Implementation'] = 1] = 'Implementation';
-})(CodeLensType || (CodeLensType = {}));
-
-class TypeScriptBaseCodeLensProvider {
-  constructor(client, cachedResponse, fileConfigurationManager) {
-    this.client = client;
-    this.cachedResponse = cachedResponse;
-    this.fileConfigurationManager = fileConfigurationManager;
-  }
-  async provideCodeLenses(document, token) {
-    const configuration = this.fileConfigurationManager.getWorkspacePreferencesForFile(document);
-    if (this.type === CodeLensType.Implementation && !configuration.implementationsCodeLens?.enabled || this.type === CodeLensType.Reference && !configuration.referencesCodeLens?.enabled) {
-      return [];
-    }
-    const response = await this.cachedResponse.execute(document, () => this.client.execute(CommandTypes.NavTree, {
-      file: document.filepath
-    }, token));
-    if (response.type !== 'response') {
-      return [];
-    }
-    const referenceableSpans = [];
-    response.body?.childItems?.forEach(item => this.walkNavTree(document, item, undefined, referenceableSpans));
-    return referenceableSpans.map(span => mainExports.CodeLens.create(span, {
-      uri: document.uri.toString(),
-      type: this.type
-    }));
-  }
-  walkNavTree(document, item, parent, results) {
-    const range = this.extractSymbol(document, item, parent);
-    if (range) {
-      results.push(range);
-    }
-    item.childItems?.forEach(child => this.walkNavTree(document, child, item, results));
-  }
-}
-
-TypeScriptBaseCodeLensProvider.cancelledCommand = {
-  title: '',
-  command: ''
-};
+TypeScriptBaseCodeLensProvider.cancelledCommand = {
+  title: '',
+  command: ''
+};
 
 TypeScriptBaseCodeLensProvider.errorCommand = {
   title: 'Could not determine references',
@@ -21998,85 +22146,31 @@ var libExports = requireLib();
 
 const which = getDefaultExportFromCjs(libExports);
 
-const typeMappings = {
-  directory: 'isDirectory',
-  file: 'isFile'
-};
-
-function checkType(type) {
-  if (Object.hasOwnProperty.call(typeMappings, type)) {
-    return;
-  }
-  throw new Error(`Invalid type specified: ${type}`);
-}
-
-const matchType = (type, stat) => stat[typeMappings[type]]();
-
-const toPath$1 = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
 
-function locatePathSync(paths, {cwd: cwd = process$1.cwd(), type: type = 'file', allowSymlinks: allowSymlinks = true} = {}) {
-  checkType(type);
-  cwd = toPath$1(cwd);
-  const statFunction = allowSymlinks ? fs$2.statSync : fs$2.lstatSync;
-  for (const path_ of paths) {
+function findUpSync(name, {cwd: cwd = process$1.cwd(), type: type = 'file', stopAt: stopAt} = {}) {
+  let directory = path__default.resolve(toPath(cwd) ?? '');
+  const {root: root} = path__default.parse(directory);
+  stopAt = path__default.resolve(directory, toPath(stopAt) ?? root);
+  const isAbsoluteName = path__default.isAbsolute(name);
+  while (directory) {
+    const filePath = isAbsoluteName ? name : path__default.join(directory, name);
     try {
-      const stat = statFunction(path__default.resolve(cwd, path_), {
+      const stats = fs$2.statSync(filePath, {
         throwIfNoEntry: false
       });
-      if (!stat) {
-        continue;
-      }
-      if (matchType(type, stat)) {
-        return path_;
+      if (type === 'file' && stats?.isFile() || type === 'directory' && stats?.isDirectory()) {
+        return filePath;
       }
     } catch {}
-  }
-}
-
-const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-const findUpStop = Symbol('findUpStop');
-
-function findUpMultipleSync(name, options = {}) {
-  let directory = path__default.resolve(toPath(options.cwd) || '');
-  const {root: root} = path__default.parse(directory);
-  const stopAt = options.stopAt || root;
-  const limit = options.limit || Number.POSITIVE_INFINITY;
-  const paths = [ name ].flat();
-  const runMatcher = locateOptions => {
-    {
-      return locatePathSync(paths, locateOptions);
-    }
-  };
-  const matches = [];
-  while (true) {
-    const foundPath = runMatcher({
-      ...options,
-      cwd: directory
-    });
-    if (foundPath === findUpStop) {
-      break;
-    }
-    if (foundPath) {
-      matches.push(path__default.resolve(directory, foundPath));
-    }
-    if (directory === stopAt || matches.length >= limit) {
+    if (directory === stopAt || directory === root) {
       break;
     }
     directory = path__default.dirname(directory);
   }
-  return matches;
 }
 
-function findUpSync(name, options = {}) {
-  const matches = findUpMultipleSync(name, {
-    ...options,
-    limit: 1
-  });
-  return matches[0];
-}
-
-function pkgUpSync({cwd: cwd} = {}) {
+function packageUpSync({cwd: cwd = process$1.cwd()} = {}) {
   return findUpSync('package.json', {
     cwd: cwd
   });
@@ -22203,7 +22297,7 @@ class TypeScriptVersionProvider {
       this.logger.log(`Resolved directory path from a file path: ${resolvedPath}`);
     }
     try {
-      const packageJsonPath = pkgUpSync({
+      const packageJsonPath = packageUpSync({
         cwd: resolvedPath
       });
       this.logger.log(`Resolved package.json location: "${packageJsonPath}"`);
@@ -22240,12 +22334,732 @@ class TypeScriptVersionProvider {
   }
 }
 
+class CommandManager {
+  constructor() {
+    this.commands = new Map;
+  }
+  dispose() {
+    this.commands.clear();
+  }
+  register(command) {
+    const entry = this.commands.get(command.id);
+    if (!entry) {
+      this.commands.set(command.id, command);
+    }
+  }
+  async handle(commandId, ...args) {
+    const entry = this.commands.get(commandId);
+    if (entry) {
+      await entry.execute(...args);
+      return true;
+    }
+    return false;
+  }
+}
+
+const variableDeclaredButNeverUsed = new Set([ 6196, 6133 ]);
+
+const unreachableCode$1 = new Set([ 7027 ]);
+
+const incorrectlyImplementsInterface = new Set([ 2420 ]);
+
+const cannotFindName = new Set([ 2552, 2304 ]);
+
+const asyncOnlyAllowedInAsyncFunctions = new Set([ 1308 ]);
+
+const addMissingAwait = 'addMissingAwait';
+
+const addMissingNewOperator = 'addMissingNewOperator';
+
+const addMissingOverride = 'fixOverrideModifier';
+
+const annotateWithTypeFromJSDoc = 'annotateWithTypeFromJSDoc';
+
+const awaitInSyncFunction = 'fixAwaitInSyncFunction';
+
+const classDoesntImplementInheritedAbstractMember = 'fixClassDoesntImplementInheritedAbstractMember';
+
+const classIncorrectlyImplementsInterface = 'fixClassIncorrectlyImplementsInterface';
+
+const constructorForDerivedNeedSuperCall = 'constructorForDerivedNeedSuperCall';
+
+const extendsInterfaceBecomesImplements = 'extendsInterfaceBecomesImplements';
+
+const fixImport = 'import';
+
+const forgottenThisPropertyAccess = 'forgottenThisPropertyAccess';
+
+const removeUnnecessaryAwait = 'removeUnnecessaryAwait';
+
+const spelling = 'spelling';
+
+const unreachableCode = 'fixUnreachableCode';
+
+const unusedIdentifier = 'unusedIdentifier';
+
+class TsCodeAction {
+  constructor(title, kind) {
+    this.title = title;
+    this.kind = kind;
+  }
+  toLspCodeAction() {
+    const codeAction = mainExports$2.CodeAction.create(this.title, this.kind);
+    if (this.command !== undefined) {
+      codeAction.command = this.command;
+    }
+    if (this.diagnostics !== undefined) {
+      codeAction.diagnostics = this.diagnostics;
+    }
+    if (this.disabled !== undefined) {
+      codeAction.disabled = this.disabled;
+    }
+    if (this.edit !== undefined) {
+      codeAction.edit = this.edit;
+    }
+    if (this.isPreferred !== undefined) {
+      codeAction.isPreferred = this.isPreferred;
+    }
+    return codeAction;
+  }
+}
+
+async function buildIndividualFixes(fixes, client, file, diagnostics, token) {
+  const documentChanges = [];
+  for (const diagnostic of diagnostics) {
+    for (const {codes: codes, fixName: fixName} of fixes) {
+      if (token.isCancellationRequested) {
+        return;
+      }
+      if (!codes.has(diagnostic.code)) {
+        continue;
+      }
+      const args = {
+        ...Range.toFileRangeRequestArgs(file, diagnostic.range),
+        errorCodes: [ +diagnostic.code ]
+      };
+      const response = await client.execute(CommandTypes.GetCodeFixes, args, token);
+      if (response.type !== 'response') {
+        continue;
+      }
+      const fix = response.body?.find(fix => fix.fixName === fixName);
+      if (fix) {
+        documentChanges.push(...fix.changes.map(change => toTextDocumentEdit(change, client)));
+        break;
+      }
+    }
+  }
+  return {
+    documentChanges: documentChanges
+  };
+}
+
+async function buildCombinedFix(fixes, client, file, diagnostics, token) {
+  for (const diagnostic of diagnostics) {
+    for (const {codes: codes, fixName: fixName} of fixes) {
+      if (token.isCancellationRequested) {
+        return;
+      }
+      if (!codes.has(diagnostic.code)) {
+        continue;
+      }
+      const args = {
+        ...Range.toFileRangeRequestArgs(file, diagnostic.range),
+        errorCodes: [ +diagnostic.code ]
+      };
+      const response = await client.execute(CommandTypes.GetCodeFixes, args, token);
+      if (response.type !== 'response' || !response.body?.length) {
+        continue;
+      }
+      const fix = response.body?.find(fix => fix.fixName === fixName);
+      if (!fix) {
+        continue;
+      }
+      if (!fix.fixId) {
+        return {
+          documentChanges: fix.changes.map(change => toTextDocumentEdit(change, client))
+        };
+      }
+      const combinedArgs = {
+        scope: {
+          type: 'file',
+          args: {
+            file: file
+          }
+        },
+        fixId: fix.fixId
+      };
+      const combinedResponse = await client.execute(CommandTypes.GetCombinedCodeFix, combinedArgs, token);
+      if (combinedResponse.type !== 'response' || !combinedResponse.body) {
+        return;
+      }
+      return {
+        documentChanges: combinedResponse.body.changes.map(change => toTextDocumentEdit(change, client))
+      };
+    }
+  }
+}
+
+class SourceAction extends TsCodeAction {}
+
+class SourceFixAll extends SourceAction {
+  constructor() {
+    super('Fix all fixable JS/TS issues', SourceFixAll.kind.value);
+  }
+  async build(client, file, diagnostics, token) {
+    this.edit = await buildIndividualFixes([ {
+      codes: incorrectlyImplementsInterface,
+      fixName: classIncorrectlyImplementsInterface
+    }, {
+      codes: asyncOnlyAllowedInAsyncFunctions,
+      fixName: awaitInSyncFunction
+    } ], client, file, diagnostics, token);
+    const edits = await buildCombinedFix([ {
+      codes: unreachableCode$1,
+      fixName: unreachableCode
+    } ], client, file, diagnostics, token);
+    if (edits?.documentChanges) {
+      this.edit?.documentChanges?.push(...edits.documentChanges);
+    }
+  }
+}
+
+SourceFixAll.kind = CodeActionKind.SourceFixAllTs;
+
+class SourceRemoveUnused extends SourceAction {
+  constructor() {
+    super('Remove all unused code', SourceRemoveUnused.kind.value);
+  }
+  async build(client, file, diagnostics, token) {
+    this.edit = await buildCombinedFix([ {
+      codes: variableDeclaredButNeverUsed,
+      fixName: unusedIdentifier
+    } ], client, file, diagnostics, token);
+  }
+}
+
+SourceRemoveUnused.kind = CodeActionKind.SourceRemoveUnusedTs;
+
+class SourceAddMissingImports extends SourceAction {
+  constructor() {
+    super('Add all missing imports', SourceAddMissingImports.kind.value);
+  }
+  async build(client, file, diagnostics, token) {
+    this.edit = await buildCombinedFix([ {
+      codes: cannotFindName,
+      fixName: fixImport
+    } ], client, file, diagnostics, token);
+  }
+}
+
+SourceAddMissingImports.kind = CodeActionKind.SourceAddMissingImportsTs;
+
+class TypeScriptAutoFixProvider {
+  constructor(client, fileConfigurationManager, diagnosticsManager) {
+    this.client = client;
+    this.fileConfigurationManager = fileConfigurationManager;
+    this.diagnosticsManager = diagnosticsManager;
+  }
+  getMetadata() {
+    return {
+      providedCodeActionKinds: TypeScriptAutoFixProvider.kindProviders.map(x => x.kind.value)
+    };
+  }
+  async provideCodeActions(document, _range, context, token) {
+    if (!context.only?.length) {
+      return undefined;
+    }
+    const sourceKinds = context.only.map(kind => new CodeActionKind(kind)).filter(codeActionKind => CodeActionKind.Source.intersects(codeActionKind));
+    if (!sourceKinds.length) {
+      return undefined;
+    }
+    if (this.client.hasPendingDiagnostics(document.uri)) {
+      return undefined;
+    }
+    const actions = this.getFixAllActions(sourceKinds);
+    const diagnostics = this.diagnosticsManager.getDiagnosticsForFile(document.filepath);
+    if (!diagnostics.length) {
+      return actions;
+    }
+    await this.fileConfigurationManager.ensureConfigurationForDocument(document, token);
+    if (token.isCancellationRequested) {
+      return undefined;
+    }
+    await Promise.all(actions.map(action => action.build(this.client, document.filepath, diagnostics, token)));
+    return actions;
+  }
+  isCodeActionResolvable(_codeAction) {
+    return false;
+  }
+  getFixAllActions(kinds) {
+    return TypeScriptAutoFixProvider.kindProviders.filter(provider => kinds.some(only => only.intersects(provider.kind))).map(provider => new provider);
+  }
+}
+
+TypeScriptAutoFixProvider.kindProviders = [ SourceFixAll, SourceRemoveUnused, SourceAddMissingImports ];
+
+class Lazy {
+  constructor(executor) {
+    this.executor = executor;
+    this._didRun = false;
+  }
+  get hasValue() {
+    return this._didRun;
+  }
+  get value() {
+    if (!this._didRun) {
+      try {
+        this._value = this.executor();
+      } catch (err) {
+        this._error = err;
+      } finally {
+        this._didRun = true;
+      }
+    }
+    if (this._error) {
+      throw this._error;
+    }
+    return this._value;
+  }
+  get rawValue() {
+    return this._value;
+  }
+}
+
+function getEditForCodeAction(client, action) {
+  return action.changes?.length ? {
+    documentChanges: action.changes.map(change => toTextDocumentEdit(change, client))
+  } : undefined;
+}
+
+async function applyCodeActionCommands(client, commands, token) {
+  if (commands?.length) {
+    for (const command of commands) {
+      await client.execute(CommandTypes.ApplyCodeActionCommand, {
+        command: command
+      }, token);
+    }
+  }
+  return true;
+}
+
+class ApplyCodeActionCommand {
+  constructor(client) {
+    this.client = client;
+    this.id = ApplyCodeActionCommand.ID;
+  }
+  async execute({action: action}) {
+    const codeActionResult = await applyCodeActionCommands(this.client, action.commands);
+    return codeActionResult;
+  }
+}
+
+ApplyCodeActionCommand.ID = '_typescript.applyCodeActionCommand';
+
+class ApplyFixAllCodeAction {
+  constructor(client, tsCodeActionProvider) {
+    this.client = client;
+    this.tsCodeActionProvider = tsCodeActionProvider;
+    this.id = ApplyFixAllCodeAction.ID;
+  }
+  async execute(args) {
+    const tsAction = this.tsCodeActionProvider.getQuickFixAllTsCodeActionByFixName(args.tsActionId);
+    if (tsAction instanceof TsQuickFixAllCodeAction && tsAction.combinedResponse) {
+      await applyCodeActionCommands(this.client, tsAction.combinedResponse.body.commands);
+    }
+  }
+}
+
+ApplyFixAllCodeAction.ID = '_typescript.applyFixAllCodeAction';
+
+class DiagnosticsSet {
+  static from(diagnostics) {
+    const values = new Map;
+    for (const diagnostic of diagnostics) {
+      values.set(DiagnosticsSet.key(diagnostic), diagnostic);
+    }
+    return new DiagnosticsSet(values);
+  }
+  static key(diagnostic) {
+    const {start: start, end: end} = diagnostic.range;
+    return `${diagnostic.code}-${start.line},${start.character}-${end.line},${end.character}`;
+  }
+  constructor(_values) {
+    this._values = _values;
+  }
+  get values() {
+    return this._values.values();
+  }
+  get size() {
+    return this._values.size;
+  }
+}
+
+class TsQuickFixCodeAction extends TsCodeAction {
+  constructor(tsAction, title, kind) {
+    super(title, kind);
+    this.tsAction = tsAction;
+  }
+}
+
+class TsQuickFixAllCodeAction extends TsQuickFixCodeAction {
+  constructor(tsAction, file, title, kind) {
+    super(tsAction, title, kind);
+    this.file = file;
+  }
+}
+
+class CodeActionSet {
+  constructor() {
+    this._actions = new Set;
+    this._fixAllActions = new Map;
+    this._aiActions = new Set;
+  }
+  * values() {
+    yield* this._actions;
+    yield* this._aiActions;
+  }
+  addAction(action) {
+    for (const existing of this._actions) {
+      if (action.tsAction.fixName === existing.tsAction.fixName && equals(action.edit, existing.edit)) {
+        this._actions.delete(existing);
+      }
+    }
+    this._actions.add(action);
+    if (action.tsAction.fixId) {
+      const existingFixAll = this._fixAllActions.get(action.tsAction.fixId);
+      if (existingFixAll) {
+        this._actions.delete(existingFixAll);
+        this._actions.add(existingFixAll);
+      }
+    }
+  }
+  addFixAllAction(fixId, action) {
+    const existing = this._fixAllActions.get(fixId);
+    if (existing) {
+      this._actions.delete(existing);
+    }
+    this.addAction(action);
+    this._fixAllActions.set(fixId, action);
+  }
+  hasFixAllAction(fixId) {
+    return this._fixAllActions.has(fixId);
+  }
+}
+
+class SupportedCodeActionProvider {
+  constructor(client) {
+    this.client = client;
+    this.fixableDiagnosticCodes = new Lazy(() => this.client.execute(CommandTypes.GetSupportedCodeFixes, null).then(response => response.type === 'response' ? response.body || [] : []).then(codes => new Set(codes)));
+  }
+  async getFixableDiagnosticsForContext(diagnostics) {
+    const fixableCodes = await this.fixableDiagnosticCodes.value;
+    return DiagnosticsSet.from(diagnostics.filter(diagnostic => typeof diagnostic.code !== 'undefined' && fixableCodes.has(diagnostic.code + '')));
+  }
+}
+
+class TypeScriptQuickFixProvider {
+  constructor(client, fileConfigurationManager, commandManager, diagnosticsManager, features) {
+    this.client = client;
+    this.fileConfigurationManager = fileConfigurationManager;
+    this.diagnosticsManager = diagnosticsManager;
+    this.features = features;
+    this._quickFixAllTsCodeActionMap = new Map;
+    commandManager.register(new ApplyCodeActionCommand(client));
+    commandManager.register(new ApplyFixAllCodeAction(client, this));
+    this.supportedCodeActionProvider = new SupportedCodeActionProvider(client);
+  }
+  getMetadata() {
+    return {
+      providedCodeActionKinds: [ CodeActionKind.QuickFix.value ]
+    };
+  }
+  async provideCodeActions(document, range, context, token) {
+    this._quickFixAllTsCodeActionMap.clear();
+    let diagnostics = context.diagnostics;
+    if (this.client.hasPendingDiagnostics(document.uri)) {
+      await new Promise(resolve => {
+        setTimeout(resolve, 500);
+      });
+      if (token.isCancellationRequested) {
+        return;
+      }
+      const allDiagnostics = [];
+      for (const diagnostic of this.diagnosticsManager.getDiagnosticsForFile(document.filepath)) {
+        if (Range.intersection(range, diagnostic.range)) {
+          const newLen = allDiagnostics.push(diagnostic);
+          if (newLen > TypeScriptQuickFixProvider._maxCodeActionsPerFile) {
+            break;
+          }
+        }
+      }
+      diagnostics = allDiagnostics;
+    }
+    const fixableDiagnostics = await this.supportedCodeActionProvider.getFixableDiagnosticsForContext(diagnostics);
+    if (!fixableDiagnostics.size || token.isCancellationRequested) {
+      return;
+    }
+    await this.fileConfigurationManager.ensureConfigurationForDocument(document, token);
+    if (token.isCancellationRequested) {
+      return;
+    }
+    const results = new CodeActionSet;
+    for (const diagnostic of fixableDiagnostics.values) {
+      await this.getFixesForDiagnostic(document, diagnostic, results, token);
+      if (token.isCancellationRequested) {
+        return;
+      }
+    }
+    const allActions = Array.from(results.values());
+    for (const action of allActions) {
+      action.isPreferred = isPreferredFix(action, allActions);
+    }
+    return allActions;
+  }
+  isCodeActionResolvable(codeAction) {
+    return codeAction instanceof TsQuickFixAllCodeAction;
+  }
+  async resolveCodeAction(codeAction, token) {
+    if (!this.isCodeActionResolvable(codeAction) || !codeAction.tsAction.fixId) {
+      return codeAction;
+    }
+    const arg = {
+      scope: {
+        type: 'file',
+        args: {
+          file: codeAction.file
+        }
+      },
+      fixId: codeAction.tsAction.fixId
+    };
+    const response = await this.client.execute(CommandTypes.GetCombinedCodeFix, arg, token);
+    if (response.type === 'response') {
+      codeAction.combinedResponse = response;
+      codeAction.edit = {
+        documentChanges: response.body.changes.map(change => toTextDocumentEdit(change, this.client))
+      };
+    }
+    return codeAction;
+  }
+  getQuickFixAllTsCodeActionByFixName(fixName) {
+    return this._quickFixAllTsCodeActionMap.get(fixName);
+  }
+  async getFixesForDiagnostic(document, diagnostic, results, token) {
+    const args = {
+      ...Range.toFileRangeRequestArgs(document.filepath, diagnostic.range),
+      errorCodes: [ +diagnostic.code ]
+    };
+    const response = await this.client.execute(CommandTypes.GetCodeFixes, args, token);
+    if (response.type !== 'response' || !response.body) {
+      return results;
+    }
+    for (const tsCodeFix of response.body) {
+      for (const action of this.getFixesForTsCodeAction(document, diagnostic, tsCodeFix)) {
+        results.addAction(action);
+      }
+      if (this.features.codeActionResolveSupport) {
+        this.addFixAllForTsCodeAction(results, document.uri, document.filepath, diagnostic, tsCodeFix);
+      }
+    }
+    return results;
+  }
+  getFixesForTsCodeAction(document, diagnostic, action) {
+    const actions = [];
+    const codeAction = new TsQuickFixCodeAction(action, action.description, mainExports$2.CodeActionKind.QuickFix);
+    codeAction.edit = getEditForCodeAction(this.client, action);
+    codeAction.diagnostics = [ diagnostic ];
+    codeAction.command = {
+      command: ApplyCodeActionCommand.ID,
+      arguments: [ {
+        action: action,
+        diagnostic: diagnostic,
+        documentUri: document.uri.toString()
+      } ],
+      title: ''
+    };
+    actions.push(codeAction);
+    return actions;
+  }
+  addFixAllForTsCodeAction(results, _resource, file, diagnostic, tsAction) {
+    if (!tsAction.fixId || results.hasFixAllAction(tsAction.fixId)) {
+      return results;
+    }
+    if (!this.diagnosticsManager.getDiagnosticsForFile(file).some(x => {
+      if (x === diagnostic) {
+        return false;
+      }
+      return x.code === diagnostic.code || fixAllErrorCodes.has(x.code) && fixAllErrorCodes.get(x.code) === fixAllErrorCodes.get(diagnostic.code);
+    })) {
+      return results;
+    }
+    const action = new TsQuickFixAllCodeAction(tsAction, file, tsAction.fixAllDescription || `${tsAction.description} (Fix all in file)`, mainExports$2.CodeActionKind.QuickFix);
+    action.diagnostics = [ diagnostic ];
+    action.command = {
+      command: ApplyFixAllCodeAction.ID,
+      arguments: [ {
+        tsActionId: tsAction.fixName
+      } ],
+      title: ''
+    };
+    this._quickFixAllTsCodeActionMap.set(tsAction.fixName, action);
+    results.addFixAllAction(tsAction.fixId, action);
+    return results;
+  }
+}
+
+TypeScriptQuickFixProvider._maxCodeActionsPerFile = 1e3;
+
+const fixAllErrorCodes = new Map([ [ 2339, 2339 ], [ 2345, 2339 ] ]);
+
+const preferredFixes = new Map([ [ annotateWithTypeFromJSDoc, {
+  priority: 2
+} ], [ constructorForDerivedNeedSuperCall, {
+  priority: 2
+} ], [ extendsInterfaceBecomesImplements, {
+  priority: 2
+} ], [ awaitInSyncFunction, {
+  priority: 2
+} ], [ removeUnnecessaryAwait, {
+  priority: 2
+} ], [ classIncorrectlyImplementsInterface, {
+  priority: 3
+} ], [ classDoesntImplementInheritedAbstractMember, {
+  priority: 3
+} ], [ unreachableCode, {
+  priority: 2
+} ], [ unusedIdentifier, {
+  priority: 2
+} ], [ forgottenThisPropertyAccess, {
+  priority: 2
+} ], [ spelling, {
+  priority: 0
+} ], [ addMissingAwait, {
+  priority: 2
+} ], [ addMissingOverride, {
+  priority: 2
+} ], [ addMissingNewOperator, {
+  priority: 2
+} ], [ fixImport, {
+  priority: 1,
+  thereCanOnlyBeOne: true
+} ] ]);
+
+function isPreferredFix(action, allActions) {
+  if (action instanceof TsQuickFixAllCodeAction) {
+    return false;
+  }
+  const fixPriority = preferredFixes.get(action.tsAction.fixName);
+  if (!fixPriority) {
+    return false;
+  }
+  return allActions.every(otherAction => {
+    if (otherAction === action) {
+      return true;
+    }
+    if (otherAction instanceof TsQuickFixAllCodeAction) {
+      return true;
+    }
+    const otherFixPriority = preferredFixes.get(otherAction.tsAction.fixName);
+    if (!otherFixPriority || otherFixPriority.priority < fixPriority.priority) {
+      return true;
+    } else if (otherFixPriority.priority > fixPriority.priority) {
+      return false;
+    }
+    if (fixPriority.thereCanOnlyBeOne && action.tsAction.fixName === otherAction.tsAction.fixName) {
+      return false;
+    }
+    return true;
+  });
+}
+
+const noopDisposable = mainExports$2.Disposable.create(() => {});
+
+const nulToken = {
+  isCancellationRequested: false,
+  onCancellationRequested: () => noopDisposable
+};
+
+class CodeActionManager {
+  constructor(client, fileConfigurationManager, commandManager, diagnosticsManager, features) {
+    this.features = features;
+    this.providerMap = new Map;
+    this.nextProviderId = 1;
+    this.resolveCodeActionsMap = new Map;
+    this.nextGlobalCodeActionId = 1;
+    this.addProvider(new TypeScriptAutoFixProvider(client, fileConfigurationManager, diagnosticsManager));
+    this.addProvider(new TypeScriptQuickFixProvider(client, fileConfigurationManager, commandManager, diagnosticsManager, features));
+  }
+  get kinds() {
+    const allKinds = [];
+    for (const [_, provider] of this.providerMap) {
+      allKinds.push(...provider.getMetadata().providedCodeActionKinds || []);
+    }
+    return allKinds;
+  }
+  async provideCodeActions(document, range, context, token) {
+    this.resolveCodeActionsMap.clear();
+    const allCodeActions = [];
+    for (const [providerId, provider] of this.providerMap.entries()) {
+      const codeActions = await provider.provideCodeActions(document, range, context, token || nulToken);
+      if (!codeActions) {
+        continue;
+      }
+      for (const action of codeActions) {
+        if (mainExports$2.Command.is(action)) {
+          allCodeActions.push(action);
+          continue;
+        }
+        const lspCodeAction = action.toLspCodeAction();
+        if (provider.isCodeActionResolvable(action)) {
+          const globalId = this.nextGlobalCodeActionId++;
+          this.resolveCodeActionsMap.set(globalId, action);
+          lspCodeAction.data = {
+            globalId: globalId,
+            providerId: providerId
+          };
+        }
+        allCodeActions.push(lspCodeAction);
+      }
+    }
+    return allCodeActions;
+  }
+  async resolveCodeAction(codeAction, token) {
+    if (!this.features.codeActionResolveSupport) {
+      return codeAction;
+    }
+    const {globalId: globalId, providerId: providerId} = codeAction.data || {};
+    if (globalId === undefined || providerId === undefined) {
+      return codeAction;
+    }
+    const provider = this.providerMap.get(providerId);
+    if (!provider || !provider.resolveCodeAction) {
+      return codeAction;
+    }
+    const tsCodeAction = this.resolveCodeActionsMap.get(globalId);
+    if (!tsCodeAction || !providerId) {
+      return codeAction;
+    }
+    const resolvedTsCodeAction = await provider.resolveCodeAction(tsCodeAction, token || nulToken);
+    if (!resolvedTsCodeAction) {
+      return codeAction;
+    }
+    const lspCodeAction = resolvedTsCodeAction.toLspCodeAction();
+    for (const property of this.features.codeActionResolveSupport.properties) {
+      if (property in lspCodeAction) {
+        codeAction[property] = lspCodeAction[property];
+      }
+    }
+    return codeAction;
+  }
+  addProvider(provider) {
+    this.providerMap.set(this.nextProviderId++, provider);
+  }
+}
+
 class LspServer {
   constructor(options) {
     this.options = options;
     this.initializeParams = null;
     this.completionDataCache = new CompletionDataCache;
-    this.typeScriptAutoFixProvider = null;
     this.features = {};
     this.cachedNavTreeResponse = new CachedResponse;
     this.implementationsCodeLensProvider = null;
@@ -22253,7 +23067,9 @@ class LspServer {
     this.logger = new PrefixingLogger(options.logger, '[lspserver]');
     this.tsClient = new TsClient(onCaseInsensitiveFileSystem(), this.logger, options.lspClient);
     this.fileConfigurationManager = new FileConfigurationManager(this.tsClient, onCaseInsensitiveFileSystem());
-    this.diagnosticQueue = new DiagnosticEventQueue(diagnostics => this.options.lspClient.publishDiagnostics(diagnostics), this.tsClient, this.features, this.logger);
+    this.commandManager = new CommandManager;
+    this.diagnosticsManager = new DiagnosticsManager(diagnostics => this.options.lspClient.publishDiagnostics(diagnostics), this.tsClient, this.features, this.logger);
+    this.codeActionsManager = new CodeActionManager(this.tsClient, this.fileConfigurationManager, this.commandManager, this.diagnosticsManager, this.features);
   }
   closeAllForTesting() {
     for (const document of this.tsClient.documentsForTesting.values()) {
@@ -22265,7 +23081,7 @@ class LspServer {
     if (!document) {
       throw new Error(`Document not open: ${uri}`);
     }
-    await this.diagnosticQueue.waitForDiagnosticsForTesting(document.filepath);
+    await this.diagnosticsManager.waitForDiagnosticsForTesting(document.filepath);
   }
   shutdown() {
     this.tsClient.shutdown();
@@ -22287,11 +23103,13 @@ class LspServer {
     }
     this.fileConfigurationManager.mergeTsPreferences(userInitializationOptions.preferences || {});
     this.features.completionDisableFilterText = userInitializationOptions.completionDisableFilterText ?? false;
+    this.features.moveToFileCodeActionSupport = userInitializationOptions.supportsMoveToFileCodeAction && typescriptVersion.version?.gte(API.v520);
     const {textDocument: textDocument} = clientCapabilities;
     if (textDocument) {
       const {codeAction: codeAction, completion: completion, definition: definition, publishDiagnostics: publishDiagnostics} = textDocument;
       if (codeAction) {
         this.features.codeActionDisabledSupport = codeAction.disabledSupport;
+        this.features.codeActionResolveSupport = codeAction.resolveSupport;
       }
       if (completion) {
         const {completionItem: completionItem} = completion;
@@ -22342,10 +23160,10 @@ class LspServer {
     process.on('SIGINT', () => {
       process.exit();
     });
-    this.typeScriptAutoFixProvider = new TypeScriptAutoFixProvider(this.tsClient);
     this.fileConfigurationManager.setGlobalConfiguration(this.workspaceRoot, hostInfo);
     this.registerHandlers();
     const prepareSupport = textDocument?.rename?.prepareSupport && this.tsClient.apiVersion.gte(API.v310);
+    const {codeActionLiteralSupport: codeActionLiteralSupport, resolveSupport: codeActionResolveSupport} = textDocument?.codeAction || {};
     const initializeResult = {
       capabilities: {
         textDocumentSync: mainExports$2.TextDocumentSyncKind.Incremental,
@@ -22353,8 +23171,13 @@ class LspServer {
           triggerCharacters: [ '.', '"', '\'', '/', '@', '<' ],
           resolveProvider: true
         },
-        codeActionProvider: clientCapabilities.textDocument?.codeAction?.codeActionLiteralSupport ? {
-          codeActionKinds: [ ...TypeScriptAutoFixProvider.kinds.map(kind => kind.value), CodeActionKind.SourceOrganizeImportsTs.value, CodeActionKind.SourceRemoveUnusedImportsTs.value, CodeActionKind.SourceSortImportsTs.value, CodeActionKind.QuickFix.value, CodeActionKind.Refactor.value ]
+        codeActionProvider: codeActionLiteralSupport || codeActionResolveSupport ? {
+          ...codeActionLiteralSupport ? {
+            codeActionKinds: [ ...this.codeActionsManager.kinds, CodeActionKind.SourceOrganizeImportsTs.value, CodeActionKind.SourceRemoveUnusedImportsTs.value, CodeActionKind.SourceSortImportsTs.value, CodeActionKind.Refactor.value ]
+          } : {},
+          ...codeActionResolveSupport ? {
+            resolveProvider: true
+          } : {}
         } : true,
         codeLensProvider: {
           resolveProvider: true
@@ -22365,7 +23188,7 @@ class LspServer {
         documentHighlightProvider: true,
         documentSymbolProvider: true,
         executeCommandProvider: {
-          commands: [ Commands.APPLY_WORKSPACE_EDIT, Commands.APPLY_CODE_ACTION, Commands.APPLY_REFACTORING, Commands.CONFIGURE_PLUGIN, Commands.ORGANIZE_IMPORTS, Commands.APPLY_RENAME_FILE, Commands.SOURCE_DEFINITION, Commands.TS_SERVER_REQUEST ]
+          commands: [ Commands.APPLY_REFACTORING, Commands.CONFIGURE_PLUGIN, Commands.ORGANIZE_IMPORTS, Commands.APPLY_RENAME_FILE, Commands.SOURCE_DEFINITION, Commands.TS_SERVER_REQUEST ]
         },
         hoverProvider: true,
         inlayHintProvider: true,
@@ -22476,7 +23299,7 @@ class LspServer {
   didChangeConfiguration(params) {
     this.fileConfigurationManager.setWorkspaceConfiguration(params.settings || {});
     const ignoredDiagnosticCodes = this.fileConfigurationManager.workspaceConfiguration.diagnostics?.ignoredCodes || [];
-    this.tsClient.interruptGetErr(() => this.diagnosticQueue.updateIgnoredDiagnosticCodes(ignoredDiagnosticCodes));
+    this.tsClient.interruptGetErr(() => this.diagnosticsManager.updateIgnoredDiagnosticCodes(ignoredDiagnosticCodes));
   }
   didOpenTextDocument(params) {
     if (this.tsClient.toOpenDocument(params.textDocument.uri, {
@@ -22498,7 +23321,7 @@ class LspServer {
     }
     this.cachedNavTreeResponse.onDocumentClose(document);
     this.tsClient.onDidCloseTextDocument(uri);
-    this.diagnosticQueue.onDidCloseFile(document.filepath);
+    this.diagnosticsManager.onDidCloseFile(document.filepath);
     this.fileConfigurationManager.onDidCloseTextDocument(document.uri);
   }
   didChangeTextDocument(params) {
@@ -22822,15 +23645,11 @@ class LspServer {
     if (!document) {
       return [];
     }
-    await this.tsClient.interruptGetErr(() => this.fileConfigurationManager.ensureConfigurationForDocument(document));
+    const actions = await this.codeActionsManager.provideCodeActions(document, params.range, params.context, token);
     const fileRangeArgs = Range.toFileRangeRequestArgs(document.filepath, params.range);
-    const actions = [];
     const kinds = params.context.only?.map(kind => new CodeActionKind(kind));
-    if (!kinds || kinds.some(kind => kind.contains(CodeActionKind.QuickFix))) {
-      actions.push(...provideQuickFix(await this.getCodeFixes(fileRangeArgs, params.context, token), this.tsClient));
-    }
-    if (!kinds || kinds.some(kind => kind.contains(CodeActionKind.Refactor))) {
-      actions.push(...provideRefactors(await this.getRefactors(fileRangeArgs, params.context, token), fileRangeArgs, this.features));
+    if (!kinds || kinds.some(kind => CodeActionKind.Refactor.contains(kind))) {
+      actions.push(...provideRefactors(await this.getRefactors(fileRangeArgs, params.context, this.features, token), fileRangeArgs, this.features));
     }
     for (const kind of kinds || []) {
       for (const command of organizeImportsCommands) {
@@ -22858,57 +23677,36 @@ class LspServer {
         }
       }
     }
-    if (kinds && !this.tsClient.hasPendingDiagnostics(document.uri)) {
-      const diagnostics = this.diagnosticQueue.getDiagnosticsForFile(document.filepath) || [];
-      if (diagnostics.length) {
-        actions.push(...await this.typeScriptAutoFixProvider.provideCodeActions(kinds, document.filepath, diagnostics));
-      }
-    }
     return actions;
   }
-  async getCodeFixes(fileRangeArgs, context, token) {
-    const errorCodes = context.diagnostics.map(diagnostic => Number(diagnostic.code));
-    const args = {
-      ...fileRangeArgs,
-      errorCodes: errorCodes
-    };
-    const response = await this.tsClient.execute(CommandTypes.GetCodeFixes, args, token);
-    return response.type === 'response' ? response : undefined;
+  async getRefactors(fileRangeArgs, context, features, token) {
+    const kinds = context.only || [ undefined ];
+    const responses = await Promise.all(kinds.map(async kind => {
+      const args = {
+        ...fileRangeArgs,
+        triggerReason: context.triggerKind === mainExports$2.CodeActionTriggerKind.Invoked ? 'invoked' : undefined,
+        kind: kind,
+        includeInteractiveActions: features.moveToFileCodeActionSupport
+      };
+      const response = await this.tsClient.execute(CommandTypes.GetApplicableRefactors, args, token);
+      return response.type === 'response' && response.body ? response.body : [];
+    }));
+    return responses.flat();
   }
-  async getRefactors(fileRangeArgs, context, token) {
-    const args = {
-      ...fileRangeArgs,
-      triggerReason: context.triggerKind === mainExports$2.CodeActionTriggerKind.Invoked ? 'invoked' : undefined,
-      kind: context.only?.length === 1 ? context.only[0] : undefined
-    };
-    const response = await this.tsClient.execute(CommandTypes.GetApplicableRefactors, args, token);
-    return response.type === 'response' ? response : undefined;
+  async codeActionResolve(params, _token) {
+    return this.codeActionsManager.resolveCodeAction(params);
   }
   async executeCommand(params, token, workDoneProgress) {
-    if (params.command === Commands.APPLY_WORKSPACE_EDIT && params.arguments) {
-      const edit = params.arguments[0];
-      await this.options.lspClient.applyWorkspaceEdit({
-        edit: edit
-      });
-    } else if (params.command === Commands.APPLY_CODE_ACTION && params.arguments) {
-      const codeAction = params.arguments[0];
-      if (!await this.applyFileCodeEdits(codeAction.changes)) {
-        return;
-      }
-      if (codeAction.commands?.length) {
-        for (const command of codeAction.commands) {
-          await this.tsClient.execute(CommandTypes.ApplyCodeActionCommand, {
-            command: command
-          }, token);
-        }
-      }
-    } else if (params.command === Commands.APPLY_REFACTORING && params.arguments) {
+    if (await this.commandManager.handle(params.command, ...params.arguments || [])) ; else if (params.command === Commands.APPLY_REFACTORING && params.arguments) {
       const args = params.arguments[0];
       const response = await this.tsClient.execute(CommandTypes.GetEditsForRefactor, args, token);
       if (response.type !== 'response' || !response.body) {
         return;
       }
       const {body: body} = response;
+      if (body?.notApplicableReason) {
+        throw new Error(body.notApplicableReason);
+      }
       if (!body?.edits.length) {
         return;
       }
@@ -23154,7 +23952,7 @@ class LspServer {
       const diagnosticEvent = event;
       if (diagnosticEvent.body?.diagnostics) {
         const {file: file, diagnostics: diagnostics} = diagnosticEvent.body;
-        this.diagnosticQueue.updateDiagnostics(getDignosticsKind(event), file, diagnostics);
+        this.diagnosticsManager.updateDiagnostics(getDignosticsKind(event), file, diagnostics);
       }
     }
   }
@@ -23325,6 +24123,7 @@ function createLspConnection(options) {
   connection.onDidCloseTextDocument(server.didCloseTextDocument.bind(server));
   connection.onDidChangeTextDocument(server.didChangeTextDocument.bind(server));
   connection.onCodeAction(server.codeAction.bind(server));
+  connection.onCodeActionResolve(server.codeActionResolve.bind(server));
   connection.onCodeLens(server.codeLens.bind(server));
   connection.onCodeLensResolve(server.codeLensResolve.bind(server));
   connection.onCompletion(server.completion.bind(server));