@typescript-deploys/pr-build 5.3.0-pr-56064-15 → 5.3.0-pr-56004-36

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.20231015`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -48109,7 +48109,7 @@ function createTypeChecker(host) {
         return result;
       }
       function createAnonymousTypeNode(type2) {
-        var _a2;
+        var _a2, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
         if (symbol) {
@@ -48135,6 +48135,20 @@ function createTypeChecker(host) {
             return visitAndTransformType(type2, createTypeNodeFromObjectType);
           }
         } else {
+          const isInstantiationExpressionType = !!(getObjectFlags(type2) & 8388608 /* InstantiationExpressionType */);
+          if (isInstantiationExpressionType) {
+            const instantiationExpressionType = type2;
+            if (isTypeQueryNode(instantiationExpressionType.node)) {
+              const typeNode = serializeExistingTypeNode(context, instantiationExpressionType.node);
+              if (typeNode) {
+                return typeNode;
+              }
+            }
+            if ((_b2 = context.visitedTypes) == null ? void 0 : _b2.has(typeId)) {
+              return createElidedInformationPlaceholder(context);
+            }
+            return visitAndTransformType(type2, createTypeNodeFromObjectType);
+          }
           return createTypeNodeFromObjectType(type2);
         }
         function shouldWriteTypeOfFunctionSymbol() {
@@ -54071,7 +54085,12 @@ function createTypeChecker(host) {
         const checkType = type.checkType;
         const constraint = getLowerBoundOfKeyType(checkType);
         if (constraint !== checkType) {
-          return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+          return getConditionalTypeInstantiation(
+            type,
+            prependTypeMapping(type.root.checkType, constraint, type.mapper),
+            /*forConstraint*/
+            false
+          );
         }
       }
       return type;
@@ -54423,7 +54442,12 @@ function createTypeChecker(host) {
       );
       const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
       if (constraint && constraint !== type.checkType) {
-        const instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+        const instantiated = getConditionalTypeInstantiation(
+          type,
+          prependTypeMapping(type.root.checkType, constraint, type.mapper),
+          /*forConstraint*/
+          true
+        );
         if (!(instantiated.flags & 131072 /* Never */)) {
           type.resolvedConstraintOfDistributive = instantiated;
           return instantiated;
@@ -57986,7 +58010,7 @@ function createTypeChecker(host) {
   function isDeferredType(type, checkTuples) {
     return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
-  function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -58032,7 +58056,7 @@ function createTypeChecker(host) {
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
         if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (checkType.flags & 1 /* Any */) {
+          if (checkType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -58142,7 +58166,9 @@ function createTypeChecker(host) {
       links.resolvedType = getConditionalType(
         root,
         /*mapper*/
-        void 0
+        void 0,
+        /*forConstraint*/
+        false
       );
       if (outerTypeParameters) {
         root.instantiations = /* @__PURE__ */ new Map();
@@ -58977,7 +59003,6 @@ function createTypeChecker(host) {
     ) : strictNullChecks && modifiers & 8 /* ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* NEUndefined */) : propType;
   }
   function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) {
-    Debug.assert(type.symbol, "anonymous type must have symbol to be instantiated");
     const result = createObjectType(type.objectFlags & ~(524288 /* CouldContainTypeVariablesComputed */ | 1048576 /* CouldContainTypeVariables */) | 64 /* Instantiated */, type.symbol);
     if (type.objectFlags & 32 /* Mapped */) {
       result.declaration = type.declaration;
@@ -58997,17 +59022,17 @@ function createTypeChecker(host) {
     result.objectFlags |= result.aliasTypeArguments ? getPropagatingFlagsOfTypes(result.aliasTypeArguments) : 0;
     return result;
   }
-  function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
+  function getConditionalTypeInstantiation(type, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     const root = type.root;
     if (root.outerTypeParameters) {
       const typeArguments = map(root.outerTypeParameters, (t) => getMappedType(t, mapper));
-      const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
+      const id = (forConstraint ? "C" : "") + getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
       let result = root.instantiations.get(id);
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
         const distributionType = root.isDistributive ? getMappedType(checkType, newMapper) : void 0;
-        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper)), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, aliasSymbol, aliasTypeArguments);
+        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
         root.instantiations.set(id, result);
       }
       return result;
@@ -59095,7 +59120,14 @@ function createTypeChecker(host) {
       );
     }
     if (flags & 16777216 /* Conditional */) {
-      return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments);
+      return getConditionalTypeInstantiation(
+        type,
+        combineTypeMappers(type.mapper, mapper),
+        /*forConstraint*/
+        false,
+        aliasSymbol,
+        aliasTypeArguments
+      );
     }
     if (flags & 33554432 /* Substitution */) {
       const newBaseType = instantiateType(type.baseType, mapper);
@@ -61636,13 +61668,6 @@ function createTypeChecker(host) {
               return result2;
             }
           }
-        } else {
-          const distributiveConstraint = hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
-          if (distributiveConstraint) {
-            if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
-              return result2;
-            }
-          }
         }
         const defaultConstraint = getDefaultConstraintOfConditionalType(source2);
         if (defaultConstraint) {
@@ -61650,6 +61675,13 @@ function createTypeChecker(host) {
             return result2;
           }
         }
+        const distributiveConstraint = !(targetFlags & 16777216 /* Conditional */) && hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
+        if (distributiveConstraint) {
+          resetErrorInfo(saveErrorInfo);
+          if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
+            return result2;
+          }
+        }
       } else {
         if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target2) && isEmptyObjectType(source2)) {
           return -1 /* True */;
@@ -62225,7 +62257,6 @@ function createTypeChecker(host) {
       const sourceObjectFlags = getObjectFlags(source2);
       const targetObjectFlags = getObjectFlags(target2);
       if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
-        Debug.assertEqual(sourceSignatures.length, targetSignatures.length);
         for (let i = 0; i < targetSignatures.length; i++) {
           const related = signatureRelatedTo(
             sourceSignatures[i],
@@ -72443,7 +72474,14 @@ function createTypeChecker(host) {
           hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0);
           hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
           if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
-            const result3 = createAnonymousType(createSymbol(0 /* None */, "__instantiationExpression" /* InstantiationExpression */), resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
+            const result3 = createAnonymousType(
+              /*symbol*/
+              void 0,
+              resolved.members,
+              callSignatures,
+              constructSignatures,
+              resolved.indexInfos
+            );
             result3.objectFlags |= 8388608 /* InstantiationExpressionType */;
             result3.node = node;
             return result3;

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.20231015`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6573,7 +6573,6 @@ var InternalSymbolName = /* @__PURE__ */ ((InternalSymbolName2) => {
   InternalSymbolName2["ExportEquals"] = "export=";
   InternalSymbolName2["Default"] = "default";
   InternalSymbolName2["This"] = "this";
-  InternalSymbolName2["InstantiationExpression"] = "__instantiationExpression";
   return InternalSymbolName2;
 })(InternalSymbolName || {});
 var NodeCheckFlags = /* @__PURE__ */ ((NodeCheckFlags2) => {
@@ -52822,7 +52821,7 @@ function createTypeChecker(host) {
         return result;
       }
       function createAnonymousTypeNode(type2) {
-        var _a2;
+        var _a2, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
         if (symbol) {
@@ -52848,6 +52847,20 @@ function createTypeChecker(host) {
             return visitAndTransformType(type2, createTypeNodeFromObjectType);
           }
         } else {
+          const isInstantiationExpressionType = !!(getObjectFlags(type2) & 8388608 /* InstantiationExpressionType */);
+          if (isInstantiationExpressionType) {
+            const instantiationExpressionType = type2;
+            if (isTypeQueryNode(instantiationExpressionType.node)) {
+              const typeNode = serializeExistingTypeNode(context, instantiationExpressionType.node);
+              if (typeNode) {
+                return typeNode;
+              }
+            }
+            if ((_b2 = context.visitedTypes) == null ? void 0 : _b2.has(typeId)) {
+              return createElidedInformationPlaceholder(context);
+            }
+            return visitAndTransformType(type2, createTypeNodeFromObjectType);
+          }
           return createTypeNodeFromObjectType(type2);
         }
         function shouldWriteTypeOfFunctionSymbol() {
@@ -58784,7 +58797,12 @@ function createTypeChecker(host) {
         const checkType = type.checkType;
         const constraint = getLowerBoundOfKeyType(checkType);
         if (constraint !== checkType) {
-          return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+          return getConditionalTypeInstantiation(
+            type,
+            prependTypeMapping(type.root.checkType, constraint, type.mapper),
+            /*forConstraint*/
+            false
+          );
         }
       }
       return type;
@@ -59136,7 +59154,12 @@ function createTypeChecker(host) {
       );
       const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
       if (constraint && constraint !== type.checkType) {
-        const instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+        const instantiated = getConditionalTypeInstantiation(
+          type,
+          prependTypeMapping(type.root.checkType, constraint, type.mapper),
+          /*forConstraint*/
+          true
+        );
         if (!(instantiated.flags & 131072 /* Never */)) {
           type.resolvedConstraintOfDistributive = instantiated;
           return instantiated;
@@ -62699,7 +62722,7 @@ function createTypeChecker(host) {
   function isDeferredType(type, checkTuples) {
     return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
-  function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -62745,7 +62768,7 @@ function createTypeChecker(host) {
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
         if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (checkType.flags & 1 /* Any */) {
+          if (checkType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -62855,7 +62878,9 @@ function createTypeChecker(host) {
       links.resolvedType = getConditionalType(
         root,
         /*mapper*/
-        void 0
+        void 0,
+        /*forConstraint*/
+        false
       );
       if (outerTypeParameters) {
         root.instantiations = /* @__PURE__ */ new Map();
@@ -63690,7 +63715,6 @@ function createTypeChecker(host) {
     ) : strictNullChecks && modifiers & 8 /* ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* NEUndefined */) : propType;
   }
   function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) {
-    Debug.assert(type.symbol, "anonymous type must have symbol to be instantiated");
     const result = createObjectType(type.objectFlags & ~(524288 /* CouldContainTypeVariablesComputed */ | 1048576 /* CouldContainTypeVariables */) | 64 /* Instantiated */, type.symbol);
     if (type.objectFlags & 32 /* Mapped */) {
       result.declaration = type.declaration;
@@ -63710,17 +63734,17 @@ function createTypeChecker(host) {
     result.objectFlags |= result.aliasTypeArguments ? getPropagatingFlagsOfTypes(result.aliasTypeArguments) : 0;
     return result;
   }
-  function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
+  function getConditionalTypeInstantiation(type, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     const root = type.root;
     if (root.outerTypeParameters) {
       const typeArguments = map(root.outerTypeParameters, (t) => getMappedType(t, mapper));
-      const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
+      const id = (forConstraint ? "C" : "") + getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
       let result = root.instantiations.get(id);
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
         const distributionType = root.isDistributive ? getMappedType(checkType, newMapper) : void 0;
-        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper)), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, aliasSymbol, aliasTypeArguments);
+        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
         root.instantiations.set(id, result);
       }
       return result;
@@ -63808,7 +63832,14 @@ function createTypeChecker(host) {
       );
     }
     if (flags & 16777216 /* Conditional */) {
-      return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments);
+      return getConditionalTypeInstantiation(
+        type,
+        combineTypeMappers(type.mapper, mapper),
+        /*forConstraint*/
+        false,
+        aliasSymbol,
+        aliasTypeArguments
+      );
     }
     if (flags & 33554432 /* Substitution */) {
       const newBaseType = instantiateType(type.baseType, mapper);
@@ -66349,13 +66380,6 @@ function createTypeChecker(host) {
               return result2;
             }
           }
-        } else {
-          const distributiveConstraint = hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
-          if (distributiveConstraint) {
-            if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
-              return result2;
-            }
-          }
         }
         const defaultConstraint = getDefaultConstraintOfConditionalType(source2);
         if (defaultConstraint) {
@@ -66363,6 +66387,13 @@ function createTypeChecker(host) {
             return result2;
           }
         }
+        const distributiveConstraint = !(targetFlags & 16777216 /* Conditional */) && hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
+        if (distributiveConstraint) {
+          resetErrorInfo(saveErrorInfo);
+          if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
+            return result2;
+          }
+        }
       } else {
         if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target2) && isEmptyObjectType(source2)) {
           return -1 /* True */;
@@ -66938,7 +66969,6 @@ function createTypeChecker(host) {
       const sourceObjectFlags = getObjectFlags(source2);
       const targetObjectFlags = getObjectFlags(target2);
       if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
-        Debug.assertEqual(sourceSignatures.length, targetSignatures.length);
         for (let i = 0; i < targetSignatures.length; i++) {
           const related = signatureRelatedTo(
             sourceSignatures[i],
@@ -77156,7 +77186,14 @@ function createTypeChecker(host) {
           hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0);
           hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
           if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
-            const result3 = createAnonymousType(createSymbol(0 /* None */, "__instantiationExpression" /* InstantiationExpression */), resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
+            const result3 = createAnonymousType(
+              /*symbol*/
+              void 0,
+              resolved.members,
+              callSignatures,
+              constructSignatures,
+              resolved.indexInfos
+            );
             result3.objectFlags |= 8388608 /* InstantiationExpressionType */;
             result3.node = node;
             return result3;
@@ -130363,6 +130400,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"));
@@ -130469,21 +130544,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);
@@ -130491,11 +130566,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) {
@@ -130668,37 +130743,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) => {
@@ -174689,7 +174733,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()) {
@@ -174712,9 +174756,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);
@@ -174756,8 +174797,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) {
@@ -175134,13 +175175,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 = {};
@@ -177993,9 +178027,6 @@ var _AutoImportProviderProject = class _AutoImportProviderProject extends Projec
   includePackageJsonAutoImports() {
     return 0 /* Off */;
   }
-  getTypeAcquisition() {
-    return { enable: false };
-  }
   /** @internal */
   getSymlinkCache() {
     return this.hostProject.getSymlinkCache();
@@ -181919,7 +181950,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)
@@ -7048,7 +7047,6 @@ declare namespace ts {
         ExportEquals = "export=",
         Default = "default",
         This = "this",
-        InstantiationExpression = "__instantiationExpression",
     }
     /**
      * This represents a string whose leading underscore have been escaped by adding extra leading underscores.