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

package/lib/typescript.d.ts

@@ -49,9 +49,11 @@ declare namespace ts {
             readonly fileName: Path;
             readonly packageName: string;
             readonly projectRootPath: Path;
+            readonly id: number;
         }
         interface PackageInstalledResponse extends ProjectResponse {
             readonly kind: ActionPackageInstalled;
+            readonly id: number;
             readonly success: boolean;
             readonly message: string;
         }

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20231114`;
+      version = `${versionMajorMinor}.0-dev.20231116`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -5779,6 +5779,7 @@ ${lanes.join("\n")}
     useNonPollingWatchers,
     tscWatchDirectory,
     inodeWatching,
+    fsWatchWithTimestamp,
     sysLog: sysLog2
   }) {
     const pollingWatches = /* @__PURE__ */ new Map();
@@ -6017,7 +6018,7 @@ ${lanes.join("\n")}
           return watchPresentFileSystemEntryWithFsWatchFile();
         }
         try {
-          const presentWatcher = fsWatchWorker(
+          const presentWatcher = (!fsWatchWithTimestamp ? fsWatchWorker : fsWatchWorkerHandlingTimestamp)(
             fileOrDirectory,
             recursive,
             inodeWatching ? callbackChangingToMissingFileSystemEntry : callback
@@ -6080,6 +6081,18 @@ ${lanes.join("\n")}
         );
       }
     }
+    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;
@@ -6139,12 +6152,13 @@ ${lanes.join("\n")}
           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,
@@ -6164,6 +6178,7 @@ ${lanes.join("\n")}
             useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER,
             tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
             inodeWatching: isLinuxOrMacOs,
+            fsWatchWithTimestamp: isMacOs,
             sysLog
           });
           const nodeSystem = {
@@ -7979,6 +7994,7 @@ ${lanes.join("\n")}
         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}'."),
@@ -12430,7 +12446,7 @@ ${lanes.join("\n")}
     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) {
@@ -20847,10 +20863,8 @@ ${lanes.join("\n")}
       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 */;
@@ -46165,7 +46179,7 @@ ${lanes.join("\n")}
           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]);
@@ -50727,6 +50741,8 @@ ${lanes.join("\n")}
             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;
@@ -50742,6 +50758,7 @@ ${lanes.join("\n")}
           if (id) {
             context.symbolDepth.set(id, depth);
           }
+          context.trackedSymbols = prevTrackedSymbols;
           return result;
           function deepCloneOrReuseNode(node) {
             if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
@@ -51044,7 +51061,7 @@ ${lanes.join("\n")}
         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(
@@ -51993,7 +52010,7 @@ ${lanes.join("\n")}
               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);
           }
@@ -77876,14 +77893,9 @@ ${lanes.join("\n")}
         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({
@@ -82788,6 +82800,16 @@ ${lanes.join("\n")}
         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);
@@ -84884,7 +84906,7 @@ ${lanes.join("\n")}
       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));
@@ -91664,7 +91686,7 @@ ${lanes.join("\n")}
     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) {
@@ -106077,7 +106099,7 @@ ${lanes.join("\n")}
         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 {
@@ -111988,8 +112010,7 @@ ${lanes.join("\n")}
               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);
             }))
           ));
         }
@@ -134067,6 +134088,7 @@ ${lanes.join("\n")}
             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;
@@ -172591,6 +172613,32 @@ ${options.prefix}` : "\n" : options.prefix
           }
           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);
         }
@@ -172648,7 +172696,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         /** @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;
@@ -172660,6 +172708,7 @@ ${options.prefix}` : "\n" : options.prefix
               const response = {
                 kind: ActionPackageInstalled,
                 projectName,
+                id,
                 success,
                 message
               };
@@ -172669,6 +172718,7 @@ ${options.prefix}` : "\n" : options.prefix
             const response = {
               kind: ActionPackageInstalled,
               projectName,
+              id,
               success: false,
               message: "Could not determine a project root path."
             };
@@ -173989,8 +174039,9 @@ ${options.prefix}` : "\n" : options.prefix
           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);
+          }
         }
       };
     }
@@ -183967,6 +184018,192 @@ ${e.message}`;
     }
   });
 
+  // src/server/typingInstallerAdapter.ts
+  var _TypingsInstallerAdapter, TypingsInstallerAdapter;
+  var init_typingInstallerAdapter = __esm({
+    "src/server/typingInstallerAdapter.ts"() {
+      "use strict";
+      init_ts7();
+      init_ts_server3();
+      _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;
+      TypingsInstallerAdapter = _TypingsInstallerAdapter;
+    }
+  });
+
   // src/server/_namespaces/ts.server.ts
   var ts_server_exports3 = {};
   __export(ts_server_exports3, {
@@ -184014,6 +184251,7 @@ ${e.message}`;
     TextStorage: () => TextStorage,
     ThrottledOperations: () => ThrottledOperations,
     TypingsCache: () => TypingsCache,
+    TypingsInstallerAdapter: () => TypingsInstallerAdapter,
     allFilesAreJsOrDts: () => allFilesAreJsOrDts,
     allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
     asNormalizedPath: () => asNormalizedPath,
@@ -184082,6 +184320,7 @@ ${e.message}`;
       init_packageJsonCache();
       init_session();
       init_scriptVersionCache();
+      init_typingInstallerAdapter();
     }
   });
 
@@ -186436,6 +186675,7 @@ ${e.message}`;
     TextStorage: () => TextStorage,
     ThrottledOperations: () => ThrottledOperations,
     TypingsCache: () => TypingsCache,
+    TypingsInstallerAdapter: () => TypingsInstallerAdapter,
     allFilesAreJsOrDts: () => allFilesAreJsOrDts,
     allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
     asNormalizedPath: () => asNormalizedPath,