typescript 5.4.0-dev.20231114 → 5.4.0-dev.20231116

package/lib/tsserver.js

@@ -2330,7 +2330,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231114`;
+var version = `${versionMajorMinor}.0-dev.20231116`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -8041,6 +8041,7 @@ function createSystemWatchFunctions({
   useNonPollingWatchers,
   tscWatchDirectory,
   inodeWatching,
+  fsWatchWithTimestamp,
   sysLog: sysLog2
 }) {
   const pollingWatches = /* @__PURE__ */ new Map();
@@ -8279,7 +8280,7 @@ function createSystemWatchFunctions({
         return watchPresentFileSystemEntryWithFsWatchFile();
       }
       try {
-        const presentWatcher = fsWatchWorker(
+        const presentWatcher = (!fsWatchWithTimestamp ? fsWatchWorker : fsWatchWorkerHandlingTimestamp)(
           fileOrDirectory,
           recursive,
           inodeWatching ? callbackChangingToMissingFileSystemEntry : callback
@@ -8342,6 +8343,18 @@ function createSystemWatchFunctions({
       );
     }
   }
+  function fsWatchWorkerHandlingTimestamp(fileOrDirectory, recursive, callback) {
+    let modifiedTime = getModifiedTime3(fileOrDirectory) || missingFileModifiedTime;
+    return fsWatchWorker(fileOrDirectory, recursive, (eventName, relativeFileName, currentModifiedTime) => {
+      if (eventName === "change") {
+        currentModifiedTime || (currentModifiedTime = getModifiedTime3(fileOrDirectory) || missingFileModifiedTime);
+        if (currentModifiedTime.getTime() === modifiedTime.getTime())
+          return;
+      }
+      modifiedTime = currentModifiedTime || getModifiedTime3(fileOrDirectory) || missingFileModifiedTime;
+      callback(eventName, relativeFileName, modifiedTime);
+    });
+  }
 }
 function patchWriteFileEnsuringDirectory(sys2) {
   const originalWriteFile = sys2.writeFile;
@@ -8370,12 +8383,13 @@ var sys = (() => {
     let activeSession;
     let profilePath = "./profile.cpuprofile";
     const Buffer2 = require("buffer").Buffer;
-    const isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
+    const isMacOs = process.platform === "darwin";
+    const isLinuxOrMacOs = process.platform === "linux" || isMacOs;
     const platform = _os.platform();
     const useCaseSensitiveFileNames2 = isFileSystemCaseSensitive();
     const fsRealpath = !!_fs.realpathSync.native ? process.platform === "win32" ? fsRealPathHandlingLongPath : _fs.realpathSync.native : _fs.realpathSync;
     const executingFilePath = __filename.endsWith("sys.js") ? _path.join(_path.dirname(__dirname), "__fake__.js") : __filename;
-    const fsSupportsRecursiveFsWatch = process.platform === "win32" || process.platform === "darwin";
+    const fsSupportsRecursiveFsWatch = process.platform === "win32" || isMacOs;
     const getCurrentDirectory = memoize(() => process.cwd());
     const { watchFile: watchFile2, watchDirectory } = createSystemWatchFunctions({
       pollingWatchFileWorker: fsWatchFileWorker,
@@ -8395,6 +8409,7 @@ var sys = (() => {
       useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER,
       tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
       inodeWatching: isLinuxOrMacOs,
+      fsWatchWithTimestamp: isMacOs,
       sysLog
     });
     const nodeSystem = {
@@ -10199,6 +10214,7 @@ var Diagnostics = {
   Type_0_is_generic_and_can_only_be_indexed_for_reading: diag(2862, 1 /* Error */, "Type_0_is_generic_and_can_only_be_indexed_for_reading_2862", "Type '{0}' is generic and can only be indexed for reading."),
   A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values: diag(2863, 1 /* Error */, "A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values_2863", "A class cannot extend a primitive type like '{0}'. Classes can only extend constructable values."),
   A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types: diag(2864, 1 /* Error */, "A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types_2864", "A class cannot implement a primitive type like '{0}'. It can only implement other named object types."),
+  Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled: diag(2865, 1 /* Error */, "Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_2865", "Import '{0}' conflicts with local value, so must be declared with a type-only import when 'isolatedModules' is enabled."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -14643,7 +14659,7 @@ function isPropertyAccessOrQualifiedName(node) {
   return kind === 211 /* PropertyAccessExpression */ || kind === 166 /* QualifiedName */;
 }
 function isCallLikeOrFunctionLikeExpression(node) {
-  return isCallLikeExpression(node) || isFunctionLike(node);
+  return isCallLikeExpression(node) || isFunctionExpressionOrArrowFunction(node);
 }
 function isCallLikeExpression(node) {
   switch (node.kind) {
@@ -23035,10 +23051,8 @@ function createNodeFactory(flags, baseFactory2) {
     return update(updated, original);
   }
   function createNumericLiteral(value, numericLiteralFlags = 0 /* None */) {
-    const text = typeof value === "number" ? value + "" : value;
-    Debug.assert(text.charCodeAt(0) !== 45 /* minus */, "Negative numbers should be created in combination with createPrefixUnaryExpression");
     const node = createBaseDeclaration(9 /* NumericLiteral */);
-    node.text = text;
+    node.text = typeof value === "number" ? value + "" : value;
     node.numericLiteralFlags = numericLiteralFlags;
     if (numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */)
       node.transformFlags |= 1024 /* ContainsES2015 */;
@@ -48400,7 +48414,7 @@ function createTypeChecker(host) {
         const nodeLinks2 = getNodeLinks(node);
         cachedResolvedSignatures.push([nodeLinks2, nodeLinks2.resolvedSignature]);
         nodeLinks2.resolvedSignature = void 0;
-        if (isFunctionLike(node)) {
+        if (isFunctionExpressionOrArrowFunction(node)) {
           const symbolLinks2 = getSymbolLinks(getSymbolOfDeclaration(node));
           const type = symbolLinks2.type;
           cachedTypes2.push([symbolLinks2, type]);
@@ -52962,6 +52976,8 @@ function createTypeChecker(host) {
           context.symbolDepth.set(id, depth + 1);
         }
         context.visitedTypes.add(typeId);
+        const prevTrackedSymbols = context.trackedSymbols;
+        context.trackedSymbols = void 0;
         const startLength = context.approximateLength;
         const result = transform2(type2);
         const addedLength = context.approximateLength - startLength;
@@ -52977,6 +52993,7 @@ function createTypeChecker(host) {
         if (id) {
           context.symbolDepth.set(id, depth);
         }
+        context.trackedSymbols = prevTrackedSymbols;
         return result;
         function deepCloneOrReuseNode(node) {
           if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
@@ -53279,7 +53296,7 @@ function createTypeChecker(host) {
       context.approximateLength += symbolName(propertySymbol).length + 1;
       if (propertySymbol.flags & 98304 /* Accessor */) {
         const writeType = getWriteTypeOfSymbol(propertySymbol);
-        if (propertyType !== writeType) {
+        if (propertyType !== writeType && !isErrorType(propertyType) && !isErrorType(writeType)) {
           const getterDeclaration = getDeclarationOfKind(propertySymbol, 177 /* GetAccessor */);
           const getterSignature = getSignatureFromDeclaration(getterDeclaration);
           typeElements.push(
@@ -54228,7 +54245,7 @@ function createTypeChecker(host) {
             return factory.createStringLiteral(name, !!singleQuote);
           }
           if (isNumericLiteralName(name) && startsWith(name, "-")) {
-            return factory.createComputedPropertyName(factory.createPrefixUnaryExpression(41 /* MinusToken */, factory.createNumericLiteral(Math.abs(+name))));
+            return factory.createComputedPropertyName(factory.createNumericLiteral(+name));
           }
           return createPropertyNameNodeForIdentifierOrLiteral(name, getEmitScriptTarget(compilerOptions), singleQuote, stringNamed, isMethod);
         }
@@ -80111,14 +80128,9 @@ function createTypeChecker(host) {
       case 15 /* NoSubstitutionTemplateLiteral */:
       case 11 /* StringLiteral */:
         return hasSkipDirectInferenceFlag(node) ? blockedStringType : getFreshTypeOfLiteralType(getStringLiteralType(node.text));
-      case 9 /* NumericLiteral */: {
+      case 9 /* NumericLiteral */:
         checkGrammarNumericLiteral(node);
-        const value = +node.text;
-        if (!isFinite(value)) {
-          return numberType;
-        }
-        return getFreshTypeOfLiteralType(getNumberLiteralType(value));
-      }
+        return getFreshTypeOfLiteralType(getNumberLiteralType(+node.text));
       case 10 /* BigIntLiteral */:
         checkGrammarBigIntLiteral(node);
         return getFreshTypeOfLiteralType(getBigIntLiteralType({
@@ -85023,6 +85035,16 @@ function createTypeChecker(host) {
       if (targetFlags & excludedMeanings) {
         const message = node.kind === 281 /* ExportSpecifier */ ? Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
         error2(node, message, symbolToString(symbol));
+      } else if (node.kind !== 281 /* ExportSpecifier */) {
+        const appearsValueyToTranspiler = compilerOptions.isolatedModules && !findAncestor(node, isTypeOnlyImportOrExportDeclaration);
+        if (appearsValueyToTranspiler && symbol.flags & (111551 /* Value */ | 1048576 /* ExportValue */)) {
+          error2(
+            node,
+            Diagnostics.Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled,
+            symbolToString(symbol),
+            isolatedModulesLikeFlagName
+          );
+        }
       }
       if (getIsolatedModules(compilerOptions) && !isTypeOnlyImportOrExportDeclaration(node) && !(node.flags & 33554432 /* Ambient */)) {
         const typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol);
@@ -87119,7 +87141,7 @@ function createTypeChecker(host) {
     if (enumResult)
       return enumResult;
     const literalValue = type.value;
-    return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "string" ? factory.createStringLiteral(literalValue) : literalValue < 0 ? factory.createPrefixUnaryExpression(41 /* MinusToken */, factory.createNumericLiteral(Math.abs(literalValue))) : factory.createNumericLiteral(literalValue);
+    return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "number" ? factory.createNumericLiteral(literalValue) : factory.createStringLiteral(literalValue);
   }
   function createLiteralConstValue(node, tracker) {
     const type = getTypeOfSymbol(getSymbolOfDeclaration(node));
@@ -93719,7 +93741,7 @@ function transformTypeScript(context) {
   function transformEnumMemberDeclarationValue(member) {
     const value = resolver.getConstantValue(member);
     if (value !== void 0) {
-      return typeof value === "string" ? factory2.createStringLiteral(value) : value < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(Math.abs(value))) : factory2.createNumericLiteral(value);
+      return typeof value === "string" ? factory2.createStringLiteral(value) : factory2.createNumericLiteral(value);
     } else {
       enableSubstitutionForNonQualifiedEnumMembers();
       if (member.initializer) {
@@ -108039,7 +108061,7 @@ function transformGenerators(context) {
       if (labelExpressions === void 0) {
         labelExpressions = [];
       }
-      const expression = factory2.createNumericLiteral(Number.MAX_SAFE_INTEGER);
+      const expression = factory2.createNumericLiteral(-1);
       if (labelExpressions[label] === void 0) {
         labelExpressions[label] = [expression];
       } else {
@@ -113914,8 +113936,7 @@ function transformDeclarations(context) {
             if (shouldStripInternal(m))
               return;
             const constValue = resolver.getConstantValue(m);
-            const newInitializer = constValue === void 0 ? void 0 : typeof constValue === "string" ? factory2.createStringLiteral(constValue) : constValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(Math.abs(constValue))) : factory2.createNumericLiteral(constValue);
-            return preserveJsDoc(factory2.updateEnumMember(m, m.name, newInitializer), m);
+            return preserveJsDoc(factory2.updateEnumMember(m, m.name, constValue !== void 0 ? typeof constValue === "string" ? factory2.createStringLiteral(constValue) : factory2.createNumericLiteral(constValue) : void 0), m);
           }))
         ));
       }
@@ -135736,6 +135757,7 @@ var DocumentHighlights;
       case 127 /* YieldKeyword */:
         return highlightSpans(getYieldOccurrences(node));
       case 103 /* InKeyword */:
+      case 147 /* OutKeyword */:
         return void 0;
       default:
         return isModifierKind(node.kind) && (isDeclaration(node.parent) || isVariableStatement(node.parent)) ? highlightSpans(getModifierOccurrences(node.kind, node.parent)) : void 0;
@@ -175255,6 +175277,7 @@ __export(ts_server_exports3, {
   TextStorage: () => TextStorage,
   ThrottledOperations: () => ThrottledOperations,
   TypingsCache: () => TypingsCache,
+  TypingsInstallerAdapter: () => TypingsInstallerAdapter,
   allFilesAreJsOrDts: () => allFilesAreJsOrDts,
   allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
   asNormalizedPath: () => asNormalizedPath,
@@ -175376,6 +175399,32 @@ var TypingsInstaller = class {
     }
     this.processCacheLocation(this.globalCachePath);
   }
+  /** @internal */
+  handleRequest(req) {
+    switch (req.kind) {
+      case "discover":
+        this.install(req);
+        break;
+      case "closeProject":
+        this.closeProject(req);
+        break;
+      case "typesRegistry": {
+        const typesRegistry = {};
+        this.typesRegistry.forEach((value, key) => {
+          typesRegistry[key] = value;
+        });
+        const response = { kind: EventTypesRegistry, typesRegistry };
+        this.sendResponse(response);
+        break;
+      }
+      case "installPackage": {
+        this.installPackage(req);
+        break;
+      }
+      default:
+        Debug.assertNever(req);
+    }
+  }
   closeProject(req) {
     this.closeWatchers(req.projectName);
   }
@@ -175433,7 +175482,7 @@ var TypingsInstaller = class {
   }
   /** @internal */
   installPackage(req) {
-    const { fileName, packageName, projectName, projectRootPath } = req;
+    const { fileName, packageName, projectName, projectRootPath, id } = req;
     const cwd = forEachAncestorDirectory(getDirectoryPath(fileName), (directory) => {
       if (this.installTypingHost.fileExists(combinePaths(directory, "package.json"))) {
         return directory;
@@ -175445,6 +175494,7 @@ var TypingsInstaller = class {
         const response = {
           kind: ActionPackageInstalled,
           projectName,
+          id,
           success,
           message
         };
@@ -175454,6 +175504,7 @@ var TypingsInstaller = class {
       const response = {
         kind: ActionPackageInstalled,
         projectName,
+        id,
         success: false,
         message: "Could not determine a project root path."
       };
@@ -176704,8 +176755,9 @@ var TypingsCache = class {
     return !typeAcquisition || !typeAcquisition.enable ? emptyArray2 : typings;
   }
   onProjectClosed(project) {
-    this.perProjectCache.delete(project.getProjectName());
-    this.installer.onProjectClosed(project);
+    if (this.perProjectCache.delete(project.getProjectName())) {
+      this.installer.onProjectClosed(project);
+    }
   }
 };
 
@@ -186633,6 +186685,184 @@ var LineLeaf = class {
   }
 };
 
+// src/server/typingInstallerAdapter.ts
+var _TypingsInstallerAdapter = class _TypingsInstallerAdapter {
+  constructor(telemetryEnabled, logger, host, globalTypingsCacheLocation, event, maxActiveRequestCount) {
+    this.telemetryEnabled = telemetryEnabled;
+    this.logger = logger;
+    this.host = host;
+    this.globalTypingsCacheLocation = globalTypingsCacheLocation;
+    this.event = event;
+    this.maxActiveRequestCount = maxActiveRequestCount;
+    this.activeRequestCount = 0;
+    this.requestQueue = createQueue();
+    this.requestMap = /* @__PURE__ */ new Map();
+    // Maps project name to newest requestQueue entry for that project
+    /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */
+    this.requestedRegistry = false;
+    this.packageInstallId = 0;
+  }
+  isKnownTypesPackageName(name) {
+    var _a;
+    const validationResult = ts_JsTyping_exports.validatePackageName(name);
+    if (validationResult !== ts_JsTyping_exports.NameValidationResult.Ok) {
+      return false;
+    }
+    if (!this.requestedRegistry) {
+      this.requestedRegistry = true;
+      this.installer.send({ kind: "typesRegistry" });
+    }
+    return !!((_a = this.typesRegistryCache) == null ? void 0 : _a.has(name));
+  }
+  installPackage(options) {
+    this.packageInstallId++;
+    const request = { kind: "installPackage", ...options, id: this.packageInstallId };
+    const promise = new Promise((resolve, reject) => {
+      (this.packageInstalledPromise ?? (this.packageInstalledPromise = /* @__PURE__ */ new Map())).set(this.packageInstallId, { resolve, reject });
+    });
+    this.installer.send(request);
+    return promise;
+  }
+  attach(projectService) {
+    this.projectService = projectService;
+    this.installer = this.createInstallerProcess();
+  }
+  onProjectClosed(p) {
+    this.installer.send({ projectName: p.getProjectName(), kind: "closeProject" });
+  }
+  enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports) {
+    const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
+    if (this.logger.hasLevel(3 /* verbose */)) {
+      this.logger.info(`TIAdapter:: Scheduling throttled operation:${stringifyIndented(request)}`);
+    }
+    if (this.activeRequestCount < this.maxActiveRequestCount) {
+      this.scheduleRequest(request);
+    } else {
+      if (this.logger.hasLevel(3 /* verbose */)) {
+        this.logger.info(`TIAdapter:: Deferring request for: ${request.projectName}`);
+      }
+      this.requestQueue.enqueue(request);
+      this.requestMap.set(request.projectName, request);
+    }
+  }
+  handleMessage(response) {
+    var _a, _b;
+    if (this.logger.hasLevel(3 /* verbose */)) {
+      this.logger.info(`TIAdapter:: Received response:${stringifyIndented(response)}`);
+    }
+    switch (response.kind) {
+      case EventTypesRegistry:
+        this.typesRegistryCache = new Map(Object.entries(response.typesRegistry));
+        break;
+      case ActionPackageInstalled: {
+        const promise = (_a = this.packageInstalledPromise) == null ? void 0 : _a.get(response.id);
+        Debug.assertIsDefined(promise, "Should find the promise for package install");
+        (_b = this.packageInstalledPromise) == null ? void 0 : _b.delete(response.id);
+        if (response.success) {
+          promise.resolve({ successMessage: response.message });
+        } else {
+          promise.reject(response.message);
+        }
+        this.projectService.updateTypingsForProject(response);
+        this.event(response, "setTypings");
+        break;
+      }
+      case EventInitializationFailed: {
+        const body = {
+          message: response.message
+        };
+        const eventName = "typesInstallerInitializationFailed";
+        this.event(body, eventName);
+        break;
+      }
+      case EventBeginInstallTypes: {
+        const body = {
+          eventId: response.eventId,
+          packages: response.packagesToInstall
+        };
+        const eventName = "beginInstallTypes";
+        this.event(body, eventName);
+        break;
+      }
+      case EventEndInstallTypes: {
+        if (this.telemetryEnabled) {
+          const body2 = {
+            telemetryEventName: "typingsInstalled",
+            payload: {
+              installedPackages: response.packagesToInstall.join(","),
+              installSuccess: response.installSuccess,
+              typingsInstallerVersion: response.typingsInstallerVersion
+            }
+          };
+          const eventName2 = "telemetry";
+          this.event(body2, eventName2);
+        }
+        const body = {
+          eventId: response.eventId,
+          packages: response.packagesToInstall,
+          success: response.installSuccess
+        };
+        const eventName = "endInstallTypes";
+        this.event(body, eventName);
+        break;
+      }
+      case ActionInvalidate: {
+        this.projectService.updateTypingsForProject(response);
+        break;
+      }
+      case ActionSet: {
+        if (this.activeRequestCount > 0) {
+          this.activeRequestCount--;
+        } else {
+          Debug.fail("TIAdapter:: Received too many responses");
+        }
+        while (!this.requestQueue.isEmpty()) {
+          const queuedRequest = this.requestQueue.dequeue();
+          if (this.requestMap.get(queuedRequest.projectName) === queuedRequest) {
+            this.requestMap.delete(queuedRequest.projectName);
+            this.scheduleRequest(queuedRequest);
+            break;
+          }
+          if (this.logger.hasLevel(3 /* verbose */)) {
+            this.logger.info(`TIAdapter:: Skipping defunct request for: ${queuedRequest.projectName}`);
+          }
+        }
+        this.projectService.updateTypingsForProject(response);
+        this.event(response, "setTypings");
+        break;
+      }
+      case ActionWatchTypingLocations:
+        this.projectService.watchTypingLocations(response);
+        break;
+      default:
+        assertType(response);
+    }
+  }
+  scheduleRequest(request) {
+    if (this.logger.hasLevel(3 /* verbose */)) {
+      this.logger.info(`TIAdapter:: Scheduling request for: ${request.projectName}`);
+    }
+    this.activeRequestCount++;
+    this.host.setTimeout(
+      () => {
+        if (this.logger.hasLevel(3 /* verbose */)) {
+          this.logger.info(`TIAdapter:: Sending request:${stringifyIndented(request)}`);
+        }
+        this.installer.send(request);
+      },
+      _TypingsInstallerAdapter.requestDelayMillis,
+      `${request.projectName}::${request.kind}`
+    );
+  }
+};
+// This number is essentially arbitrary.  Processing more than one typings request
+// at a time makes sense, but having too many in the pipe results in a hang
+// (see https://github.com/nodejs/node/issues/7657).
+// It would be preferable to base our limit on the amount of space left in the
+// buffer, but we have yet to find a way to retrieve that value.
+_TypingsInstallerAdapter.requestDelayMillis = 100;
+var TypingsInstallerAdapter = _TypingsInstallerAdapter;
+
 // src/tsserver/_namespaces/ts.server.ts
 var ts_server_exports4 = {};
 __export(ts_server_exports4, {
@@ -186680,6 +186910,7 @@ __export(ts_server_exports4, {
   TextStorage: () => TextStorage,
   ThrottledOperations: () => ThrottledOperations,
   TypingsCache: () => TypingsCache,
+  TypingsInstallerAdapter: () => TypingsInstallerAdapter,
   allFilesAreJsOrDts: () => allFilesAreJsOrDts,
   allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
   asNormalizedPath: () => asNormalizedPath,
@@ -186799,7 +187030,7 @@ function initializeNodeSystem() {
   const sys2 = Debug.checkDefined(sys);
   const childProcess = require("child_process");
   const fs = require("fs");
-  class Logger6 {
+  class Logger7 {
     constructor(logFilename, traceToConsole, level) {
       this.logFilename = logFilename;
       this.traceToConsole = traceToConsole;
@@ -186866,7 +187097,7 @@ function initializeNodeSystem() {
       s = `[${nowString()}] ${s}
 `;
       if (!this.inGroup || this.firstInGroup) {
-        const prefix = Logger6.padStringRight(type + " " + this.seq.toString(), "          ");
+        const prefix = Logger7.padStringRight(type + " " + this.seq.toString(), "          ");
         s = prefix + s;
       }
       this.write(s, type);
@@ -187003,7 +187234,7 @@ function initializeNodeSystem() {
     const unsubstitutedLogFileName = cmdLineLogFileName ? stripQuotes(cmdLineLogFileName) : envLogOptions.logToFile ? envLogOptions.file || libDirectory + "/.log" + process.pid.toString() : void 0;
     const substitutedLogFileName = unsubstitutedLogFileName ? unsubstitutedLogFileName.replace("PID", process.pid.toString()) : void 0;
     const logVerbosity = cmdLineVerbosity || envLogOptions.detailLevel;
-    return new Logger6(substitutedLogFileName, envLogOptions.traceToConsole, logVerbosity);
+    return new Logger7(substitutedLogFileName, envLogOptions.traceToConsole, logVerbosity);
   }
   function writeMessage(buf) {
     if (!canWrite) {
@@ -187063,45 +187294,22 @@ function startNodeSession(options, logger, cancellationToken) {
     output: process.stdout,
     terminal: false
   });
-  const _NodeTypingsInstaller = class _NodeTypingsInstaller {
+  const _NodeTypingsInstallerAdapter = class _NodeTypingsInstallerAdapter extends TypingsInstallerAdapter {
     constructor(telemetryEnabled2, logger2, host, globalTypingsCacheLocation, typingSafeListLocation2, typesMapLocation2, npmLocation2, validateDefaultNpmLocation2, event) {
-      this.telemetryEnabled = telemetryEnabled2;
-      this.logger = logger2;
-      this.host = host;
-      this.globalTypingsCacheLocation = globalTypingsCacheLocation;
+      super(
+        telemetryEnabled2,
+        logger2,
+        host,
+        globalTypingsCacheLocation,
+        event,
+        _NodeTypingsInstallerAdapter.maxActiveRequestCount
+      );
       this.typingSafeListLocation = typingSafeListLocation2;
       this.typesMapLocation = typesMapLocation2;
       this.npmLocation = npmLocation2;
       this.validateDefaultNpmLocation = validateDefaultNpmLocation2;
-      this.event = event;
-      this.activeRequestCount = 0;
-      this.requestQueue = createQueue();
-      this.requestMap = /* @__PURE__ */ new Map();
-      // Maps operation ID to newest requestQueue entry with that ID
-      /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */
-      this.requestedRegistry = false;
-    }
-    isKnownTypesPackageName(name) {
-      const validationResult = ts_JsTyping_exports.validatePackageName(name);
-      if (validationResult !== ts_JsTyping_exports.NameValidationResult.Ok) {
-        return false;
-      }
-      if (this.requestedRegistry) {
-        return !!this.typesRegistryCache && this.typesRegistryCache.has(name);
-      }
-      this.requestedRegistry = true;
-      this.send({ kind: "typesRegistry" });
-      return false;
-    }
-    installPackage(options2) {
-      this.send({ kind: "installPackage", ...options2 });
-      Debug.assert(this.packageInstalledPromise === void 0);
-      return new Promise((resolve, reject) => {
-        this.packageInstalledPromise = { resolve, reject };
-      });
     }
-    attach(projectService) {
-      this.projectService = projectService;
+    createInstallerProcess() {
       if (this.logger.hasLevel(2 /* requestTime */)) {
         this.logger.info("Binding...");
       }
@@ -187140,135 +187348,7 @@ function startNodeSession(options, logger, cancellationToken) {
       process.on("exit", () => {
         this.installer.kill();
       });
-    }
-    onProjectClosed(p) {
-      this.send({ projectName: p.getProjectName(), kind: "closeProject" });
-    }
-    send(rq) {
-      this.installer.send(rq);
-    }
-    enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports) {
-      const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
-      if (this.logger.hasLevel(3 /* verbose */)) {
-        if (this.logger.hasLevel(3 /* verbose */)) {
-          this.logger.info(`Scheduling throttled operation:${stringifyIndented(request)}`);
-        }
-      }
-      const operationId = project.getProjectName();
-      const operation = () => {
-        if (this.logger.hasLevel(3 /* verbose */)) {
-          this.logger.info(`Sending request:${stringifyIndented(request)}`);
-        }
-        this.send(request);
-      };
-      const queuedRequest = { operationId, operation };
-      if (this.activeRequestCount < _NodeTypingsInstaller.maxActiveRequestCount) {
-        this.scheduleRequest(queuedRequest);
-      } else {
-        if (this.logger.hasLevel(3 /* verbose */)) {
-          this.logger.info(`Deferring request for: ${operationId}`);
-        }
-        this.requestQueue.enqueue(queuedRequest);
-        this.requestMap.set(operationId, queuedRequest);
-      }
-    }
-    handleMessage(response) {
-      if (this.logger.hasLevel(3 /* verbose */)) {
-        this.logger.info(`Received response:${stringifyIndented(response)}`);
-      }
-      switch (response.kind) {
-        case EventTypesRegistry:
-          this.typesRegistryCache = new Map(Object.entries(response.typesRegistry));
-          break;
-        case ActionPackageInstalled: {
-          const { success, message } = response;
-          if (success) {
-            this.packageInstalledPromise.resolve({ successMessage: message });
-          } else {
-            this.packageInstalledPromise.reject(message);
-          }
-          this.packageInstalledPromise = void 0;
-          this.projectService.updateTypingsForProject(response);
-          this.event(response, "setTypings");
-          break;
-        }
-        case EventInitializationFailed: {
-          const body = {
-            message: response.message
-          };
-          const eventName = "typesInstallerInitializationFailed";
-          this.event(body, eventName);
-          break;
-        }
-        case EventBeginInstallTypes: {
-          const body = {
-            eventId: response.eventId,
-            packages: response.packagesToInstall
-          };
-          const eventName = "beginInstallTypes";
-          this.event(body, eventName);
-          break;
-        }
-        case EventEndInstallTypes: {
-          if (this.telemetryEnabled) {
-            const body2 = {
-              telemetryEventName: "typingsInstalled",
-              payload: {
-                installedPackages: response.packagesToInstall.join(","),
-                installSuccess: response.installSuccess,
-                typingsInstallerVersion: response.typingsInstallerVersion
-              }
-            };
-            const eventName2 = "telemetry";
-            this.event(body2, eventName2);
-          }
-          const body = {
-            eventId: response.eventId,
-            packages: response.packagesToInstall,
-            success: response.installSuccess
-          };
-          const eventName = "endInstallTypes";
-          this.event(body, eventName);
-          break;
-        }
-        case ActionInvalidate: {
-          this.projectService.updateTypingsForProject(response);
-          break;
-        }
-        case ActionSet: {
-          if (this.activeRequestCount > 0) {
-            this.activeRequestCount--;
-          } else {
-            Debug.fail("Received too many responses");
-          }
-          while (!this.requestQueue.isEmpty()) {
-            const queuedRequest = this.requestQueue.dequeue();
-            if (this.requestMap.get(queuedRequest.operationId) === queuedRequest) {
-              this.requestMap.delete(queuedRequest.operationId);
-              this.scheduleRequest(queuedRequest);
-              break;
-            }
-            if (this.logger.hasLevel(3 /* verbose */)) {
-              this.logger.info(`Skipping defunct request for: ${queuedRequest.operationId}`);
-            }
-          }
-          this.projectService.updateTypingsForProject(response);
-          this.event(response, "setTypings");
-          break;
-        }
-        case ActionWatchTypingLocations:
-          this.projectService.watchTypingLocations(response);
-          break;
-        default:
-          assertType(response);
-      }
-    }
-    scheduleRequest(request) {
-      if (this.logger.hasLevel(3 /* verbose */)) {
-        this.logger.info(`Scheduling request for: ${request.operationId}`);
-      }
-      this.activeRequestCount++;
-      this.host.setTimeout(request.operation, _NodeTypingsInstaller.requestDelayMillis);
+      return this.installer;
     }
   };
   // This number is essentially arbitrary.  Processing more than one typings request
@@ -187276,21 +187356,20 @@ function startNodeSession(options, logger, cancellationToken) {
   // (see https://github.com/nodejs/node/issues/7657).
   // It would be preferable to base our limit on the amount of space left in the
   // buffer, but we have yet to find a way to retrieve that value.
-  _NodeTypingsInstaller.maxActiveRequestCount = 10;
-  _NodeTypingsInstaller.requestDelayMillis = 100;
-  let NodeTypingsInstaller = _NodeTypingsInstaller;
+  _NodeTypingsInstallerAdapter.maxActiveRequestCount = 10;
+  let NodeTypingsInstallerAdapter = _NodeTypingsInstallerAdapter;
   class IOSession extends Session3 {
     constructor() {
       const event = (body, eventName) => {
         this.event(body, eventName);
       };
       const host = sys;
-      const typingsInstaller = disableAutomaticTypingAcquisition ? void 0 : new NodeTypingsInstaller(telemetryEnabled, logger, host, getGlobalTypingsCacheLocation(), typingSafeListLocation, typesMapLocation, npmLocation, validateDefaultNpmLocation, event);
+      const typingsInstaller = disableAutomaticTypingAcquisition ? void 0 : new NodeTypingsInstallerAdapter(telemetryEnabled, logger, host, getGlobalTypingsCacheLocation(), typingSafeListLocation, typesMapLocation, npmLocation, validateDefaultNpmLocation, event);
       super({
         host,
         cancellationToken,
         ...options,
-        typingsInstaller: typingsInstaller || nullTypingsInstaller,
+        typingsInstaller,
         byteLength: Buffer.byteLength,
         hrtime: process.hrtime,
         logger,