typescript-language-server 5.0.0 → 5.1.0

package/lib/cli.mjs

@@ -1,21 +1,11 @@
 #!/usr/bin/env node
 import fs$2, { promises, statSync, existsSync, readFileSync } from 'node:fs';
 
-import require$$0 from 'node:events';
-
-import require$$1 from 'node:child_process';
-
-import * as path from 'node:path';
-
-import path__default, { extname, resolve } from 'node:path';
-
-import process$1 from 'node:process';
-
-import require$$0$4, { promisify as promisify$1 } from 'node:util';
+import { createRequire } from 'node:module';
 
-import require$$0$1, { promisify } from 'util';
+import require$$0, { promisify } from 'util';
 
-import require$$1$1 from 'path';
+import require$$1 from 'path';
 
 import require$$2 from 'os';
 
@@ -23,15 +13,19 @@ import crypto from 'crypto';
 
 import require$$4 from 'net';
 
-import require$$0$2 from 'url';
+import require$$0$1 from 'url';
 
-import require$$0$3 from 'fs';
+import require$$0$2 from 'fs';
 
 import require$$3 from 'child_process';
 
-import require$$0$5 from 'constants';
+import * as path from 'node:path';
+
+import path__default, { extname, resolve } from 'node:path';
+
+import require$$0$3 from 'constants';
 
-import require$$0$6 from 'stream';
+import require$$0$4 from 'stream';
 
 import require$$5 from 'assert';
 
@@ -41,9 +35,13 @@ import 'node:fs/promises';
 
 import stream from 'node:stream';
 
-import { createRequire } from 'node:module';
+import { promisify as promisify$1 } from 'node:util';
+
+import ChildProcess from 'node:child_process';
+
+import require$$1$1 from 'fs/promises';
 
-import require$$1$2 from 'fs/promises';
+import process$1 from 'node:process';
 
 import { fileURLToPath } from 'node:url';
 
