typescript-language-server 5.1.3 → 5.2.0

package/lib/cli.mjs

@@ -1,11 +1,21 @@
 #!/usr/bin/env node
 import fs$2, { promises, statSync, existsSync, readFileSync } from 'node:fs';
 
-import { createRequire } from 'node:module';
+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, { promisify } from 'util';
+import require$$0$3, { promisify as promisify$1 } from 'node:util';
 
-import require$$1 from 'path';
+import require$$0$1, { promisify } from 'util';
+
+import require$$1$1 from 'path';
 
 import require$$2 from 'os';
 
@@ -13,35 +23,25 @@ import crypto from 'crypto';
 
 import require$$4 from 'net';
 
-import require$$0$1 from 'url';
+import require$$0$2 from 'url';
 
-import require$$0$2 from 'fs';
+import require$$2$1 from 'fs';
 
 import require$$3 from 'child_process';
 
-import * as path from 'node:path';
-
-import path__default, { extname, resolve } from 'node:path';
-
-import require$$0$3 from 'constants';
+import require$$0$4 from 'constants';
 
-import require$$0$4 from 'stream';
+import require$$0$5 from 'stream';
 
 import require$$5 from 'assert';
 
 import os from 'node:os';
 
-import 'node:fs/promises';
+import fsPromises from 'node:fs/promises';
 
 import stream from 'node:stream';
 
-import { promisify as promisify$1 } from 'node:util';
-
-import ChildProcess from 'node:child_process';
-
-import require$$1$1 from 'fs/promises';
-
-import process$1 from 'node:process';
+import { createRequire } from 'node:module';
 
 import { fileURLToPath } from 'node:url';
 
