@typescript-deploys/pr-build 5.3.0-pr-56161-5 → 5.3.0-pr-55811-15

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.20231020`;
+var version = `${versionMajorMinor}.0-insiders.20231023`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -54051,6 +54051,18 @@ function createTypeChecker(host) {
   function replaceIndexedAccess(instantiable, type, replacement) {
     return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
   }
+  function getLimitedConstraint(type) {
+    const constraint = getConstraintTypeFromMappedType(type.mappedType);
+    if (!(constraint.flags & 1048576 /* Union */ || constraint.flags & 2097152 /* Intersection */)) {
+      return;
+    }
+    const origin = constraint.flags & 1048576 /* Union */ ? constraint.origin : constraint;
+    if (!origin || !(origin.flags & 2097152 /* Intersection */)) {
+      return;
+    }
+    const limitedConstraint = getIntersectionType(origin.types.filter((t) => t !== type.constraintType));
+    return limitedConstraint !== neverType ? limitedConstraint : void 0;
+  }
   function resolveReverseMappedTypeMembers(type) {
     const indexInfo = getIndexInfoOfType(type.source, stringType);
     const modifiers = getMappedTypeModifiers(type.mappedType);
@@ -54058,7 +54070,14 @@ function createTypeChecker(host) {
     const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
     const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
     const members = createSymbolTable();
+    const limitedConstraint = getLimitedConstraint(type);
     for (const prop of getPropertiesOfType(type.source)) {
+      if (limitedConstraint) {
+        const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
+        if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
+          continue;
+        }
+      }
       const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
       const inferredProp = createSymbol(4 /* Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags);
       inferredProp.declarations = prop.declarations;
@@ -62732,6 +62751,9 @@ function createTypeChecker(host) {
   }
   function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
     if (depth >= maxDepth) {
+      if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
+        type = getMappedTargetWithSymbol(type);
+      }
       if (type.flags & 2097152 /* Intersection */) {
         return some(type.types, (t) => isDeeplyNestedType(t, stack, depth, maxDepth));
       }
@@ -62740,7 +62762,7 @@ function createTypeChecker(host) {
       let lastTypeId = 0;
       for (let i = 0; i < depth; i++) {
         const t = stack[i];
-        if (t.flags & 2097152 /* Intersection */ ? some(t.types, (u) => getRecursionIdentity(u) === identity2) : getRecursionIdentity(t) === identity2) {
+        if (hasMatchingRecursionIdentity(t, identity2)) {
           if (t.id >= lastTypeId) {
             count++;
             if (count >= maxDepth) {
@@ -62753,18 +62775,29 @@ function createTypeChecker(host) {
     }
     return false;
   }
+  function getMappedTargetWithSymbol(type) {
+    let target;
+    while ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && (target = getModifiersTypeFromMappedType(type)) && (target.symbol || target.flags & 2097152 /* Intersection */ && some(target.types, (t) => !!t.symbol))) {
+      type = target;
+    }
+    return type;
+  }
+  function hasMatchingRecursionIdentity(type, identity2) {
+    if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
+      type = getMappedTargetWithSymbol(type);
+    }
+    if (type.flags & 2097152 /* Intersection */) {
+      return some(type.types, (t) => hasMatchingRecursionIdentity(t, identity2));
+    }
+    return getRecursionIdentity(type) === identity2;
+  }
   function getRecursionIdentity(type) {
     if (type.flags & 524288 /* Object */ && !isObjectOrArrayLiteralType(type)) {
       if (getObjectFlags(type) & 4 /* Reference */ && type.node) {
         return type.node;
       }
-      if (type.symbol) {
-        if (getObjectFlags(type) & 32 /* Mapped */) {
-          type = getMappedTargetWithSymbol(type);
-        }
-        if (!(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
-          return type.symbol;
-        }
+      if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
+        return type.symbol;
       }
       if (isTupleType(type)) {
         return type.target;
@@ -62784,13 +62817,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function getMappedTargetWithSymbol(type) {
-    let target = type;
-    while ((getObjectFlags(target) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && isMappedTypeWithKeyofConstraintDeclaration(target)) {
-      target = getModifiersTypeFromMappedType(target);
-    }
-    return target.symbol ? target : type;
-  }
   function isPropertyIdenticalTo(sourceProp, targetProp) {
     return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
   }
@@ -64172,7 +64198,7 @@ function createTypeChecker(host) {
       }
     }
     function inferToMappedType(source, target, constraintType) {
-      if (constraintType.flags & 1048576 /* Union */) {
+      if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
         let result = false;
         for (const type of constraintType.types) {
           result = inferToMappedType(source, target, type) || result;
@@ -79690,7 +79716,7 @@ function createTypeChecker(host) {
       error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
       const text = getTextOfPropertyName(member.name);
-      if (isNumericLiteralName(text)) {
+      if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
         error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
       }
     }

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.20231020`;
+var version = `${versionMajorMinor}.0-insiders.20231023`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -58763,6 +58763,18 @@ function createTypeChecker(host) {
   function replaceIndexedAccess(instantiable, type, replacement) {
     return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
   }
+  function getLimitedConstraint(type) {
+    const constraint = getConstraintTypeFromMappedType(type.mappedType);
+    if (!(constraint.flags & 1048576 /* Union */ || constraint.flags & 2097152 /* Intersection */)) {
+      return;
+    }
+    const origin = constraint.flags & 1048576 /* Union */ ? constraint.origin : constraint;
+    if (!origin || !(origin.flags & 2097152 /* Intersection */)) {
+      return;
+    }
+    const limitedConstraint = getIntersectionType(origin.types.filter((t) => t !== type.constraintType));
+    return limitedConstraint !== neverType ? limitedConstraint : void 0;
+  }
   function resolveReverseMappedTypeMembers(type) {
     const indexInfo = getIndexInfoOfType(type.source, stringType);
     const modifiers = getMappedTypeModifiers(type.mappedType);
@@ -58770,7 +58782,14 @@ function createTypeChecker(host) {
     const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
     const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
     const members = createSymbolTable();
+    const limitedConstraint = getLimitedConstraint(type);
     for (const prop of getPropertiesOfType(type.source)) {
+      if (limitedConstraint) {
+        const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
+        if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
+          continue;
+        }
+      }
       const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
       const inferredProp = createSymbol(4 /* Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags);
       inferredProp.declarations = prop.declarations;
@@ -67444,6 +67463,9 @@ function createTypeChecker(host) {
   }
   function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
     if (depth >= maxDepth) {
+      if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
+        type = getMappedTargetWithSymbol(type);
+      }
       if (type.flags & 2097152 /* Intersection */) {
         return some(type.types, (t) => isDeeplyNestedType(t, stack, depth, maxDepth));
       }
@@ -67452,7 +67474,7 @@ function createTypeChecker(host) {
       let lastTypeId = 0;
       for (let i = 0; i < depth; i++) {
         const t = stack[i];
-        if (t.flags & 2097152 /* Intersection */ ? some(t.types, (u) => getRecursionIdentity(u) === identity2) : getRecursionIdentity(t) === identity2) {
+        if (hasMatchingRecursionIdentity(t, identity2)) {
           if (t.id >= lastTypeId) {
             count++;
             if (count >= maxDepth) {
@@ -67465,18 +67487,29 @@ function createTypeChecker(host) {
     }
     return false;
   }
+  function getMappedTargetWithSymbol(type) {
+    let target;
+    while ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && (target = getModifiersTypeFromMappedType(type)) && (target.symbol || target.flags & 2097152 /* Intersection */ && some(target.types, (t) => !!t.symbol))) {
+      type = target;
+    }
+    return type;
+  }
+  function hasMatchingRecursionIdentity(type, identity2) {
+    if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
+      type = getMappedTargetWithSymbol(type);
+    }
+    if (type.flags & 2097152 /* Intersection */) {
+      return some(type.types, (t) => hasMatchingRecursionIdentity(t, identity2));
+    }
+    return getRecursionIdentity(type) === identity2;
+  }
   function getRecursionIdentity(type) {
     if (type.flags & 524288 /* Object */ && !isObjectOrArrayLiteralType(type)) {
       if (getObjectFlags(type) & 4 /* Reference */ && type.node) {
         return type.node;
       }
-      if (type.symbol) {
-        if (getObjectFlags(type) & 32 /* Mapped */) {
-          type = getMappedTargetWithSymbol(type);
-        }
-        if (!(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
-          return type.symbol;
-        }
+      if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
+        return type.symbol;
       }
       if (isTupleType(type)) {
         return type.target;
@@ -67496,13 +67529,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function getMappedTargetWithSymbol(type) {
-    let target = type;
-    while ((getObjectFlags(target) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && isMappedTypeWithKeyofConstraintDeclaration(target)) {
-      target = getModifiersTypeFromMappedType(target);
-    }
-    return target.symbol ? target : type;
-  }
   function isPropertyIdenticalTo(sourceProp, targetProp) {
     return compareProperties2(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
   }
@@ -68884,7 +68910,7 @@ function createTypeChecker(host) {
       }
     }
     function inferToMappedType(source, target, constraintType) {
-      if (constraintType.flags & 1048576 /* Union */) {
+      if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
         let result = false;
         for (const type of constraintType.types) {
           result = inferToMappedType(source, target, type) || result;
@@ -84402,7 +84428,7 @@ function createTypeChecker(host) {
       error2(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
       const text = getTextOfPropertyName(member.name);
-      if (isNumericLiteralName(text)) {
+      if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
         error2(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
       }
     }
@@ -149961,7 +149987,8 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         defaultImport,
         namedImports && arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
         namespaceLikeImport,
-        compilerOptions
+        compilerOptions,
+        preferences
       );
       newDeclarations = combine(newDeclarations, declarations);
     });
@@ -150666,7 +150693,8 @@ function codeActionForFixWorker(changes, sourceFile, symbolName2, fix, includeSy
           defaultImport,
           namedImports,
           namespaceLikeImport,
-          program.getCompilerOptions()
+          program.getCompilerOptions(),
+          preferences
         ),
         /*blankLineBetween*/
         true,
@@ -150798,7 +150826,7 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor
     const newSpecifiers = stableSort(
       namedImports.map(
         (namedImport) => factory.createImportSpecifier(
-          (!clause.isTypeOnly || promoteFromTypeOnly2) && needsTypeOnly(namedImport),
+          (!clause.isTypeOnly || promoteFromTypeOnly2) && shouldUseTypeOnly(namedImport, preferences),
           /*propertyName*/
           void 0,
           factory.createIdentifier(namedImport.name)
@@ -150862,21 +150890,24 @@ function getImportTypePrefix(moduleSpecifier, quotePreference) {
 function needsTypeOnly({ addAsTypeOnly }) {
   return addAsTypeOnly === 2 /* Required */;
 }
-function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport, compilerOptions) {
+function shouldUseTypeOnly(info, preferences) {
+  return needsTypeOnly(info) || !!preferences.preferTypeOnlyAutoImports && info.addAsTypeOnly !== 4 /* NotAllowed */;
+}
+function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport, compilerOptions, preferences) {
   const quotedModuleSpecifier = makeStringLiteral(moduleSpecifier, quotePreference);
   let statements;
   if (defaultImport !== void 0 || (namedImports == null ? void 0 : namedImports.length)) {
-    const topLevelTypeOnly = (!defaultImport || needsTypeOnly(defaultImport)) && every(namedImports, needsTypeOnly) || compilerOptions.verbatimModuleSyntax && (defaultImport == null ? void 0 : defaultImport.addAsTypeOnly) !== 4 /* NotAllowed */ && !some(namedImports, (i) => i.addAsTypeOnly === 4 /* NotAllowed */);
+    const topLevelTypeOnly = (!defaultImport || needsTypeOnly(defaultImport)) && every(namedImports, needsTypeOnly) || (compilerOptions.verbatimModuleSyntax || preferences.preferTypeOnlyAutoImports) && (defaultImport == null ? void 0 : defaultImport.addAsTypeOnly) !== 4 /* NotAllowed */ && !some(namedImports, (i) => i.addAsTypeOnly === 4 /* NotAllowed */);
     statements = combine(
       statements,
       makeImport(
         defaultImport && factory.createIdentifier(defaultImport.name),
         namedImports == null ? void 0 : namedImports.map(
-          ({ addAsTypeOnly, name }) => factory.createImportSpecifier(
-            !topLevelTypeOnly && addAsTypeOnly === 2 /* Required */,
+          (namedImport) => factory.createImportSpecifier(
+            !topLevelTypeOnly && shouldUseTypeOnly(namedImport, preferences),
             /*propertyName*/
             void 0,
-            factory.createIdentifier(name)
+            factory.createIdentifier(namedImport.name)
           )
         ),
         moduleSpecifier,
@@ -150889,14 +150920,14 @@ function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImp
     const declaration = namespaceLikeImport.importKind === 3 /* CommonJS */ ? factory.createImportEqualsDeclaration(
       /*modifiers*/
       void 0,
-      needsTypeOnly(namespaceLikeImport),
+      shouldUseTypeOnly(namespaceLikeImport, preferences),
       factory.createIdentifier(namespaceLikeImport.name),
       factory.createExternalModuleReference(quotedModuleSpecifier)
     ) : factory.createImportDeclaration(
       /*modifiers*/
       void 0,
       factory.createImportClause(
-        needsTypeOnly(namespaceLikeImport),
+        shouldUseTypeOnly(namespaceLikeImport, preferences),
         /*name*/
         void 0,
         factory.createNamespaceImport(factory.createIdentifier(namespaceLikeImport.name))

package/lib/typescript.d.ts

@@ -8742,6 +8742,7 @@ declare namespace ts {
         readonly interactiveInlayHints?: boolean;
         readonly allowRenameOfImportPath?: boolean;
         readonly autoImportFileExcludePatterns?: string[];
+        readonly preferTypeOnlyAutoImports?: boolean;
         readonly organizeImportsIgnoreCase?: "auto" | boolean;
         readonly organizeImportsCollation?: "ordinal" | "unicode";
         readonly organizeImportsLocale?: string;

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-insiders.20231020`;
+      version = `${versionMajorMinor}.0-insiders.20231023`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -56530,6 +56530,18 @@ ${lanes.join("\n")}
     function replaceIndexedAccess(instantiable, type, replacement) {
       return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
     }
+    function getLimitedConstraint(type) {
+      const constraint = getConstraintTypeFromMappedType(type.mappedType);
+      if (!(constraint.flags & 1048576 /* Union */ || constraint.flags & 2097152 /* Intersection */)) {
+        return;
+      }
+      const origin = constraint.flags & 1048576 /* Union */ ? constraint.origin : constraint;
+      if (!origin || !(origin.flags & 2097152 /* Intersection */)) {
+        return;
+      }
+      const limitedConstraint = getIntersectionType(origin.types.filter((t) => t !== type.constraintType));
+      return limitedConstraint !== neverType ? limitedConstraint : void 0;
+    }
     function resolveReverseMappedTypeMembers(type) {
       const indexInfo = getIndexInfoOfType(type.source, stringType);
       const modifiers = getMappedTypeModifiers(type.mappedType);
@@ -56537,7 +56549,14 @@ ${lanes.join("\n")}
       const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
       const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
       const members = createSymbolTable();
+      const limitedConstraint = getLimitedConstraint(type);
       for (const prop of getPropertiesOfType(type.source)) {
+        if (limitedConstraint) {
+          const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
+          if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
+            continue;
+          }
+        }
         const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
         const inferredProp = createSymbol(4 /* Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags);
         inferredProp.declarations = prop.declarations;
@@ -65211,6 +65230,9 @@ ${lanes.join("\n")}
     }
     function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
       if (depth >= maxDepth) {
+        if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
+          type = getMappedTargetWithSymbol(type);
+        }
         if (type.flags & 2097152 /* Intersection */) {
           return some(type.types, (t) => isDeeplyNestedType(t, stack, depth, maxDepth));
         }
@@ -65219,7 +65241,7 @@ ${lanes.join("\n")}
         let lastTypeId = 0;
         for (let i = 0; i < depth; i++) {
           const t = stack[i];
-          if (t.flags & 2097152 /* Intersection */ ? some(t.types, (u) => getRecursionIdentity(u) === identity2) : getRecursionIdentity(t) === identity2) {
+          if (hasMatchingRecursionIdentity(t, identity2)) {
             if (t.id >= lastTypeId) {
               count++;
               if (count >= maxDepth) {
@@ -65232,18 +65254,29 @@ ${lanes.join("\n")}
       }
       return false;
     }
+    function getMappedTargetWithSymbol(type) {
+      let target;
+      while ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && (target = getModifiersTypeFromMappedType(type)) && (target.symbol || target.flags & 2097152 /* Intersection */ && some(target.types, (t) => !!t.symbol))) {
+        type = target;
+      }
+      return type;
+    }
+    function hasMatchingRecursionIdentity(type, identity2) {
+      if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
+        type = getMappedTargetWithSymbol(type);
+      }
+      if (type.flags & 2097152 /* Intersection */) {
+        return some(type.types, (t) => hasMatchingRecursionIdentity(t, identity2));
+      }
+      return getRecursionIdentity(type) === identity2;
+    }
     function getRecursionIdentity(type) {
       if (type.flags & 524288 /* Object */ && !isObjectOrArrayLiteralType(type)) {
         if (getObjectFlags(type) & 4 /* Reference */ && type.node) {
           return type.node;
         }
-        if (type.symbol) {
-          if (getObjectFlags(type) & 32 /* Mapped */) {
-            type = getMappedTargetWithSymbol(type);
-          }
-          if (!(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
-            return type.symbol;
-          }
+        if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
+          return type.symbol;
         }
         if (isTupleType(type)) {
           return type.target;
@@ -65263,13 +65296,6 @@ ${lanes.join("\n")}
       }
       return type;
     }
-    function getMappedTargetWithSymbol(type) {
-      let target = type;
-      while ((getObjectFlags(target) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && isMappedTypeWithKeyofConstraintDeclaration(target)) {
-        target = getModifiersTypeFromMappedType(target);
-      }
-      return target.symbol ? target : type;
-    }
     function isPropertyIdenticalTo(sourceProp, targetProp) {
       return compareProperties2(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
     }
@@ -66651,7 +66677,7 @@ ${lanes.join("\n")}
         }
       }
       function inferToMappedType(source, target, constraintType) {
-        if (constraintType.flags & 1048576 /* Union */) {
+        if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
           let result = false;
           for (const type of constraintType.types) {
             result = inferToMappedType(source, target, type) || result;
@@ -82169,7 +82195,7 @@ ${lanes.join("\n")}
         error2(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
       } else {
         const text = getTextOfPropertyName(member.name);
-        if (isNumericLiteralName(text)) {
+        if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
           error2(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
         }
       }
@@ -148682,7 +148708,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           defaultImport,
           namedImports && arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
           namespaceLikeImport,
-          compilerOptions
+          compilerOptions,
+          preferences
         );
         newDeclarations = combine(newDeclarations, declarations);
       });
@@ -149387,7 +149414,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             defaultImport,
             namedImports,
             namespaceLikeImport,
-            program.getCompilerOptions()
+            program.getCompilerOptions(),
+            preferences
           ),
           /*blankLineBetween*/
           true,
@@ -149519,7 +149547,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       const newSpecifiers = stableSort(
         namedImports.map(
           (namedImport) => factory.createImportSpecifier(
-            (!clause.isTypeOnly || promoteFromTypeOnly2) && needsTypeOnly(namedImport),
+            (!clause.isTypeOnly || promoteFromTypeOnly2) && shouldUseTypeOnly(namedImport, preferences),
             /*propertyName*/
             void 0,
             factory.createIdentifier(namedImport.name)
@@ -149583,21 +149611,24 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   function needsTypeOnly({ addAsTypeOnly }) {
     return addAsTypeOnly === 2 /* Required */;
   }
-  function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport, compilerOptions) {
+  function shouldUseTypeOnly(info, preferences) {
+    return needsTypeOnly(info) || !!preferences.preferTypeOnlyAutoImports && info.addAsTypeOnly !== 4 /* NotAllowed */;
+  }
+  function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport, compilerOptions, preferences) {
     const quotedModuleSpecifier = makeStringLiteral(moduleSpecifier, quotePreference);
     let statements;
     if (defaultImport !== void 0 || (namedImports == null ? void 0 : namedImports.length)) {
-      const topLevelTypeOnly = (!defaultImport || needsTypeOnly(defaultImport)) && every(namedImports, needsTypeOnly) || compilerOptions.verbatimModuleSyntax && (defaultImport == null ? void 0 : defaultImport.addAsTypeOnly) !== 4 /* NotAllowed */ && !some(namedImports, (i) => i.addAsTypeOnly === 4 /* NotAllowed */);
+      const topLevelTypeOnly = (!defaultImport || needsTypeOnly(defaultImport)) && every(namedImports, needsTypeOnly) || (compilerOptions.verbatimModuleSyntax || preferences.preferTypeOnlyAutoImports) && (defaultImport == null ? void 0 : defaultImport.addAsTypeOnly) !== 4 /* NotAllowed */ && !some(namedImports, (i) => i.addAsTypeOnly === 4 /* NotAllowed */);
       statements = combine(
         statements,
         makeImport(
           defaultImport && factory.createIdentifier(defaultImport.name),
           namedImports == null ? void 0 : namedImports.map(
-            ({ addAsTypeOnly, name }) => factory.createImportSpecifier(
-              !topLevelTypeOnly && addAsTypeOnly === 2 /* Required */,
+            (namedImport) => factory.createImportSpecifier(
+              !topLevelTypeOnly && shouldUseTypeOnly(namedImport, preferences),
               /*propertyName*/
               void 0,
-              factory.createIdentifier(name)
+              factory.createIdentifier(namedImport.name)
             )
           ),
           moduleSpecifier,
@@ -149610,14 +149641,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       const declaration = namespaceLikeImport.importKind === 3 /* CommonJS */ ? factory.createImportEqualsDeclaration(
         /*modifiers*/
         void 0,
-        needsTypeOnly(namespaceLikeImport),
+        shouldUseTypeOnly(namespaceLikeImport, preferences),
         factory.createIdentifier(namespaceLikeImport.name),
         factory.createExternalModuleReference(quotedModuleSpecifier)
       ) : factory.createImportDeclaration(
         /*modifiers*/
         void 0,
         factory.createImportClause(
-          needsTypeOnly(namespaceLikeImport),
+          shouldUseTypeOnly(namespaceLikeImport, preferences),
           /*name*/
           void 0,
           factory.createNamespaceImport(factory.createIdentifier(namespaceLikeImport.name))

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.20231020`;
+var version = `${versionMajorMinor}.0-insiders.20231023`;
 
 // src/compiler/core.ts
 var emptyArray = [];

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-56161-5",
+  "version": "5.3.0-pr-55811-15",
   "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": "dcaa0b853cdd7d1d26b312a499a64451a9fe41e5"
+  "gitHead": "2aeee792ffeabc91b8b8d9806cc4c3be910d772b"
 }