@typescript-deploys/pr-build 5.3.0-pr-56064-2 → 5.3.0-pr-56105-6

package/README.md

@@ -2,7 +2,6 @@
 # TypeScript
 
 [![GitHub Actions CI](https://github.com/microsoft/TypeScript/workflows/CI/badge.svg)](https://github.com/microsoft/TypeScript/actions?query=workflow%3ACI)
-[![Devops Build Status](https://dev.azure.com/typescript/TypeScript/_apis/build/status/Typescript/node10)](https://dev.azure.com/typescript/TypeScript/_build?definitionId=7)
 [![npm version](https://badge.fury.io/js/typescript.svg)](https://www.npmjs.com/package/typescript)
 [![Downloads](https://img.shields.io/npm/dm/typescript.svg)](https://www.npmjs.com/package/typescript)
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/microsoft/TypeScript/badge)](https://api.securityscorecards.dev/projects/github.com/microsoft/TypeScript)

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-insiders.20231011`;
+var version = `${versionMajorMinor}.0-insiders.20231013`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -62237,7 +62237,7 @@ function createTypeChecker(host) {
       const incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
       const sourceObjectFlags = getObjectFlags(source2);
       const targetObjectFlags = getObjectFlags(target2);
-      if (sourceSignatures.length === targetSignatures.length && (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target)) {
+      if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
         for (let i = 0; i < targetSignatures.length; i++) {
           const related = signatureRelatedTo(
             sourceSignatures[i],
@@ -69464,8 +69464,21 @@ function createTypeChecker(host) {
   function getEnclosingClassFromThisParameter(node) {
     const thisParameter = getThisParameterFromNodeContext(node);
     let thisType = (thisParameter == null ? void 0 : thisParameter.type) && getTypeFromTypeNode(thisParameter.type);
-    if (thisType && thisType.flags & 262144 /* TypeParameter */) {
-      thisType = getConstraintOfTypeParameter(thisType);
+    if (thisType) {
+      if (thisType.flags & 262144 /* TypeParameter */) {
+        thisType = getConstraintOfTypeParameter(thisType);
+      }
+    } else {
+      const thisContainer = getThisContainer(
+        node,
+        /*includeArrowFunctions*/
+        false,
+        /*includeClassComputedPropertyName*/
+        false
+      );
+      if (isFunctionLike(thisContainer)) {
+        thisType = getContextualThisParameterType(thisContainer);
+      }
     }
     if (thisType && getObjectFlags(thisType) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
       return getTargetType(thisType);

package/lib/tsserver.js

@@ -2328,7 +2328,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-insiders.20231011`;
+var version = `${versionMajorMinor}.0-insiders.20231013`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -66949,7 +66949,7 @@ function createTypeChecker(host) {
       const incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
       const sourceObjectFlags = getObjectFlags(source2);
       const targetObjectFlags = getObjectFlags(target2);
-      if (sourceSignatures.length === targetSignatures.length && (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target)) {
+      if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
         for (let i = 0; i < targetSignatures.length; i++) {
           const related = signatureRelatedTo(
             sourceSignatures[i],
@@ -74176,8 +74176,21 @@ function createTypeChecker(host) {
   function getEnclosingClassFromThisParameter(node) {
     const thisParameter = getThisParameterFromNodeContext(node);
     let thisType = (thisParameter == null ? void 0 : thisParameter.type) && getTypeFromTypeNode(thisParameter.type);
-    if (thisType && thisType.flags & 262144 /* TypeParameter */) {
-      thisType = getConstraintOfTypeParameter(thisType);
+    if (thisType) {
+      if (thisType.flags & 262144 /* TypeParameter */) {
+        thisType = getConstraintOfTypeParameter(thisType);
+      }
+    } else {
+      const thisContainer = getThisContainer(
+        node,
+        /*includeArrowFunctions*/
+        false,
+        /*includeClassComputedPropertyName*/
+        false
+      );
+      if (isFunctionLike(thisContainer)) {
+        thisType = getContextualThisParameterType(thisContainer);
+      }
     }
     if (thisType && getObjectFlags(thisType) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
       return getTargetType(thisType);
@@ -130381,6 +130394,44 @@ __export(ts_JsTyping_exports, {
   validatePackageName: () => validatePackageName
 });
 
+// src/jsTyping/shared.ts
+var ActionSet = "action::set";
+var ActionInvalidate = "action::invalidate";
+var ActionPackageInstalled = "action::packageInstalled";
+var EventTypesRegistry = "event::typesRegistry";
+var EventBeginInstallTypes = "event::beginInstallTypes";
+var EventEndInstallTypes = "event::endInstallTypes";
+var EventInitializationFailed = "event::initializationFailed";
+var ActionWatchTypingLocations = "action::watchTypingLocations";
+var Arguments;
+((Arguments2) => {
+  Arguments2.GlobalCacheLocation = "--globalTypingsCacheLocation";
+  Arguments2.LogFile = "--logFile";
+  Arguments2.EnableTelemetry = "--enableTelemetry";
+  Arguments2.TypingSafeListLocation = "--typingSafeListLocation";
+  Arguments2.TypesMapLocation = "--typesMapLocation";
+  Arguments2.NpmLocation = "--npmLocation";
+  Arguments2.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation";
+})(Arguments || (Arguments = {}));
+function hasArgument(argumentName) {
+  return sys.args.includes(argumentName);
+}
+function findArgument(argumentName) {
+  const index = sys.args.indexOf(argumentName);
+  return index >= 0 && index < sys.args.length - 1 ? sys.args[index + 1] : void 0;
+}
+function nowString() {
+  const d = /* @__PURE__ */ new Date();
+  return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${d.getMilliseconds().toString().padStart(3, "0")}`;
+}
+var indentStr = "\n    ";
+function indent2(str) {
+  return indentStr + str.replace(/\n/g, indentStr);
+}
+function stringifyIndented(json) {
+  return indent2(JSON.stringify(json, void 0, 2));
+}
+
 // src/jsTyping/jsTyping.ts
 function isTypingUpToDate(cachedTyping, availableTypingVersions) {
   const availableVersion = new Version(getProperty(availableTypingVersions, `ts${versionMajorMinor}`) || getProperty(availableTypingVersions, "latest"));
@@ -130487,21 +130538,21 @@ function discoverTypings(host, log, fileNames, projectRootPath, safeList, packag
     );
     addInferredTypings(module2, "Inferred typings from unresolved imports");
   }
-  packageNameToTypingLocation.forEach((typing, name) => {
-    const registryEntry = typesRegistry.get(name);
-    if (inferredTypings.has(name) && inferredTypings.get(name) === void 0 && registryEntry !== void 0 && isTypingUpToDate(typing, registryEntry)) {
-      inferredTypings.set(name, typing.typingLocation);
-    }
-  });
   for (const excludeTypingName of exclude) {
     const didDelete = inferredTypings.delete(excludeTypingName);
     if (didDelete && log)
       log(`Typing for ${excludeTypingName} is in exclude list, will be ignored.`);
   }
+  packageNameToTypingLocation.forEach((typing, name) => {
+    const registryEntry = typesRegistry.get(name);
+    if (inferredTypings.get(name) === false && registryEntry !== void 0 && isTypingUpToDate(typing, registryEntry)) {
+      inferredTypings.set(name, typing.typingLocation);
+    }
+  });
   const newTypingNames = [];
   const cachedTypingPaths = [];
   inferredTypings.forEach((inferred, typing) => {
-    if (inferred !== void 0) {
+    if (inferred) {
       cachedTypingPaths.push(inferred);
     } else {
       newTypingNames.push(typing);
@@ -130509,11 +130560,11 @@ function discoverTypings(host, log, fileNames, projectRootPath, safeList, packag
   });
   const result = { cachedTypingPaths, newTypingNames, filesToWatch };
   if (log)
-    log(`Result: ${JSON.stringify(result)}`);
+    log(`Finished typings discovery:${stringifyIndented(result)}`);
   return result;
   function addInferredTyping(typingName) {
     if (!inferredTypings.has(typingName)) {
-      inferredTypings.set(typingName, void 0);
+      inferredTypings.set(typingName, false);
     }
   }
   function addInferredTypings(typingNames, message) {
@@ -130686,37 +130737,6 @@ function renderPackageNameValidationFailureWorker(typing, result, name, isScopeN
   }
 }
 
-// src/jsTyping/shared.ts
-var ActionSet = "action::set";
-var ActionInvalidate = "action::invalidate";
-var ActionPackageInstalled = "action::packageInstalled";
-var EventTypesRegistry = "event::typesRegistry";
-var EventBeginInstallTypes = "event::beginInstallTypes";
-var EventEndInstallTypes = "event::endInstallTypes";
-var EventInitializationFailed = "event::initializationFailed";
-var ActionWatchTypingLocations = "action::watchTypingLocations";
-var Arguments;
-((Arguments2) => {
-  Arguments2.GlobalCacheLocation = "--globalTypingsCacheLocation";
-  Arguments2.LogFile = "--logFile";
-  Arguments2.EnableTelemetry = "--enableTelemetry";
-  Arguments2.TypingSafeListLocation = "--typingSafeListLocation";
-  Arguments2.TypesMapLocation = "--typesMapLocation";
-  Arguments2.NpmLocation = "--npmLocation";
-  Arguments2.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation";
-})(Arguments || (Arguments = {}));
-function hasArgument(argumentName) {
-  return sys.args.includes(argumentName);
-}
-function findArgument(argumentName) {
-  const index = sys.args.indexOf(argumentName);
-  return index >= 0 && index < sys.args.length - 1 ? sys.args[index + 1] : void 0;
-}
-function nowString() {
-  const d = /* @__PURE__ */ new Date();
-  return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${d.getMilliseconds().toString().padStart(3, "0")}`;
-}
-
 // src/services/types.ts
 var ScriptSnapshot;
 ((ScriptSnapshot2) => {
@@ -166334,7 +166354,6 @@ function getOutliningSpanForNode(n, sourceFile) {
     case 275 /* NamedImports */:
     case 279 /* NamedExports */:
     case 300 /* ImportAttributes */:
-    case 300 /* AssertClause */:
       return spanForImportExportElements(n);
   }
   function spanForImportExportElements(node) {
@@ -174708,7 +174727,7 @@ var TypingsInstaller = class {
   }
   install(req) {
     if (this.log.isEnabled()) {
-      this.log.writeLine(`Got install request ${JSON.stringify(req)}`);
+      this.log.writeLine(`Got install request${stringifyIndented(req)}`);
     }
     if (req.cachePath) {
       if (this.log.isEnabled()) {
@@ -174731,9 +174750,6 @@ var TypingsInstaller = class {
       this.typesRegistry,
       req.compilerOptions
     );
-    if (this.log.isEnabled()) {
-      this.log.writeLine(`Finished typings discovery: ${JSON.stringify(discoverTypingsResult)}`);
-    }
     this.watchFiles(req.projectName, discoverTypingsResult.filesToWatch);
     if (discoverTypingsResult.newTypingNames.length) {
       this.installTypings(req, req.cachePath || this.globalCachePath, discoverTypingsResult.cachedTypingPaths, discoverTypingsResult.newTypingNames);
@@ -174775,8 +174791,8 @@ var TypingsInstaller = class {
       const npmConfig = JSON.parse(this.installTypingHost.readFile(packageJson));
       const npmLock = JSON.parse(this.installTypingHost.readFile(packageLockJson));
       if (this.log.isEnabled()) {
-        this.log.writeLine(`Loaded content of '${packageJson}': ${JSON.stringify(npmConfig)}`);
-        this.log.writeLine(`Loaded content of '${packageLockJson}'`);
+        this.log.writeLine(`Loaded content of '${packageJson}':${stringifyIndented(npmConfig)}`);
+        this.log.writeLine(`Loaded content of '${packageLockJson}':${stringifyIndented(npmLock)}`);
       }
       if (npmConfig.devDependencies && npmLock.dependencies) {
         for (const key in npmConfig.devDependencies) {
@@ -175153,13 +175169,6 @@ function removeSorted(array, remove, compare) {
     array.splice(removeIndex, 1);
   }
 }
-var indentStr = "\n    ";
-function indent2(str) {
-  return indentStr + str.replace(/\n/g, indentStr);
-}
-function stringifyIndented(json) {
-  return indentStr + JSON.stringify(json);
-}
 
 // src/server/_namespaces/ts.server.protocol.ts
 var ts_server_protocol_exports = {};
@@ -178012,9 +178021,6 @@ var _AutoImportProviderProject = class _AutoImportProviderProject extends Projec
   includePackageJsonAutoImports() {
     return 0 /* Off */;
   }
-  getTypeAcquisition() {
-    return { enable: false };
-  }
   /** @internal */
   getSymlinkCache() {
     return this.hostProject.getSymlinkCache();
@@ -181938,7 +181944,7 @@ function formatMessage2(msg, logger, byteLength, newLine) {
   const verboseLogging = logger.hasLevel(3 /* verbose */);
   const json = JSON.stringify(msg);
   if (verboseLogging) {
-    logger.info(`${msg.type}:${indent2(JSON.stringify(msg, void 0, " "))}`);
+    logger.info(`${msg.type}:${stringifyIndented(msg)}`);
   }
   const len = byteLength(json, "utf8");
   return `Content-Length: ${1 + len}\r

package/lib/typescript.d.ts

@@ -3450,7 +3450,6 @@ declare namespace ts {
             getLanguageService(): never;
             getHostForAutoImportProvider(): never;
             getProjectReferences(): readonly ts.ProjectReference[] | undefined;
-            getTypeAcquisition(): TypeAcquisition;
         }
         /**
          * If a file is opened, the server will look for a tsconfig (or jsconfig)

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-insiders.20231011`;
+      version = `${versionMajorMinor}.0-insiders.20231013`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -64716,7 +64716,7 @@ ${lanes.join("\n")}
         const incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
         const sourceObjectFlags = getObjectFlags(source2);
         const targetObjectFlags = getObjectFlags(target2);
-        if (sourceSignatures.length === targetSignatures.length && (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target)) {
+        if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
           for (let i = 0; i < targetSignatures.length; i++) {
             const related = signatureRelatedTo(
               sourceSignatures[i],
@@ -71943,8 +71943,21 @@ ${lanes.join("\n")}
     function getEnclosingClassFromThisParameter(node) {
       const thisParameter = getThisParameterFromNodeContext(node);
       let thisType = (thisParameter == null ? void 0 : thisParameter.type) && getTypeFromTypeNode(thisParameter.type);
-      if (thisType && thisType.flags & 262144 /* TypeParameter */) {
-        thisType = getConstraintOfTypeParameter(thisType);
+      if (thisType) {
+        if (thisType.flags & 262144 /* TypeParameter */) {
+          thisType = getConstraintOfTypeParameter(thisType);
+        }
+      } else {
+        const thisContainer = getThisContainer(
+          node,
+          /*includeArrowFunctions*/
+          false,
+          /*includeClassComputedPropertyName*/
+          false
+        );
+        if (isFunctionLike(thisContainer)) {
+          thisType = getContextualThisParameterType(thisContainer);
+        }
       }
       if (thisType && getObjectFlags(thisType) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
         return getTargetType(thisType);
@@ -128622,6 +128635,66 @@ ${lanes.join("\n")}
     }
   });
 
+  // src/jsTyping/shared.ts
+  function hasArgument(argumentName) {
+    return sys.args.includes(argumentName);
+  }
+  function findArgument(argumentName) {
+    const index = sys.args.indexOf(argumentName);
+    return index >= 0 && index < sys.args.length - 1 ? sys.args[index + 1] : void 0;
+  }
+  function nowString() {
+    const d = /* @__PURE__ */ new Date();
+    return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${d.getMilliseconds().toString().padStart(3, "0")}`;
+  }
+  function indent2(str) {
+    return indentStr + str.replace(/\n/g, indentStr);
+  }
+  function stringifyIndented(json) {
+    return indent2(JSON.stringify(json, void 0, 2));
+  }
+  var ActionSet, ActionInvalidate, ActionPackageInstalled, EventTypesRegistry, EventBeginInstallTypes, EventEndInstallTypes, EventInitializationFailed, ActionWatchTypingLocations, Arguments, indentStr;
+  var init_shared = __esm({
+    "src/jsTyping/shared.ts"() {
+      "use strict";
+      init_ts3();
+      ActionSet = "action::set";
+      ActionInvalidate = "action::invalidate";
+      ActionPackageInstalled = "action::packageInstalled";
+      EventTypesRegistry = "event::typesRegistry";
+      EventBeginInstallTypes = "event::beginInstallTypes";
+      EventEndInstallTypes = "event::endInstallTypes";
+      EventInitializationFailed = "event::initializationFailed";
+      ActionWatchTypingLocations = "action::watchTypingLocations";
+      ((Arguments2) => {
+        Arguments2.GlobalCacheLocation = "--globalTypingsCacheLocation";
+        Arguments2.LogFile = "--logFile";
+        Arguments2.EnableTelemetry = "--enableTelemetry";
+        Arguments2.TypingSafeListLocation = "--typingSafeListLocation";
+        Arguments2.TypesMapLocation = "--typesMapLocation";
+        Arguments2.NpmLocation = "--npmLocation";
+        Arguments2.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation";
+      })(Arguments || (Arguments = {}));
+      indentStr = "\n    ";
+    }
+  });
+
+  // src/jsTyping/types.ts
+  var init_types2 = __esm({
+    "src/jsTyping/types.ts"() {
+      "use strict";
+    }
+  });
+
+  // src/jsTyping/_namespaces/ts.server.ts
+  var init_ts_server = __esm({
+    "src/jsTyping/_namespaces/ts.server.ts"() {
+      "use strict";
+      init_shared();
+      init_types2();
+    }
+  });
+
   // src/jsTyping/jsTyping.ts
   function isTypingUpToDate(cachedTyping, availableTypingVersions) {
     const availableVersion = new Version(getProperty(availableTypingVersions, `ts${versionMajorMinor}`) || getProperty(availableTypingVersions, "latest"));
@@ -128676,21 +128749,21 @@ ${lanes.join("\n")}
       );
       addInferredTypings(module2, "Inferred typings from unresolved imports");
     }
-    packageNameToTypingLocation.forEach((typing, name) => {
-      const registryEntry = typesRegistry.get(name);
-      if (inferredTypings.has(name) && inferredTypings.get(name) === void 0 && registryEntry !== void 0 && isTypingUpToDate(typing, registryEntry)) {
-        inferredTypings.set(name, typing.typingLocation);
-      }
-    });
     for (const excludeTypingName of exclude) {
       const didDelete = inferredTypings.delete(excludeTypingName);
       if (didDelete && log)
         log(`Typing for ${excludeTypingName} is in exclude list, will be ignored.`);
     }
+    packageNameToTypingLocation.forEach((typing, name) => {
+      const registryEntry = typesRegistry.get(name);
+      if (inferredTypings.get(name) === false && registryEntry !== void 0 && isTypingUpToDate(typing, registryEntry)) {
+        inferredTypings.set(name, typing.typingLocation);
+      }
+    });
     const newTypingNames = [];
     const cachedTypingPaths = [];
     inferredTypings.forEach((inferred, typing) => {
-      if (inferred !== void 0) {
+      if (inferred) {
         cachedTypingPaths.push(inferred);
       } else {
         newTypingNames.push(typing);
@@ -128698,11 +128771,11 @@ ${lanes.join("\n")}
     });
     const result = { cachedTypingPaths, newTypingNames, filesToWatch };
     if (log)
-      log(`Result: ${JSON.stringify(result)}`);
+      log(`Finished typings discovery:${stringifyIndented(result)}`);
     return result;
     function addInferredTyping(typingName) {
       if (!inferredTypings.has(typingName)) {
-        inferredTypings.set(typingName, void 0);
+        inferredTypings.set(typingName, false);
       }
     }
     function addInferredTypings(typingNames, message) {
@@ -128869,6 +128942,7 @@ ${lanes.join("\n")}
     "src/jsTyping/jsTyping.ts"() {
       "use strict";
       init_ts3();
+      init_ts_server();
       unprefixedNodeCoreModuleList = [
         "assert",
         "assert/strict",
@@ -128956,59 +129030,6 @@ ${lanes.join("\n")}
     }
   });
 
-  // src/jsTyping/shared.ts
-  function hasArgument(argumentName) {
-    return sys.args.includes(argumentName);
-  }
-  function findArgument(argumentName) {
-    const index = sys.args.indexOf(argumentName);
-    return index >= 0 && index < sys.args.length - 1 ? sys.args[index + 1] : void 0;
-  }
-  function nowString() {
-    const d = /* @__PURE__ */ new Date();
-    return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${d.getMilliseconds().toString().padStart(3, "0")}`;
-  }
-  var ActionSet, ActionInvalidate, ActionPackageInstalled, EventTypesRegistry, EventBeginInstallTypes, EventEndInstallTypes, EventInitializationFailed, ActionWatchTypingLocations, Arguments;
-  var init_shared = __esm({
-    "src/jsTyping/shared.ts"() {
-      "use strict";
-      init_ts3();
-      ActionSet = "action::set";
-      ActionInvalidate = "action::invalidate";
-      ActionPackageInstalled = "action::packageInstalled";
-      EventTypesRegistry = "event::typesRegistry";
-      EventBeginInstallTypes = "event::beginInstallTypes";
-      EventEndInstallTypes = "event::endInstallTypes";
-      EventInitializationFailed = "event::initializationFailed";
-      ActionWatchTypingLocations = "action::watchTypingLocations";
-      ((Arguments2) => {
-        Arguments2.GlobalCacheLocation = "--globalTypingsCacheLocation";
-        Arguments2.LogFile = "--logFile";
-        Arguments2.EnableTelemetry = "--enableTelemetry";
-        Arguments2.TypingSafeListLocation = "--typingSafeListLocation";
-        Arguments2.TypesMapLocation = "--typesMapLocation";
-        Arguments2.NpmLocation = "--npmLocation";
-        Arguments2.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation";
-      })(Arguments || (Arguments = {}));
-    }
-  });
-
-  // src/jsTyping/types.ts
-  var init_types2 = __esm({
-    "src/jsTyping/types.ts"() {
-      "use strict";
-    }
-  });
-
-  // src/jsTyping/_namespaces/ts.server.ts
-  var init_ts_server = __esm({
-    "src/jsTyping/_namespaces/ts.server.ts"() {
-      "use strict";
-      init_shared();
-      init_types2();
-    }
-  });
-
   // src/jsTyping/_namespaces/ts.ts
   var init_ts3 = __esm({
     "src/jsTyping/_namespaces/ts.ts"() {
@@ -165718,7 +165739,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       case 275 /* NamedImports */:
       case 279 /* NamedExports */:
       case 300 /* ImportAttributes */:
-      case 300 /* AssertClause */:
         return spanForImportExportElements(n);
     }
     function spanForImportExportElements(node) {
@@ -171926,7 +171946,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         install(req) {
           if (this.log.isEnabled()) {
-            this.log.writeLine(`Got install request ${JSON.stringify(req)}`);
+            this.log.writeLine(`Got install request${stringifyIndented(req)}`);
           }
           if (req.cachePath) {
             if (this.log.isEnabled()) {
@@ -171949,9 +171969,6 @@ ${options.prefix}` : "\n" : options.prefix
             this.typesRegistry,
             req.compilerOptions
           );
-          if (this.log.isEnabled()) {
-            this.log.writeLine(`Finished typings discovery: ${JSON.stringify(discoverTypingsResult)}`);
-          }
           this.watchFiles(req.projectName, discoverTypingsResult.filesToWatch);
           if (discoverTypingsResult.newTypingNames.length) {
             this.installTypings(req, req.cachePath || this.globalCachePath, discoverTypingsResult.cachedTypingPaths, discoverTypingsResult.newTypingNames);
@@ -171993,8 +172010,8 @@ ${options.prefix}` : "\n" : options.prefix
             const npmConfig = JSON.parse(this.installTypingHost.readFile(packageJson));
             const npmLock = JSON.parse(this.installTypingHost.readFile(packageLockJson));
             if (this.log.isEnabled()) {
-              this.log.writeLine(`Loaded content of '${packageJson}': ${JSON.stringify(npmConfig)}`);
-              this.log.writeLine(`Loaded content of '${packageLockJson}'`);
+              this.log.writeLine(`Loaded content of '${packageJson}':${stringifyIndented(npmConfig)}`);
+              this.log.writeLine(`Loaded content of '${packageLockJson}':${stringifyIndented(npmLock)}`);
             }
             if (npmConfig.devDependencies && npmLock.dependencies) {
               for (const key in npmConfig.devDependencies) {
@@ -172341,13 +172358,7 @@ ${options.prefix}` : "\n" : options.prefix
       array.splice(removeIndex, 1);
     }
   }
-  function indent2(str) {
-    return indentStr + str.replace(/\n/g, indentStr);
-  }
-  function stringifyIndented(json) {
-    return indentStr + JSON.stringify(json);
-  }
-  var ThrottledOperations, GcTimer, indentStr;
+  var ThrottledOperations, GcTimer;
   var init_utilities5 = __esm({
     "src/server/utilities.ts"() {
       "use strict";
@@ -172419,7 +172430,6 @@ ${options.prefix}` : "\n" : options.prefix
           (_b = perfLogger) == null ? void 0 : _b.logStopScheduledOperation();
         }
       };
-      indentStr = "\n    ";
     }
   });
 
@@ -175321,9 +175331,6 @@ ${options.prefix}` : "\n" : options.prefix
         includePackageJsonAutoImports() {
           return 0 /* Off */;
         }
-        getTypeAcquisition() {
-          return { enable: false };
-        }
         /** @internal */
         getSymlinkCache() {
           return this.hostProject.getSymlinkCache();
@@ -179252,7 +179259,7 @@ Dynamic files must always be opened with service's current directory or service
     const verboseLogging = logger.hasLevel(3 /* verbose */);
     const json = JSON.stringify(msg);
     if (verboseLogging) {
-      logger.info(`${msg.type}:${indent2(JSON.stringify(msg, void 0, " "))}`);
+      logger.info(`${msg.type}:${stringifyIndented(msg)}`);
     }
     const len = byteLength(json, "utf8");
     return `Content-Length: ${1 + len}\r

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-insiders.20231011`;
+var version = `${versionMajorMinor}.0-insiders.20231013`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -24111,20 +24111,20 @@ var Parser;
       function doJSDocScan() {
         let state = 1 /* SawAsterisk */;
         let margin;
-        let indent2 = start - (content.lastIndexOf("\n", start) + 1) + 4;
+        let indent3 = start - (content.lastIndexOf("\n", start) + 1) + 4;
         function pushComment(text) {
           if (!margin) {
-            margin = indent2;
+            margin = indent3;
           }
           comments.push(text);
-          indent2 += text.length;
+          indent3 += text.length;
         }
         nextTokenJSDoc();
         while (parseOptionalJsdoc(5 /* WhitespaceTrivia */))
           ;
         if (parseOptionalJsdoc(4 /* NewLineTrivia */)) {
           state = 0 /* BeginningOfLine */;
-          indent2 = 0;
+          indent3 = 0;
         }
         loop:
           while (true) {
@@ -24133,14 +24133,14 @@ var Parser;
                 removeTrailingWhitespace(comments);
                 if (!commentsPos)
                   commentsPos = getNodePos();
-                addTag(parseTag(indent2));
+                addTag(parseTag(indent3));
                 state = 0 /* BeginningOfLine */;
                 margin = void 0;
                 break;
               case 4 /* NewLineTrivia */:
                 comments.push(scanner.getTokenText());
                 state = 0 /* BeginningOfLine */;
-                indent2 = 0;
+                indent3 = 0;
                 break;
               case 42 /* AsteriskToken */:
                 const asterisk = scanner.getTokenText();
@@ -24150,16 +24150,16 @@ var Parser;
                 } else {
                   Debug.assert(state === 0 /* BeginningOfLine */);
                   state = 1 /* SawAsterisk */;
-                  indent2 += asterisk.length;
+                  indent3 += asterisk.length;
                 }
                 break;
               case 5 /* WhitespaceTrivia */:
                 Debug.assert(state !== 2 /* SavingComments */, "whitespace shouldn't come from the scanner while saving top-level comment text");
                 const whitespace = scanner.getTokenText();
-                if (margin !== void 0 && indent2 + whitespace.length > margin) {
-                  comments.push(whitespace.slice(margin - indent2));
+                if (margin !== void 0 && indent3 + whitespace.length > margin) {
+                  comments.push(whitespace.slice(margin - indent3));
                 }
-                indent2 += whitespace.length;
+                indent3 += whitespace.length;
                 break;
               case 1 /* EndOfFileToken */:
                 break loop;
@@ -24361,7 +24361,7 @@ var Parser;
         }
         return parseTagComments(margin, indentText.slice(margin));
       }
-      function parseTagComments(indent2, initialMargin) {
+      function parseTagComments(indent3, initialMargin) {
         const commentsPos2 = getNodePos();
         let comments2 = [];
         const parts2 = [];
@@ -24370,10 +24370,10 @@ var Parser;
         let margin;
         function pushComment(text) {
           if (!margin) {
-            margin = indent2;
+            margin = indent3;
           }
           comments2.push(text);
-          indent2 += text.length;
+          indent3 += text.length;
         }
         if (initialMargin !== void 0) {
           if (initialMargin !== "") {
@@ -24388,7 +24388,7 @@ var Parser;
               case 4 /* NewLineTrivia */:
                 state = 0 /* BeginningOfLine */;
                 comments2.push(scanner.getTokenText());
-                indent2 = 0;
+                indent3 = 0;
                 break;
               case 60 /* AtToken */:
                 scanner.resetTokenState(scanner.getTokenEnd() - 1);
@@ -24398,11 +24398,11 @@ var Parser;
               case 5 /* WhitespaceTrivia */:
                 Debug.assert(state !== 2 /* SavingComments */ && state !== 3 /* SavingBackticks */, "whitespace shouldn't come from the scanner while saving comment text");
                 const whitespace = scanner.getTokenText();
-                if (margin !== void 0 && indent2 + whitespace.length > margin) {
-                  comments2.push(whitespace.slice(margin - indent2));
+                if (margin !== void 0 && indent3 + whitespace.length > margin) {
+                  comments2.push(whitespace.slice(margin - indent3));
                   state = 2 /* SavingComments */;
                 }
-                indent2 += whitespace.length;
+                indent3 += whitespace.length;
                 break;
               case 19 /* OpenBraceToken */:
                 state = 2 /* SavingComments */;
@@ -24435,7 +24435,7 @@ var Parser;
               case 42 /* AsteriskToken */:
                 if (state === 0 /* BeginningOfLine */) {
                   state = 1 /* SawAsterisk */;
-                  indent2 += 1;
+                  indent3 += 1;
                   break;
                 }
               default:
@@ -24500,8 +24500,8 @@ var Parser;
       function isJSDocLinkTag(kind) {
         return kind === "link" || kind === "linkcode" || kind === "linkplain";
       }
-      function parseUnknownTag(start2, tagName, indent2, indentText) {
-        return finishNode(factory2.createJSDocUnknownTag(tagName, parseTrailingTagComments(start2, getNodePos(), indent2, indentText)), start2);
+      function parseUnknownTag(start2, tagName, indent3, indentText) {
+        return finishNode(factory2.createJSDocUnknownTag(tagName, parseTrailingTagComments(start2, getNodePos(), indent3, indentText)), start2);
       }
       function addTag(tag) {
         if (!tag) {
@@ -24548,7 +24548,7 @@ var Parser;
             return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && !node.typeArguments;
         }
       }
-      function parseParameterOrPropertyTag(start2, tagName, target, indent2) {
+      function parseParameterOrPropertyTag(start2, tagName, target, indent3) {
         let typeExpression = tryParseTypeExpression();
         let isNameFirst = !typeExpression;
         skipWhitespaceOrAsterisk();
@@ -24557,8 +24557,8 @@ var Parser;
         if (isNameFirst && !lookAhead(parseJSDocLinkPrefix)) {
           typeExpression = tryParseTypeExpression();
         }
-        const comment = parseTrailingTagComments(start2, getNodePos(), indent2, indentText);
-        const nestedTypeLiteral = parseNestedTypeLiteral(typeExpression, name, target, indent2);
+        const comment = parseTrailingTagComments(start2, getNodePos(), indent3, indentText);
+        const nestedTypeLiteral = parseNestedTypeLiteral(typeExpression, name, target, indent3);
         if (nestedTypeLiteral) {
           typeExpression = nestedTypeLiteral;
           isNameFirst = true;
@@ -24566,12 +24566,12 @@ var Parser;
         const result2 = target === 1 /* Property */ ? factory2.createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) : factory2.createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment);
         return finishNode(result2, start2);
       }
-      function parseNestedTypeLiteral(typeExpression, name, target, indent2) {
+      function parseNestedTypeLiteral(typeExpression, name, target, indent3) {
         if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) {
           const pos = getNodePos();
           let child;
           let children;
-          while (child = tryParse(() => parseChildParameterOrPropertyTag(target, indent2, name))) {
+          while (child = tryParse(() => parseChildParameterOrPropertyTag(target, indent3, name))) {
             if (child.kind === 348 /* JSDocParameterTag */ || child.kind === 355 /* JSDocPropertyTag */) {
               children = append(children, child);
             } else if (child.kind === 352 /* JSDocTemplateTag */) {
@@ -24584,14 +24584,14 @@ var Parser;
           }
         }
       }
-      function parseReturnTag(start2, tagName, indent2, indentText) {
+      function parseReturnTag(start2, tagName, indent3, indentText) {
         if (some(tags, isJSDocReturnTag)) {
           parseErrorAt(tagName.pos, scanner.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
         }
         const typeExpression = tryParseTypeExpression();
-        return finishNode(factory2.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start2, getNodePos(), indent2, indentText)), start2);
+        return finishNode(factory2.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start2, getNodePos(), indent3, indentText)), start2);
       }
-      function parseTypeTag(start2, tagName, indent2, indentText) {
+      function parseTypeTag(start2, tagName, indent3, indentText) {
         if (some(tags, isJSDocTypeTag)) {
           parseErrorAt(tagName.pos, scanner.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
         }
@@ -24599,25 +24599,25 @@ var Parser;
           /*mayOmitBraces*/
           true
         );
-        const comments2 = indent2 !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start2, getNodePos(), indent2, indentText) : void 0;
+        const comments2 = indent3 !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start2, getNodePos(), indent3, indentText) : void 0;
         return finishNode(factory2.createJSDocTypeTag(tagName, typeExpression, comments2), start2);
       }
-      function parseSeeTag(start2, tagName, indent2, indentText) {
+      function parseSeeTag(start2, tagName, indent3, indentText) {
         const isMarkdownOrJSDocLink = token() === 23 /* OpenBracketToken */ || lookAhead(() => nextTokenJSDoc() === 60 /* AtToken */ && tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && isJSDocLinkTag(scanner.getTokenValue()));
         const nameExpression = isMarkdownOrJSDocLink ? void 0 : parseJSDocNameReference();
-        const comments2 = indent2 !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start2, getNodePos(), indent2, indentText) : void 0;
+        const comments2 = indent3 !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start2, getNodePos(), indent3, indentText) : void 0;
         return finishNode(factory2.createJSDocSeeTag(tagName, nameExpression, comments2), start2);
       }
-      function parseThrowsTag(start2, tagName, indent2, indentText) {
+      function parseThrowsTag(start2, tagName, indent3, indentText) {
         const typeExpression = tryParseTypeExpression();
-        const comment = parseTrailingTagComments(start2, getNodePos(), indent2, indentText);
+        const comment = parseTrailingTagComments(start2, getNodePos(), indent3, indentText);
         return finishNode(factory2.createJSDocThrowsTag(tagName, typeExpression, comment), start2);
       }
-      function parseAuthorTag(start2, tagName, indent2, indentText) {
+      function parseAuthorTag(start2, tagName, indent3, indentText) {
         const commentStart = getNodePos();
         const textOnly = parseAuthorNameAndEmail();
         let commentEnd = scanner.getTokenFullStart();
-        const comments2 = parseTrailingTagComments(start2, commentEnd, indent2, indentText);
+        const comments2 = parseTrailingTagComments(start2, commentEnd, indent3, indentText);
         if (!comments2) {
           commentEnd = scanner.getTokenFullStart();
         }
@@ -24701,19 +24701,19 @@ var Parser;
         skipWhitespace();
         return finishNode(factory2.createJSDocEnumTag(tagName, typeExpression, parseTrailingTagComments(start2, getNodePos(), margin, indentText)), start2);
       }
-      function parseTypedefTag(start2, tagName, indent2, indentText) {
+      function parseTypedefTag(start2, tagName, indent3, indentText) {
         let typeExpression = tryParseTypeExpression();
         skipWhitespaceOrAsterisk();
         const fullName = parseJSDocTypeNameWithNamespace();
         skipWhitespace();
-        let comment = parseTagComments(indent2);
+        let comment = parseTagComments(indent3);
         let end2;
         if (!typeExpression || isObjectOrObjectArrayTypeReference(typeExpression.type)) {
           let child;
           let childTypeTag;
           let jsDocPropertyTags;
           let hasChildren = false;
-          while (child = tryParse(() => parseChildPropertyTag(indent2))) {
+          while (child = tryParse(() => parseChildPropertyTag(indent3))) {
             if (child.kind === 352 /* JSDocTemplateTag */) {
               break;
             }
@@ -24741,7 +24741,7 @@ var Parser;
         }
         end2 = end2 || comment !== void 0 ? getNodePos() : (fullName ?? typeExpression ?? tagName).end;
         if (!comment) {
-          comment = parseTrailingTagComments(start2, end2, indent2, indentText);
+          comment = parseTrailingTagComments(start2, end2, indent3, indentText);
         }
         const typedefTag = factory2.createJSDocTypedefTag(tagName, typeExpression, fullName, comment);
         return finishNode(typedefTag, start2, end2);
@@ -24771,11 +24771,11 @@ var Parser;
         }
         return typeNameOrNamespaceName;
       }
-      function parseCallbackTagParameters(indent2) {
+      function parseCallbackTagParameters(indent3) {
         const pos = getNodePos();
         let child;
         let parameters;
-        while (child = tryParse(() => parseChildParameterOrPropertyTag(4 /* CallbackParameter */, indent2))) {
+        while (child = tryParse(() => parseChildParameterOrPropertyTag(4 /* CallbackParameter */, indent3))) {
           if (child.kind === 352 /* JSDocTemplateTag */) {
             parseErrorAtRange(child.tagName, Diagnostics.A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag);
             break;
@@ -24784,11 +24784,11 @@ var Parser;
         }
         return createNodeArray(parameters || [], pos);
       }
-      function parseJSDocSignature(start2, indent2) {
-        const parameters = parseCallbackTagParameters(indent2);
+      function parseJSDocSignature(start2, indent3) {
+        const parameters = parseCallbackTagParameters(indent3);
         const returnTag = tryParse(() => {
           if (parseOptionalJsdoc(60 /* AtToken */)) {
-            const tag = parseTag(indent2);
+            const tag = parseTag(indent3);
             if (tag && tag.kind === 349 /* JSDocReturnTag */) {
               return tag;
             }
@@ -24801,23 +24801,23 @@ var Parser;
           returnTag
         ), start2);
       }
-      function parseCallbackTag(start2, tagName, indent2, indentText) {
+      function parseCallbackTag(start2, tagName, indent3, indentText) {
         const fullName = parseJSDocTypeNameWithNamespace();
         skipWhitespace();
-        let comment = parseTagComments(indent2);
-        const typeExpression = parseJSDocSignature(start2, indent2);
+        let comment = parseTagComments(indent3);
+        const typeExpression = parseJSDocSignature(start2, indent3);
         if (!comment) {
-          comment = parseTrailingTagComments(start2, getNodePos(), indent2, indentText);
+          comment = parseTrailingTagComments(start2, getNodePos(), indent3, indentText);
         }
         const end2 = comment !== void 0 ? getNodePos() : typeExpression.end;
         return finishNode(factory2.createJSDocCallbackTag(tagName, typeExpression, fullName, comment), start2, end2);
       }
-      function parseOverloadTag(start2, tagName, indent2, indentText) {
+      function parseOverloadTag(start2, tagName, indent3, indentText) {
         skipWhitespace();
-        let comment = parseTagComments(indent2);
-        const typeExpression = parseJSDocSignature(start2, indent2);
+        let comment = parseTagComments(indent3);
+        const typeExpression = parseJSDocSignature(start2, indent3);
         if (!comment) {
-          comment = parseTrailingTagComments(start2, getNodePos(), indent2, indentText);
+          comment = parseTrailingTagComments(start2, getNodePos(), indent3, indentText);
         }
         const end2 = comment !== void 0 ? getNodePos() : typeExpression.end;
         return finishNode(factory2.createJSDocOverloadTag(tagName, typeExpression, comment), start2, end2);
@@ -24833,17 +24833,17 @@ var Parser;
         }
         return a.escapedText === b.escapedText;
       }
-      function parseChildPropertyTag(indent2) {
-        return parseChildParameterOrPropertyTag(1 /* Property */, indent2);
+      function parseChildPropertyTag(indent3) {
+        return parseChildParameterOrPropertyTag(1 /* Property */, indent3);
       }
-      function parseChildParameterOrPropertyTag(target, indent2, name) {
+      function parseChildParameterOrPropertyTag(target, indent3, name) {
         let canParseTag = true;
         let seenAsterisk = false;
         while (true) {
           switch (nextTokenJSDoc()) {
             case 60 /* AtToken */:
               if (canParseTag) {
-                const child = tryParseChildTag(target, indent2);
+                const child = tryParseChildTag(target, indent3);
                 if (child && (child.kind === 348 /* JSDocParameterTag */ || child.kind === 355 /* JSDocPropertyTag */) && name && (isIdentifier(child.name) || !escapedTextsEqual(name, child.name.left))) {
                   return false;
                 }
@@ -24869,7 +24869,7 @@ var Parser;
           }
         }
       }
-      function tryParseChildTag(target, indent2) {
+      function tryParseChildTag(target, indent3) {
         Debug.assert(token() === 60 /* AtToken */);
         const start2 = scanner.getTokenFullStart();
         nextTokenJSDoc();
@@ -24889,14 +24889,14 @@ var Parser;
             t = 2 /* Parameter */ | 4 /* CallbackParameter */;
             break;
           case "template":
-            return parseTemplateTag(start2, tagName, indent2, indentText);
+            return parseTemplateTag(start2, tagName, indent3, indentText);
           default:
             return false;
         }
         if (!(target & t)) {
           return false;
         }
-        return parseParameterOrPropertyTag(start2, tagName, target, indent2);
+        return parseParameterOrPropertyTag(start2, tagName, target, indent3);
       }
       function parseTemplateTagTypeParameter() {
         const typeParameterPos = getNodePos();
@@ -24937,10 +24937,10 @@ var Parser;
         } while (parseOptionalJsdoc(28 /* CommaToken */));
         return createNodeArray(typeParameters, pos);
       }
-      function parseTemplateTag(start2, tagName, indent2, indentText) {
+      function parseTemplateTag(start2, tagName, indent3, indentText) {
         const constraint = token() === 19 /* OpenBraceToken */ ? parseJSDocTypeExpression() : void 0;
         const typeParameters = parseTemplateTagTypeParameters();
-        return finishNode(factory2.createJSDocTemplateTag(tagName, constraint, typeParameters, parseTrailingTagComments(start2, getNodePos(), indent2, indentText)), start2);
+        return finishNode(factory2.createJSDocTemplateTag(tagName, constraint, typeParameters, parseTrailingTagComments(start2, getNodePos(), indent3, indentText)), start2);
       }
       function parseOptionalJsdoc(t) {
         if (token() === t) {
@@ -31404,6 +31404,42 @@ __export(ts_JsTyping_exports, {
   validatePackageName: () => validatePackageName
 });
 
+// src/jsTyping/shared.ts
+var ActionSet = "action::set";
+var ActionPackageInstalled = "action::packageInstalled";
+var EventTypesRegistry = "event::typesRegistry";
+var EventBeginInstallTypes = "event::beginInstallTypes";
+var EventEndInstallTypes = "event::endInstallTypes";
+var ActionWatchTypingLocations = "action::watchTypingLocations";
+var Arguments;
+((Arguments2) => {
+  Arguments2.GlobalCacheLocation = "--globalTypingsCacheLocation";
+  Arguments2.LogFile = "--logFile";
+  Arguments2.EnableTelemetry = "--enableTelemetry";
+  Arguments2.TypingSafeListLocation = "--typingSafeListLocation";
+  Arguments2.TypesMapLocation = "--typesMapLocation";
+  Arguments2.NpmLocation = "--npmLocation";
+  Arguments2.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation";
+})(Arguments || (Arguments = {}));
+function hasArgument(argumentName) {
+  return sys.args.includes(argumentName);
+}
+function findArgument(argumentName) {
+  const index = sys.args.indexOf(argumentName);
+  return index >= 0 && index < sys.args.length - 1 ? sys.args[index + 1] : void 0;
+}
+function nowString() {
+  const d = /* @__PURE__ */ new Date();
+  return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${d.getMilliseconds().toString().padStart(3, "0")}`;
+}
+var indentStr = "\n    ";
+function indent(str) {
+  return indentStr + str.replace(/\n/g, indentStr);
+}
+function stringifyIndented(json) {
+  return indent(JSON.stringify(json, void 0, 2));
+}
+
 // src/jsTyping/jsTyping.ts
 function isTypingUpToDate(cachedTyping, availableTypingVersions) {
   const availableVersion = new Version(getProperty(availableTypingVersions, `ts${versionMajorMinor}`) || getProperty(availableTypingVersions, "latest"));
@@ -31510,21 +31546,21 @@ function discoverTypings(host, log2, fileNames, projectRootPath, safeList, packa
     );
     addInferredTypings(module2, "Inferred typings from unresolved imports");
   }
-  packageNameToTypingLocation.forEach((typing, name) => {
-    const registryEntry = typesRegistry.get(name);
-    if (inferredTypings.has(name) && inferredTypings.get(name) === void 0 && registryEntry !== void 0 && isTypingUpToDate(typing, registryEntry)) {
-      inferredTypings.set(name, typing.typingLocation);
-    }
-  });
   for (const excludeTypingName of exclude) {
     const didDelete = inferredTypings.delete(excludeTypingName);
     if (didDelete && log2)
       log2(`Typing for ${excludeTypingName} is in exclude list, will be ignored.`);
   }
+  packageNameToTypingLocation.forEach((typing, name) => {
+    const registryEntry = typesRegistry.get(name);
+    if (inferredTypings.get(name) === false && registryEntry !== void 0 && isTypingUpToDate(typing, registryEntry)) {
+      inferredTypings.set(name, typing.typingLocation);
+    }
+  });
   const newTypingNames = [];
   const cachedTypingPaths = [];
   inferredTypings.forEach((inferred, typing) => {
-    if (inferred !== void 0) {
+    if (inferred) {
       cachedTypingPaths.push(inferred);
     } else {
       newTypingNames.push(typing);
@@ -31532,11 +31568,11 @@ function discoverTypings(host, log2, fileNames, projectRootPath, safeList, packa
   });
   const result = { cachedTypingPaths, newTypingNames, filesToWatch };
   if (log2)
-    log2(`Result: ${JSON.stringify(result)}`);
+    log2(`Finished typings discovery:${stringifyIndented(result)}`);
   return result;
   function addInferredTyping(typingName) {
     if (!inferredTypings.has(typingName)) {
-      inferredTypings.set(typingName, void 0);
+      inferredTypings.set(typingName, false);
     }
   }
   function addInferredTypings(typingNames, message) {
@@ -31709,35 +31745,6 @@ function renderPackageNameValidationFailureWorker(typing, result, name, isScopeN
   }
 }
 
-// src/jsTyping/shared.ts
-var ActionSet = "action::set";
-var ActionPackageInstalled = "action::packageInstalled";
-var EventTypesRegistry = "event::typesRegistry";
-var EventBeginInstallTypes = "event::beginInstallTypes";
-var EventEndInstallTypes = "event::endInstallTypes";
-var ActionWatchTypingLocations = "action::watchTypingLocations";
-var Arguments;
-((Arguments2) => {
-  Arguments2.GlobalCacheLocation = "--globalTypingsCacheLocation";
-  Arguments2.LogFile = "--logFile";
-  Arguments2.EnableTelemetry = "--enableTelemetry";
-  Arguments2.TypingSafeListLocation = "--typingSafeListLocation";
-  Arguments2.TypesMapLocation = "--typesMapLocation";
-  Arguments2.NpmLocation = "--npmLocation";
-  Arguments2.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation";
-})(Arguments || (Arguments = {}));
-function hasArgument(argumentName) {
-  return sys.args.includes(argumentName);
-}
-function findArgument(argumentName) {
-  const index = sys.args.indexOf(argumentName);
-  return index >= 0 && index < sys.args.length - 1 ? sys.args[index + 1] : void 0;
-}
-function nowString() {
-  const d = /* @__PURE__ */ new Date();
-  return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${d.getMilliseconds().toString().padStart(3, "0")}`;
-}
-
 // src/typingsInstallerCore/typingsInstaller.ts
 var nullLog = {
   isEnabled: () => false,
@@ -31820,7 +31827,7 @@ var TypingsInstaller = class {
   }
   install(req) {
     if (this.log.isEnabled()) {
-      this.log.writeLine(`Got install request ${JSON.stringify(req)}`);
+      this.log.writeLine(`Got install request${stringifyIndented(req)}`);
     }
     if (req.cachePath) {
       if (this.log.isEnabled()) {
@@ -31843,9 +31850,6 @@ var TypingsInstaller = class {
       this.typesRegistry,
       req.compilerOptions
     );
-    if (this.log.isEnabled()) {
-      this.log.writeLine(`Finished typings discovery: ${JSON.stringify(discoverTypingsResult)}`);
-    }
     this.watchFiles(req.projectName, discoverTypingsResult.filesToWatch);
     if (discoverTypingsResult.newTypingNames.length) {
       this.installTypings(req, req.cachePath || this.globalCachePath, discoverTypingsResult.cachedTypingPaths, discoverTypingsResult.newTypingNames);
@@ -31887,8 +31891,8 @@ var TypingsInstaller = class {
       const npmConfig = JSON.parse(this.installTypingHost.readFile(packageJson));
       const npmLock = JSON.parse(this.installTypingHost.readFile(packageLockJson));
       if (this.log.isEnabled()) {
-        this.log.writeLine(`Loaded content of '${packageJson}': ${JSON.stringify(npmConfig)}`);
-        this.log.writeLine(`Loaded content of '${packageLockJson}'`);
+        this.log.writeLine(`Loaded content of '${packageJson}':${stringifyIndented(npmConfig)}`);
+        this.log.writeLine(`Loaded content of '${packageLockJson}':${stringifyIndented(npmLock)}`);
       }
       if (npmConfig.devDependencies && npmLock.dependencies) {
         for (const key in npmConfig.devDependencies) {
@@ -32226,8 +32230,7 @@ var NodeTypingsInstaller = class extends TypingsInstaller {
   }
   sendResponse(response) {
     if (this.log.isEnabled()) {
-      this.log.writeLine(`Sending response:
-    ${JSON.stringify(response)}`);
+      this.log.writeLine(`Sending response:${stringifyIndented(response)}`);
     }
     process.send(response);
     if (this.log.isEnabled()) {
@@ -32253,12 +32256,12 @@ var NodeTypingsInstaller = class extends TypingsInstaller {
     try {
       const stdout = this.nodeExecSync(command, { ...options, encoding: "utf-8" });
       if (this.log.isEnabled()) {
-        this.log.writeLine(`    Succeeded. stdout:${indent(sys.newLine, stdout)}`);
+        this.log.writeLine(`    Succeeded. stdout:${indent2(sys.newLine, stdout)}`);
       }
       return false;
     } catch (error) {
       const { stdout, stderr } = error;
-      this.log.writeLine(`    Failed. stdout:${indent(sys.newLine, stdout)}${sys.newLine}    stderr:${indent(sys.newLine, stderr)}`);
+      this.log.writeLine(`    Failed. stdout:${indent2(sys.newLine, stdout)}${sys.newLine}    stderr:${indent2(sys.newLine, stderr)}`);
       return true;
     }
   }
@@ -32302,7 +32305,7 @@ process.on("message", (req) => {
   ));
   installer.handleRequest(req);
 });
-function indent(newline, str) {
+function indent2(newline, str) {
   return str && str.length ? `${newline}    ` + str.replace(/\r?\n/, `${newline}    `) : "";
 }
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.3.0-pr-56064-2",
+  "version": "5.3.0-pr-56105-6",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -115,5 +115,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "30d62732db9cd2e6141fce1006649683150f00c4"
+  "gitHead": "566459088f5187e53c11777b58ecce6f3f3e0bea"
 }