@@ -173,6 +171,36 @@ function requireArgument() {
 
 var command = {};
 
+const require$5 = createRequire(import.meta.url);
+
+function __require$5() {
+  return require$5('node:events');
+}
+
+const require$4 = createRequire(import.meta.url);
+
+function __require$4() {
+  return require$4('node:child_process');
+}
+
+const require$3 = createRequire(import.meta.url);
+
+function __require$3() {
+  return require$3('node:path');
+}
+
+const require$2 = createRequire(import.meta.url);
+
+function __require$2() {
+  return require$2('node:fs');
+}
+
+const require$1 = createRequire(import.meta.url);
+
+function __require$1() {
+  return require$1('node:process');
+}
+
 var help = {};
 
 var hasRequiredHelp;
@@ -751,11 +779,11 @@ var hasRequiredCommand;
 function requireCommand() {
   if (hasRequiredCommand) return command;
   hasRequiredCommand = 1;
-  const EventEmitter = require$$0.EventEmitter;
-  const childProcess = require$$1;
-  const path = path__default;
-  const fs = fs$2;
-  const process = process$1;
+  const EventEmitter = __require$5().EventEmitter;
+  const childProcess = __require$4();
+  const path = __require$3();
+  const fs = __require$2();
+  const process = __require$1();
   const {Argument: Argument, humanReadableArgName: humanReadableArgName} = requireArgument();
   const {CommanderError: CommanderError} = requireError();
   const {Help: Help, stripColor: stripColor} = requireHelp();
@@ -1605,7 +1633,7 @@ function requireCommand() {
         return arg.length > 1 && arg[0] === '-';
       }
       const negativeNumberArg = arg => {
-        if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg)) return false;
+        if (!/^-(\d+|\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;
@@ -2127,6 +2155,12 @@ const {program: program$1, createCommand: createCommand, createArgument: createA
 
 var main$3 = {};
 
+const require = createRequire(import.meta.url);
+
+function __require() {
+  return require('node:util');
+}
+
 var is$2 = {};
 
 var hasRequiredIs$2;
@@ -5334,7 +5368,7 @@ function requireRil() {
   Object.defineProperty(ril, '__esModule', {
     value: true
   });
-  const util_1 = require$$0$1;
+  const util_1 = require$$0;
   const api_1 = requireApi$2();
   class MessageBuffer extends api_1.AbstractMessageBuffer {
     constructor(encoding = 'utf-8') {
@@ -5522,7 +5556,7 @@ function requireMain$3() {
     exports.createMessageConnection = exports.createServerSocketTransport = exports.createClientSocketTransport = exports.createServerPipeTransport = exports.createClientPipeTransport = exports.generateRandomPipeName = exports.StreamMessageWriter = exports.StreamMessageReader = exports.SocketMessageWriter = exports.SocketMessageReader = exports.PortMessageWriter = exports.PortMessageReader = exports.IPCMessageWriter = exports.IPCMessageReader = void 0;
     const ril_1 = requireRil();
     ril_1.default.install();
-    const path = require$$1$1;
+    const path = require$$1;
     const os = require$$2;
     const crypto_1 = crypto;
     const net_1 = require$$4;
@@ -11133,9 +11167,9 @@ function requireFiles() {
     value: true
   });
   files.resolveModulePath = files.FileSystem = files.resolveGlobalYarnPath = files.resolveGlobalNodePath = files.resolve = files.uriToFilePath = void 0;
-  const url = require$$0$2;
-  const path = require$$1$1;
-  const fs = require$$0$3;
+  const url = require$$0$1;
+  const path = require$$1;
+  const fs = require$$0$2;
   const child_process_1 = require$$3;
   function uriToFilePath(uri) {
     let parsed = url.parse(uri);
@@ -11468,7 +11502,7 @@ function requireMain() {
       value: true
     });
     exports.createConnection = exports.Files = void 0;
-    const node_util_1 = require$$0$4;
+    const node_util_1 = __require();
     const Is = requireIs$2();
     const server_1 = requireServer();
     const fm = requireFiles();
@@ -11902,7 +11936,7 @@ var hasRequiredPolyfills;
 function requirePolyfills() {
   if (hasRequiredPolyfills) return polyfills;
   hasRequiredPolyfills = 1;
-  var constants = require$$0$5;
+  var constants = require$$0$3;
   var origCwd = process.cwd;
   var cwd = null;
   var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -12174,7 +12208,7 @@ var hasRequiredLegacyStreams;
 function requireLegacyStreams() {
   if (hasRequiredLegacyStreams) return legacyStreams;
   hasRequiredLegacyStreams = 1;
-  var Stream = require$$0$6.Stream;
+  var Stream = require$$0$4.Stream;
   legacyStreams = legacy;
   function legacy(fs) {
     return {
@@ -12298,11 +12332,11 @@ var hasRequiredGracefulFs;
 function requireGracefulFs() {
   if (hasRequiredGracefulFs) return gracefulFs;
   hasRequiredGracefulFs = 1;
-  var fs = require$$0$3;
+  var fs = require$$0$2;
   var polyfills = requirePolyfills();
   var legacy = requireLegacyStreams();
   var clone = requireClone();
-  var util = require$$0$1;
+  var util = require$$0;
   var gracefulQueue;
   var previousSymbol;
   if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
@@ -12701,7 +12735,7 @@ var hasRequiredUtils$1;
 function requireUtils$1() {
   if (hasRequiredUtils$1) return utils$1;
   hasRequiredUtils$1 = 1;
-  const path = require$$1$1;
+  const path = require$$1;
   utils$1.checkPath = function checkPath(pth) {
     if (process.platform === 'win32') {
       const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''));
@@ -12834,7 +12868,7 @@ function requireStat() {
   if (hasRequiredStat) return stat;
   hasRequiredStat = 1;
   const fs = requireFs();
-  const path = require$$1$1;
+  const path = require$$1;
   const u = requireUniversalify().fromPromise;
   function getStats(src, dest, opts) {
     const statFunc = opts.dereference ? file => fs.stat(file, {
@@ -12990,6 +13024,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;
@@ -12998,11 +13054,12 @@ function requireCopy$1() {
   if (hasRequiredCopy$1) return copy_1;
   hasRequiredCopy$1 = 1;
   const fs = requireFs();
-  const path = require$$1$1;
+  const path = require$$1;
   const {mkdirs: mkdirs} = requireMkdirs();
   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 = {
@@ -13070,17 +13127,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);
     }
@@ -13124,7 +13179,7 @@ function requireCopySync() {
   if (hasRequiredCopySync) return copySync_1;
   hasRequiredCopySync = 1;
   const fs = requireGracefulFs();
-  const path = require$$1$1;
+  const path = require$$1;
   const mkdirsSync = requireMkdirs().mkdirsSync;
   const utimesMillisSync = requireUtimes().utimesMillisSync;
   const stat = requireStat();
@@ -13301,7 +13356,7 @@ function requireEmpty() {
   hasRequiredEmpty = 1;
   const u = requireUniversalify().fromPromise;
   const fs = requireFs();
-  const path = require$$1$1;
+  const path = require$$1;
   const mkdir = requireMkdirs();
   const remove = requireRemove();
   const emptyDir = u(async function emptyDir(dir) {
@@ -13342,7 +13397,7 @@ function requireFile() {
   if (hasRequiredFile) return file$1;
   hasRequiredFile = 1;
   const u = requireUniversalify().fromPromise;
-  const path = require$$1$1;
+  const path = require$$1;
   const fs = requireFs();
   const mkdir = requireMkdirs();
   async function createFile(file) {
@@ -13401,7 +13456,7 @@ function requireLink() {
   if (hasRequiredLink) return link;
   hasRequiredLink = 1;
   const u = requireUniversalify().fromPromise;
-  const path = require$$1$1;
+  const path = require$$1;
   const fs = requireFs();
   const mkdir = requireMkdirs();
   const {pathExists: pathExists} = requirePathExists();
@@ -13458,7 +13513,7 @@ var hasRequiredSymlinkPaths;
 function requireSymlinkPaths() {
   if (hasRequiredSymlinkPaths) return symlinkPaths_1;
   hasRequiredSymlinkPaths = 1;
-  const path = require$$1$1;
+  const path = require$$1;
   const fs = requireFs();
   const {pathExists: pathExists} = requirePathExists();
   const u = requireUniversalify().fromPromise;
@@ -13571,7 +13626,7 @@ function requireSymlink() {
   if (hasRequiredSymlink) return symlink;
   hasRequiredSymlink = 1;
   const u = requireUniversalify().fromPromise;
-  const path = require$$1$1;
+  const path = require$$1;
   const fs = requireFs();
   const {mkdirs: mkdirs, mkdirsSync: mkdirsSync} = requireMkdirs();
   const {symlinkPaths: symlinkPaths, symlinkPathsSync: symlinkPathsSync} = requireSymlinkPaths();
@@ -13683,7 +13738,7 @@ function requireJsonfile$1() {
   try {
     _fs = requireGracefulFs();
   } catch (_) {
-    _fs = require$$0$3;
+    _fs = require$$0$2;
   }
   const universalify = requireUniversalify();
   const {stringify: stringify, stripBom: stripBom} = requireUtils();
@@ -13778,7 +13833,7 @@ function requireOutputFile() {
   hasRequiredOutputFile = 1;
   const u = requireUniversalify().fromPromise;
   const fs = requireFs();
-  const path = require$$1$1;
+  const path = require$$1;
   const mkdir = requireMkdirs();
   const pathExists = requirePathExists().pathExists;
   async function outputFile(file, data, encoding = 'utf-8') {
@@ -13865,7 +13920,7 @@ function requireMove$1() {
   if (hasRequiredMove$1) return move_1;
   hasRequiredMove$1 = 1;
   const fs = requireFs();
-  const path = require$$1$1;
+  const path = require$$1;
   const {copy: copy} = requireCopy();
   const {remove: remove} = requireRemove();
   const {mkdirp: mkdirp} = requireMkdirs();
@@ -13920,7 +13975,7 @@ function requireMoveSync() {
   if (hasRequiredMoveSync) return moveSync_1;
   hasRequiredMoveSync = 1;
   const fs = requireGracefulFs();
-  const path = require$$1$1;
+  const path = require$$1;
   const copySync = requireCopy().copySync;
   const removeSync = requireRemove().removeSync;
   const mkdirpSync = requireMkdirs().mkdirpSync;
@@ -15205,6 +15260,9 @@ function requireIdentifiers() {
   hasRequiredIdentifiers = 1;
   const numeric = /^[0-9]+$/;
   const compareIdentifiers = (a, b) => {
+    if (typeof a === 'number' && typeof b === 'number') {
+      return a === b ? 0 : a < b ? -1 : 1;
+    }
     const anum = numeric.test(a);
     const bnum = numeric.test(b);
     if (anum && bnum) {
@@ -15312,7 +15370,25 @@ function requireSemver$1() {
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
-      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+      if (this.major < other.major) {
+        return -1;
+      }
+      if (this.major > other.major) {
+        return 1;
+      }
+      if (this.minor < other.minor) {
+        return -1;
+      }
+      if (this.minor > other.minor) {
+        return 1;
+      }
+      if (this.patch < other.patch) {
+        return -1;
+      }
+      if (this.patch > other.patch) {
+        return 1;
+      }
+      return 0;
     }
     comparePre(other) {
       if (!(other instanceof SemVer)) {
@@ -16140,6 +16216,7 @@ function requireRange() {
     return result;
   };
   const parseComparator = (comp, options) => {
+    comp = comp.replace(re[t.BUILD], '');
     debug('comp', comp, options);
     comp = replaceCarets(comp, options);
     debug('caret', comp);
@@ -18191,7 +18268,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)) {
@@ -18466,7 +18543,7 @@ class NodeTsServerProcessFactory {
     if (useIpc) {
       runtimeArgs.push('--useNodeIpc');
     }
-    const childProcess = require$$1.fork(tsServerPath, runtimeArgs, {
+    const childProcess = ChildProcess.fork(tsServerPath, runtimeArgs, {
       silent: true,
       cwd: undefined,
       env: generatePatchedEnv(process.env, tsServerPath),
@@ -19305,7 +19382,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();
       });
     }
@@ -19375,43 +19453,124 @@ class TsClient {
   }
 }
 
-const pDebounce = (fn, wait, options = {}) => {
+const pDebounce = (functionToDebounce, wait, options = {}) => {
   if (!Number.isFinite(wait)) {
     throw new TypeError('Expected `wait` to be a finite number');
   }
   let leadingValue;
   let timeout;
-  let resolveList = [];
+  let promiseHandlers = [];
+  const onAbort = () => {
+    clearTimeout(timeout);
+    timeout = undefined;
+    try {
+      options.signal?.throwIfAborted();
+    } catch (error) {
+      for (const {reject: reject} of promiseHandlers) {
+        reject(error);
+      }
+      promiseHandlers = [];
+    }
+  };
   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 = null;
-        const result = options.before ? leadingValue : fn.apply(this, arguments_);
-        for (resolve of resolveList) {
-          resolve(result);
+      timeout = setTimeout(async () => {
+        timeout = undefined;
+        const currentHandlers = promiseHandlers;
+        promiseHandlers = [];
+        try {
+          const result = options.before ? leadingValue : await functionToDebounce.apply(this, arguments_);
+          for (const {resolve: resolveFunction} of currentHandlers) {
+            resolveFunction(result);
+          }
+        } catch (error) {
+          for (const {reject: rejectFunction} of currentHandlers) {
+            rejectFunction(error);
+          }
         }
-        resolveList = [];
+        leadingValue = undefined;
+        options.signal?.removeEventListener('abort', onAbort);
       }, wait);
       if (shouldCallNow) {
-        leadingValue = fn.apply(this, arguments_);
-        resolve(leadingValue);
+        (async () => {
+          try {
+            leadingValue = await functionToDebounce.apply(this, arguments_);
+            resolve(leadingValue);
+          } catch (error) {
+            reject(error);
+          }
+        })();
       } else {
-        resolveList.push(resolve);
+        promiseHandlers.push({
+          resolve: resolve,
+          reject: reject
+        });
+        if (options.signal && promiseHandlers.length === 1) {
+          options.signal.addEventListener('abort', onAbort, {
+            once: true
+          });
+        }
       }
     });
   };
 };
 
-pDebounce.promise = function_ => {
+pDebounce.promise = (function_, options = {}) => {
   let currentPromise;
+  let queuedCall;
   return async function(...arguments_) {
     if (currentPromise) {
-      return currentPromise;
+      if (!options.after) {
+        return currentPromise;
+      }
+      queuedCall ??= {
+        resolvers: []
+      };
+      queuedCall.arguments = arguments_;
+      queuedCall.context = this;
+      return new Promise((resolve, reject) => {
+        queuedCall.resolvers.push({
+          resolve: resolve,
+          reject: reject
+        });
+      });
     }
+    currentPromise = (async () => {
+      let result;
+      let initialError;
+      try {
+        result = await function_.apply(this, arguments_);
+      } catch (error) {
+        initialError = error;
+      }
+      while (queuedCall) {
+        const call = queuedCall;
+        queuedCall = undefined;
+        try {
+          const queuedResult = await function_.apply(call.context, call.arguments);
+          for (const {resolve: resolve} of call.resolvers) {
+            resolve(queuedResult);
+          }
+        } catch (error) {
+          for (const {reject: reject} of call.resolvers) {
+            reject(error);
+          }
+        }
+      }
+      if (initialError) {
+        throw initialError;
+      }
+      return result;
+    })();
     try {
-      currentPromise = function_.apply(this, arguments_);
       return await currentPromise;
     } finally {
       currentPromise = undefined;
@@ -19741,7 +19900,7 @@ class FileDiagnostics {
   }
 }
 
-class DiagnosticEventQueue {
+class DiagnosticsManager {
   constructor(publishDiagnostics, client, features, logger) {
     this.publishDiagnostics = publishDiagnostics;
     this.client = client;
@@ -19858,8 +20017,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',
@@ -20682,19 +20839,6 @@ 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(CodeActionKind) {
@@ -21298,8 +21442,9 @@ function areFileConfigurationsEqual(a, b) {
 }
 
 class FileConfigurationManager {
-  constructor(client, onCaseInsensitiveFileSystem) {
+  constructor(client, lspClient, onCaseInsensitiveFileSystem) {
     this.client = client;
+    this.lspClient = lspClient;
     this.tsPreferences = deepmerge({}, DEFAULT_TSSERVER_PREFERENCES);
     this.workspaceConfiguration = deepmerge({}, DEFAULT_WORKSPACE_CONFIGURATION);
     this.formatOptions = new ResourceMap(undefined, {
@@ -21344,7 +21489,15 @@ class FileConfigurationManager {
     });
   }
   async ensureConfigurationForDocument(document, token) {
-    return this.ensureConfigurationOptions(document, undefined, token);
+    const formattingOptions = await this.getFormattingOptions(document);
+    return this.ensureConfigurationOptions(document, formattingOptions, token);
+  }
+  async getFormattingOptions(document) {
+    const formatConfiguration = await this.lspClient.getWorkspaceConfiguration(document.uri.toString(), 'formattingOptions') || {};
+    return {
+      tabSize: typeof formatConfiguration.tabSize === 'number' ? formatConfiguration.tabSize : undefined,
+      insertSpaces: typeof formatConfiguration.insertSpaces === 'boolean' ? formatConfiguration.insertSpaces : undefined
+    };
   }
   async ensureConfigurationOptions(document, options, token) {
     const currentOptions = this.getFileOptions(document, options);
@@ -21440,187 +21593,6 @@ 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';
-
-const unusedIdentifier = 'unusedIdentifier';
-
-const fixImport = 'import';
-
-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;
-      }
-    }
-  }
-  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;
-    }
-  }
-  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, '\\$&');
 }
@@ -22006,8 +21978,8 @@ function requirePosix() {
     value: true
   });
   posix.sync = posix.isexe = void 0;
-  const fs_1 = require$$0$3;
-  const promises_1 = require$$1$2;
+  const fs_1 = require$$0$2;
+  const promises_1 = require$$1$1;
   const isexe = async (path, options = {}) => {
     const {ignoreErrors: ignoreErrors = false} = options;
     try {
@@ -22062,8 +22034,8 @@ function requireWin32() {
     value: true
   });
   win32.sync = win32.isexe = void 0;
-  const fs_1 = require$$0$3;
-  const promises_1 = require$$1$2;
+  const fs_1 = require$$0$2;
+  const promises_1 = require$$1$1;
   const isexe = async (path, options = {}) => {
     const {ignoreErrors: ignoreErrors = false} = options;
     try {
@@ -22183,7 +22155,7 @@ function requireLib() {
   if (hasRequiredLib) return lib;
   hasRequiredLib = 1;
   const {isexe: isexe, sync: isexeSync} = requireCjs();
-  const {join: join, delimiter: delimiter, sep: sep, posix: posix} = require$$1$1;
+  const {join: join, delimiter: delimiter, sep: sep, posix: posix} = require$$1;
   const isWindows = process.platform === 'win32';
   const rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? '' : sep}]`.replace(/(\\)/g, '\\$1'));
   const rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -22465,20 +22437,742 @@ class TypeScriptVersionProvider {
   }
 }
 
-class LspServer {
-  constructor(options) {
-    this.options = options;
-    this.initializeParams = null;
-    this.completionDataCache = new CompletionDataCache;
-    this.typeScriptAutoFixProvider = null;
-    this.features = {};
+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.features = {};
     this.cachedNavTreeResponse = new CachedResponse;
     this.implementationsCodeLensProvider = null;
     this.referencesCodeLensProvider = null;
     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.fileConfigurationManager = new FileConfigurationManager(this.tsClient, this.options.lspClient, onCaseInsensitiveFileSystem());
+    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()) {
@@ -22490,7 +23184,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();
@@ -22518,6 +23212,7 @@ class LspServer {
       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;
@@ -22568,10 +23263,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,
@@ -22579,8 +23274,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
@@ -22591,7 +23291,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,
@@ -22702,7 +23402,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, {
@@ -22724,7 +23424,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) {
@@ -23048,13 +23748,9 @@ 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 => CodeActionKind.QuickFix.contains(kind))) {
-      actions.push(...provideQuickFix(await this.getCodeFixes(fileRangeArgs, params.context, token), this.tsClient));
-    }
     if (!kinds || kinds.some(kind => CodeActionKind.Refactor.contains(kind))) {
       actions.push(...provideRefactors(await this.getRefactors(fileRangeArgs, params.context, this.features, token), fileRangeArgs, this.features));
     }
@@ -23071,36 +23767,24 @@ class LspServer {
           skipDestructiveCodeActions = documentHasErrors;
           mode = OrganizeImportsMode.SortAndCombine;
         }
-        const response = await this.tsClient.interruptGetErr(() => this.tsClient.execute(CommandTypes.OrganizeImports, {
-          scope: {
-            type: 'file',
-            args: fileRangeArgs
-          },
-          skipDestructiveCodeActions: skipDestructiveCodeActions,
-          mode: mode
-        }, token));
+        const response = await this.tsClient.interruptGetErr(async () => {
+          await this.fileConfigurationManager.ensureConfigurationForDocument(document, token);
+          return this.tsClient.execute(CommandTypes.OrganizeImports, {
+            scope: {
+              type: 'file',
+              args: fileRangeArgs
+            },
+            skipDestructiveCodeActions: skipDestructiveCodeActions,
+            mode: mode
+          }, token);
+        });
         if (response.type === 'response' && response.body) {
           actions.push(...provideOrganizeImports(command, response, this.tsClient));
         }
       }
     }
-    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 => {
@@ -23115,25 +23799,11 @@ class LspServer {
     }));
     return responses.flat();
   }
+  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) {
@@ -23174,6 +23844,7 @@ class LspServer {
       const additionalArguments = params.arguments[1] || {};
       const body = await this.tsClient.interruptGetErr(async () => {
         await this.fileConfigurationManager.ensureConfigurationForDocument(document);
+        const mode = additionalArguments.mode ?? (additionalArguments.skipDestructiveCodeActions ? OrganizeImportsMode.SortAndCombine : OrganizeImportsMode.All);
         const response = await this.tsClient.execute(CommandTypes.OrganizeImports, {
           scope: {
             type: 'file',
@@ -23182,7 +23853,7 @@ class LspServer {
             }
           },
           skipDestructiveCodeActions: additionalArguments.skipDestructiveCodeActions,
-          mode: additionalArguments.skipDestructiveCodeActions ? OrganizeImportsMode.SortAndCombine : OrganizeImportsMode.All
+          mode: mode
         }, token);
         if (response.type !== 'response') {
           return;
@@ -23388,7 +24059,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);
       }
     }
   }
@@ -23532,6 +24203,12 @@ class LspClientImpl {
   logMessage(args) {
     this.connection.sendNotification(mainExports$2.LogMessageNotification.type, args);
   }
+  async getWorkspaceConfiguration(scopeUri, section) {
+    return await this.connection.workspace.getConfiguration({
+      scopeUri: scopeUri,
+      section: section
+    });
+  }
   async applyWorkspaceEdit(params) {
     return this.connection.workspace.applyEdit(params);
   }
@@ -23559,6 +24236,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));