@@ -171,36 +171,6 @@ 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;
@@ -779,11 +749,11 @@ var hasRequiredCommand;
 function requireCommand() {
   if (hasRequiredCommand) return command;
   hasRequiredCommand = 1;
-  const EventEmitter = __require$5().EventEmitter;
-  const childProcess = __require$4();
-  const path = __require$3();
-  const fs = __require$2();
-  const process = __require$1();
+  const EventEmitter = require$$0.EventEmitter;
+  const childProcess = require$$1;
+  const path = path__default;
+  const fs = fs$2;
+  const process = process$1;
   const {Argument: Argument, humanReadableArgName: humanReadableArgName} = requireArgument();
   const {CommanderError: CommanderError} = requireError();
   const {Help: Help, stripColor: stripColor} = requireHelp();
@@ -2155,12 +2125,6 @@ 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;
@@ -5368,7 +5332,7 @@ function requireRil() {
   Object.defineProperty(ril, '__esModule', {
     value: true
   });
-  const util_1 = require$$0;
+  const util_1 = require$$0$1;
   const api_1 = requireApi$2();
   class MessageBuffer extends api_1.AbstractMessageBuffer {
     constructor(encoding = 'utf-8') {
@@ -5556,7 +5520,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;
+    const path = require$$1$1;
     const os = require$$2;
     const crypto_1 = crypto;
     const net_1 = require$$4;
@@ -11167,9 +11131,9 @@ function requireFiles() {
     value: true
   });
   files.resolveModulePath = files.FileSystem = files.resolveGlobalYarnPath = files.resolveGlobalNodePath = files.resolve = files.uriToFilePath = void 0;
-  const url = require$$0$1;
-  const path = require$$1;
-  const fs = require$$0$2;
+  const url = require$$0$2;
+  const path = require$$1$1;
+  const fs = require$$2$1;
   const child_process_1 = require$$3;
   function uriToFilePath(uri) {
     let parsed = url.parse(uri);
@@ -11502,7 +11466,7 @@ function requireMain() {
       value: true
     });
     exports.createConnection = exports.Files = void 0;
-    const node_util_1 = __require();
+    const node_util_1 = require$$0$3;
     const Is = requireIs$2();
     const server_1 = requireServer();
     const fm = requireFiles();
@@ -11791,6 +11755,8 @@ var LogLevel;
 })(LogLevel || (LogLevel = {}));
 
 class LspClientLogger {
+  client;
+  level;
   constructor(client, level) {
     this.client = client;
     this.level = level;
@@ -11851,6 +11817,8 @@ class LspClientLogger {
 }
 
 class PrefixingLogger {
+  logger;
+  prefix;
   constructor(logger, prefix) {
     this.logger = logger;
     this.prefix = prefix;
@@ -11936,7 +11904,7 @@ var hasRequiredPolyfills;
 function requirePolyfills() {
   if (hasRequiredPolyfills) return polyfills;
   hasRequiredPolyfills = 1;
-  var constants = require$$0$3;
+  var constants = require$$0$4;
   var origCwd = process.cwd;
   var cwd = null;
   var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -12208,7 +12176,7 @@ var hasRequiredLegacyStreams;
 function requireLegacyStreams() {
   if (hasRequiredLegacyStreams) return legacyStreams;
   hasRequiredLegacyStreams = 1;
-  var Stream = require$$0$4.Stream;
+  var Stream = require$$0$5.Stream;
   legacyStreams = legacy;
   function legacy(fs) {
     return {
@@ -12332,11 +12300,11 @@ var hasRequiredGracefulFs;
 function requireGracefulFs() {
   if (hasRequiredGracefulFs) return gracefulFs;
   hasRequiredGracefulFs = 1;
-  var fs = require$$0$2;
+  var fs = require$$2$1;
   var polyfills = requirePolyfills();
   var legacy = requireLegacyStreams();
   var clone = requireClone();
-  var util = require$$0;
+  var util = require$$0$1;
   var gracefulQueue;
   var previousSymbol;
   if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
@@ -12735,7 +12703,7 @@ var hasRequiredUtils$1;
 function requireUtils$1() {
   if (hasRequiredUtils$1) return utils$1;
   hasRequiredUtils$1 = 1;
-  const path = require$$1;
+  const path = require$$1$1;
   utils$1.checkPath = function checkPath(pth) {
     if (process.platform === 'win32') {
       const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''));
@@ -12834,24 +12802,39 @@ function requireUtimes() {
   const u = requireUniversalify().fromPromise;
   async function utimesMillis(path, atime, mtime) {
     const fd = await fs.open(path, 'r+');
-    let closeErr = null;
+    let error = null;
     try {
       await fs.futimes(fd, atime, mtime);
+    } catch (futimesErr) {
+      error = futimesErr;
     } finally {
       try {
         await fs.close(fd);
-      } catch (e) {
-        closeErr = e;
+      } catch (closeErr) {
+        if (!error) error = closeErr;
       }
     }
-    if (closeErr) {
-      throw closeErr;
+    if (error) {
+      throw error;
     }
   }
   function utimesMillisSync(path, atime, mtime) {
     const fd = fs.openSync(path, 'r+');
-    fs.futimesSync(fd, atime, mtime);
-    return fs.closeSync(fd);
+    let error = null;
+    try {
+      fs.futimesSync(fd, atime, mtime);
+    } catch (futimesErr) {
+      error = futimesErr;
+    } finally {
+      try {
+        fs.closeSync(fd);
+      } catch (closeErr) {
+        if (!error) error = closeErr;
+      }
+    }
+    if (error) {
+      throw error;
+    }
   }
   utimes = {
     utimesMillis: u(utimesMillis),
@@ -12868,7 +12851,7 @@ function requireStat() {
   if (hasRequiredStat) return stat;
   hasRequiredStat = 1;
   const fs = requireFs();
-  const path = require$$1;
+  const path = require$$1$1;
   const u = requireUniversalify().fromPromise;
   function getStats(src, dest, opts) {
     const statFunc = opts.dereference ? file => fs.stat(file, {
@@ -13054,7 +13037,7 @@ function requireCopy$1() {
   if (hasRequiredCopy$1) return copy_1;
   hasRequiredCopy$1 = 1;
   const fs = requireFs();
-  const path = require$$1;
+  const path = require$$1$1;
   const {mkdirs: mkdirs} = requireMkdirs();
   const {pathExists: pathExists} = requirePathExists();
   const {utimesMillis: utimesMillis} = requireUtimes();
@@ -13158,11 +13141,13 @@ function requireCopy$1() {
     if (opts.dereference) {
       resolvedDest = path.resolve(process.cwd(), resolvedDest);
     }
-    if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
-      throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
-    }
-    if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
-      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+    if (resolvedSrc !== resolvedDest) {
+      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+      }
+      if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+      }
     }
     await fs.unlink(dest);
     return fs.symlink(resolvedSrc, dest);
@@ -13179,7 +13164,7 @@ function requireCopySync() {
   if (hasRequiredCopySync) return copySync_1;
   hasRequiredCopySync = 1;
   const fs = requireGracefulFs();
-  const path = require$$1;
+  const path = require$$1$1;
   const mkdirsSync = requireMkdirs().mkdirsSync;
   const utimesMillisSync = requireUtimes().utimesMillisSync;
   const stat = requireStat();
@@ -13287,11 +13272,13 @@ function requireCopySync() {
       if (opts.dereference) {
         resolvedDest = path.resolve(process.cwd(), resolvedDest);
       }
-      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
-        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
-      }
-      if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
-        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+      if (resolvedSrc !== resolvedDest) {
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
       }
       return copyLink(resolvedSrc, dest);
     }
@@ -13356,7 +13343,7 @@ function requireEmpty() {
   hasRequiredEmpty = 1;
   const u = requireUniversalify().fromPromise;
   const fs = requireFs();
-  const path = require$$1;
+  const path = require$$1$1;
   const mkdir = requireMkdirs();
   const remove = requireRemove();
   const emptyDir = u(async function emptyDir(dir) {
@@ -13397,7 +13384,7 @@ function requireFile() {
   if (hasRequiredFile) return file$1;
   hasRequiredFile = 1;
   const u = requireUniversalify().fromPromise;
-  const path = require$$1;
+  const path = require$$1$1;
   const fs = requireFs();
   const mkdir = requireMkdirs();
   async function createFile(file) {
@@ -13456,7 +13443,7 @@ function requireLink() {
   if (hasRequiredLink) return link;
   hasRequiredLink = 1;
   const u = requireUniversalify().fromPromise;
-  const path = require$$1;
+  const path = require$$1$1;
   const fs = requireFs();
   const mkdir = requireMkdirs();
   const {pathExists: pathExists} = requirePathExists();
@@ -13464,11 +13451,15 @@ function requireLink() {
   async function createLink(srcpath, dstpath) {
     let dstStat;
     try {
-      dstStat = await fs.lstat(dstpath);
+      dstStat = await fs.lstat(dstpath, {
+        bigint: true
+      });
     } catch {}
     let srcStat;
     try {
-      srcStat = await fs.lstat(srcpath);
+      srcStat = await fs.lstat(srcpath, {
+        bigint: true
+      });
     } catch (err) {
       err.message = err.message.replace('lstat', 'ensureLink');
       throw err;
@@ -13484,10 +13475,14 @@ function requireLink() {
   function createLinkSync(srcpath, dstpath) {
     let dstStat;
     try {
-      dstStat = fs.lstatSync(dstpath);
+      dstStat = fs.lstatSync(dstpath, {
+        bigint: true
+      });
     } catch {}
     try {
-      const srcStat = fs.lstatSync(srcpath);
+      const srcStat = fs.lstatSync(srcpath, {
+        bigint: true
+      });
       if (dstStat && areIdentical(srcStat, dstStat)) return;
     } catch (err) {
       err.message = err.message.replace('lstat', 'ensureLink');
@@ -13513,7 +13508,7 @@ var hasRequiredSymlinkPaths;
 function requireSymlinkPaths() {
   if (hasRequiredSymlinkPaths) return symlinkPaths_1;
   hasRequiredSymlinkPaths = 1;
-  const path = require$$1;
+  const path = require$$1$1;
   const fs = requireFs();
   const {pathExists: pathExists} = requirePathExists();
   const u = requireUniversalify().fromPromise;
@@ -13626,7 +13621,7 @@ function requireSymlink() {
   if (hasRequiredSymlink) return symlink;
   hasRequiredSymlink = 1;
   const u = requireUniversalify().fromPromise;
-  const path = require$$1;
+  const path = require$$1$1;
   const fs = requireFs();
   const {mkdirs: mkdirs, mkdirsSync: mkdirsSync} = requireMkdirs();
   const {symlinkPaths: symlinkPaths, symlinkPathsSync: symlinkPathsSync} = requireSymlinkPaths();
@@ -13639,7 +13634,27 @@ function requireSymlink() {
       stats = await fs.lstat(dstpath);
     } catch {}
     if (stats && stats.isSymbolicLink()) {
-      const [srcStat, dstStat] = await Promise.all([ fs.stat(srcpath), fs.stat(dstpath) ]);
+      let srcStat;
+      if (path.isAbsolute(srcpath)) {
+        srcStat = await fs.stat(srcpath, {
+          bigint: true
+        });
+      } else {
+        const dstdir = path.dirname(dstpath);
+        const relativeToDst = path.join(dstdir, srcpath);
+        try {
+          srcStat = await fs.stat(relativeToDst, {
+            bigint: true
+          });
+        } catch {
+          srcStat = await fs.stat(srcpath, {
+            bigint: true
+          });
+        }
+      }
+      const dstStat = await fs.stat(dstpath, {
+        bigint: true
+      });
       if (areIdentical(srcStat, dstStat)) return;
     }
     const relative = await symlinkPaths(srcpath, dstpath);
@@ -13657,8 +13672,27 @@ function requireSymlink() {
       stats = fs.lstatSync(dstpath);
     } catch {}
     if (stats && stats.isSymbolicLink()) {
-      const srcStat = fs.statSync(srcpath);
-      const dstStat = fs.statSync(dstpath);
+      let srcStat;
+      if (path.isAbsolute(srcpath)) {
+        srcStat = fs.statSync(srcpath, {
+          bigint: true
+        });
+      } else {
+        const dstdir = path.dirname(dstpath);
+        const relativeToDst = path.join(dstdir, srcpath);
+        try {
+          srcStat = fs.statSync(relativeToDst, {
+            bigint: true
+          });
+        } catch {
+          srcStat = fs.statSync(srcpath, {
+            bigint: true
+          });
+        }
+      }
+      const dstStat = fs.statSync(dstpath, {
+        bigint: true
+      });
       if (areIdentical(srcStat, dstStat)) return;
     }
     const relative = symlinkPathsSync(srcpath, dstpath);
@@ -13714,6 +13748,9 @@ function requireUtils() {
   function stringify(obj, {EOL: EOL = '\n', finalEOL: finalEOL = true, replacer: replacer = null, spaces: spaces} = {}) {
     const EOF = finalEOL ? EOL : '';
     const str = JSON.stringify(obj, replacer, spaces);
+    if (str === undefined) {
+      throw new TypeError(`Converting ${typeof obj} value to JSON is not supported`);
+    }
     return str.replace(/\n/g, EOL) + EOF;
   }
   function stripBom(content) {
@@ -13738,7 +13775,7 @@ function requireJsonfile$1() {
   try {
     _fs = requireGracefulFs();
   } catch (_) {
-    _fs = require$$0$2;
+    _fs = require$$2$1;
   }
   const universalify = requireUniversalify();
   const {stringify: stringify, stripBom: stripBom} = requireUtils();
@@ -13833,7 +13870,7 @@ function requireOutputFile() {
   hasRequiredOutputFile = 1;
   const u = requireUniversalify().fromPromise;
   const fs = requireFs();
-  const path = require$$1;
+  const path = require$$1$1;
   const mkdir = requireMkdirs();
   const pathExists = requirePathExists().pathExists;
   async function outputFile(file, data, encoding = 'utf-8') {
@@ -13920,7 +13957,7 @@ function requireMove$1() {
   if (hasRequiredMove$1) return move_1;
   hasRequiredMove$1 = 1;
   const fs = requireFs();
-  const path = require$$1;
+  const path = require$$1$1;
   const {copy: copy} = requireCopy();
   const {remove: remove} = requireRemove();
   const {mkdirp: mkdirp} = requireMkdirs();
@@ -13975,7 +14012,7 @@ function requireMoveSync() {
   if (hasRequiredMoveSync) return moveSync_1;
   hasRequiredMoveSync = 1;
   const fs = requireGracefulFs();
-  const path = require$$1;
+  const path = require$$1$1;
   const copySync = requireCopy().copySync;
   const removeSync = requireRemove().removeSync;
   const mkdirpSync = requireMkdirs().mkdirpSync;
@@ -14815,6 +14852,7 @@ var CommandTypes;
   CommandTypes['ProvideCallHierarchyIncomingCalls'] = 'provideCallHierarchyIncomingCalls';
   CommandTypes['ProvideCallHierarchyOutgoingCalls'] = 'provideCallHierarchyOutgoingCalls';
   CommandTypes['ProvideInlayHints'] = 'provideInlayHints';
+  CommandTypes['WatchChange'] = 'watchChange';
 })(CommandTypes || (CommandTypes = {}));
 
 var HighlightSpanKind;
@@ -14963,6 +15001,8 @@ var ScriptTarget;
   ScriptTarget['ES2020'] = 'es2020';
   ScriptTarget['ES2021'] = 'es2021';
   ScriptTarget['ES2022'] = 'es2022';
+  ScriptTarget['ES2023'] = 'es2023';
+  ScriptTarget['ES2024'] = 'es2024';
   ScriptTarget['ESNext'] = 'esnext';
   ScriptTarget['JSON'] = 'json';
   ScriptTarget['Latest'] = 'esnext';
@@ -15006,27 +15046,39 @@ var OrganizeImportsMode;
   OrganizeImportsMode['RemoveUnused'] = 'RemoveUnused';
 })(OrganizeImportsMode || (OrganizeImportsMode = {}));
 
-class KindModifiers {}
-
-KindModifiers.optional = 'optional';
-
-KindModifiers.deprecated = 'deprecated';
-
-KindModifiers.color = 'color';
-
-KindModifiers.dtsFile = '.d.ts';
-
-KindModifiers.tsFile = '.ts';
-
-KindModifiers.tsxFile = '.tsx';
-
-KindModifiers.jsFile = '.js';
-
-KindModifiers.jsxFile = '.jsx';
-
-KindModifiers.jsonFile = '.json';
-
-KindModifiers.fileExtensionKindModifiers = [ KindModifiers.dtsFile, KindModifiers.tsFile, KindModifiers.tsxFile, KindModifiers.jsFile, KindModifiers.jsxFile, KindModifiers.jsonFile ];
+var EventName;
+
+(function(EventName) {
+  EventName['syntaxDiag'] = 'syntaxDiag';
+  EventName['semanticDiag'] = 'semanticDiag';
+  EventName['suggestionDiag'] = 'suggestionDiag';
+  EventName['configFileDiag'] = 'configFileDiag';
+  EventName['telemetry'] = 'telemetry';
+  EventName['projectLanguageServiceState'] = 'projectLanguageServiceState';
+  EventName['projectsUpdatedInBackground'] = 'projectsUpdatedInBackground';
+  EventName['beginInstallTypes'] = 'beginInstallTypes';
+  EventName['endInstallTypes'] = 'endInstallTypes';
+  EventName['typesInstallerInitializationFailed'] = 'typesInstallerInitializationFailed';
+  EventName['surveyReady'] = 'surveyReady';
+  EventName['projectLoadingStart'] = 'projectLoadingStart';
+  EventName['projectLoadingFinish'] = 'projectLoadingFinish';
+  EventName['createFileWatcher'] = 'createFileWatcher';
+  EventName['createDirectoryWatcher'] = 'createDirectoryWatcher';
+  EventName['closeFileWatcher'] = 'closeFileWatcher';
+})(EventName || (EventName = {}));
+
+class KindModifiers {
+  static optional='optional';
+  static deprecated='deprecated';
+  static color='color';
+  static dtsFile='.d.ts';
+  static tsFile='.ts';
+  static tsxFile='.tsx';
+  static jsFile='.js';
+  static jsxFile='.jsx';
+  static jsonFile='.json';
+  static fileExtensionKindModifiers=[ KindModifiers.dtsFile, KindModifiers.tsFile, KindModifiers.tsxFile, KindModifiers.jsFile, KindModifiers.jsxFile, KindModifiers.jsonFile ];
+}
 
 const SYMBOL_DISPLAY_PART_KIND_MAP = {
   aliasName: 0,
@@ -15071,9 +15123,10 @@ var ServerResponse;
 
 (function(ServerResponse) {
   class Cancelled {
+    reason;
+    type='cancelled';
     constructor(reason) {
       this.reason = reason;
-      this.type = 'cancelled';
     }
   }
   ServerResponse.Cancelled = Cancelled;
@@ -15094,6 +15147,7 @@ var ClientCapability;
 })(ClientCapability || (ClientCapability = {}));
 
 class ClientCapabilities {
+  capabilities;
   constructor(...capabilities) {
     this.capabilities = new Set(capabilities);
   }
@@ -16016,6 +16070,49 @@ function requireCoerce() {
   return coerce_1;
 }
 
+var truncate_1;
+
+var hasRequiredTruncate;
+
+function requireTruncate() {
+  if (hasRequiredTruncate) return truncate_1;
+  hasRequiredTruncate = 1;
+  const parse = requireParse();
+  const constants = requireConstants();
+  const SemVer = requireSemver$1();
+  const truncate = (version, truncation, options) => {
+    if (!constants.RELEASE_TYPES.includes(truncation)) {
+      return null;
+    }
+    const clonedVersion = cloneInputVersion(version, options);
+    return clonedVersion && doTruncation(clonedVersion, truncation);
+  };
+  const cloneInputVersion = (version, options) => {
+    const versionStringToParse = version instanceof SemVer ? version.version : version;
+    return parse(versionStringToParse, options);
+  };
+  const doTruncation = (version, truncation) => {
+    if (isPrerelease(truncation)) {
+      return version.version;
+    }
+    version.prerelease = [];
+    switch (truncation) {
+     case 'major':
+      version.minor = 0;
+      version.patch = 0;
+      break;
+
+     case 'minor':
+      version.patch = 0;
+      break;
+    }
+    return version.format();
+  };
+  const isPrerelease = type => type.startsWith('pre');
+  truncate_1 = truncate;
+  return truncate_1;
+}
+
 var lrucache;
 
 var hasRequiredLrucache;
@@ -17080,6 +17177,7 @@ function requireSemver() {
   const lte = requireLte();
   const cmp = requireCmp();
   const coerce = requireCoerce();
+  const truncate = requireTruncate();
   const Comparator = requireComparator();
   const Range = requireRange();
   const satisfies = requireSatisfies();
@@ -17118,6 +17216,7 @@ function requireSemver() {
     lte: lte,
     cmp: cmp,
     coerce: coerce,
+    truncate: truncate,
     Comparator: Comparator,
     Range: Range,
     satisfies: satisfies,
@@ -17149,9 +17248,38 @@ var semverExports = requireSemver();
 const semver = getDefaultExportFromCjs(semverExports);
 
 class API {
+  displayName;
+  version;
+  fullVersionString;
   static fromSimpleString(value) {
     return new API(value, value, value);
   }
+  static defaultVersion=API.fromSimpleString('1.0.0');
+  static v300=API.fromSimpleString('3.0.0');
+  static v310=API.fromSimpleString('3.1.0');
+  static v314=API.fromSimpleString('3.1.4');
+  static v320=API.fromSimpleString('3.2.0');
+  static v333=API.fromSimpleString('3.3.3');
+  static v340=API.fromSimpleString('3.4.0');
+  static v345=API.fromSimpleString('3.4.5');
+  static v350=API.fromSimpleString('3.5.0');
+  static v380=API.fromSimpleString('3.8.0');
+  static v381=API.fromSimpleString('3.8.1');
+  static v390=API.fromSimpleString('3.9.0');
+  static v400=API.fromSimpleString('4.0.0');
+  static v401=API.fromSimpleString('4.0.1');
+  static v420=API.fromSimpleString('4.2.0');
+  static v430=API.fromSimpleString('4.3.0');
+  static v440=API.fromSimpleString('4.4.0');
+  static v460=API.fromSimpleString('4.6.0');
+  static v470=API.fromSimpleString('4.7.0');
+  static v480=API.fromSimpleString('4.8.0');
+  static v490=API.fromSimpleString('4.9.0');
+  static v500=API.fromSimpleString('5.0.0');
+  static v510=API.fromSimpleString('5.1.0');
+  static v520=API.fromSimpleString('5.2.0');
+  static v540=API.fromSimpleString('5.4.0');
+  static v544=API.fromSimpleString('5.4.4');
   static fromVersionString(versionString) {
     let version = semver.valid(versionString);
     if (!version) {
@@ -17179,56 +17307,6 @@ class API {
   }
 }
 
-API.defaultVersion = API.fromSimpleString('1.0.0');
-
-API.v300 = API.fromSimpleString('3.0.0');
-
-API.v310 = API.fromSimpleString('3.1.0');
-
-API.v314 = API.fromSimpleString('3.1.4');
-
-API.v320 = API.fromSimpleString('3.2.0');
-
-API.v333 = API.fromSimpleString('3.3.3');
-
-API.v340 = API.fromSimpleString('3.4.0');
-
-API.v345 = API.fromSimpleString('3.4.5');
-
-API.v350 = API.fromSimpleString('3.5.0');
-
-API.v380 = API.fromSimpleString('3.8.0');
-
-API.v381 = API.fromSimpleString('3.8.1');
-
-API.v390 = API.fromSimpleString('3.9.0');
-
-API.v400 = API.fromSimpleString('4.0.0');
-
-API.v401 = API.fromSimpleString('4.0.1');
-
-API.v420 = API.fromSimpleString('4.2.0');
-
-API.v430 = API.fromSimpleString('4.3.0');
-
-API.v440 = API.fromSimpleString('4.4.0');
-
-API.v460 = API.fromSimpleString('4.6.0');
-
-API.v470 = API.fromSimpleString('4.7.0');
-
-API.v480 = API.fromSimpleString('4.8.0');
-
-API.v490 = API.fromSimpleString('4.9.0');
-
-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) {
   if (a === b) {
     return true;
@@ -17244,6 +17322,11 @@ function coalesce(array) {
 }
 
 class Delayer {
+  defaultDelay;
+  timeout;
+  completionPromise;
+  onSuccess;
+  task;
   constructor(defaultDelay) {
     this.defaultDelay = defaultDelay;
     this.timeout = null;
@@ -17310,7 +17393,7 @@ const getRootTempDir = (() => {
 const getInstanceTempDir = (() => {
   let dir;
   return () => {
-    dir ?? (dir = path__default.join(getRootTempDir(), makeRandomHexString(20)));
+    dir ??= path__default.join(getRootTempDir(), makeRandomHexString(20));
     if (!fs$2.existsSync(dir)) {
       fs$2.mkdirSync(dir);
     }
@@ -17345,10 +17428,18 @@ const onCaseInsensitiveFileSystem = (() => {
 })();
 
 class ResourceMap {
+  _normalizePath;
+  config;
+  static defaultPathNormalizer=resource => {
+    if (resource.scheme === 'file') {
+      return resource.fsPath;
+    }
+    return resource.toString(true);
+  };
+  _map=new Map;
   constructor(_normalizePath = ResourceMap.defaultPathNormalizer, config) {
     this._normalizePath = _normalizePath;
     this.config = config;
-    this._map = new Map;
   }
   get size() {
     return this._map.size;
@@ -17410,13 +17501,6 @@ class ResourceMap {
   }
 }
 
-ResourceMap.defaultPathNormalizer = resource => {
-  if (resource.scheme === 'file') {
-    return resource.fsPath;
-  }
-  return resource.toString(true);
-};
-
 function mode2ScriptKind(mode) {
   switch (mode) {
    case typescript:
@@ -17464,14 +17548,16 @@ class PendingDiagnostics extends ResourceMap {
 }
 
 class GetErrRequest {
+  client;
+  files;
   static executeGetErrRequest(client, files, onDone) {
     return new GetErrRequest(client, files, onDone);
   }
+  _done=false;
+  _token=new mainExports$2.CancellationTokenSource;
   constructor(client, files, onDone) {
     this.client = client;
     this.files = files;
-    this._done = false;
-    this._token = new mainExports$2.CancellationTokenSource;
     if (!this.isErrorReportingEnabled()) {
       this._done = true;
       setImmediate(onDone);
@@ -17518,6 +17604,9 @@ class GetErrRequest {
 }
 
 class LspDocument {
+  _document;
+  _uri;
+  _filepath;
   constructor(doc, filepath) {
     const {uri: uri, languageId: languageId, version: version, text: text} = doc;
     this._document = TextDocument.create(uri, languageId, version, text);
@@ -17585,12 +17674,17 @@ class LspDocument {
 }
 
 class LspDocuments {
+  client;
+  lspClient;
+  _validateJavaScript=true;
+  _validateTypeScript=true;
+  modeIds=new Set;
+  _files=[];
+  documents=new Map;
+  pendingDiagnostics;
+  diagnosticDelayer;
+  pendingGetErr;
   constructor(client, lspClient, onCaseInsensitiveFileSystem) {
-    this._validateJavaScript = true;
-    this._validateTypeScript = true;
-    this.modeIds = new Set;
-    this._files = [];
-    this.documents = new Map;
     this.client = client;
     this.lspClient = lspClient;
     const pathNormalizer = path => this.client.toTsFilePath(path.toString());
@@ -17625,7 +17719,7 @@ class LspDocuments {
       if (detectedLanguageId) {
         this.lspClient.logMessage({
           type: mainExports$2.MessageType.Warning,
-          message: `Invalid langaugeId "${textDocument.languageId}" provided for uri "${textDocument.uri}". Correcting to "${detectedLanguageId}"`
+          message: `Invalid languageId "${textDocument.languageId}" provided for uri "${textDocument.uri}". Correcting to "${detectedLanguageId}"`
         });
         textDocument.languageId = detectedLanguageId;
       } else {
@@ -17685,10 +17779,10 @@ class LspDocuments {
     }
     this.client.cancelInflightRequestsForResource(document.uri);
     for (const change of params.contentChanges) {
-      let line = 0;
-      let offset = 0;
-      let endLine = 0;
-      let endOffset = 0;
+      let line;
+      let offset;
+      let endLine;
+      let endOffset;
       if (mainExports$2.TextDocumentContentChangeEvent.isIncremental(change)) {
         line = change.range.start.line + 1;
         offset = change.range.start.character + 1;
@@ -17844,6 +17938,7 @@ var TypeScriptServerPlugin;
 })(TypeScriptServerPlugin || (TypeScriptServerPlugin = {}));
 
 class PluginManager {
+  _plugins;
   setPlugins(plugins) {
     this._plugins = this.readPlugins(plugins);
   }
@@ -17864,6 +17959,11 @@ class PluginManager {
 }
 
 class TypeScriptServerError extends Error {
+  serverId;
+  version;
+  response;
+  serverMessage;
+  serverStack;
   static create(serverId, version, response) {
     const parsedResult = TypeScriptServerError.parseErrorText(response);
     return new TypeScriptServerError(serverId, version, response, parsedResult?.message, parsedResult?.stack);
@@ -18027,25 +18127,78 @@ const temporaryDirectory$1 = await promises.realpath(os.tmpdir());
 
 promisify$1(stream.pipeline);
 
-const getPath = (prefix = '') => path__default.join(temporaryDirectory$1, prefix + uniqueString());
+function assertSafePathComponent(pathComponent) {
+  if (typeof pathComponent !== 'string') {
+    throw new TypeError(`Expected a string, got ${typeof pathComponent}`);
+  }
+  const trimmed = pathComponent.trim();
+  const isSafe = trimmed !== '' && trimmed !== '.' && trimmed !== '..' && !pathComponent.includes('/') && !pathComponent.includes('\\') && !pathComponent.includes('\0');
+  if (!isSafe) {
+    throw new Error(`Unsafe path component: ${JSON.stringify(pathComponent)}`);
+  }
+}
+
+function resolveParentDirectory(parentDirectory, rootDirectory) {
+  assertSafePathComponent(parentDirectory);
+  const base = rootDirectory ?? temporaryDirectory$1;
+  const resolved = path__default.join(base, parentDirectory);
+  fs$2.mkdirSync(resolved, {
+    recursive: true
+  });
+  return resolved;
+}
+
+const getPath = (prefix = '', {parentDirectory: parentDirectory, rootDirectory: rootDirectory} = {}) => {
+  if (prefix) {
+    assertSafePathComponent(prefix);
+  }
+  if (rootDirectory !== undefined) {
+    if (!path__default.isAbsolute(rootDirectory)) {
+      throw new Error('The `rootDirectory` option must be an absolute path');
+    }
+    fs$2.mkdirSync(rootDirectory, {
+      recursive: true
+    });
+  }
+  const parent = parentDirectory ? resolveParentDirectory(parentDirectory, rootDirectory) : rootDirectory ?? temporaryDirectory$1;
+  return path__default.join(parent, prefix + uniqueString());
+};
 
-function temporaryFile({name: name, extension: extension} = {}) {
-  if (name) {
+function temporaryFile({name: name, extension: extension, parentDirectory: parentDirectory, rootDirectory: rootDirectory} = {}) {
+  if (name !== undefined && name !== null) {
     if (extension !== undefined && extension !== null) {
       throw new Error('The `name` and `extension` options are mutually exclusive');
     }
-    return path__default.join(temporaryDirectory(), name);
+    assertSafePathComponent(name);
+    return path__default.join(temporaryDirectory({
+      parentDirectory: parentDirectory,
+      rootDirectory: rootDirectory
+    }), name);
+  }
+  if (extension !== undefined && extension !== null) {
+    assertSafePathComponent(extension);
   }
-  return getPath() + (extension === undefined || extension === null ? '' : '.' + extension.replace(/^\./, ''));
+  return getPath('', {
+    parentDirectory: parentDirectory,
+    rootDirectory: rootDirectory
+  }) + (extension === undefined || extension === null ? '' : '.' + extension.replace(/^\./, ''));
 }
 
-function temporaryDirectory({prefix: prefix = ''} = {}) {
-  const directory = getPath(prefix);
-  fs$2.mkdirSync(directory);
+function temporaryDirectory({prefix: prefix = '', parentDirectory: parentDirectory, rootDirectory: rootDirectory} = {}) {
+  const directory = getPath(prefix, {
+    parentDirectory: parentDirectory,
+    rootDirectory: rootDirectory
+  });
+  fs$2.mkdirSync(directory, {
+    recursive: true
+  });
   return directory;
 }
 
 class NodeRequestCanceller {
+  _serverId;
+  _tracer;
+  cancellationPipeName;
   constructor(_serverId, _tracer) {
     this._serverId = _serverId;
     this._tracer = _tracer;
@@ -18080,10 +18233,8 @@ var RequestQueueingType;
 })(RequestQueueingType || (RequestQueueingType = {}));
 
 class RequestQueue {
-  constructor() {
-    this.queue = [];
-    this.sequenceNumber = 0;
-  }
+  queue=[];
+  sequenceNumber=0;
   get length() {
     return this.queue.length;
   }
@@ -18124,10 +18275,8 @@ class RequestQueue {
 }
 
 class CallbackMap {
-  constructor() {
-    this._callbacks = new Map;
-    this._asyncCallbacks = new Map;
-  }
+  _callbacks=new Map;
+  _asyncCallbacks=new Map;
   destroy(cause) {
     const cancellation = new ServerResponse.Cancelled(cause);
     for (const callback of this._callbacks.values()) {
@@ -18166,6 +18315,20 @@ var ExecutionTarget;
 })(ExecutionTarget || (ExecutionTarget = {}));
 
 class SingleTsServer {
+  _serverId;
+  _serverSource;
+  _process;
+  _tsServerLogFile;
+  _requestCanceller;
+  _version;
+  _tracer;
+  _requestQueue=new RequestQueue;
+  _callbacks=new CallbackMap;
+  _pendingResponses=new Set;
+  _eventHandlers=new Set;
+  _exitHandlers=new Set;
+  _errorHandlers=new Set;
+  _stdErrHandlers=new Set;
   constructor(_serverId, _serverSource, _process, _tsServerLogFile, _requestCanceller, _version, _tracer) {
     this._serverId = _serverId;
     this._serverSource = _serverSource;
@@ -18174,13 +18337,6 @@ class SingleTsServer {
     this._requestCanceller = _requestCanceller;
     this._version = _version;
     this._tracer = _tracer;
-    this._requestQueue = new RequestQueue;
-    this._callbacks = new CallbackMap;
-    this._pendingResponses = new Set;
-    this._eventHandlers = new Set;
-    this._exitHandlers = new Set;
-    this._errorHandlers = new Set;
-    this._stdErrHandlers = new Set;
     this._process.onData(msg => {
       this.dispatchMessage(msg);
     });
@@ -18355,6 +18511,7 @@ class SingleTsServer {
   logTrace(message) {
     this._tracer.logTrace(this._serverId, message);
   }
+  static fenceCommands=new Set([ 'change', 'close', 'open', 'updateOpen' ]);
   static getQueueingType(command, lowPriority) {
     if (SingleTsServer.fenceCommands.has(command)) {
       return RequestQueueingType.Fence;
@@ -18363,9 +18520,10 @@ class SingleTsServer {
   }
 }
 
-SingleTsServer.fenceCommands = new Set([ 'change', 'close', 'open', 'updateOpen' ]);
-
 class RequestRouter {
+  servers;
+  delegate;
+  static sharedCommands=new Set([ CommandTypes.Change, CommandTypes.Close, CommandTypes.Open, CommandTypes.UpdateOpen, CommandTypes.Configure ]);
   constructor(servers, delegate) {
     this.servers = servers;
     this.delegate = delegate;
@@ -18420,14 +18578,18 @@ class RequestRouter {
   }
 }
 
-RequestRouter.sharedCommands = new Set([ CommandTypes.Change, CommandTypes.Close, CommandTypes.Open, CommandTypes.UpdateOpen, CommandTypes.Configure ]);
-
 class SyntaxRoutingTsServer {
+  static syntaxAlwaysCommands=new Set([ CommandTypes.NavTree, CommandTypes.GetOutliningSpans, CommandTypes.JsxClosingTag, CommandTypes.SelectionRange, CommandTypes.Format, CommandTypes.Formatonkey, CommandTypes.DocCommentTemplate ]);
+  static semanticCommands=new Set([ CommandTypes.Geterr, CommandTypes.GeterrForProject, CommandTypes.ProjectInfo, CommandTypes.ConfigurePlugin ]);
+  static syntaxAllowedCommands=new Set([ CommandTypes.CompletionDetails, CommandTypes.CompletionInfo, CommandTypes.Definition, CommandTypes.DefinitionAndBoundSpan, CommandTypes.DocumentHighlights, CommandTypes.Implementation, CommandTypes.Navto, CommandTypes.Quickinfo, CommandTypes.References, CommandTypes.Rename, CommandTypes.SignatureHelp ]);
+  syntaxServer;
+  semanticServer;
+  router;
+  _projectLoading=true;
+  _eventHandlers=new Set;
+  _exitHandlers=new Set;
+  _errorHandlers=new Set;
   constructor(servers, delegate, enableDynamicRouting) {
-    this._projectLoading = true;
-    this._eventHandlers = new Set;
-    this._exitHandlers = new Set;
-    this._errorHandlers = new Set;
     this.syntaxServer = servers.syntax;
     this.semanticServer = servers.semantic;
     this.router = new RequestRouter([ {
@@ -18460,15 +18622,15 @@ class SyntaxRoutingTsServer {
     });
     this.semanticServer.onEvent(event => {
       switch (event.event) {
-       case 'projectLoadingStart':
+       case EventName.projectLoadingStart:
         this._projectLoading = true;
         break;
 
-       case 'projectLoadingFinish':
-       case 'semanticDiag':
-       case 'syntaxDiag':
-       case 'suggestionDiag':
-       case 'configFileDiag':
+       case EventName.projectLoadingFinish:
+       case EventName.semanticDiag:
+       case EventName.syntaxDiag:
+       case EventName.suggestionDiag:
+       case EventName.configFileDiag:
         this._projectLoading = false;
         break;
       }
@@ -18511,12 +18673,6 @@ class SyntaxRoutingTsServer {
   }
 }
 
-SyntaxRoutingTsServer.syntaxAlwaysCommands = new Set([ CommandTypes.NavTree, CommandTypes.GetOutliningSpans, CommandTypes.JsxClosingTag, CommandTypes.SelectionRange, CommandTypes.Format, CommandTypes.Formatonkey, CommandTypes.DocCommentTemplate ]);
-
-SyntaxRoutingTsServer.semanticCommands = new Set([ CommandTypes.Geterr, CommandTypes.GeterrForProject, CommandTypes.ProjectInfo, CommandTypes.ConfigurePlugin ]);
-
-SyntaxRoutingTsServer.syntaxAllowedCommands = new Set([ CommandTypes.CompletionDetails, CommandTypes.CompletionInfo, CommandTypes.Definition, CommandTypes.DefinitionAndBoundSpan, CommandTypes.DocumentHighlights, CommandTypes.Implementation, CommandTypes.Navto, CommandTypes.Quickinfo, CommandTypes.References, CommandTypes.Rename, CommandTypes.SignatureHelp ]);
-
 var RequestState;
 
 (function(RequestState) {
@@ -18527,9 +18683,10 @@ var RequestState;
     type: 1
   };
   class Errored {
+    err;
+    type=2;
     constructor(err) {
       this.err = err;
-      this.type = 2;
     }
   }
   RequestState.Errored = Errored;
@@ -18543,7 +18700,7 @@ class NodeTsServerProcessFactory {
     if (useIpc) {
       runtimeArgs.push('--useNodeIpc');
     }
-    const childProcess = ChildProcess.fork(tsServerPath, runtimeArgs, {
+    const childProcess = require$$1.fork(tsServerPath, runtimeArgs, {
       silent: true,
       cwd: undefined,
       env: generatePatchedEnv(process.env, tsServerPath),
@@ -18597,6 +18754,7 @@ function getTssDebugBrk() {
 }
 
 class IpcChildServerProcess {
+  _process;
   constructor(_process) {
     this._process = _process;
   }
@@ -18621,6 +18779,8 @@ class IpcChildServerProcess {
 }
 
 class StdioChildServerProcess {
+  _process;
+  _reader;
   constructor(_process) {
     this._process = _process;
     this._reader = new Reader(this._process.stdout);
@@ -18652,12 +18812,12 @@ class StdioChildServerProcess {
 }
 
 class Reader {
+  buffer=new ProtocolBuffer;
+  nextMessageLength=-1;
+  _onError=_error => {};
+  _onData=_data => {};
+  isDisposed=false;
   constructor(readable) {
-    this.buffer = new ProtocolBuffer;
-    this.nextMessageLength = -1;
-    this._onError = _error => {};
-    this._onData = _data => {};
-    this.isDisposed = false;
     readable.on('data', data => this.onLengthData(data));
   }
   dispose() {
@@ -18711,17 +18871,10 @@ const backslashR = Buffer.from('\r', 'utf8')[0];
 const backslashN = Buffer.from('\n', 'utf8')[0];
 
 class ProtocolBuffer {
-  constructor() {
-    this.index = 0;
-    this.buffer = Buffer.allocUnsafe(defaultSize);
-  }
+  index=0;
+  buffer=Buffer.allocUnsafe(defaultSize);
   append(data) {
-    let toAppend = null;
-    if (Buffer.isBuffer(data)) {
-      toAppend = data;
-    } else {
-      toAppend = Buffer.from(data, 'utf8');
-    }
+    const toAppend = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8');
     if (this.buffer.length - this.index >= toAppend.length) {
       toAppend.copy(this.buffer, this.index, 0, toAppend.length);
     } else {
@@ -18792,7 +18945,7 @@ var TsServerLogLevel;
      case 'terse':
       return TsServerLogLevel.Terse;
 
-     case 'requestTime':
+     case 'requesttime':
       return TsServerLogLevel.RequestTime;
 
      case 'verbose':
@@ -18823,18 +18976,39 @@ var TsServerLogLevel;
   TsServerLogLevel.toString = toString;
 })(TsServerLogLevel || (TsServerLogLevel = {}));
 
+var SyntaxServerConfiguration;
+
+(function(SyntaxServerConfiguration) {
+  SyntaxServerConfiguration[SyntaxServerConfiguration['Never'] = 0] = 'Never';
+  SyntaxServerConfiguration[SyntaxServerConfiguration['Always'] = 1] = 'Always';
+  SyntaxServerConfiguration[SyntaxServerConfiguration['Auto'] = 2] = 'Auto';
+})(SyntaxServerConfiguration || (SyntaxServerConfiguration = {}));
+
 function toSyntaxServerConfiguration(value) {
   switch (value) {
    case 'never':
-    return 0;
+    return SyntaxServerConfiguration.Never;
 
    case 'auto':
-    return 2;
+    return SyntaxServerConfiguration.Auto;
   }
-  return 2;
+  return SyntaxServerConfiguration.Auto;
 }
 
+var CompositeServerType;
+
+(function(CompositeServerType) {
+  CompositeServerType[CompositeServerType['Single'] = 0] = 'Single';
+  CompositeServerType[CompositeServerType['SeparateSyntax'] = 1] = 'SeparateSyntax';
+  CompositeServerType[CompositeServerType['DynamicSeparateSyntax'] = 2] = 'DynamicSeparateSyntax';
+  CompositeServerType[CompositeServerType['SyntaxOnly'] = 3] = 'SyntaxOnly';
+})(CompositeServerType || (CompositeServerType = {}));
+
 class TypeScriptServerSpawner {
+  _apiVersion;
+  _logDirectoryProvider;
+  _logger;
+  _tracer;
   constructor(_apiVersion, _logDirectoryProvider, _logger, _tracer) {
     this._apiVersion = _apiVersion;
     this._logDirectoryProvider = _logDirectoryProvider;
@@ -18845,10 +19019,10 @@ class TypeScriptServerSpawner {
     let primaryServer;
     const serverType = this.getCompositeServerType(version, capabilities, configuration);
     switch (serverType) {
-     case 1:
-     case 2:
+     case CompositeServerType.SeparateSyntax:
+     case CompositeServerType.DynamicSeparateSyntax:
       {
-        const enableDynamicRouting = serverType === 2;
+        const enableDynamicRouting = serverType === CompositeServerType.DynamicSeparateSyntax;
         primaryServer = new SyntaxRoutingTsServer({
           syntax: this.spawnTsServer('syntax', version, configuration, pluginManager),
           semantic: this.spawnTsServer('semantic', version, configuration, pluginManager)
@@ -18856,13 +19030,13 @@ class TypeScriptServerSpawner {
         break;
       }
 
-     case 0:
+     case CompositeServerType.Single:
       {
         primaryServer = this.spawnTsServer('main', version, configuration, pluginManager);
         break;
       }
 
-     case 3:
+     case CompositeServerType.SyntaxOnly:
       {
         primaryServer = this.spawnTsServer('syntax', version, configuration, pluginManager);
         break;
@@ -18872,20 +19046,20 @@ class TypeScriptServerSpawner {
   }
   getCompositeServerType(version, capabilities, configuration) {
     if (!capabilities.has(ClientCapability.Semantic)) {
-      return 3;
+      return CompositeServerType.SyntaxOnly;
     }
     switch (configuration.useSyntaxServer) {
-     case 1:
-      return 3;
+     case SyntaxServerConfiguration.Always:
+      return CompositeServerType.SyntaxOnly;
 
-     case 0:
-      return 0;
+     case SyntaxServerConfiguration.Never:
+      return CompositeServerType.Single;
 
-     case 2:
+     case SyntaxServerConfiguration.Auto:
       if (version.version?.gte(API.v340)) {
-        return version.version?.gte(API.v400) ? 2 : 1;
+        return version.version?.gte(API.v400) ? CompositeServerType.DynamicSeparateSyntax : CompositeServerType.SeparateSyntax;
       }
-      return 0;
+      return CompositeServerType.Single;
     }
   }
   spawnTsServer(kind, version, configuration, pluginManager) {
@@ -18918,7 +19092,6 @@ class TypeScriptServerSpawner {
   getTsServerArgs(kind, configuration, apiVersion, pluginManager, cancellationPipeName) {
     const args = [];
     let tsServerLogFile;
-    let tsServerTraceDirectory;
     if (kind === 'syntax') {
       if (apiVersion.gte(API.v401)) {
         args.push('--serverMode', 'partialSemantic');
@@ -18956,12 +19129,14 @@ class TypeScriptServerSpawner {
       this._logger.info(`using npm from ${npmLocation}`);
       args.push('--npmLocation', `"${npmLocation}"`);
     }
+    if (configuration.useClientFileWatcher && apiVersion.gte(API.v544)) {
+      args.push('--canUseWatchEvents');
+    }
     args.push('--locale', locale || 'en');
     args.push('--validateDefaultNpmLocation');
     return {
       args: args,
-      tsServerLogFile: tsServerLogFile,
-      tsServerTraceDirectory: tsServerTraceDirectory
+      tsServerLogFile: tsServerLogFile
     };
   }
   isLoggingEnabled(configuration) {
@@ -18998,6 +19173,8 @@ var Trace;
 })(Trace || (Trace = {}));
 
 class Tracer {
+  logger;
+  trace;
   constructor(logger, trace) {
     this.logger = logger;
     this.trace = trace;
@@ -19045,167 +19222,642 @@ class Tracer {
   }
 }
 
-class ZipfileURI extends URI {
-  constructor(uri, components) {
-    super(components);
-    this._originalUri = uri;
-  }
-  toString(_skipEncoding = false) {
-    return this._originalUri;
-  }
-  static parse(value, _strict = false) {
-    const uri = URI.parse(value, _strict);
-    return new ZipfileURI(value, uri);
-  }
+var index_min = {};
+
+var hasRequiredIndex_min;
+
+function requireIndex_min() {
+  if (hasRequiredIndex_min) return index_min;
+  hasRequiredIndex_min = 1;
+  (function(exports) {
+    var a = (t, e) => () => (e || t((e = {
+      exports: {}
+    }).exports, e), e.exports);
+    var _ = a(i => {
+      Object.defineProperty(i, '__esModule', {
+        value: true
+      });
+      i.sync = i.isexe = void 0;
+      var M = fs$2, x = fsPromises, q = async (t, e = {}) => {
+        let {ignoreErrors: r = false} = e;
+        try {
+          return d(await (0, x.stat)(t), e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === 'EACCES') return false;
+          throw n;
+        }
+      };
+      i.isexe = q;
+      var m = (t, e = {}) => {
+        let {ignoreErrors: r = false} = e;
+        try {
+          return d((0, M.statSync)(t), e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === 'EACCES') return false;
+          throw n;
+        }
+      };
+      i.sync = m;
+      var d = (t, e) => t.isFile() && A(t, e), A = (t, e) => {
+        let r = e.uid ?? process.getuid?.(), s = e.groups ?? process.getgroups?.() ?? [], n = e.gid ?? process.getgid?.() ?? s[0];
+        if (r === void 0 || n === void 0) throw new Error('cannot get uid or gid');
+        let u = new Set([ n, ...s ]), c = t.mode, S = t.uid, P = t.gid, f = parseInt('100', 8), l = parseInt('010', 8), j = parseInt('001', 8), C = f | l;
+        return !!(c & j || c & l && u.has(P) || c & f && S === r || c & C && r === 0);
+      };
+    });
+    var g = a(o => {
+      Object.defineProperty(o, '__esModule', {
+        value: true
+      });
+      o.sync = o.isexe = void 0;
+      var T = fs$2, I = fsPromises, D = path__default, F = async (t, e = {}) => {
+        let {ignoreErrors: r = false} = e;
+        try {
+          return y(await (0, I.stat)(t), t, e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === 'EACCES') return false;
+          throw n;
+        }
+      };
+      o.isexe = F;
+      var L = (t, e = {}) => {
+        let {ignoreErrors: r = false} = e;
+        try {
+          return y((0, T.statSync)(t), t, e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === 'EACCES') return false;
+          throw n;
+        }
+      };
+      o.sync = L;
+      var B = (t, e) => {
+        let {pathExt: r = process.env.PATHEXT || ''} = e, s = r.split(D.delimiter);
+        if (s.indexOf('') !== -1) return true;
+        for (let n of s) {
+          let u = n.toLowerCase(), c = t.substring(t.length - u.length).toLowerCase();
+          if (u && c === u) return true;
+        }
+        return false;
+      }, y = (t, e, r) => t.isFile() && B(e, r);
+    });
+    var p = a(h => {
+      Object.defineProperty(h, '__esModule', {
+        value: true
+      });
+    });
+    var v = exports && exports.__createBinding || (Object.create ? function(t, e, r, s) {
+      s === void 0 && (s = r);
+      var n = Object.getOwnPropertyDescriptor(e, r);
+      (!n || ('get' in n ? !e.__esModule : n.writable || n.configurable)) && (n = {
+        enumerable: true,
+        get: function() {
+          return e[r];
+        }
+      }), Object.defineProperty(t, s, n);
+    } : function(t, e, r, s) {
+      s === void 0 && (s = r), t[s] = e[r];
+    }), G = exports && exports.__setModuleDefault || (Object.create ? function(t, e) {
+      Object.defineProperty(t, 'default', {
+        enumerable: true,
+        value: e
+      });
+    } : function(t, e) {
+      t.default = e;
+    }), w = exports && exports.__importStar || function() {
+      var t = function(e) {
+        return t = Object.getOwnPropertyNames || function(r) {
+          var s = [];
+          for (var n in r) Object.prototype.hasOwnProperty.call(r, n) && (s[s.length] = n);
+          return s;
+        }, t(e);
+      };
+      return function(e) {
+        if (e && e.__esModule) return e;
+        var r = {};
+        if (e != null) for (var s = t(e), n = 0; n < s.length; n++) s[n] !== 'default' && v(r, e, s[n]);
+        return G(r, e), r;
+      };
+    }(), X = exports && exports.__exportStar || function(t, e) {
+      for (var r in t) r !== 'default' && !Object.prototype.hasOwnProperty.call(e, r) && v(e, t, r);
+    };
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    });
+    exports.sync = exports.isexe = exports.posix = exports.win32 = void 0;
+    var E = w(_());
+    exports.posix = E;
+    var O = w(g());
+    exports.win32 = O;
+    X(p(), exports);
+    var H = process.env._ISEXE_TEST_PLATFORM_ || process.platform, b = H === 'win32' ? O : E;
+    exports.isexe = b.isexe;
+    exports.sync = b.sync;
+  })(index_min);
+  return index_min;
 }
 
-var ServerState;
+var lib;
 
-(function(ServerState) {
-  ServerState.None = {
-    type: 0
-  };
-  class Running {
-    constructor(server, apiVersion, tsserverVersion, languageServiceEnabled) {
-      this.server = server;
-      this.apiVersion = apiVersion;
-      this.tsserverVersion = tsserverVersion;
-      this.languageServiceEnabled = languageServiceEnabled;
-      this.type = 1;
-      this.toCancelOnResourceChange = new Set;
-    }
-    updateTsserverVersion(tsserverVersion) {
-      this.tsserverVersion = tsserverVersion;
-    }
-    updateLanguageServiceEnabled(enabled) {
-      this.languageServiceEnabled = enabled;
-    }
-  }
-  ServerState.Running = Running;
-  class Errored {
-    constructor(error, tsServerLogFile) {
-      this.error = error;
-      this.tsServerLogFile = tsServerLogFile;
-      this.type = 2;
+var hasRequiredLib;
+
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  const {isexe: isexe, sync: isexeSync} = requireIndex_min();
+  const {join: join, delimiter: delimiter, sep: sep, posix: posix} = require$$1$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}`);
+  const getNotFoundError = cmd => Object.assign(new Error(`not found: ${cmd}`), {
+    code: 'ENOENT'
+  });
+  const getPathInfo = (cmd, {path: optPath = process.env.PATH, pathExt: optPathExt = process.env.PATHEXT, delimiter: optDelimiter = delimiter}) => {
+    const pathEnv = cmd.match(rSlash) ? [ '' ] : [ ...isWindows ? [ process.cwd() ] : [], ...(optPath || '').split(optDelimiter) ];
+    if (isWindows) {
+      const pathExtExe = optPathExt || [ '.EXE', '.CMD', '.BAT', '.COM' ].join(optDelimiter);
+      const pathExt = pathExtExe.split(optDelimiter).flatMap(item => [ item, item.toLowerCase() ]);
+      if (cmd.includes('.') && pathExt[0] !== '') {
+        pathExt.unshift('');
+      }
+      return {
+        pathEnv: pathEnv,
+        pathExt: pathExt,
+        pathExtExe: pathExtExe
+      };
     }
-  }
-  ServerState.Errored = Errored;
-})(ServerState || (ServerState = {}));
+    return {
+      pathEnv: pathEnv,
+      pathExt: [ '' ]
+    };
+  };
+  const getPathPart = (raw, cmd) => {
+    const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+    const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : '';
+    return prefix + join(pathPart, cmd);
+  };
+  const which = async (cmd, opt = {}) => {
+    const {pathEnv: pathEnv, pathExt: pathExt, pathExtExe: pathExtExe} = getPathInfo(cmd, opt);
+    const found = [];
+    for (const envPart of pathEnv) {
+      const p = getPathPart(envPart, cmd);
+      for (const ext of pathExt) {
+        const withExt = p + ext;
+        const is = await isexe(withExt, {
+          pathExt: pathExtExe,
+          ignoreErrors: true
+        });
+        if (is) {
+          if (!opt.all) {
+            return withExt;
+          }
+          found.push(withExt);
+        }
+      }
+    }
+    if (opt.all && found.length) {
+      return found;
+    }
+    if (opt.nothrow) {
+      return null;
+    }
+    throw getNotFoundError(cmd);
+  };
+  const whichSync = (cmd, opt = {}) => {
+    const {pathEnv: pathEnv, pathExt: pathExt, pathExtExe: pathExtExe} = getPathInfo(cmd, opt);
+    const found = [];
+    for (const pathEnvPart of pathEnv) {
+      const p = getPathPart(pathEnvPart, cmd);
+      for (const ext of pathExt) {
+        const withExt = p + ext;
+        const is = isexeSync(withExt, {
+          pathExt: pathExtExe,
+          ignoreErrors: true
+        });
+        if (is) {
+          if (!opt.all) {
+            return withExt;
+          }
+          found.push(withExt);
+        }
+      }
+    }
+    if (opt.all && found.length) {
+      return found;
+    }
+    if (opt.nothrow) {
+      return null;
+    }
+    throw getNotFoundError(cmd);
+  };
+  lib = which;
+  which.sync = whichSync;
+  return lib;
+}
 
-function getDignosticsKind(event) {
-  switch (event.event) {
-   case 'syntaxDiag':
-    return 0;
+var libExports = requireLib();
 
-   case 'semanticDiag':
-    return 1;
+const which = getDefaultExportFromCjs(libExports);
 
-   case 'suggestionDiag':
-    return 2;
+const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+
+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 stats = fs$2.statSync(filePath, {
+        throwIfNoEntry: false
+      });
+      if (type === 'file' && stats?.isFile() || type === 'directory' && stats?.isDirectory()) {
+        return filePath;
+      }
+    } catch {}
+    if (directory === stopAt || directory === root) {
+      break;
+    }
+    directory = path__default.dirname(directory);
   }
-  throw new Error('Unknown dignostics kind');
 }
 
-class ServerInitializingIndicator {
-  constructor(lspClient) {
-    this.lspClient = lspClient;
-  }
-  reset() {
-    if (this._task) {
-      const task = this._task;
-      this._task = undefined;
-      task.then(reporter => reporter.done());
+function packageUpSync({cwd: cwd = process$1.cwd()} = {}) {
+  return findUpSync('package.json', {
+    cwd: cwd
+  });
+}
+
+function findPathToModule(dir, moduleNames) {
+  const stat = statSync(dir);
+  if (stat.isDirectory()) {
+    const candidates = moduleNames.map(moduleName => resolve(dir, moduleName));
+    const modulePath = candidates.find(existsSync);
+    if (modulePath) {
+      return modulePath;
     }
   }
-  startedLoadingProject(projectName) {
-    this.reset();
-    this._loadingProjectName = projectName;
-    this._task = this.lspClient.createProgressReporter();
-    this._task.then(reporter => reporter.begin('Initializing JS/TS language features…'));
-  }
-  finishedLoadingProject(projectName) {
-    if (this._loadingProjectName === projectName) {
-      this.reset();
-    }
+  const parent = resolve(dir, '..');
+  if (parent !== dir) {
+    return findPathToModule(parent, moduleNames);
   }
 }
 
-const emptyAuthority = 'ts-nul-authority';
-
-const inMemoryResourcePrefix = '^';
+var TypeScriptVersionSource;
 
-const RE_IN_MEMORY_FILEPATH = /^\^\/([^/]+)\/([^/]*)\/(.+)$/;
+(function(TypeScriptVersionSource) {
+  TypeScriptVersionSource['Bundled'] = 'bundled';
+  TypeScriptVersionSource['UserSetting'] = 'user-setting';
+  TypeScriptVersionSource['Workspace'] = 'workspace';
+})(TypeScriptVersionSource || (TypeScriptVersionSource = {}));
 
-class TsClient {
-  constructor(onCaseInsensitiveFileSystem, logger, lspClient) {
-    this.apiVersion = API.defaultVersion;
-    this.typescriptVersionSource = 'bundled';
-    this.serverState = ServerState.None;
-    this.isNeovimHost = false;
-    this.workspaceFolders = [];
-    this.useSyntaxServer = 2;
-    this.pluginManager = new PluginManager;
-    this.documents = new LspDocuments(this, lspClient, onCaseInsensitiveFileSystem);
-    this.logger = new PrefixingLogger(logger, '[tsclient]');
-    this.tsserverLogger = new PrefixingLogger(this.logger, '[tsserver]');
-    this.lspClient = lspClient;
-    this.loadingIndicator = new ServerInitializingIndicator(this.lspClient);
-  }
-  get documentsForTesting() {
-    return this.documents.documentsForTesting;
+class TypeScriptVersion {
+  source;
+  path;
+  logger;
+  _api;
+  constructor(source, path, logger) {
+    this.source = source;
+    this.path = path;
+    this.logger = logger;
+    this._api = null;
   }
-  openTextDocument(textDocument) {
-    return this.documents.openTextDocument(textDocument);
+  get tsServerPath() {
+    return this.path;
   }
-  onDidCloseTextDocument(uri) {
-    this.documents.onDidCloseTextDocument(uri);
+  get isValid() {
+    return this.version !== null;
   }
-  onDidChangeTextDocument(params) {
-    this.documents.onDidChangeTextDocument(params);
+  get version() {
+    if (this._api) {
+      return this._api;
+    }
+    this._api = this.getTypeScriptVersion(this.tsServerPath);
+    return this._api;
   }
-  lastFileOrDummy() {
-    return this.documents.files[0] || this.workspaceFolders[0]?.uri.fsPath;
+  get versionString() {
+    const version = this.version;
+    return version ? version.displayName : null;
   }
-  toTsFilePath(stringUri) {
-    if (this.isNeovimHost && stringUri.startsWith('zipfile:')) {
-      return stringUri;
-    }
-    const resource = URI.parse(stringUri);
-    if (disabledSchemes.has(resource.scheme)) {
-      return undefined;
+  getTypeScriptVersion(serverPath) {
+    this.logger.log(`Resolving TypeScript version from path "${serverPath}"...`);
+    if (!fs$2.existsSync(serverPath)) {
+      this.logger.log('Server path does not exist on disk');
+      return null;
     }
-    if (resource.scheme === file) {
-      return resource.fsPath;
+    const p = serverPath.split(path__default.sep);
+    if (p.length <= 2) {
+      this.logger.log('Server path is invalid (has less than two path components).');
+      return null;
     }
-    return inMemoryResourcePrefix + '/' + resource.scheme + '/' + (resource.authority || emptyAuthority) + (resource.path.startsWith('/') ? resource.path : '/' + resource.path) + (resource.fragment ? '#' + resource.fragment : '');
-  }
-  toOpenDocument(textDocumentUri, options = {}) {
-    const filepath = this.toTsFilePath(textDocumentUri);
-    const document = filepath && this.documents.get(filepath);
-    if (!document) {
-      const uri = URI.parse(textDocumentUri);
-      if (!options.suppressAlertOnFailure && !disabledSchemes.has(uri.scheme)) {
-        console.error(`Unexpected resource ${textDocumentUri}`);
+    const p2 = p.slice(0, -2);
+    const modulePath = p2.join(path__default.sep);
+    let fileName = path__default.join(modulePath, 'package.json');
+    if (!fs$2.existsSync(fileName)) {
+      if (path__default.basename(modulePath) === 'built') {
+        fileName = path__default.join(modulePath, '..', 'package.json');
       }
-      return undefined;
     }
-    return document;
-  }
-  requestDiagnosticsForTesting() {
-    this.documents.requestDiagnosticsForTesting();
-  }
-  hasPendingDiagnostics(resource) {
-    return this.documents.hasPendingDiagnostics(resource);
-  }
-  toResource(filepath) {
-    if (this.isNeovimHost && filepath.startsWith('zipfile:')) {
-      return ZipfileURI.parse(filepath);
+    if (!fs$2.existsSync(fileName)) {
+      this.logger.log(`Failed to find package.json at path "${fileName}"`);
+      return null;
     }
-    if (filepath.startsWith(inMemoryResourcePrefix)) {
-      const parts = filepath.match(RE_IN_MEMORY_FILEPATH);
-      if (parts) {
-        const resource = URI.parse(parts[1] + '://' + (parts[2] === emptyAuthority ? '' : parts[2]) + '/' + parts[3]);
-        const tsFilepath = this.toTsFilePath(resource.toString());
+    this.logger.log(`Reading version from package.json at "${fileName}"`);
+    const contents = fs$2.readFileSync(fileName).toString();
+    let desc;
+    try {
+      desc = JSON.parse(contents);
+    } catch {
+      this.logger.log('Failed parsing contents of package.json.');
+      return null;
+    }
+    if (!desc?.version) {
+      this.logger.log('Failed reading version number from package.json.');
+      return null;
+    }
+    this.logger.log(`Resolved TypeScript version to "${desc.version}"`);
+    return API.fromVersionString(desc.version);
+  }
+}
+
+const MODULE_FOLDERS = [ 'node_modules/typescript/lib', '.vscode/pnpify/typescript/lib', '.yarn/sdks/typescript/lib' ];
+
+class TypeScriptVersionProvider {
+  userTsserverPath;
+  logger;
+  constructor(userTsserverPath, logger) {
+    this.userTsserverPath = userTsserverPath;
+    this.logger = logger;
+  }
+  getUserSettingVersion() {
+    if (!this.userTsserverPath) {
+      return null;
+    }
+    this.logger.log(`Resolving user-provided tsserver path "${this.userTsserverPath}"...`);
+    let resolvedPath = this.userTsserverPath;
+    if (!path__default.isAbsolute(resolvedPath)) {
+      const binaryPath = which.sync(resolvedPath, {
+        nothrow: true
+      });
+      if (binaryPath) {
+        resolvedPath = binaryPath;
+      }
+      this.logger.log(`Non-absolute tsserver path resolved to "${binaryPath ? resolvedPath : '<failed>'}"`);
+    }
+    let stat = fs$2.lstatSync(resolvedPath, {
+      throwIfNoEntry: false
+    });
+    if (stat?.isSymbolicLink()) {
+      resolvedPath = fs$2.realpathSync(resolvedPath);
+      this.logger.log(`Symbolic link tsserver path resolved to "${resolvedPath}"`);
+    }
+    stat = fs$2.lstatSync(resolvedPath, {
+      throwIfNoEntry: false
+    });
+    if (stat?.isFile()) {
+      if (path__default.basename(resolvedPath) === 'tsserver.js') {
+        this.logger.log(`Resolved tsserver location: ${resolvedPath}`);
+        return new TypeScriptVersion(TypeScriptVersionSource.UserSetting, resolvedPath, this.logger);
+      }
+      resolvedPath = path__default.dirname(resolvedPath);
+      this.logger.log(`Resolved directory path from a file path: ${resolvedPath}`);
+    }
+    try {
+      const packageJsonPath = packageUpSync({
+        cwd: resolvedPath
+      });
+      this.logger.log(`Resolved package.json location: "${packageJsonPath}"`);
+      if (packageJsonPath) {
+        resolvedPath = path__default.join(path__default.dirname(packageJsonPath), 'lib', 'tsserver.js');
+        this.logger.log(`Resolved tsserver location: "${resolvedPath}"`);
+      }
+    } catch {}
+    return new TypeScriptVersion(TypeScriptVersionSource.UserSetting, resolvedPath, this.logger);
+  }
+  getWorkspaceVersion(workspaceFolders) {
+    for (const p of workspaceFolders) {
+      const libFolder = findPathToModule(p, MODULE_FOLDERS);
+      if (libFolder) {
+        const tsServerPath = path__default.join(libFolder, 'tsserver.js');
+        const version = new TypeScriptVersion(TypeScriptVersionSource.Workspace, tsServerPath, this.logger);
+        if (version.isValid) {
+          return version;
+        }
+      }
+    }
+    return null;
+  }
+  bundledVersion() {
+    const require = createRequire(import.meta.url);
+    try {
+      const file = require.resolve('typescript');
+      const tsServerPath = path__default.join(path__default.dirname(file), 'tsserver.js');
+      const bundledVersion = new TypeScriptVersion(TypeScriptVersionSource.Bundled, tsServerPath, this.logger);
+      return bundledVersion;
+    } catch {
+      return null;
+    }
+  }
+}
+
+class ZipfileURI extends URI {
+  _originalUri;
+  constructor(uri, components) {
+    super(components);
+    this._originalUri = uri;
+  }
+  toString(_skipEncoding = false) {
+    return this._originalUri;
+  }
+  static parse(value, _strict = false) {
+    const uri = URI.parse(value, _strict);
+    return new ZipfileURI(value, uri);
+  }
+}
+
+var ServerState;
+
+(function(ServerState) {
+  let Type;
+  (function(Type) {
+    Type[Type['None'] = 0] = 'None';
+    Type[Type['Running'] = 1] = 'Running';
+    Type[Type['Errored'] = 2] = 'Errored';
+  })(Type = ServerState.Type || (ServerState.Type = {}));
+  ServerState.None = {
+    type: Type.None
+  };
+  class Running {
+    server;
+    apiVersion;
+    tsserverVersion;
+    languageServiceEnabled;
+    type=Type.Running;
+    constructor(server, apiVersion, tsserverVersion, languageServiceEnabled) {
+      this.server = server;
+      this.apiVersion = apiVersion;
+      this.tsserverVersion = tsserverVersion;
+      this.languageServiceEnabled = languageServiceEnabled;
+    }
+    toCancelOnResourceChange=new Set;
+    updateTsserverVersion(tsserverVersion) {
+      this.tsserverVersion = tsserverVersion;
+    }
+    updateLanguageServiceEnabled(enabled) {
+      this.languageServiceEnabled = enabled;
+    }
+  }
+  ServerState.Running = Running;
+  class Errored {
+    error;
+    tsServerLogFile;
+    type=Type.Errored;
+    constructor(error, tsServerLogFile) {
+      this.error = error;
+      this.tsServerLogFile = tsServerLogFile;
+    }
+  }
+  ServerState.Errored = Errored;
+})(ServerState || (ServerState = {}));
+
+var DiagnosticKind;
+
+(function(DiagnosticKind) {
+  DiagnosticKind[DiagnosticKind['Syntax'] = 0] = 'Syntax';
+  DiagnosticKind[DiagnosticKind['Semantic'] = 1] = 'Semantic';
+  DiagnosticKind[DiagnosticKind['Suggestion'] = 2] = 'Suggestion';
+})(DiagnosticKind || (DiagnosticKind = {}));
+
+function getDignosticsKind(event) {
+  switch (event.event) {
+   case 'syntaxDiag':
+    return DiagnosticKind.Syntax;
+
+   case 'semanticDiag':
+    return DiagnosticKind.Semantic;
+
+   case 'suggestionDiag':
+    return DiagnosticKind.Suggestion;
+  }
+  throw new Error('Unknown dignostics kind');
+}
+
+class ServerInitializingIndicator {
+  lspClient;
+  _loadingProjectName;
+  _task;
+  constructor(lspClient) {
+    this.lspClient = lspClient;
+  }
+  reset() {
+    if (this._task) {
+      const task = this._task;
+      this._task = undefined;
+      task.then(reporter => reporter.done());
+    }
+  }
+  startedLoadingProject(projectName) {
+    this.reset();
+    this._loadingProjectName = projectName;
+    this._task = this.lspClient.createProgressReporter();
+    this._task.then(reporter => reporter.begin('Initializing JS/TS language features…'));
+  }
+  finishedLoadingProject(projectName) {
+    if (this._loadingProjectName === projectName) {
+      this.reset();
+    }
+  }
+}
+
+const emptyAuthority = 'ts-nul-authority';
+
+const inMemoryResourcePrefix = '^';
+
+const RE_IN_MEMORY_FILEPATH = /^\^\/([^/]+)\/([^/]*)\/(.+)$/;
+
+class TsClient {
+  apiVersion=API.defaultVersion;
+  typescriptVersionSource=TypeScriptVersionSource.Bundled;
+  pluginManager;
+  serverState=ServerState.None;
+  lspClient;
+  logger;
+  tsserverLogger;
+  loadingIndicator;
+  isNeovimHost=false;
+  tracer;
+  workspaceFolders=[];
+  documents;
+  useSyntaxServer=SyntaxServerConfiguration.Auto;
+  onEvent;
+  onExit;
+  constructor(onCaseInsensitiveFileSystem, logger, lspClient) {
+    this.pluginManager = new PluginManager;
+    this.documents = new LspDocuments(this, lspClient, onCaseInsensitiveFileSystem);
+    this.logger = new PrefixingLogger(logger, '[tsclient]');
+    this.tsserverLogger = new PrefixingLogger(this.logger, '[tsserver]');
+    this.lspClient = lspClient;
+    this.loadingIndicator = new ServerInitializingIndicator(this.lspClient);
+  }
+  get documentsForTesting() {
+    return this.documents.documentsForTesting;
+  }
+  openTextDocument(textDocument) {
+    return this.documents.openTextDocument(textDocument);
+  }
+  onDidCloseTextDocument(uri) {
+    this.documents.onDidCloseTextDocument(uri);
+  }
+  onDidChangeTextDocument(params) {
+    this.documents.onDidChangeTextDocument(params);
+  }
+  lastFileOrDummy() {
+    return this.documents.files[0] || this.workspaceFolders[0]?.uri.fsPath;
+  }
+  toTsFilePath(stringUri) {
+    if (this.isNeovimHost && stringUri.startsWith('zipfile:')) {
+      return stringUri;
+    }
+    const resource = URI.parse(stringUri);
+    if (disabledSchemes.has(resource.scheme)) {
+      return undefined;
+    }
+    if (resource.scheme === file) {
+      return resource.fsPath;
+    }
+    return inMemoryResourcePrefix + '/' + resource.scheme + '/' + (resource.authority || emptyAuthority) + (resource.path.startsWith('/') ? resource.path : '/' + resource.path) + (resource.fragment ? '#' + resource.fragment : '');
+  }
+  toOpenDocument(textDocumentUri, options = {}) {
+    const filepath = this.toTsFilePath(textDocumentUri);
+    const document = filepath && this.documents.get(filepath);
+    if (!document) {
+      const uri = URI.parse(textDocumentUri);
+      if (!options.suppressAlertOnFailure && !disabledSchemes.has(uri.scheme)) {
+        console.error(`Unexpected resource ${textDocumentUri}`);
+      }
+      return undefined;
+    }
+    return document;
+  }
+  requestDiagnosticsForTesting() {
+    this.documents.requestDiagnosticsForTesting();
+  }
+  hasPendingDiagnostics(resource) {
+    return this.documents.hasPendingDiagnostics(resource);
+  }
+  toResource(filepath) {
+    if (this.isNeovimHost && filepath.startsWith('zipfile:')) {
+      return ZipfileURI.parse(filepath);
+    }
+    if (filepath.startsWith(inMemoryResourcePrefix)) {
+      const parts = filepath.match(RE_IN_MEMORY_FILEPATH);
+      if (parts) {
+        const resource = URI.parse(parts[1] + '://' + (parts[2] === emptyAuthority ? '' : parts[2]) + '/' + parts[3]);
+        const tsFilepath = this.toTsFilePath(resource.toString());
         const document = tsFilepath && this.documents.get(tsFilepath);
         return document ? document.uri : resource;
       }
@@ -19228,7 +19880,7 @@ class TsClient {
     return undefined;
   }
   get capabilities() {
-    if (this.useSyntaxServer === 1) {
+    if (this.useSyntaxServer === SyntaxServerConfiguration.Always) {
       return new ClientCapabilities(ClientCapability.Syntax, ClientCapability.EnhancedSyntax);
     }
     if (this.apiVersion.gte(API.v400)) {
@@ -19261,6 +19913,9 @@ class TsClient {
       });
     }
   }
+  sendWatchChanges(args) {
+    this.executeWithoutWaitingForResponse(CommandTypes.WatchChange, args);
+  }
   start(workspaceRoot, options) {
     this.apiVersion = options.typescriptVersion.version || API.defaultVersion;
     this.typescriptVersionSource = options.typescriptVersion.source;
@@ -19302,24 +19957,28 @@ class TsClient {
     return true;
   }
   serviceExited() {
-    if (this.serverState.type === 1) {
+    if (this.serverState.type === ServerState.Type.Running) {
       this.serverState.server.kill();
     }
     this.loadingIndicator.reset();
   }
   dispatchEvent(event) {
     switch (event.event) {
-     case 'syntaxDiag':
-     case 'semanticDiag':
-     case 'suggestionDiag':
-     case 'configFileDiag':
+     case EventName.syntaxDiag:
+     case EventName.semanticDiag:
+     case EventName.suggestionDiag:
+     case EventName.configFileDiag:
+      this.loadingIndicator.reset();
+
+     case EventName.createDirectoryWatcher:
+     case EventName.createFileWatcher:
+     case EventName.closeFileWatcher:
       {
-        this.loadingIndicator.reset();
         this.onEvent?.(event);
         break;
       }
 
-     case 'projectsUpdatedInBackground':
+     case EventName.projectsUpdatedInBackground:
       {
         this.loadingIndicator.reset();
         const body = event.body;
@@ -19328,11 +19987,11 @@ class TsClient {
         break;
       }
 
-     case 'projectLoadingStart':
+     case EventName.projectLoadingStart:
       this.loadingIndicator.startedLoadingProject(event.body.projectName);
       break;
 
-     case 'projectLoadingFinish':
+     case EventName.projectLoadingFinish:
       this.loadingIndicator.finishedLoadingProject(event.body.projectName);
       break;
     }
@@ -19341,7 +20000,7 @@ class TsClient {
     if (this.loadingIndicator) {
       this.loadingIndicator.reset();
     }
-    if (this.serverState.type === 1) {
+    if (this.serverState.type === ServerState.Type.Running) {
       this.serverState.server.kill();
     }
     this.serverState = ServerState.None;
@@ -19350,7 +20009,7 @@ class TsClient {
     let executions;
     if (config?.cancelOnResourceChange) {
       const runningServerState = this.serverState;
-      if (token && runningServerState.type === 1) {
+      if (token && runningServerState.type === ServerState.Type.Running) {
         const source = new mainExports$1.CancellationTokenSource;
         token.onCancellationRequested(() => source.cancel());
         const inFlight = {
@@ -19420,7 +20079,7 @@ class TsClient {
     return this.documents.interruptGetErr(f);
   }
   cancelInflightRequestsForResource(resource) {
-    if (this.serverState.type !== 1) {
+    if (this.serverState.type !== ServerState.Type.Running) {
       return;
     }
     for (const request of this.serverState.toCancelOnResourceChange) {
@@ -19431,7 +20090,7 @@ class TsClient {
   }
   executeImpl(command, args, executeInfo) {
     const serverState = this.serverState;
-    if (serverState.type === 1) {
+    if (serverState.type === ServerState.Type.Running) {
       return serverState.server.executeImpl(command, args, executeInfo);
     } else {
       return [ Promise.resolve(ServerResponse.NoServer) ];
@@ -19442,7 +20101,7 @@ class TsClient {
     if (error instanceof TypeScriptServerError && error.serverErrorText) {
       this.tsserverLogger.error(error.serverErrorText);
     }
-    if (this.serverState.type === 1) {
+    if (this.serverState.type === ServerState.Type.Running) {
       this.logger.info('Killing TS Server');
       const logfile = this.serverState.server.tsServerLogFile;
       this.serverState.server.kill();
@@ -19847,14 +20506,18 @@ function toDocumentHighlightKind(kind) {
 }
 
 class FileDiagnostics {
+  uri;
+  onPublishDiagnostics;
+  client;
+  features;
+  closed=false;
+  diagnosticsPerKind=new Map;
+  firePublishDiagnostics=pDebounce(() => this.publishDiagnostics(), 50);
   constructor(uri, onPublishDiagnostics, client, features) {
     this.uri = uri;
     this.onPublishDiagnostics = onPublishDiagnostics;
     this.client = client;
     this.features = features;
-    this.closed = false;
-    this.diagnosticsPerKind = new Map;
-    this.firePublishDiagnostics = pDebounce(() => this.publishDiagnostics(), 50);
   }
   update(kind, diagnostics) {
     if (this.diagnosticsPerKind.get(kind)?.length === 0 && diagnostics.length === 0) {
@@ -19901,16 +20564,20 @@ class FileDiagnostics {
 }
 
 class DiagnosticsManager {
+  publishDiagnostics;
+  client;
+  features;
+  logger;
+  diagnostics=new Map;
+  ignoredDiagnosticCodes=new Set;
   constructor(publishDiagnostics, client, features, logger) {
     this.publishDiagnostics = publishDiagnostics;
     this.client = client;
     this.features = features;
     this.logger = logger;
-    this.diagnostics = new Map;
-    this.ignoredDiagnosticCodes = new Set;
   }
   updateDiagnostics(kind, file, diagnostics) {
-    if (kind !== 0 && !this.client.hasCapabilityForResource(this.client.toResource(file), ClientCapability.Semantic)) {
+    if (kind !== DiagnosticKind.Syntax && !this.client.hasCapabilityForResource(this.client.toResource(file), ClientCapability.Semantic)) {
       return;
     }
     if (this.ignoredDiagnosticCodes.size) {
@@ -19934,6 +20601,22 @@ class DiagnosticsManager {
     diagnosticsForFile?.onDidClose();
     this.diagnostics.delete(uri);
   }
+  clearDiagnosticsForFile(file) {
+    if (!this.features.diagnosticsSupport) {
+      return;
+    }
+    const uri = this.client.toResourceUri(file);
+    const diagnosticsForFile = this.diagnostics.get(uri);
+    if (diagnosticsForFile) {
+      diagnosticsForFile.onDidClose();
+      this.diagnostics.delete(uri);
+    } else {
+      this.publishDiagnostics({
+        uri: uri,
+        diagnostics: []
+      });
+    }
+  }
   async waitForDiagnosticsForTesting(file) {
     const uri = this.client.toResourceUri(file);
     let diagnosticsForFile = this.diagnostics.get(uri);
@@ -19951,6 +20634,8 @@ class DiagnosticsManager {
 }
 
 class SourceDefinitionCommand {
+  static id='_typescript.goToSourceDefinition';
+  static minVersion=API.v470;
   static async execute(uri, position, client, lspClient, reporter, token) {
     if (client.apiVersion.lt(SourceDefinitionCommand.minVersion)) {
       lspClient.showErrorMessage('Go to Source Definition failed. Requires TypeScript 4.7+.');
@@ -19985,37 +20670,6 @@ class SourceDefinitionCommand {
   }
 }
 
-SourceDefinitionCommand.id = '_typescript.goToSourceDefinition';
-
-SourceDefinitionCommand.minVersion = API.v470;
-
-class TSServerRequestCommand {
-  static execute(client, command, args, config, token) {
-    if (args && typeof args === 'object' && !Array.isArray(args)) {
-      const requestArgs = args;
-      const hasFile = typeof requestArgs.file === 'string';
-      if (hasFile) {
-        const newArgs = {
-          ...args
-        };
-        if (hasFile) {
-          const document = client.toOpenDocument(requestArgs.file);
-          if (document) {
-            newArgs.file = document.filepath;
-          }
-        }
-        args = newArgs;
-      }
-    }
-    if (config && token && typeof config === 'object' && !Array.isArray(config)) {
-      config.token = token;
-    }
-    return client.executeCustom(command, args, config);
-  }
-}
-
-TSServerRequestCommand.id = 'typescript.tsserverRequest';
-
 const Commands = {
   APPLY_REFACTORING: '_typescript.applyRefactoring',
   CONFIGURE_PLUGIN: '_typescript.configurePlugin',
@@ -20023,18 +20677,25 @@ const Commands = {
   APPLY_RENAME_FILE: '_typescript.applyRenameFile',
   APPLY_COMPLETION_CODE_ACTION: '_typescript.applyCompletionCodeAction',
   SELECT_REFACTORING: '_typescript.selectRefactoring',
-  SOURCE_DEFINITION: SourceDefinitionCommand.id,
-  TS_SERVER_REQUEST: TSServerRequestCommand.id
+  SOURCE_DEFINITION: SourceDefinitionCommand.id
 };
 
 const TypescriptVersionNotification = new mainExports$2.NotificationType('$/typescriptVersion');
 
+var MarkdownStringTextNewlineStyle;
+
+(function(MarkdownStringTextNewlineStyle) {
+  MarkdownStringTextNewlineStyle[MarkdownStringTextNewlineStyle['Paragraph'] = 0] = 'Paragraph';
+  MarkdownStringTextNewlineStyle[MarkdownStringTextNewlineStyle['Break'] = 1] = 'Break';
+})(MarkdownStringTextNewlineStyle || (MarkdownStringTextNewlineStyle = {}));
+
 class MarkdownString {
+  value;
   constructor(value = '') {
     this.value = value;
   }
-  appendText(value, newlineStyle = 0) {
-    this.value += escapeMarkdownSyntaxTokens(value).replace(/([ \t]+)/g, (_match, g1) => '&nbsp;'.repeat(g1.length)).replace(/>/gm, '\\>').replace(/\n/g, newlineStyle === 1 ? '\\\n' : '\n\n');
+  appendText(value, newlineStyle = MarkdownStringTextNewlineStyle.Paragraph) {
+    this.value += escapeMarkdownSyntaxTokens(value).replace(/([ \t]+)/g, (_match, g1) => '&nbsp;'.repeat(g1.length)).replace(/>/gm, '\\>').replace(/\n/g, newlineStyle === MarkdownStringTextNewlineStyle.Break ? '\\\n' : '\n\n');
     return this;
   }
   appendMarkdown(value) {
@@ -20250,8 +20911,9 @@ class SnippetString {
   static _escape(value) {
     return value.replace(/\$|}|\\/g, '\\$&');
   }
+  _tabstop=1;
+  value;
   constructor(value) {
-    this._tabstop = 1;
     this.value = value || '';
   }
   appendText(str) {
@@ -20302,10 +20964,8 @@ class SnippetString {
 }
 
 class CompletionDataCache {
-  constructor() {
-    this.store = new Map;
-    this.lastCacheId = 0;
-  }
+  store=new Map;
+  lastCacheId=0;
   reset() {
     this.lastCacheId = 0;
     this.store.clear();
@@ -20839,6 +21499,34 @@ function toTsTriggerReason(context) {
   }
 }
 
+class TSServerRequestCommand {
+  tsClient;
+  static ID='typescript.tsserverRequest';
+  id=TSServerRequestCommand.ID;
+  constructor(tsClient) {
+    this.tsClient = tsClient;
+  }
+  async execute(command, args, config) {
+    if (args && typeof args === 'object' && !Array.isArray(args)) {
+      const requestArgs = args;
+      const hasFile = typeof requestArgs.file === 'string';
+      if (hasFile) {
+        const newArgs = {
+          ...args
+        };
+        if (hasFile) {
+          const document = this.tsClient.toOpenDocument(requestArgs.file);
+          if (document) {
+            newArgs.file = document.filepath;
+          }
+        }
+        args = newArgs;
+      }
+    }
+    return await this.tsClient.executeCustom(command, args, config);
+  }
+}
+
 var CodeActionKind$1;
 
 (function(CodeActionKind) {
@@ -20926,6 +21614,20 @@ function asKind(action) {
 }
 
 class CodeActionKind {
+  value;
+  static sep='.';
+  static Empty=new CodeActionKind(mainExports$2.CodeActionKind.Empty);
+  static QuickFix=new CodeActionKind(mainExports$2.CodeActionKind.QuickFix);
+  static Refactor=new CodeActionKind(mainExports$2.CodeActionKind.Refactor);
+  static Source=new CodeActionKind(mainExports$2.CodeActionKind.Source);
+  static SourceAddMissingImportsTs=CodeActionKind.Source.append('addMissingImports').append('ts');
+  static SourceFixAll=new CodeActionKind(mainExports$2.CodeActionKind.SourceFixAll);
+  static SourceFixAllTs=CodeActionKind.SourceFixAll.append('ts');
+  static SourceOrganizeImports=new CodeActionKind(mainExports$2.CodeActionKind.SourceOrganizeImports);
+  static SourceOrganizeImportsTs=CodeActionKind.SourceOrganizeImports.append('ts');
+  static SourceRemoveUnusedImportsTs=CodeActionKind.Source.append('removeUnusedImports').append('ts');
+  static SourceRemoveUnusedTs=CodeActionKind.Source.append('removeUnused').append('ts');
+  static SourceSortImportsTs=CodeActionKind.Source.append('sortImports').append('ts');
   constructor(value) {
     this.value = value;
   }
@@ -20943,32 +21645,6 @@ class CodeActionKind {
   }
 }
 
-CodeActionKind.sep = '.';
-
-CodeActionKind.Empty = new CodeActionKind(mainExports$2.CodeActionKind.Empty);
-
-CodeActionKind.QuickFix = new CodeActionKind(mainExports$2.CodeActionKind.QuickFix);
-
-CodeActionKind.Refactor = new CodeActionKind(mainExports$2.CodeActionKind.Refactor);
-
-CodeActionKind.Source = new CodeActionKind(mainExports$2.CodeActionKind.Source);
-
-CodeActionKind.SourceAddMissingImportsTs = CodeActionKind.Source.append('addMissingImports').append('ts');
-
-CodeActionKind.SourceFixAll = new CodeActionKind(mainExports$2.CodeActionKind.SourceFixAll);
-
-CodeActionKind.SourceFixAllTs = CodeActionKind.SourceFixAll.append('ts');
-
-CodeActionKind.SourceOrganizeImports = new CodeActionKind(mainExports$2.CodeActionKind.SourceOrganizeImports);
-
-CodeActionKind.SourceOrganizeImportsTs = CodeActionKind.SourceOrganizeImports.append('ts');
-
-CodeActionKind.SourceRemoveUnusedImportsTs = CodeActionKind.Source.append('removeUnusedImports').append('ts');
-
-CodeActionKind.SourceRemoveUnusedTs = CodeActionKind.Source.append('removeUnused').append('ts');
-
-CodeActionKind.SourceSortImportsTs = CodeActionKind.Source.append('sortImports').append('ts');
-
 const organizeImportsCommand = {
   title: 'Organize Imports',
   kind: CodeActionKind.SourceOrganizeImportsTs,
@@ -21195,13 +21871,13 @@ function parseKindModifier(kindModifiers) {
   return new Set(kindModifiers.split(/,|\s+/g));
 }
 
-var cjs$1;
+var cjs;
 
-var hasRequiredCjs$1;
+var hasRequiredCjs;
 
-function requireCjs$1() {
-  if (hasRequiredCjs$1) return cjs$1;
-  hasRequiredCjs$1 = 1;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
   var isMergeableObject = function isMergeableObject(value) {
     return isNonNullObject(value) && !isSpecial(value);
   };
@@ -21297,11 +21973,11 @@ function requireCjs$1() {
     }, {});
   };
   var deepmerge_1 = deepmerge;
-  cjs$1 = deepmerge_1;
-  return cjs$1;
+  cjs = deepmerge_1;
+  return cjs;
 }
 
-var cjsExports = requireCjs$1();
+var cjsExports = requireCjs();
 
 const deepmerge = getDefaultExportFromCjs(cjsExports);
 
@@ -21367,6 +22043,9 @@ function getInferredProjectCompilerOptions(version, workspaceConfig) {
   if (workspaceConfig.strictFunctionTypes) {
     projectConfig.strictFunctionTypes = true;
   }
+  if (workspaceConfig.strict) {
+    projectConfig.strict = true;
+  }
   if (workspaceConfig.module) {
     projectConfig.module = workspaceConfig.module;
   }
@@ -21428,9 +22107,10 @@ const DEFAULT_IMPLICIT_PROJECT_CONFIGURATION = {
   checkJs: false,
   experimentalDecorators: false,
   module: ModuleKind.ESNext,
+  strict: true,
   strictFunctionTypes: true,
   strictNullChecks: true,
-  target: ScriptTarget.ES2020
+  target: ScriptTarget.ES2024
 };
 
 const DEFAULT_WORKSPACE_CONFIGURATION = {
@@ -21442,12 +22122,18 @@ function areFileConfigurationsEqual(a, b) {
 }
 
 class FileConfigurationManager {
+  client;
+  lspClient;
+  features;
+  tsPreferences=deepmerge({}, DEFAULT_TSSERVER_PREFERENCES);
+  workspaceConfiguration=deepmerge({}, DEFAULT_WORKSPACE_CONFIGURATION);
+  fileOptionsCache;
+  formatOptionsCache;
+  initialConfigurationRequestsMap;
   constructor(client, lspClient, features, onCaseInsensitiveFileSystem) {
     this.client = client;
     this.lspClient = lspClient;
     this.features = features;
-    this.tsPreferences = deepmerge({}, DEFAULT_TSSERVER_PREFERENCES);
-    this.workspaceConfiguration = deepmerge({}, DEFAULT_WORKSPACE_CONFIGURATION);
     this.fileOptionsCache = new ResourceMap(undefined, {
       onCaseInsensitiveFileSystem: onCaseInsensitiveFileSystem
     });
@@ -21631,6 +22317,17 @@ var CodeLensType;
 })(CodeLensType || (CodeLensType = {}));
 
 class TypeScriptBaseCodeLensProvider {
+  client;
+  cachedResponse;
+  fileConfigurationManager;
+  static cancelledCommand={
+    title: '',
+    command: ''
+  };
+  static errorCommand={
+    title: 'Could not determine references',
+    command: ''
+  };
   constructor(client, cachedResponse, fileConfigurationManager) {
     this.client = client;
     this.cachedResponse = cachedResponse;
@@ -21663,16 +22360,6 @@ class TypeScriptBaseCodeLensProvider {
   }
 }
 
-TypeScriptBaseCodeLensProvider.cancelledCommand = {
-  title: '',
-  command: ''
-};
-
-TypeScriptBaseCodeLensProvider.errorCommand = {
-  title: 'Could not determine references',
-  command: ''
-};
-
 function getSymbolRange(document, item) {
   if (item.nameSpan) {
     return Range.fromTextSpan(item.nameSpan);
@@ -21831,6 +22518,7 @@ class TypeScriptReferencesCodeLensProvider extends TypeScriptBaseCodeLensProvide
 }
 
 class TypeScriptInlayHintsProvider {
+  static minVersion=API.v440;
   static async provideInlayHints(textDocument, range, client, lspClient, fileConfigurationManager, token) {
     if (client.apiVersion.lt(TypeScriptInlayHintsProvider.minVersion)) {
       lspClient.showErrorMessage('Inlay Hints request failed. Requires TypeScript 4.4+.');
@@ -21883,8 +22571,6 @@ class TypeScriptInlayHintsProvider {
   }
 }
 
-TypeScriptInlayHintsProvider.minVersion = API.v440;
-
 function areInlayHintsEnabledForFile(fileConfigurationManager, document) {
   const preferences = fileConfigurationManager.getPreferences(document);
   return preferences.includeInlayParameterNameHints === 'literals' || preferences.includeInlayParameterNameHints === 'all' || preferences.includeInlayEnumMemberValueHints || preferences.includeInlayFunctionLikeReturnTypeHints || preferences.includeInlayFunctionParameterTypeHints || preferences.includeInlayPropertyDeclarationTypeHints || preferences.includeInlayVariableTypeHints;
@@ -21934,539 +22620,65 @@ function transformSpans(doc, spans) {
 }
 
 class CachedResponse {
-  constructor() {
-    this.version = -1;
-    this.document = '';
-  }
+  response;
+  version=-1;
+  document='';
   execute(document, resolve) {
     if (this.response && this.matches(document)) {
       return this.response = this.response.then(result => result.type === 'cancelled' ? resolve() : result);
     }
     return this.reset(document, resolve);
   }
-  onDocumentClose(document) {
-    if (this.document === document.uri.toString()) {
-      this.response = undefined;
-      this.version = -1;
-      this.document = '';
-    }
-  }
-  matches(document) {
-    return this.version === document.version && this.document === document.uri.toString();
-  }
-  async reset(document, resolve) {
-    this.version = document.version;
-    this.document = document.uri.toString();
-    return this.response = resolve();
-  }
-}
-
-class LogDirectoryProvider {
-  constructor(rootPath) {
-    this.rootPath = rootPath;
-  }
-  getNewLogDirectory() {
-    const root = this.logDirectory();
-    if (root) {
-      try {
-        return fs$2.mkdtempSync(path__default.join(root, 'tsserver-log-'));
-      } catch {
-        return undefined;
-      }
-    }
-    return undefined;
-  }
-  logDirectory() {
-    if (!this.rootPath) {
-      return undefined;
-    }
-    try {
-      if (!fs$2.existsSync(this.rootPath)) {
-        fs$2.mkdirSync(this.rootPath);
-      }
-      return this.rootPath;
-    } catch {
-      return undefined;
-    }
-  }
-}
-
-var cjs = {};
-
-var posix = {};
-
-var hasRequiredPosix;
-
-function requirePosix() {
-  if (hasRequiredPosix) return posix;
-  hasRequiredPosix = 1;
-  Object.defineProperty(posix, '__esModule', {
-    value: true
-  });
-  posix.sync = posix.isexe = void 0;
-  const fs_1 = require$$0$2;
-  const promises_1 = require$$1$1;
-  const isexe = async (path, options = {}) => {
-    const {ignoreErrors: ignoreErrors = false} = options;
-    try {
-      return checkStat(await (0, promises_1.stat)(path), options);
-    } catch (e) {
-      const er = e;
-      if (ignoreErrors || er.code === 'EACCES') return false;
-      throw er;
-    }
-  };
-  posix.isexe = isexe;
-  const sync = (path, options = {}) => {
-    const {ignoreErrors: ignoreErrors = false} = options;
-    try {
-      return checkStat((0, fs_1.statSync)(path), options);
-    } catch (e) {
-      const er = e;
-      if (ignoreErrors || er.code === 'EACCES') return false;
-      throw er;
-    }
-  };
-  posix.sync = sync;
-  const checkStat = (stat, options) => stat.isFile() && checkMode(stat, options);
-  const checkMode = (stat, options) => {
-    const myUid = options.uid ?? process.getuid?.();
-    const myGroups = options.groups ?? process.getgroups?.() ?? [];
-    const myGid = options.gid ?? process.getgid?.() ?? myGroups[0];
-    if (myUid === undefined || myGid === undefined) {
-      throw new Error('cannot get uid or gid');
-    }
-    const groups = new Set([ myGid, ...myGroups ]);
-    const mod = stat.mode;
-    const uid = stat.uid;
-    const gid = stat.gid;
-    const u = parseInt('100', 8);
-    const g = parseInt('010', 8);
-    const o = parseInt('001', 8);
-    const ug = u | g;
-    return !!(mod & o || mod & g && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0);
-  };
-  return posix;
-}
-
-var win32 = {};
-
-var hasRequiredWin32;
-
-function requireWin32() {
-  if (hasRequiredWin32) return win32;
-  hasRequiredWin32 = 1;
-  Object.defineProperty(win32, '__esModule', {
-    value: true
-  });
-  win32.sync = win32.isexe = void 0;
-  const fs_1 = require$$0$2;
-  const promises_1 = require$$1$1;
-  const isexe = async (path, options = {}) => {
-    const {ignoreErrors: ignoreErrors = false} = options;
-    try {
-      return checkStat(await (0, promises_1.stat)(path), path, options);
-    } catch (e) {
-      const er = e;
-      if (ignoreErrors || er.code === 'EACCES') return false;
-      throw er;
-    }
-  };
-  win32.isexe = isexe;
-  const sync = (path, options = {}) => {
-    const {ignoreErrors: ignoreErrors = false} = options;
-    try {
-      return checkStat((0, fs_1.statSync)(path), path, options);
-    } catch (e) {
-      const er = e;
-      if (ignoreErrors || er.code === 'EACCES') return false;
-      throw er;
-    }
-  };
-  win32.sync = sync;
-  const checkPathExt = (path, options) => {
-    const {pathExt: pathExt = process.env.PATHEXT || ''} = options;
-    const peSplit = pathExt.split(';');
-    if (peSplit.indexOf('') !== -1) {
-      return true;
-    }
-    for (let i = 0; i < peSplit.length; i++) {
-      const p = peSplit[i].toLowerCase();
-      const ext = path.substring(path.length - p.length).toLowerCase();
-      if (p && ext === p) {
-        return true;
-      }
-    }
-    return false;
-  };
-  const checkStat = (stat, path, options) => stat.isFile() && checkPathExt(path, options);
-  return win32;
-}
-
-var options$1 = {};
-
-var hasRequiredOptions;
-
-function requireOptions() {
-  if (hasRequiredOptions) return options$1;
-  hasRequiredOptions = 1;
-  Object.defineProperty(options$1, '__esModule', {
-    value: true
-  });
-  return options$1;
-}
-
-var hasRequiredCjs;
-
-function requireCjs() {
-  if (hasRequiredCjs) return cjs;
-  hasRequiredCjs = 1;
-  (function(exports) {
-    var __createBinding = cjs && cjs.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === undefined) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = {
-          enumerable: true,
-          get: function() {
-            return m[k];
-          }
-        };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === undefined) k2 = k;
-      o[k2] = m[k];
-    });
-    var __setModuleDefault = cjs && cjs.__setModuleDefault || (Object.create ? function(o, v) {
-      Object.defineProperty(o, 'default', {
-        enumerable: true,
-        value: v
-      });
-    } : function(o, v) {
-      o['default'] = v;
-    });
-    var __importStar = cjs && cjs.__importStar || function(mod) {
-      if (mod && mod.__esModule) return mod;
-      var result = {};
-      if (mod != null) for (var k in mod) if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-      __setModuleDefault(result, mod);
-      return result;
-    };
-    var __exportStar = cjs && cjs.__exportStar || function(m, exports) {
-      for (var p in m) if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-    };
-    Object.defineProperty(exports, '__esModule', {
-      value: true
-    });
-    exports.sync = exports.isexe = exports.posix = exports.win32 = void 0;
-    const posix = __importStar(requirePosix());
-    exports.posix = posix;
-    const win32 = __importStar(requireWin32());
-    exports.win32 = win32;
-    __exportStar(requireOptions(), exports);
-    const platform = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
-    const impl = platform === 'win32' ? win32 : posix;
-    exports.isexe = impl.isexe;
-    exports.sync = impl.sync;
-  })(cjs);
-  return cjs;
-}
-
-var lib;
-
-var hasRequiredLib;
-
-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;
-  const isWindows = process.platform === 'win32';
-  const rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? '' : sep}]`.replace(/(\\)/g, '\\$1'));
-  const rRel = new RegExp(`^\\.${rSlash.source}`);
-  const getNotFoundError = cmd => Object.assign(new Error(`not found: ${cmd}`), {
-    code: 'ENOENT'
-  });
-  const getPathInfo = (cmd, {path: optPath = process.env.PATH, pathExt: optPathExt = process.env.PATHEXT, delimiter: optDelimiter = delimiter}) => {
-    const pathEnv = cmd.match(rSlash) ? [ '' ] : [ ...isWindows ? [ process.cwd() ] : [], ...(optPath || '').split(optDelimiter) ];
-    if (isWindows) {
-      const pathExtExe = optPathExt || [ '.EXE', '.CMD', '.BAT', '.COM' ].join(optDelimiter);
-      const pathExt = pathExtExe.split(optDelimiter).flatMap(item => [ item, item.toLowerCase() ]);
-      if (cmd.includes('.') && pathExt[0] !== '') {
-        pathExt.unshift('');
-      }
-      return {
-        pathEnv: pathEnv,
-        pathExt: pathExt,
-        pathExtExe: pathExtExe
-      };
-    }
-    return {
-      pathEnv: pathEnv,
-      pathExt: [ '' ]
-    };
-  };
-  const getPathPart = (raw, cmd) => {
-    const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
-    const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : '';
-    return prefix + join(pathPart, cmd);
-  };
-  const which = async (cmd, opt = {}) => {
-    const {pathEnv: pathEnv, pathExt: pathExt, pathExtExe: pathExtExe} = getPathInfo(cmd, opt);
-    const found = [];
-    for (const envPart of pathEnv) {
-      const p = getPathPart(envPart, cmd);
-      for (const ext of pathExt) {
-        const withExt = p + ext;
-        const is = await isexe(withExt, {
-          pathExt: pathExtExe,
-          ignoreErrors: true
-        });
-        if (is) {
-          if (!opt.all) {
-            return withExt;
-          }
-          found.push(withExt);
-        }
-      }
-    }
-    if (opt.all && found.length) {
-      return found;
-    }
-    if (opt.nothrow) {
-      return null;
-    }
-    throw getNotFoundError(cmd);
-  };
-  const whichSync = (cmd, opt = {}) => {
-    const {pathEnv: pathEnv, pathExt: pathExt, pathExtExe: pathExtExe} = getPathInfo(cmd, opt);
-    const found = [];
-    for (const pathEnvPart of pathEnv) {
-      const p = getPathPart(pathEnvPart, cmd);
-      for (const ext of pathExt) {
-        const withExt = p + ext;
-        const is = isexeSync(withExt, {
-          pathExt: pathExtExe,
-          ignoreErrors: true
-        });
-        if (is) {
-          if (!opt.all) {
-            return withExt;
-          }
-          found.push(withExt);
-        }
-      }
-    }
-    if (opt.all && found.length) {
-      return found;
-    }
-    if (opt.nothrow) {
-      return null;
-    }
-    throw getNotFoundError(cmd);
-  };
-  lib = which;
-  which.sync = whichSync;
-  return lib;
-}
-
-var libExports = requireLib();
-
-const which = getDefaultExportFromCjs(libExports);
-
-const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-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 stats = fs$2.statSync(filePath, {
-        throwIfNoEntry: false
-      });
-      if (type === 'file' && stats?.isFile() || type === 'directory' && stats?.isDirectory()) {
-        return filePath;
-      }
-    } catch {}
-    if (directory === stopAt || directory === root) {
-      break;
-    }
-    directory = path__default.dirname(directory);
-  }
-}
-
-function packageUpSync({cwd: cwd = process$1.cwd()} = {}) {
-  return findUpSync('package.json', {
-    cwd: cwd
-  });
-}
-
-function findPathToModule(dir, moduleNames) {
-  const stat = statSync(dir);
-  if (stat.isDirectory()) {
-    const candidates = moduleNames.map(moduleName => resolve(dir, moduleName));
-    const modulePath = candidates.find(existsSync);
-    if (modulePath) {
-      return modulePath;
-    }
-  }
-  const parent = resolve(dir, '..');
-  if (parent !== dir) {
-    return findPathToModule(parent, moduleNames);
-  }
-}
-
-class TypeScriptVersion {
-  constructor(source, path, logger) {
-    this.source = source;
-    this.path = path;
-    this.logger = logger;
-    this._api = null;
-  }
-  get tsServerPath() {
-    return this.path;
-  }
-  get isValid() {
-    return this.version !== null;
-  }
-  get version() {
-    if (this._api) {
-      return this._api;
+  onDocumentClose(document) {
+    if (this.document === document.uri.toString()) {
+      this.response = undefined;
+      this.version = -1;
+      this.document = '';
     }
-    this._api = this.getTypeScriptVersion(this.tsServerPath);
-    return this._api;
   }
-  get versionString() {
-    const version = this.version;
-    return version ? version.displayName : null;
+  matches(document) {
+    return this.version === document.version && this.document === document.uri.toString();
   }
-  getTypeScriptVersion(serverPath) {
-    this.logger.log(`Resolving TypeScript version from path "${serverPath}"...`);
-    if (!fs$2.existsSync(serverPath)) {
-      this.logger.log('Server path does not exist on disk');
-      return null;
-    }
-    const p = serverPath.split(path__default.sep);
-    if (p.length <= 2) {
-      this.logger.log('Server path is invalid (has less than two path components).');
-      return null;
-    }
-    const p2 = p.slice(0, -2);
-    const modulePath = p2.join(path__default.sep);
-    let fileName = path__default.join(modulePath, 'package.json');
-    if (!fs$2.existsSync(fileName)) {
-      if (path__default.basename(modulePath) === 'built') {
-        fileName = path__default.join(modulePath, '..', 'package.json');
-      }
-    }
-    if (!fs$2.existsSync(fileName)) {
-      this.logger.log(`Failed to find package.json at path "${fileName}"`);
-      return null;
-    }
-    this.logger.log(`Reading version from package.json at "${fileName}"`);
-    const contents = fs$2.readFileSync(fileName).toString();
-    let desc = null;
-    try {
-      desc = JSON.parse(contents);
-    } catch {
-      this.logger.log('Failed parsing contents of package.json.');
-      return null;
-    }
-    if (!desc?.version) {
-      this.logger.log('Failed reading version number from package.json.');
-      return null;
-    }
-    this.logger.log(`Resolved TypeScript version to "${desc.version}"`);
-    return API.fromVersionString(desc.version);
+  async reset(document, resolve) {
+    this.version = document.version;
+    this.document = document.uri.toString();
+    return this.response = resolve();
   }
 }
 
-const MODULE_FOLDERS = [ 'node_modules/typescript/lib', '.vscode/pnpify/typescript/lib', '.yarn/sdks/typescript/lib' ];
-
-class TypeScriptVersionProvider {
-  constructor(userTsserverPath, logger) {
-    this.userTsserverPath = userTsserverPath;
-    this.logger = logger;
+class LogDirectoryProvider {
+  rootPath;
+  constructor(rootPath) {
+    this.rootPath = rootPath;
   }
-  getUserSettingVersion() {
-    if (!this.userTsserverPath) {
-      return null;
-    }
-    this.logger.log(`Resolving user-provided tsserver path "${this.userTsserverPath}"...`);
-    let resolvedPath = this.userTsserverPath;
-    if (!path__default.isAbsolute(resolvedPath)) {
-      const binaryPath = which.sync(resolvedPath, {
-        nothrow: true
-      });
-      if (binaryPath) {
-        resolvedPath = binaryPath;
-      }
-      this.logger.log(`Non-absolute tsserver path resolved to "${binaryPath ? resolvedPath : '<failed>'}"`);
-    }
-    let stat = fs$2.lstatSync(resolvedPath, {
-      throwIfNoEntry: false
-    });
-    if (stat?.isSymbolicLink()) {
-      resolvedPath = fs$2.realpathSync(resolvedPath);
-      this.logger.log(`Symbolic link tsserver path resolved to "${resolvedPath}"`);
-    }
-    stat = fs$2.lstatSync(resolvedPath, {
-      throwIfNoEntry: false
-    });
-    if (stat?.isFile()) {
-      if (path__default.basename(resolvedPath) === 'tsserver.js') {
-        this.logger.log(`Resolved tsserver location: ${resolvedPath}`);
-        return new TypeScriptVersion('user-setting', resolvedPath, this.logger);
+  getNewLogDirectory() {
+    const root = this.logDirectory();
+    if (root) {
+      try {
+        return fs$2.mkdtempSync(path__default.join(root, 'tsserver-log-'));
+      } catch {
+        return undefined;
       }
-      resolvedPath = path__default.dirname(resolvedPath);
-      this.logger.log(`Resolved directory path from a file path: ${resolvedPath}`);
     }
-    try {
-      const packageJsonPath = packageUpSync({
-        cwd: resolvedPath
-      });
-      this.logger.log(`Resolved package.json location: "${packageJsonPath}"`);
-      if (packageJsonPath) {
-        resolvedPath = path__default.join(path__default.dirname(packageJsonPath), 'lib', 'tsserver.js');
-        this.logger.log(`Resolved tsserver location: "${resolvedPath}"`);
-      }
-    } catch {}
-    return new TypeScriptVersion('user-setting', resolvedPath, this.logger);
+    return undefined;
   }
-  getWorkspaceVersion(workspaceFolders) {
-    for (const p of workspaceFolders) {
-      const libFolder = findPathToModule(p, MODULE_FOLDERS);
-      if (libFolder) {
-        const tsServerPath = path__default.join(libFolder, 'tsserver.js');
-        const version = new TypeScriptVersion('workspace', tsServerPath, this.logger);
-        if (version.isValid) {
-          return version;
-        }
-      }
+  logDirectory() {
+    if (!this.rootPath) {
+      return undefined;
     }
-    return null;
-  }
-  bundledVersion() {
-    const require = createRequire(import.meta.url);
     try {
-      const file = require.resolve('typescript');
-      const tsServerPath = path__default.join(path__default.dirname(file), 'tsserver.js');
-      const bundledVersion = new TypeScriptVersion('bundled', tsServerPath, this.logger);
-      return bundledVersion;
+      if (!fs$2.existsSync(this.rootPath)) {
+        fs$2.mkdirSync(this.rootPath);
+      }
+      return this.rootPath;
     } catch {
-      return null;
+      return undefined;
     }
   }
 }
 
 class CommandManager {
-  constructor() {
-    this.commands = new Map;
-  }
+  commands=new Map;
   dispose() {
     this.commands.clear();
   }
@@ -22479,13 +22691,15 @@ class CommandManager {
   get registeredIds() {
     return Array.from(this.commands.keys());
   }
+  handlesCommand(commandId) {
+    return this.commands.has(commandId);
+  }
   async handle(commandId, ...args) {
     const entry = this.commands.get(commandId);
     if (entry) {
-      await entry.execute(...args);
-      return true;
+      return await entry.execute(...args);
     }
-    return false;
+    return null;
   }
 }
 
@@ -22530,6 +22744,13 @@ const unreachableCode = 'fixUnreachableCode';
 const unusedIdentifier = 'unusedIdentifier';
 
 class TsCodeAction {
+  title;
+  kind;
+  command;
+  diagnostics;
+  disabled;
+  edit;
+  isPreferred;
   constructor(title, kind) {
     this.title = title;
     this.kind = kind;
@@ -22634,6 +22855,7 @@ async function buildCombinedFix(fixes, client, file, diagnostics, token) {
 class SourceAction extends TsCodeAction {}
 
 class SourceFixAll extends SourceAction {
+  static kind=CodeActionKind.SourceFixAllTs;
   constructor() {
     super('Fix all fixable JS/TS issues', SourceFixAll.kind.value);
   }
@@ -22655,9 +22877,8 @@ class SourceFixAll extends SourceAction {
   }
 }
 
-SourceFixAll.kind = CodeActionKind.SourceFixAllTs;
-
 class SourceRemoveUnused extends SourceAction {
+  static kind=CodeActionKind.SourceRemoveUnusedTs;
   constructor() {
     super('Remove all unused code', SourceRemoveUnused.kind.value);
   }
@@ -22669,9 +22890,8 @@ class SourceRemoveUnused extends SourceAction {
   }
 }
 
-SourceRemoveUnused.kind = CodeActionKind.SourceRemoveUnusedTs;
-
 class SourceAddMissingImports extends SourceAction {
+  static kind=CodeActionKind.SourceAddMissingImportsTs;
   constructor() {
     super('Add all missing imports', SourceAddMissingImports.kind.value);
   }
@@ -22683,9 +22903,11 @@ class SourceAddMissingImports extends SourceAction {
   }
 }
 
-SourceAddMissingImports.kind = CodeActionKind.SourceAddMissingImportsTs;
-
 class TypeScriptAutoFixProvider {
+  client;
+  fileConfigurationManager;
+  diagnosticsManager;
+  static kindProviders=[ SourceFixAll, SourceRemoveUnused, SourceAddMissingImports ];
   constructor(client, fileConfigurationManager, diagnosticsManager) {
     this.client = client;
     this.fileConfigurationManager = fileConfigurationManager;
@@ -22727,12 +22949,13 @@ class TypeScriptAutoFixProvider {
   }
 }
 
-TypeScriptAutoFixProvider.kindProviders = [ SourceFixAll, SourceRemoveUnused, SourceAddMissingImports ];
-
 class Lazy {
+  executor;
+  _didRun=false;
+  _value;
+  _error;
   constructor(executor) {
     this.executor = executor;
-    this._didRun = false;
   }
   get hasValue() {
     return this._didRun;
@@ -22775,9 +22998,11 @@ async function applyCodeActionCommands(client, commands, token) {
 }
 
 class ApplyCodeActionCommand {
+  client;
+  static ID='_typescript.applyCodeActionCommand';
+  id=ApplyCodeActionCommand.ID;
   constructor(client) {
     this.client = client;
-    this.id = ApplyCodeActionCommand.ID;
   }
   async execute({action: action}) {
     const codeActionResult = await applyCodeActionCommands(this.client, action.commands);
@@ -22785,13 +23010,14 @@ class ApplyCodeActionCommand {
   }
 }
 
-ApplyCodeActionCommand.ID = '_typescript.applyCodeActionCommand';
-
 class ApplyFixAllCodeAction {
+  client;
+  tsCodeActionProvider;
+  static ID='_typescript.applyFixAllCodeAction';
+  id=ApplyFixAllCodeAction.ID;
   constructor(client, tsCodeActionProvider) {
     this.client = client;
     this.tsCodeActionProvider = tsCodeActionProvider;
-    this.id = ApplyFixAllCodeAction.ID;
   }
   async execute(args) {
     const tsAction = this.tsCodeActionProvider.getQuickFixAllTsCodeActionByFixName(args.tsActionId);
@@ -22801,9 +23027,8 @@ class ApplyFixAllCodeAction {
   }
 }
 
-ApplyFixAllCodeAction.ID = '_typescript.applyFixAllCodeAction';
-
 class DiagnosticsSet {
+  _values;
   static from(diagnostics) {
     const values = new Map;
     for (const diagnostic of diagnostics) {
@@ -22827,6 +23052,7 @@ class DiagnosticsSet {
 }
 
 class TsQuickFixCodeAction extends TsCodeAction {
+  tsAction;
   constructor(tsAction, title, kind) {
     super(title, kind);
     this.tsAction = tsAction;
@@ -22834,18 +23060,18 @@ class TsQuickFixCodeAction extends TsCodeAction {
 }
 
 class TsQuickFixAllCodeAction extends TsQuickFixCodeAction {
+  file;
   constructor(tsAction, file, title, kind) {
     super(tsAction, title, kind);
     this.file = file;
   }
+  combinedResponse;
 }
 
 class CodeActionSet {
-  constructor() {
-    this._actions = new Set;
-    this._fixAllActions = new Map;
-    this._aiActions = new Set;
-  }
+  _actions=new Set;
+  _fixAllActions=new Map;
+  _aiActions=new Set;
   * values() {
     yield* this._actions;
     yield* this._aiActions;
@@ -22879,23 +23105,30 @@ class CodeActionSet {
 }
 
 class SupportedCodeActionProvider {
+  client;
   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 + '')));
   }
+  fixableDiagnosticCodes=new Lazy(() => this.client.execute(CommandTypes.GetSupportedCodeFixes, null).then(response => response.type === 'response' ? response.body || [] : []).then(codes => new Set(codes)));
 }
 
 class TypeScriptQuickFixProvider {
+  client;
+  fileConfigurationManager;
+  diagnosticsManager;
+  features;
+  static _maxCodeActionsPerFile=1e3;
+  _quickFixAllTsCodeActionMap=new Map;
+  supportedCodeActionProvider;
   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);
@@ -23038,8 +23271,6 @@ class TypeScriptQuickFixProvider {
   }
 }
 
-TypeScriptQuickFixProvider._maxCodeActionsPerFile = 1e3;
-
 const fixAllErrorCodes = new Map([ [ 2339, 2339 ], [ 2345, 2339 ] ]);
 
 const preferredFixes = new Map([ [ annotateWithTypeFromJSDoc, {
@@ -23111,12 +23342,13 @@ const nulToken = {
 };
 
 class CodeActionManager {
+  features;
+  providerMap=new Map;
+  nextProviderId=1;
+  resolveCodeActionsMap=new Map;
+  nextGlobalCodeActionId=1;
   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));
   }
@@ -23187,21 +23419,307 @@ class CodeActionManager {
   }
 }
 
+class WatchEventManager {
+  options;
+  watchers=new Map;
+  coverage=new Map;
+  coverageUsage=new Map;
+  workspacePaths;
+  registration;
+  registrationHash;
+  updateRegistrationQueue=Promise.resolve();
+  readyForRegistration=false;
+  disposed=false;
+  constructor(options) {
+    this.options = options;
+    this.workspacePaths = options.workspaceFolders.map(folder => this.normalizePath(folder.fsPath));
+    for (const folder of options.workspaceFolders) {
+      const key = this.coverageKey(folder.fsPath, '**/*');
+      const kind = mainExports$2.WatchKind.Create | mainExports$2.WatchKind.Change | mainExports$2.WatchKind.Delete;
+      const entry = {
+        key: key,
+        normalizedBase: this.normalizePath(folder.fsPath),
+        watcher: {
+          globPattern: {
+            baseUri: folder.toString(),
+            pattern: '**/*'
+          },
+          kind: kind
+        },
+        watchKind: kind,
+        permanent: true
+      };
+      this.coverage.set(key, entry);
+    }
+  }
+  onInitialized() {
+    this.readyForRegistration = true;
+    this.updateRegistration();
+  }
+  dispose() {
+    this.disposed = true;
+    this.registration?.dispose();
+    this.registration = undefined;
+    this.watchers.clear();
+    this.coverage.clear();
+    this.coverageUsage.clear();
+  }
+  handleTsserverEvent(event) {
+    switch (event.event) {
+     case EventName.createFileWatcher:
+      this.addFileWatcher(event.body);
+      return true;
+
+     case EventName.createDirectoryWatcher:
+      this.addDirectoryWatcher(event.body);
+      return true;
+
+     case EventName.closeFileWatcher:
+      this.closeWatcher(event.body);
+      return true;
+
+     default:
+      return false;
+    }
+  }
+  handleFileChanges(params) {
+    if (!this.watchers.size || !params.changes.length) {
+      return;
+    }
+    const collected = new Map;
+    for (const change of params.changes) {
+      const uri = URI.parse(change.uri);
+      const fsPath = uri.fsPath;
+      const normalizedFsPath = this.normalizePath(fsPath);
+      for (const watcher of this.watchers.values()) {
+        if (!this.watcherMatchesPath(watcher, normalizedFsPath)) {
+          continue;
+        }
+        if (change.type === mainExports$2.FileChangeType.Changed && watcher.ignoreUpdate) {
+          continue;
+        }
+        const changes = this.ensureChangeBucket(collected, watcher.id);
+        switch (change.type) {
+         case mainExports$2.FileChangeType.Created:
+          changes.created.push(normalizedFsPath);
+          break;
+
+         case mainExports$2.FileChangeType.Deleted:
+          changes.deleted.push(normalizedFsPath);
+          break;
+
+         case mainExports$2.FileChangeType.Changed:
+          changes.updated.push(normalizedFsPath);
+          break;
+        }
+      }
+    }
+    if (!collected.size) {
+      return;
+    }
+    const payload = [];
+    for (const [id, changes] of collected.entries()) {
+      payload.push({
+        id: id,
+        created: changes.created.length ? changes.created : undefined,
+        deleted: changes.deleted.length ? changes.deleted : undefined,
+        updated: changes.updated.length ? changes.updated : undefined
+      });
+    }
+    this.options.sendWatchChanges(payload.length === 1 ? payload[0] : payload);
+  }
+  ensureChangeBucket(collected, id) {
+    let bucket = collected.get(id);
+    if (!bucket) {
+      bucket = {
+        created: [],
+        deleted: [],
+        updated: []
+      };
+      collected.set(id, bucket);
+    }
+    return bucket;
+  }
+  addFileWatcher(body) {
+    const normalizedPath = this.normalizePath(body.path);
+    const watcher = {
+      id: body.id,
+      path: body.path,
+      normalizedPath: normalizedPath,
+      kind: 'file',
+      recursive: false,
+      ignoreUpdate: false
+    };
+    watcher.coverageKey = this.ensureCoverageForWatcher(watcher);
+    this.watchers.set(body.id, watcher);
+  }
+  addDirectoryWatcher(body) {
+    const normalizedPath = this.normalizePath(body.path);
+    const watcher = {
+      id: body.id,
+      path: body.path,
+      normalizedPath: normalizedPath,
+      kind: 'directory',
+      recursive: !!body.recursive,
+      ignoreUpdate: !!body.ignoreUpdate
+    };
+    watcher.coverageKey = this.ensureCoverageForWatcher(watcher);
+    this.watchers.set(body.id, watcher);
+  }
+  closeWatcher(body) {
+    const watcher = this.watchers.get(body.id);
+    if (!watcher) {
+      return;
+    }
+    this.watchers.delete(body.id);
+    if (!watcher.coverageKey) {
+      return;
+    }
+    const usage = (this.coverageUsage.get(watcher.coverageKey) ?? 1) - 1;
+    if (usage <= 0) {
+      this.coverageUsage.delete(watcher.coverageKey);
+      const coverage = this.coverage.get(watcher.coverageKey);
+      if (coverage && !coverage.permanent) {
+        this.coverage.delete(watcher.coverageKey);
+        this.registrationHash = undefined;
+        this.updateRegistration();
+      }
+    } else {
+      this.coverageUsage.set(watcher.coverageKey, usage);
+    }
+  }
+  ensureCoverageForWatcher(watcher) {
+    if (this.isCoveredByWorkspace(watcher.normalizedPath)) {
+      return undefined;
+    }
+    const basePath = watcher.kind === 'file' ? path__default.dirname(watcher.path) : watcher.path;
+    const pattern = watcher.kind === 'file' ? path__default.basename(watcher.path) : watcher.recursive ? '**/*' : '*';
+    const coverageKey = this.coverageKey(basePath, pattern);
+    const desiredWatchKind = watcher.ignoreUpdate ? mainExports$2.WatchKind.Create | mainExports$2.WatchKind.Delete : mainExports$2.WatchKind.Create | mainExports$2.WatchKind.Change | mainExports$2.WatchKind.Delete;
+    const existing = this.coverage.get(coverageKey);
+    let coverageChanged = false;
+    if (existing) {
+      const addedChangeWatch = desiredWatchKind !== existing.watchKind && (existing.watchKind & mainExports$2.WatchKind.Change) === 0 && (desiredWatchKind & mainExports$2.WatchKind.Change) !== 0;
+      if (addedChangeWatch) {
+        const updated = this.createCoverageEntry(basePath, pattern, desiredWatchKind, coverageKey, false);
+        this.coverage.set(coverageKey, updated);
+        coverageChanged = true;
+      }
+    } else {
+      const entry = this.createCoverageEntry(basePath, pattern, desiredWatchKind, coverageKey, false);
+      this.coverage.set(coverageKey, entry);
+      coverageChanged = true;
+    }
+    this.coverageUsage.set(coverageKey, (this.coverageUsage.get(coverageKey) ?? 0) + 1);
+    if (coverageChanged) {
+      this.registrationHash = undefined;
+      this.updateRegistration();
+    }
+    return coverageKey;
+  }
+  createCoverageEntry(basePath, pattern, watchKind, key, permanent) {
+    return {
+      key: key,
+      watchKind: watchKind,
+      normalizedBase: this.normalizePath(basePath),
+      watcher: {
+        globPattern: {
+          baseUri: URI.file(basePath).toString(),
+          pattern: pattern
+        },
+        kind: watchKind
+      },
+      permanent: permanent
+    };
+  }
+  updateRegistration() {
+    this.updateRegistrationQueue = this.updateRegistrationQueue.then(() => this.doUpdateRegistration());
+  }
+  async doUpdateRegistration() {
+    if (this.disposed || !this.readyForRegistration) {
+      return;
+    }
+    const watchers = Array.from(this.coverage.values(), entry => entry.watcher);
+    if (!watchers.length) {
+      this.registration?.dispose();
+      this.registration = undefined;
+      this.registrationHash = undefined;
+      return;
+    }
+    const hash = watchers.map(watcher => {
+      const {baseUri: baseUri, pattern: pattern} = watcher.globPattern;
+      const baseUriString = typeof baseUri === 'string' ? baseUri : baseUri.uri;
+      return `${baseUriString}|${pattern}|${watcher.kind}`;
+    }).join('-');
+    if (hash === this.registrationHash) {
+      return;
+    }
+    this.registrationHash = hash;
+    try {
+      this.registration?.dispose();
+      this.registration = await this.options.lspClient.registerDidChangeWatchedFilesCapability(watchers);
+      if (this.disposed) {
+        this.registration.dispose();
+        this.registration = undefined;
+      }
+    } catch (err) {
+      this.options.logger.warn('Failed to register file watchers for tsserver watch events', err);
+    }
+  }
+  watcherMatchesPath(watcher, normalizedFsPath) {
+    if (watcher.kind === 'file') {
+      return watcher.normalizedPath === normalizedFsPath;
+    }
+    const base = watcher.normalizedPath;
+    if (watcher.recursive) {
+      return normalizedFsPath === base || normalizedFsPath.startsWith(base + '/');
+    }
+    return this.dirname(normalizedFsPath) === base;
+  }
+  isCoveredByWorkspace(normalizedPath) {
+    return this.workspacePaths.some(base => normalizedPath === base || normalizedPath.startsWith(base + '/'));
+  }
+  normalizePath(filePath) {
+    const normalized = path__default.normalize(filePath).replace(/\\/g, '/');
+    const isDriveRoot = /^[a-zA-Z]:\/?$/.test(normalized);
+    const isPosixRoot = normalized === '/';
+    const trimmed = isDriveRoot || isPosixRoot ? normalized.replace(/\/+$/, '/') : normalized.replace(/\/+$/, '');
+    return this.options.caseInsensitive ? trimmed.toLowerCase() : trimmed;
+  }
+  dirname(normalizedPath) {
+    const dir = normalizedPath.substring(0, normalizedPath.lastIndexOf('/'));
+    return dir || normalizedPath;
+  }
+  coverageKey(basePath, pattern) {
+    return `${this.normalizePath(basePath)}|${pattern}`;
+  }
+}
+
 class LspServer {
+  options;
+  tsClient;
+  fileConfigurationManager;
+  initializeParams=null;
+  diagnosticsManager;
+  completionDataCache=new CompletionDataCache;
+  logger;
+  codeActionsManager;
+  commandManager;
+  workspaceRoot;
+  features={};
+  cachedNavTreeResponse=new CachedResponse;
+  implementationsCodeLensProvider=null;
+  referencesCodeLensProvider=null;
+  watchEventManager=null;
   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, this.options.lspClient, this.features, 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);
+    this.commandManager.register(new TSServerRequestCommand(this.tsClient));
   }
   closeAllForTesting() {
     for (const document of this.tsClient.documentsForTesting.values()) {
@@ -23216,6 +23734,8 @@ class LspServer {
     await this.diagnosticsManager.waitForDiagnosticsForTesting(document.filepath);
   }
   shutdown() {
+    this.watchEventManager?.dispose();
+    this.watchEventManager = null;
     this.tsClient.shutdown();
   }
   initialize(params) {
@@ -23265,6 +23785,22 @@ class LspServer {
     this.fileConfigurationManager.mergeTsPreferences({
       useLabelDetailsInCompletionEntries: this.features.completionLabelDetails
     });
+    const requestedWatchEvents = tsserver?.useClientFileWatcher ?? false;
+    let canUseWatchEvents = false;
+    if (requestedWatchEvents) {
+      const supportsFileWatcherRegistration = Boolean(workspace?.didChangeWatchedFiles?.dynamicRegistration);
+      const supportsRelativePatterns = workspace?.didChangeWatchedFiles?.relativePatternSupport === true;
+      const typescriptSupportsWatchEvents = typescriptVersion.version?.gte(API.v544);
+      if (!supportsFileWatcherRegistration) {
+        this.logger.logIgnoringVerbosity(LogLevel.Warning, 'Client does not support dynamic file watcher registration; falling back to tsserver file watching.');
+      } else if (!supportsRelativePatterns) {
+        this.logger.logIgnoringVerbosity(LogLevel.Warning, 'Client does not support relative file watcher patterns; falling back to tsserver file watching.');
+      } else if (!typescriptSupportsWatchEvents) {
+        this.logger.logIgnoringVerbosity(LogLevel.Warning, 'Client-side file watching requires TypeScript 5.4.4 or newer; disabling useClientFileWatcher.');
+      } else {
+        canUseWatchEvents = true;
+      }
+    }
     const tsserverLogVerbosity = tsserver?.logVerbosity && TsServerLogLevel.fromString(tsserver.logVerbosity);
     const started = this.tsClient.start(this.workspaceRoot, {
       trace: Trace.fromString(tsserver?.trace || 'off'),
@@ -23284,7 +23820,8 @@ class LspServer {
           throw new Error(`tsserver process has exited (exit code: ${exitCode}, signal: ${signal}). Stopping the server.`);
         }
       },
-      useSyntaxServer: toSyntaxServerConfiguration(userInitializationOptions.tsserver?.useSyntaxServer)
+      useClientFileWatcher: tsserver?.useClientFileWatcher ?? false,
+      useSyntaxServer: toSyntaxServerConfiguration(tsserver?.useSyntaxServer)
     });
     if (!started) {
       throw new Error('tsserver process has failed to start.');
@@ -23295,6 +23832,15 @@ class LspServer {
     process.on('SIGINT', () => {
       process.exit();
     });
+    if (canUseWatchEvents) {
+      this.watchEventManager = new WatchEventManager({
+        lspClient: this.options.lspClient,
+        logger: this.logger,
+        workspaceFolders: this.getWorkspaceFolders(),
+        sendWatchChanges: changes => this.tsClient.sendWatchChanges(changes),
+        caseInsensitive: onCaseInsensitiveFileSystem()
+      });
+    }
     this.fileConfigurationManager.setGlobalConfiguration(this.workspaceRoot, hostInfo);
     this.registerHandlers();
     const prepareSupport = textDocument?.rename?.prepareSupport && this.tsClient.apiVersion.gte(API.v310);
@@ -23323,7 +23869,7 @@ class LspServer {
         documentHighlightProvider: true,
         documentSymbolProvider: true,
         executeCommandProvider: {
-          commands: [ Commands.APPLY_REFACTORING, Commands.CONFIGURE_PLUGIN, Commands.ORGANIZE_IMPORTS, Commands.APPLY_RENAME_FILE, Commands.SOURCE_DEFINITION, Commands.TS_SERVER_REQUEST, ...this.commandManager.registeredIds ]
+          commands: [ Commands.APPLY_REFACTORING, Commands.CONFIGURE_PLUGIN, Commands.ORGANIZE_IMPORTS, Commands.APPLY_RENAME_FILE, Commands.SOURCE_DEFINITION, ...this.commandManager.registeredIds ]
         },
         hoverProvider: true,
         inlayHintProvider: true,
@@ -23392,6 +23938,7 @@ class LspServer {
       version: apiVersion.displayName,
       source: typescriptVersionSource
     });
+    this.watchEventManager?.onInitialized();
   }
   findTypescriptVersion(userTsserverPath, fallbackTsserverPath) {
     const typescriptVersionProvider = new TypeScriptVersionProvider(userTsserverPath, this.logger);
@@ -23431,6 +23978,12 @@ class LspServer {
     }
     return undefined;
   }
+  getWorkspaceFolders() {
+    if (this.workspaceRoot) {
+      return [ URI.file(this.workspaceRoot) ];
+    }
+    return [];
+  }
   didChangeConfiguration(params) {
     this.fileConfigurationManager.setWorkspaceConfiguration(params.settings || {});
     const ignoredDiagnosticCodes = this.fileConfigurationManager.workspaceConfiguration.diagnostics?.ignoredCodes || [];
@@ -23465,9 +24018,18 @@ class LspServer {
     this.fileConfigurationManager.onDidCloseTextDocument(document.uri);
   }
   didChangeTextDocument(params) {
+    if (this.fileConfigurationManager.workspaceConfiguration.diagnostics?.eagerClear) {
+      const document = this.tsClient.toOpenDocument(params.textDocument.uri);
+      if (document) {
+        this.diagnosticsManager.clearDiagnosticsForFile(document.filepath);
+      }
+    }
     this.tsClient.onDidChangeTextDocument(params);
   }
   didSaveTextDocument(_params) {}
+  didChangeWatchedFiles(params) {
+    this.watchEventManager?.handleFileChanges(params);
+  }
   async definition(params, token) {
     return this.getDefinition({
       type: this.features.definitionLinkSupport ? CommandTypes.DefinitionAndBoundSpan : CommandTypes.Definition,
@@ -23608,14 +24170,13 @@ class LspServer {
     return mainExports$2.CompletionList.create(completions, isIncomplete);
   }
   async completionResolve(item, token) {
-    let document = undefined;
     const data = item.data;
     if (data?.cacheId !== undefined) {
       const cachedData = this.completionDataCache.get(data.cacheId);
       item.data = cachedData;
       if (cachedData?.file) {
         const uri = this.tsClient.toResourceUri(cachedData.file);
-        document = this.tsClient.toOpenDocument(uri);
+        const document = this.tsClient.toOpenDocument(uri);
         if (document) {
           const response = await this.tsClient.interruptGetErr(() => this.tsClient.execute(CommandTypes.CompletionDetails, cachedData, token));
           if (response.type !== 'response' || !response.body?.length) {
@@ -23839,7 +24400,9 @@ class LspServer {
     return this.codeActionsManager.resolveCodeAction(params);
   }
   async executeCommand(params, token, workDoneProgress) {
-    if (await this.commandManager.handle(params.command, ...params.arguments || [])) ; else if (params.command === Commands.APPLY_REFACTORING && params.arguments) {
+    if (this.commandManager.handlesCommand(params.command)) {
+      return 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) {
@@ -23920,12 +24483,6 @@ class LspServer {
       const [uri, position] = params.arguments || [];
       const reporter = await this.options.lspClient.createProgressReporter(token, workDoneProgress);
       return SourceDefinitionCommand.execute(uri, position, this.tsClient, this.options.lspClient, reporter, token);
-    } else if (params.command === Commands.TS_SERVER_REQUEST) {
-      const [command, args, config] = params.arguments || [];
-      if (typeof command !== 'string') {
-        throw new Error(`"Command" argument must be a string, got: ${typeof command}`);
-      }
-      return TSServerRequestCommand.execute(this.tsClient, command, args, config, token);
     } else {
       this.logger.error(`Unknown command ${params.command}.`);
     }
@@ -24090,8 +24647,11 @@ class LspServer {
     }
   }
   onTsEvent(event) {
+    if (this.watchEventManager?.handleTsserverEvent(event)) {
+      return;
+    }
     const eventName = event.event;
-    if (eventName === 'semanticDiag' || eventName === 'syntaxDiag' || eventName === 'suggestionDiag') {
+    if (eventName === EventName.semanticDiag || eventName === EventName.syntaxDiag || eventName === EventName.suggestionDiag) {
       const diagnosticEvent = event;
       if (diagnosticEvent.body?.diagnostics) {
         const {file: file, diagnostics: diagnostics} = diagnosticEvent.body;
@@ -24207,6 +24767,7 @@ var progressExports = requireProgress();
 const nullProgressReporter = progressExports.attachWorkDone(undefined, undefined);
 
 class LspClientImpl {
+  connection;
   constructor(connection) {
     this.connection = connection;
   }
@@ -24254,6 +24815,11 @@ class LspClientImpl {
   async sendNotification(type, params) {
     await this.connection.sendNotification(type, params);
   }
+  async registerDidChangeWatchedFilesCapability(watchers) {
+    return await this.connection.client.register(mainExports$2.DidChangeWatchedFilesNotification.type, {
+      watchers: watchers
+    });
+  }
 }
 
 function createLspConnection(options) {
@@ -24271,6 +24837,7 @@ function createLspConnection(options) {
   connection.onDidSaveTextDocument(server.didSaveTextDocument.bind(server));
   connection.onDidCloseTextDocument(server.didCloseTextDocument.bind(server));
   connection.onDidChangeTextDocument(server.didChangeTextDocument.bind(server));
+  connection.onDidChangeWatchedFiles(server.didChangeWatchedFiles.bind(server));
   connection.onCodeAction(server.codeAction.bind(server));
   connection.onCodeActionResolve(server.codeActionResolve.bind(server));
   connection.onCodeLens(server.codeLens.bind(server));