typescript 5.0.0-dev.20230213 → 5.0.0-dev.20230215

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230213`;
+      version = `${versionMajorMinor}.0-dev.20230215`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4477,13 +4477,14 @@ ${lanes.join("\n")}
         TypeFlags2[TypeFlags2["AnyOrUnknown"] = 3] = "AnyOrUnknown";
         TypeFlags2[TypeFlags2["Nullable"] = 98304] = "Nullable";
         TypeFlags2[TypeFlags2["Literal"] = 2944] = "Literal";
-        TypeFlags2[TypeFlags2["Unit"] = 109440] = "Unit";
+        TypeFlags2[TypeFlags2["Unit"] = 109472] = "Unit";
+        TypeFlags2[TypeFlags2["Freshable"] = 2976] = "Freshable";
         TypeFlags2[TypeFlags2["StringOrNumberLiteral"] = 384] = "StringOrNumberLiteral";
         TypeFlags2[TypeFlags2["StringOrNumberLiteralOrUnique"] = 8576] = "StringOrNumberLiteralOrUnique";
         TypeFlags2[TypeFlags2["DefinitelyFalsy"] = 117632] = "DefinitelyFalsy";
         TypeFlags2[TypeFlags2["PossiblyFalsy"] = 117724] = "PossiblyFalsy";
         TypeFlags2[TypeFlags2["Intrinsic"] = 67359327] = "Intrinsic";
-        TypeFlags2[TypeFlags2["Primitive"] = 131068] = "Primitive";
+        TypeFlags2[TypeFlags2["Primitive"] = 134348796] = "Primitive";
         TypeFlags2[TypeFlags2["StringLike"] = 402653316] = "StringLike";
         TypeFlags2[TypeFlags2["NumberLike"] = 296] = "NumberLike";
         TypeFlags2[TypeFlags2["BigIntLike"] = 2112] = "BigIntLike";
@@ -13673,7 +13674,7 @@ ${lanes.join("\n")}
     return kind === 1 /* CommonJS */ || kind === 100 /* Node16 */ || kind === 199 /* NodeNext */;
   }
   function isEffectiveExternalModule(node, compilerOptions) {
-    return isExternalModule(node) || compilerOptions.isolatedModules || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
+    return isExternalModule(node) || getIsolatedModules(compilerOptions) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
   }
   function isEffectiveStrictModeSourceFile(node, compilerOptions) {
     switch (node.scriptKind) {
@@ -13694,7 +13695,7 @@ ${lanes.join("\n")}
     if (startsWithUseStrict(node.statements)) {
       return true;
     }
-    if (isExternalModule(node) || compilerOptions.isolatedModules) {
+    if (isExternalModule(node) || getIsolatedModules(compilerOptions)) {
       if (getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */) {
         return true;
       }
@@ -18026,7 +18027,7 @@ ${lanes.join("\n")}
     return !!(compilerOptions.declaration || compilerOptions.composite);
   }
   function shouldPreserveConstEnums(compilerOptions) {
-    return !!(compilerOptions.preserveConstEnums || compilerOptions.isolatedModules);
+    return !!(compilerOptions.preserveConstEnums || getIsolatedModules(compilerOptions));
   }
   function isIncrementalCompilation(options) {
     return !!(options.incremental || options.composite);
@@ -45179,15 +45180,14 @@ ${lanes.join("\n")}
       getTypeOfPropertyOfContextualType,
       getFullyQualifiedName,
       getResolvedSignature: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* Normal */),
-      getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray) => getResolvedSignatureWorker(
+      getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray) => runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignatureWorker(
         call,
         candidatesOutArray,
         /*argumentCount*/
         void 0,
-        32 /* IsForStringLiteralArgumentCompletions */,
-        editingArgument
-      ),
-      getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */),
+        32 /* IsForStringLiteralArgumentCompletions */
+      )),
+      getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => runWithoutResolvedSignatureCaching(node, () => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */)),
       getExpandedParameters,
       hasEffectiveRestParameter,
       containsArgumentsReference,
@@ -45381,32 +45381,41 @@ ${lanes.join("\n")}
       getMemberOverrideModifierStatus,
       isTypeParameterPossiblyReferenced
     };
-    function runWithInferenceBlockedFromSourceNode(node, fn) {
+    function runWithoutResolvedSignatureCaching(node, fn) {
       const containingCall = findAncestor(node, isCallLikeExpression);
       const containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
+      if (containingCall) {
+        getNodeLinks(containingCall).resolvedSignature = void 0;
+      }
+      const result = fn();
+      if (containingCall) {
+        getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
+      }
+      return result;
+    }
+    function runWithInferenceBlockedFromSourceNode(node, fn) {
+      const containingCall = findAncestor(node, isCallLikeExpression);
       if (containingCall) {
         let toMarkSkip = node;
         do {
           getNodeLinks(toMarkSkip).skipDirectInference = true;
           toMarkSkip = toMarkSkip.parent;
         } while (toMarkSkip && toMarkSkip !== containingCall);
-        getNodeLinks(containingCall).resolvedSignature = void 0;
       }
-      const result = fn();
+      const result = runWithoutResolvedSignatureCaching(node, fn);
       if (containingCall) {
         let toMarkSkip = node;
         do {
           getNodeLinks(toMarkSkip).skipDirectInference = void 0;
           toMarkSkip = toMarkSkip.parent;
         } while (toMarkSkip && toMarkSkip !== containingCall);
-        getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
       }
       return result;
     }
-    function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode, editingArgument) {
+    function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
       const node = getParseTreeNode(nodeIn, isCallLikeExpression);
       apparentArgumentCount = argumentCount;
-      const res = !node ? void 0 : editingArgument ? runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignature(node, candidatesOutArray, checkMode)) : getResolvedSignature(node, candidatesOutArray, checkMode);
+      const res = !node ? void 0 : getResolvedSignature(node, candidatesOutArray, checkMode);
       apparentArgumentCount = void 0;
       return res;
     }
@@ -48368,7 +48377,7 @@ ${lanes.join("\n")}
       return shouldTreatPropertiesOfExternalModuleAsExports(type) ? getPropertyOfType(type, memberName) : void 0;
     }
     function shouldTreatPropertiesOfExternalModuleAsExports(resolvedExternalModuleType) {
-      return !(resolvedExternalModuleType.flags & 131068 /* Primitive */ || getObjectFlags(resolvedExternalModuleType) & 1 /* Class */ || // `isArrayOrTupleLikeType` is too expensive to use in this auto-imports hot path
+      return !(resolvedExternalModuleType.flags & 134348796 /* Primitive */ || getObjectFlags(resolvedExternalModuleType) & 1 /* Class */ || // `isArrayOrTupleLikeType` is too expensive to use in this auto-imports hot path
       isArrayType(resolvedExternalModuleType) || isTupleType(resolvedExternalModuleType));
     }
     function getExportsOfSymbol(symbol) {
@@ -52567,8 +52576,8 @@ ${lanes.join("\n")}
         const t = types[i];
         flags |= t.flags;
         if (!(t.flags & 98304 /* Nullable */)) {
-          if (t.flags & (512 /* BooleanLiteral */ | 1024 /* EnumLiteral */)) {
-            const baseType = t.flags & 512 /* BooleanLiteral */ ? booleanType : getBaseTypeOfEnumLiteralType(t);
+          if (t.flags & (512 /* BooleanLiteral */ | 1056 /* EnumLike */)) {
+            const baseType = t.flags & 512 /* BooleanLiteral */ ? booleanType : getBaseTypeOfEnumLikeType(t);
             if (baseType.flags & 1048576 /* Union */) {
               const count = baseType.types.length;
               if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType(baseType.types[count - 1])) {
@@ -52852,6 +52861,8 @@ ${lanes.join("\n")}
           return !!target.baseTypesResolved;
         case 8 /* WriteType */:
           return !!getSymbolLinks(target).writeType;
+        case 9 /* ParameterInitializerContainsUndefined */:
+          return getNodeLinks(target).parameterInitializerContainsUndefined !== void 0;
       }
       return Debug.assertNever(propertyName);
     }
@@ -54443,8 +54454,8 @@ ${lanes.join("\n")}
       }
       return links.declaredType;
     }
-    function getBaseTypeOfEnumLiteralType(type) {
-      return type.flags & 1024 /* EnumLiteral */ && !(type.flags & 1048576 /* Union */) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
+    function getBaseTypeOfEnumLikeType(type) {
+      return type.flags & 1056 /* EnumLike */ && type.symbol.flags & 8 /* EnumMember */ ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
     }
     function getDeclaredTypeOfEnum(symbol) {
       const links = getSymbolLinks(symbol);
@@ -54457,7 +54468,7 @@ ${lanes.join("\n")}
                 if (hasBindableName(member)) {
                   const memberSymbol = getSymbolOfDeclaration(member);
                   const value = getEnumMemberValue(member);
-                  const memberType = value !== void 0 ? getFreshTypeOfLiteralType(getEnumLiteralType(value, getSymbolId(symbol), memberSymbol)) : createTypeWithSymbol(32 /* Enum */, memberSymbol);
+                  const memberType = getFreshTypeOfLiteralType(value !== void 0 ? getEnumLiteralType(value, getSymbolId(symbol), memberSymbol) : createComputedEnumType(memberSymbol));
                   getSymbolLinks(memberSymbol).declaredType = memberType;
                   memberTypeList.push(getRegularTypeOfLiteralType(memberType));
                 }
@@ -54471,7 +54482,7 @@ ${lanes.join("\n")}
           symbol,
           /*aliasTypeArguments*/
           void 0
-        ) : createTypeWithSymbol(32 /* Enum */, symbol);
+        ) : createComputedEnumType(symbol);
         if (enumType.flags & 1048576 /* Union */) {
           enumType.flags |= 1024 /* EnumLiteral */;
           enumType.symbol = symbol;
@@ -54480,6 +54491,15 @@ ${lanes.join("\n")}
       }
       return links.declaredType;
     }
+    function createComputedEnumType(symbol) {
+      const regularType = createTypeWithSymbol(32 /* Enum */, symbol);
+      const freshType = createTypeWithSymbol(32 /* Enum */, symbol);
+      regularType.regularType = regularType;
+      regularType.freshType = freshType;
+      freshType.regularType = regularType;
+      freshType.freshType = freshType;
+      return regularType;
+    }
     function getDeclaredTypeOfEnumMember(symbol) {
       const links = getSymbolLinks(symbol);
       if (!links.declaredType) {
@@ -58168,7 +58188,7 @@ ${lanes.join("\n")}
             orderedRemoveItemAt(typeSet, 1);
           }
         }
-        if (includes & (2944 /* Literal */ | 8192 /* UniqueESSymbol */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 16384 /* Void */ && includes & 32768 /* Undefined */) {
+        if (includes & (32 /* Enum */ | 2944 /* Literal */ | 8192 /* UniqueESSymbol */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 16384 /* Void */ && includes & 32768 /* Undefined */) {
           removeRedundantLiteralTypes(typeSet, includes, !!(unionReduction & 2 /* Subtype */));
         }
         if (includes & 128 /* StringLiteral */ && includes & 134217728 /* TemplateLiteral */) {
@@ -58299,7 +58319,7 @@ ${lanes.join("\n")}
             type = undefinedType;
           }
           if (!typeSet.has(type.id.toString())) {
-            if (type.flags & 109440 /* Unit */ && includes & 109440 /* Unit */) {
+            if (type.flags & 109472 /* Unit */ && includes & 109472 /* Unit */) {
               includes |= 67108864 /* NonPrimitive */;
             }
             typeSet.set(type.id.toString(), type);
@@ -58575,7 +58595,7 @@ ${lanes.join("\n")}
       const typeVariable = getTypeParameterFromMappedType(mappedType);
       return isDistributive(getNameTypeFromMappedType(mappedType) || typeVariable);
       function isDistributive(type) {
-        return type.flags & (3 /* AnyOrUnknown */ | 131068 /* Primitive */ | 131072 /* Never */ | 262144 /* TypeParameter */ | 524288 /* Object */ | 67108864 /* NonPrimitive */) ? true : type.flags & 16777216 /* Conditional */ ? type.root.isDistributive && type.checkType === typeVariable : type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */) ? every(type.types, isDistributive) : type.flags & 8388608 /* IndexedAccess */ ? isDistributive(type.objectType) && isDistributive(type.indexType) : type.flags & 33554432 /* Substitution */ ? isDistributive(type.baseType) && isDistributive(type.constraint) : type.flags & 268435456 /* StringMapping */ ? isDistributive(type.type) : false;
+        return type.flags & (3 /* AnyOrUnknown */ | 134348796 /* Primitive */ | 131072 /* Never */ | 262144 /* TypeParameter */ | 524288 /* Object */ | 67108864 /* NonPrimitive */) ? true : type.flags & 16777216 /* Conditional */ ? type.root.isDistributive && type.checkType === typeVariable : type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */) ? every(type.types, isDistributive) : type.flags & 8388608 /* IndexedAccess */ ? isDistributive(type.objectType) && isDistributive(type.indexType) : type.flags & 33554432 /* Substitution */ ? isDistributive(type.baseType) && isDistributive(type.constraint) : type.flags & 268435456 /* StringMapping */ ? isDistributive(type.type) : false;
       }
     }
     function getLiteralTypeFromPropertyName(name) {
@@ -59672,7 +59692,7 @@ ${lanes.join("\n")}
       return type;
     }
     function getFreshTypeOfLiteralType(type) {
-      if (type.flags & 2944 /* Literal */) {
+      if (type.flags & 2976 /* Freshable */) {
         if (!type.freshType) {
           const freshType = createLiteralType(type.flags, type.value, type.symbol, type);
           freshType.freshType = freshType;
@@ -59683,10 +59703,10 @@ ${lanes.join("\n")}
       return type;
     }
     function getRegularTypeOfLiteralType(type) {
-      return type.flags & 2944 /* Literal */ ? type.regularType : type.flags & 1048576 /* Union */ ? type.regularType || (type.regularType = mapType(type, getRegularTypeOfLiteralType)) : type;
+      return type.flags & 2976 /* Freshable */ ? type.regularType : type.flags & 1048576 /* Union */ ? type.regularType || (type.regularType = mapType(type, getRegularTypeOfLiteralType)) : type;
     }
     function isFreshLiteralType(type) {
-      return !!(type.flags & 2944 /* Literal */) && type.freshType === type;
+      return !!(type.flags & 2976 /* Freshable */) && type.freshType === type;
     }
     function getStringLiteralType(value) {
       let type;
@@ -60365,13 +60385,13 @@ ${lanes.join("\n")}
       return type;
     }
     function getUniqueLiteralFilledInstantiation(type) {
-      return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
+      return type.flags & (134348796 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
     }
     function getPermissiveInstantiation(type) {
-      return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
+      return type.flags & (134348796 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
     }
     function getRestrictiveInstantiation(type) {
-      if (type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */)) {
+      if (type.flags & (134348796 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */)) {
         return type;
       }
       if (type.restrictiveInstantiation) {
@@ -60951,7 +60971,7 @@ ${lanes.join("\n")}
       }
     }
     function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-      if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
+      if (target.flags & (134348796 /* Primitive */ | 131072 /* Never */))
         return false;
       if (isTupleLikeType(source)) {
         return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
@@ -61000,7 +61020,7 @@ ${lanes.join("\n")}
       }
     }
     function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
-      if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
+      if (target.flags & (134348796 /* Primitive */ | 131072 /* Never */))
         return false;
       return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
     }
@@ -61023,16 +61043,24 @@ ${lanes.join("\n")}
         void 0
       ) !== 0 /* False */;
     }
-    function isAnySignature(s) {
-      return !s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && signatureHasRestParameter(s) && (getTypeOfParameter(s.parameters[0]) === anyArrayType || isTypeAny(getTypeOfParameter(s.parameters[0]))) && isTypeAny(getReturnTypeOfSignature(s));
+    function isTopSignature(s) {
+      if (!s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && signatureHasRestParameter(s)) {
+        const paramType = getTypeOfParameter(s.parameters[0]);
+        const restType = isArrayType(paramType) ? getTypeArguments(paramType)[0] : paramType;
+        return !!(restType.flags & (1 /* Any */ | 131072 /* Never */) && getReturnTypeOfSignature(s).flags & 3 /* AnyOrUnknown */);
+      }
+      return false;
     }
     function compareSignaturesRelated(source, target, checkMode, reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) {
       if (source === target) {
         return -1 /* True */;
       }
-      if (isAnySignature(target)) {
+      if (!(checkMode & 16 /* StrictTopSignature */ && isTopSignature(source)) && isTopSignature(target)) {
         return -1 /* True */;
       }
+      if (checkMode & 16 /* StrictTopSignature */ && isTopSignature(source) && !isTopSignature(target)) {
+        return 0 /* False */;
+      }
       const targetCount = getParameterCount(target);
       const sourceHasMoreParameters = !hasEffectiveRestParameter(target) && (checkMode & 8 /* StrictArity */ ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
       if (sourceHasMoreParameters) {
@@ -61250,7 +61278,9 @@ ${lanes.join("\n")}
     function isSimpleTypeRelatedTo(source, target, relation, errorReporter) {
       const s = source.flags;
       const t = target.flags;
-      if (t & 3 /* AnyOrUnknown */ || s & 131072 /* Never */ || source === wildcardType)
+      if (t & 1 /* Any */ || s & 131072 /* Never */ || source === wildcardType)
+        return true;
+      if (t & 2 /* Unknown */ && !(relation === strictSubtypeRelation && s & 1 /* Any */))
         return true;
       if (t & 131072 /* Never */)
         return false;
@@ -61647,7 +61677,7 @@ ${lanes.join("\n")}
         return isRelatedTo(source2, target2, 3 /* Both */, reportErrors2);
       }
       function isRelatedTo(originalSource, originalTarget, recursionFlags = 3 /* Both */, reportErrors2 = false, headMessage2, intersectionState = 0 /* None */) {
-        if (originalSource.flags & 524288 /* Object */ && originalTarget.flags & 131068 /* Primitive */) {
+        if (originalSource.flags & 524288 /* Object */ && originalTarget.flags & 134348796 /* Primitive */) {
           if (relation === comparableRelation && !(originalTarget.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(originalTarget, originalSource, relation) || isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors2 ? reportError : void 0)) {
             return -1 /* True */;
           }
@@ -61711,7 +61741,7 @@ ${lanes.join("\n")}
               return 0 /* False */;
             }
           }
-          const isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source2)) && !(intersectionState & 2 /* Target */) && source2.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source2 !== globalObjectType && target2.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target2) && (getPropertiesOfType(source2).length > 0 || typeHasCallOrConstructSignatures2(source2));
+          const isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source2)) && !(intersectionState & 2 /* Target */) && source2.flags & (134348796 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source2 !== globalObjectType && target2.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target2) && (getPropertiesOfType(source2).length > 0 || typeHasCallOrConstructSignatures2(source2));
           const isComparingJsxAttributes = !!(getObjectFlags(source2) & 2048 /* JsxAttributes */);
           if (isPerformingCommonPropertyChecks && !hasCommonProperties(source2, target2, isComparingJsxAttributes)) {
             if (reportErrors2) {
@@ -61773,7 +61803,7 @@ ${lanes.join("\n")}
             maybeSuppress = !!errorInfo;
           }
         }
-        if (source2.flags & 524288 /* Object */ && target2.flags & 131068 /* Primitive */) {
+        if (source2.flags & 524288 /* Object */ && target2.flags & 134348796 /* Primitive */) {
           tryElaborateErrorsForPrimitivesAndObjects(source2, target2);
         } else if (source2.symbol && source2.flags & 524288 /* Object */ && globalObjectType === source2) {
           reportError(Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
@@ -61919,15 +61949,15 @@ ${lanes.join("\n")}
       }
       function unionOrIntersectionRelatedTo(source2, target2, reportErrors2, intersectionState) {
         if (source2.flags & 1048576 /* Union */) {
-          return relation === comparableRelation ? someTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */), intersectionState) : eachTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */), intersectionState);
+          return relation === comparableRelation ? someTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 134348796 /* Primitive */), intersectionState) : eachTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 134348796 /* Primitive */), intersectionState);
         }
         if (target2.flags & 1048576 /* Union */) {
-          return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source2), target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */) && !(target2.flags & 131068 /* Primitive */));
+          return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source2), target2, reportErrors2 && !(source2.flags & 134348796 /* Primitive */) && !(target2.flags & 134348796 /* Primitive */));
         }
         if (target2.flags & 2097152 /* Intersection */) {
           return typeRelatedToEachType(source2, target2, reportErrors2, 2 /* Target */);
         }
-        if (relation === comparableRelation && target2.flags & 131068 /* Primitive */) {
+        if (relation === comparableRelation && target2.flags & 134348796 /* Primitive */) {
           const constraints = sameMap(source2.types, (t) => t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(t) || unknownType : t);
           if (constraints !== source2.types) {
             source2 = getIntersectionType(constraints);
@@ -62820,7 +62850,7 @@ ${lanes.join("\n")}
             }
             return 0 /* False */;
           }
-          const sourceIsPrimitive = !!(sourceFlags & 131068 /* Primitive */);
+          const sourceIsPrimitive = !!(sourceFlags & 134348796 /* Primitive */);
           if (relation !== identityRelation) {
             source2 = getApparentType(source2);
             sourceFlags = source2.flags;
@@ -63490,10 +63520,11 @@ ${lanes.join("\n")}
         return (source2, target2) => reportIncompatibleError(Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source2), typeToString(target2));
       }
       function signatureRelatedTo(source2, target2, erase, reportErrors2, intersectionState, incompatibleReporter) {
+        const checkMode = relation === subtypeRelation ? 16 /* StrictTopSignature */ : relation === strictSubtypeRelation ? 16 /* StrictTopSignature */ | 8 /* StrictArity */ : 0 /* None */;
         return compareSignaturesRelated(
           erase ? getErasedSignature(source2) : source2,
           erase ? getErasedSignature(target2) : target2,
-          relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0,
+          checkMode,
           reportErrors2,
           reportError,
           incompatibleReporter,
@@ -63618,7 +63649,7 @@ ${lanes.join("\n")}
         if (sourceInfo) {
           return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2, intersectionState);
         }
-        if (!(intersectionState & 1 /* Source */) && isObjectTypeWithInferableIndex(source2)) {
+        if (!(intersectionState & 1 /* Source */) && (relation !== strictSubtypeRelation || getObjectFlags(source2) & 8192 /* FreshLiteral */) && isObjectTypeWithInferableIndex(source2)) {
           return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
         }
         if (reportErrors2) {
@@ -64163,10 +64194,10 @@ ${lanes.join("\n")}
       return void 0;
     }
     function isNeitherUnitTypeNorNever(type) {
-      return !(type.flags & (109440 /* Unit */ | 131072 /* Never */));
+      return !(type.flags & (109472 /* Unit */ | 131072 /* Never */));
     }
     function isUnitType(type) {
-      return !!(type.flags & 109440 /* Unit */);
+      return !!(type.flags & 109472 /* Unit */);
     }
     function isUnitLikeType(type) {
       const t = getBaseConstraintOrType(type);
@@ -64179,7 +64210,7 @@ ${lanes.join("\n")}
       return type.flags & 16 /* Boolean */ ? true : type.flags & 1048576 /* Union */ ? type.flags & 1024 /* EnumLiteral */ ? true : every(type.types, isUnitType) : isUnitType(type);
     }
     function getBaseTypeOfLiteralType(type) {
-      return type.flags & 1024 /* EnumLiteral */ ? getBaseTypeOfEnumLiteralType(type) : type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 512 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? getBaseTypeOfLiteralTypeUnion(type) : type;
+      return type.flags & 1056 /* EnumLike */ ? getBaseTypeOfEnumLikeType(type) : type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 512 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? getBaseTypeOfLiteralTypeUnion(type) : type;
     }
     function getBaseTypeOfLiteralTypeUnion(type) {
       var _a2;
@@ -64187,7 +64218,7 @@ ${lanes.join("\n")}
       return (_a2 = getCachedType(key)) != null ? _a2 : setCachedType(key, mapType(type, getBaseTypeOfLiteralType));
     }
     function getWidenedLiteralType(type) {
-      return type.flags & 1024 /* EnumLiteral */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) : type.flags & 128 /* StringLiteral */ && isFreshLiteralType(type) ? stringType : type.flags & 256 /* NumberLiteral */ && isFreshLiteralType(type) ? numberType : type.flags & 2048 /* BigIntLiteral */ && isFreshLiteralType(type) ? bigintType : type.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(type) ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedLiteralType) : type;
+      return type.flags & 1056 /* EnumLike */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLikeType(type) : type.flags & 128 /* StringLiteral */ && isFreshLiteralType(type) ? stringType : type.flags & 256 /* NumberLiteral */ && isFreshLiteralType(type) ? numberType : type.flags & 2048 /* BigIntLiteral */ && isFreshLiteralType(type) ? bigintType : type.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(type) ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedLiteralType) : type;
     }
     function getWidenedUniqueESSymbolType(type) {
       return type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedUniqueESSymbolType) : type;
@@ -64720,8 +64751,8 @@ ${lanes.join("\n")}
       }
       return false;
     }
-    function isTypeParameterAtTopLevel(type, typeParameter) {
-      return !!(type === typeParameter || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isTypeParameterAtTopLevel(t, typeParameter)) || type.flags & 16777216 /* Conditional */ && (getTrueTypeFromConditionalType(type) === typeParameter || getFalseTypeFromConditionalType(type) === typeParameter));
+    function isTypeParameterAtTopLevel(type, tp, depth = 0) {
+      return !!(type === tp || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isTypeParameterAtTopLevel(t, tp, depth)) || depth < 3 && type.flags & 16777216 /* Conditional */ && (isTypeParameterAtTopLevel(getTrueTypeFromConditionalType(type), tp, depth + 1) || isTypeParameterAtTopLevel(getFalseTypeFromConditionalType(type), tp, depth + 1)));
     }
     function isTypeParameterAtTopLevelInReturnType(signature, typeParameter) {
       const typePredicate = getTypePredicateOfSignature(signature);
@@ -64815,7 +64846,7 @@ ${lanes.join("\n")}
             yield targetProp;
           } else if (matchDiscriminantProperties) {
             const targetType = getTypeOfSymbol(targetProp);
-            if (targetType.flags & 109440 /* Unit */) {
+            if (targetType.flags & 109472 /* Unit */) {
               const sourceType = getTypeOfSymbol(sourceProp);
               if (!(sourceType.flags & 1 /* Any */ || getRegularTypeOfLiteralType(sourceType) === getRegularTypeOfLiteralType(targetType))) {
                 yield targetProp;
@@ -64876,10 +64907,10 @@ ${lanes.join("\n")}
       return getBigIntLiteralType(parseValidBigInt(text));
     }
     function isMemberOfStringMapping(source, target) {
-      if (target.flags & (4 /* String */ | 1 /* Any */)) {
+      if (target.flags & 1 /* Any */) {
         return true;
       }
-      if (target.flags & 134217728 /* TemplateLiteral */) {
+      if (target.flags & (4 /* String */ | 134217728 /* TemplateLiteral */)) {
         return isTypeAssignableTo(source, target);
       }
       if (target.flags & 268435456 /* StringMapping */) {
@@ -65574,7 +65605,7 @@ ${lanes.join("\n")}
     }
     function hasPrimitiveConstraint(type) {
       const constraint = getConstraintOfTypeParameter(type);
-      return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 /* Conditional */ ? getDefaultConstraintOfConditionalType(constraint) : constraint, 131068 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
+      return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 /* Conditional */ ? getDefaultConstraintOfConditionalType(constraint) : constraint, 134348796 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
     }
     function isObjectLiteralType2(type) {
       return !!(getObjectFlags(type) & 128 /* ObjectLiteral */);
@@ -66056,7 +66087,7 @@ ${lanes.join("\n")}
       return 83886079 /* UnknownFacts */;
     }
     function getIntersectionTypeFacts(type) {
-      const ignoreObjects = maybeTypeOfKind(type, 131068 /* Primitive */);
+      const ignoreObjects = maybeTypeOfKind(type, 134348796 /* Primitive */);
       let oredFacts = 0 /* None */;
       let andedFacts = 134217727 /* All */;
       for (const t of type.types) {
@@ -66255,7 +66286,7 @@ ${lanes.join("\n")}
         }
         return true;
       }
-      if (source.flags & 1024 /* EnumLiteral */ && getBaseTypeOfEnumLiteralType(source) === target) {
+      if (source.flags & 1056 /* EnumLike */ && getBaseTypeOfEnumLikeType(source) === target) {
         return true;
       }
       return containsType(target.types, source);
@@ -67319,7 +67350,7 @@ ${lanes.join("\n")}
         }
         if (assumeTrue) {
           if (!doubleEquals && (type.flags & 2 /* Unknown */ || someType(type, isEmptyAnonymousObjectType))) {
-            if (valueType.flags & (131068 /* Primitive */ | 67108864 /* NonPrimitive */) || isEmptyAnonymousObjectType(valueType)) {
+            if (valueType.flags & (134348796 /* Primitive */ | 67108864 /* NonPrimitive */) || isEmptyAnonymousObjectType(valueType)) {
               return valueType;
             }
             if (valueType.flags & 524288 /* Object */) {
@@ -67369,7 +67400,7 @@ ${lanes.join("\n")}
           let groundClauseTypes;
           for (let i = 0; i < clauseTypes.length; i += 1) {
             const t = clauseTypes[i];
-            if (t.flags & (131068 /* Primitive */ | 67108864 /* NonPrimitive */)) {
+            if (t.flags & (134348796 /* Primitive */ | 67108864 /* NonPrimitive */)) {
               if (groundClauseTypes !== void 0) {
                 groundClauseTypes.push(t);
               }
@@ -67517,18 +67548,29 @@ ${lanes.join("\n")}
         return (_a3 = getCachedType(key2)) != null ? _a3 : setCachedType(key2, getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived));
       }
       function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) {
-        const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
         if (!assumeTrue) {
-          return filterType(type, (t) => !isRelated(t, candidate));
+          if (checkDerived) {
+            return filterType(type, (t) => !isTypeDerivedFrom(t, candidate));
+          }
+          const trueType2 = getNarrowedType(
+            type,
+            candidate,
+            /*assumeTrue*/
+            true,
+            /*checkDerived*/
+            false
+          );
+          return filterType(type, (t) => !isTypeSubsetOf(t, trueType2));
         }
         if (type.flags & 3 /* AnyOrUnknown */) {
           return candidate;
         }
+        const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
         const keyPropertyName = type.flags & 1048576 /* Union */ ? getKeyPropertyName(type) : void 0;
         const narrowedType = mapType(candidate, (c) => {
           const discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
           const matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
-          const directlyRelated = mapType(matching || type, checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType);
+          const directlyRelated = mapType(matching || type, checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeSubtypeOf(c, t) && !isTypeIdenticalTo(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType);
           return directlyRelated.flags & 131072 /* Never */ ? mapType(type, (t) => maybeTypeOfKind(t, 465829888 /* Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) : directlyRelated;
         });
         return !(narrowedType.flags & 131072 /* Never */) ? narrowedType : isTypeSubtypeOf(candidate, type) ? candidate : isTypeAssignableTo(type, candidate) ? type : isTypeAssignableTo(candidate, type) ? candidate : getIntersectionType([type, candidate]);
@@ -67684,15 +67726,25 @@ ${lanes.join("\n")}
     function isConstVariable(symbol) {
       return symbol.flags & 3 /* Variable */ && (getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* Const */) !== 0;
     }
-    function removeOptionalityFromDeclaredType(declaredType, declaration) {
-      if (pushTypeResolution(declaration.symbol, 2 /* DeclaredType */)) {
-        const annotationIncludesUndefined = strictNullChecks && declaration.kind === 166 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !(getTypeFacts(checkExpression(declaration.initializer)) & 16777216 /* IsUndefined */);
-        popTypeResolution();
-        return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
-      } else {
-        reportCircularityError(declaration.symbol);
-        return declaredType;
+    function parameterInitializerContainsUndefined(declaration) {
+      const links = getNodeLinks(declaration);
+      if (links.parameterInitializerContainsUndefined === void 0) {
+        if (!pushTypeResolution(declaration, 9 /* ParameterInitializerContainsUndefined */)) {
+          reportCircularityError(declaration.symbol);
+          return true;
+        }
+        const containsUndefined = !!(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */);
+        if (!popTypeResolution()) {
+          reportCircularityError(declaration.symbol);
+          return true;
+        }
+        links.parameterInitializerContainsUndefined = containsUndefined;
       }
+      return links.parameterInitializerContainsUndefined;
+    }
+    function removeOptionalityFromDeclaredType(declaredType, declaration) {
+      const removeUndefined = strictNullChecks && declaration.kind === 166 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !parameterInitializerContainsUndefined(declaration);
+      return removeUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
     }
     function isConstraintPosition(type, node) {
       const parent2 = node.parent;
@@ -70858,7 +70910,7 @@ ${lanes.join("\n")}
     function reportNonexistentProperty(propNode, containingType, isUncheckedJS) {
       let errorInfo;
       let relatedInfo;
-      if (!isPrivateIdentifier(propNode) && containingType.flags & 1048576 /* Union */ && !(containingType.flags & 131068 /* Primitive */)) {
+      if (!isPrivateIdentifier(propNode) && containingType.flags & 1048576 /* Union */ && !(containingType.flags & 134348796 /* Primitive */)) {
         for (const subtype of containingType.types) {
           if (!getPropertyOfType(subtype, propNode.escapedText) && !getApplicableIndexInfoForName(subtype, propNode.escapedText)) {
             errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(propNode), typeToString(subtype));
@@ -71455,7 +71507,7 @@ ${lanes.join("\n")}
         } else {
           const contextualType = getIndexedAccessType(restType, getNumberLiteralType(i - index), 256 /* Contextual */);
           const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
-          const hasPrimitiveContextualType = inConstContext || maybeTypeOfKind(contextualType, 131068 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
+          const hasPrimitiveContextualType = inConstContext || maybeTypeOfKind(contextualType, 134348796 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
           types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
           flags.push(1 /* Required */);
         }
@@ -74705,7 +74757,7 @@ ${lanes.join("\n")}
       if (leftType === silentNeverType || rightType === silentNeverType) {
         return silentNeverType;
       }
-      if (!isTypeAny(leftType) && allTypesAssignableToKind(leftType, 131068 /* Primitive */)) {
+      if (!isTypeAny(leftType) && allTypesAssignableToKind(leftType, 134348796 /* Primitive */)) {
         error(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
       }
       if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures2(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
@@ -75291,7 +75343,7 @@ ${lanes.join("\n")}
             return leftType;
           } else {
             checkAssignmentOperator(rightType);
-            return getRegularTypeOfObjectLiteral(rightType);
+            return rightType;
           }
         case 27 /* CommaToken */:
           if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isIndirectCall(left.parent)) {
@@ -77198,6 +77250,9 @@ ${lanes.join("\n")}
           case 273 /* ImportSpecifier */:
           case 79 /* Identifier */:
             return 1 /* ExportValue */;
+          case 170 /* MethodSignature */:
+          case 168 /* PropertySignature */:
+            return 2 /* ExportType */;
           default:
             return Debug.failBadSyntaxKind(d);
         }
@@ -77221,7 +77276,7 @@ ${lanes.join("\n")}
       ))) {
         return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0];
       }
-      if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* Primitive */ | 131072 /* Never */)) {
+      if (allTypesAssignableToKind(getBaseConstraintOrType(type), 134348796 /* Primitive */ | 131072 /* Never */)) {
         return void 0;
       }
       const thenFunction = getTypeOfPropertyOfType(type, "then");
@@ -77273,7 +77328,7 @@ ${lanes.join("\n")}
       return awaitedType || errorType;
     }
     function isThenableType(type) {
-      if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* Primitive */ | 131072 /* Never */)) {
+      if (allTypesAssignableToKind(getBaseConstraintOrType(type), 134348796 /* Primitive */ | 131072 /* Never */)) {
         return false;
       }
       const thenFunction = getTypeOfPropertyOfType(type, "then");
@@ -77322,7 +77377,7 @@ ${lanes.join("\n")}
           return awaitedType;
         }
       }
-      Debug.assert(getPromisedTypeOfPromise(type) === void 0, "type provided should not be a non-generic 'promise'-like.");
+      Debug.assert(isAwaitedTypeInstantiation(type) || getPromisedTypeOfPromise(type) === void 0, "type provided should not be a non-generic 'promise'-like.");
       return type;
     }
     function getAwaitedType(type, errorNode, diagnosticMessage, arg0) {
@@ -81581,6 +81636,8 @@ ${lanes.join("\n")}
       if (!(links.flags & 1 /* TypeChecked */)) {
         links.deferredNodes || (links.deferredNodes = /* @__PURE__ */ new Set());
         links.deferredNodes.add(node);
+      } else {
+        Debug.assert(!links.deferredNodes, "A type-checked file should have no deferred nodes.");
       }
     }
     function checkDeferredNodes(context) {
@@ -81588,6 +81645,7 @@ ${lanes.join("\n")}
       if (links.deferredNodes) {
         links.deferredNodes.forEach(checkDeferredNode);
       }
+      links.deferredNodes = void 0;
     }
     function checkDeferredNode(node) {
       var _a2, _b;
@@ -82668,7 +82726,7 @@ ${lanes.join("\n")}
       return !!(type.flags & 524288 /* Object */) && getSignaturesOfType(type, 0 /* Call */).length > 0;
     }
     function getTypeReferenceSerializationKind(typeNameIn, location) {
-      var _a2, _b;
+      var _a2;
       const typeName = getParseTreeNode(typeNameIn, isEntityName);
       if (!typeName)
         return 0 /* Unknown */;
@@ -82700,7 +82758,7 @@ ${lanes.join("\n")}
         location
       );
       const resolvedSymbol = valueSymbol && valueSymbol.flags & 2097152 /* Alias */ ? resolveAlias(valueSymbol) : valueSymbol;
-      isTypeOnly || (isTypeOnly = !!((_b = valueSymbol == null ? void 0 : valueSymbol.declarations) == null ? void 0 : _b.every(isTypeOnlyImportOrExportDeclaration)));
+      isTypeOnly || (isTypeOnly = !!(valueSymbol && getTypeOnlyAliasDeclaration(valueSymbol, 111551 /* Value */)));
       const typeSymbol = resolveEntityName(
         typeName,
         788968 /* Type */,
@@ -82851,7 +82909,7 @@ ${lanes.join("\n")}
       return false;
     }
     function literalTypeToNode(type, enclosing, tracker) {
-      const enumResult = type.flags & 1024 /* EnumLiteral */ ? nodeBuilder.symbolToExpression(
+      const enumResult = type.flags & 1056 /* EnumLike */ ? nodeBuilder.symbolToExpression(
         type.symbol,
         111551 /* Value */,
         enclosing,
@@ -84412,7 +84470,7 @@ ${lanes.join("\n")}
     }
     function isSimpleLiteralEnumReference(expr) {
       if ((isPropertyAccessExpression(expr) || isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression)) && isEntityNameExpression(expr.expression)) {
-        return !!(checkExpressionCached(expr).flags & 1024 /* EnumLiteral */);
+        return !!(checkExpressionCached(expr).flags & 1056 /* EnumLike */);
       }
     }
     function checkAmbientInitializer(node) {
@@ -84814,10 +84872,10 @@ ${lanes.join("\n")}
     }
     function findMostOverlappyType(source, unionTarget) {
       let bestMatch;
-      if (!(source.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
+      if (!(source.flags & (134348796 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
         let matchingCount = 0;
         for (const target of unionTarget.types) {
-          if (!(target.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
+          if (!(target.flags & (134348796 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
             const overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
             if (overlap.flags & 4194304 /* Index */) {
               return target;
@@ -84835,7 +84893,7 @@ ${lanes.join("\n")}
     }
     function filterPrimitivesIfContainsNonPrimitive(type) {
       if (maybeTypeOfKind(type, 67108864 /* NonPrimitive */)) {
-        const result = filterType(type, (t) => !(t.flags & 131068 /* Primitive */));
+        const result = filterType(type, (t) => !(t.flags & 134348796 /* Primitive */));
         if (!(result.flags & 131072 /* Never */)) {
           return result;
         }
@@ -85035,6 +85093,7 @@ ${lanes.join("\n")}
         SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
         SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
         SignatureCheckMode3[SignatureCheckMode3["StrictArity"] = 8] = "StrictArity";
+        SignatureCheckMode3[SignatureCheckMode3["StrictTopSignature"] = 16] = "StrictTopSignature";
         SignatureCheckMode3[SignatureCheckMode3["Callback"] = 3] = "Callback";
         return SignatureCheckMode3;
       })(SignatureCheckMode || {});
@@ -89751,7 +89810,7 @@ ${lanes.join("\n")}
       return node;
     }
     function tryGetConstEnumValue(node) {
-      if (compilerOptions.isolatedModules) {
+      if (getIsolatedModules(compilerOptions)) {
         return void 0;
       }
       return isPropertyAccessExpression(node) || isElementAccessExpression(node) ? resolver.getConstantValue(node) : void 0;
@@ -106193,7 +106252,7 @@ ${lanes.join("\n")}
       if (node.isDeclarationFile) {
         return node;
       }
-      if (isExternalModule(node) || compilerOptions.isolatedModules) {
+      if (isExternalModule(node) || getIsolatedModules(compilerOptions)) {
         currentSourceFile = node;
         importRequireStatements = void 0;
         let result = updateExternalModule(node);
@@ -106400,7 +106459,7 @@ ${lanes.join("\n")}
     }
     function onEmitNode(hint, node, emitCallback) {
       if (isSourceFile(node)) {
-        if ((isExternalModule(node) || compilerOptions.isolatedModules) && compilerOptions.importHelpers) {
+        if ((isExternalModule(node) || getIsolatedModules(compilerOptions)) && compilerOptions.importHelpers) {
           helperNameSubstitutions = /* @__PURE__ */ new Map();
         }
         previousOnEmitNode(hint, node, emitCallback);
@@ -116988,7 +117047,7 @@ ${lanes.join("\n")}
       let imports;
       let moduleAugmentations;
       let ambientModules;
-      if ((options.isolatedModules || isExternalModuleFile) && !file.isDeclarationFile) {
+      if ((getIsolatedModules(options) || isExternalModuleFile) && !file.isDeclarationFile) {
         if (options.importHelpers) {
           imports = [createSyntheticImport(externalHelpersModuleNameText, file)];
         }
@@ -117709,12 +117768,12 @@ ${lanes.join("\n")}
       if (options.exactOptionalPropertyTypes && !getStrictOptionValue(options, "strictNullChecks")) {
         createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "exactOptionalPropertyTypes", "strictNullChecks");
       }
-      if (options.isolatedModules) {
+      if (options.isolatedModules || options.verbatimModuleSyntax) {
         if (options.out) {
-          createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "isolatedModules");
+          createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", options.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules");
         }
         if (options.outFile) {
-          createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "outFile", "isolatedModules");
+          createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "outFile", options.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules");
         }
       }
       if (options.inlineSourceMap) {
@@ -119271,7 +119330,7 @@ ${lanes.join("\n")}
             return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
           }
           const compilerOptions = programOfThisState.getCompilerOptions();
-          if (compilerOptions && (compilerOptions.isolatedModules || outFile(compilerOptions))) {
+          if (compilerOptions && (getIsolatedModules(compilerOptions) || outFile(compilerOptions))) {
             return [sourceFileWithUpdatedShape];
           }
           const seenFileNamesMap = /* @__PURE__ */ new Map();
@@ -119686,7 +119745,7 @@ ${lanes.join("\n")}
       return;
     if (!isChangedSignature(state, affectedFile.resolvedPath))
       return;
-    if (state.compilerOptions.isolatedModules) {
+    if (getIsolatedModules(state.compilerOptions)) {
       const seenFileNamesMap = /* @__PURE__ */ new Map();
       seenFileNamesMap.set(affectedFile.resolvedPath, true);
       const queue = BuilderState.getReferencedByPaths(state, affectedFile.resolvedPath);
@@ -139964,7 +140023,8 @@ ${lanes.join("\n")}
           quotePreference,
           defaultImport,
           namedImports && arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
-          namespaceLikeImport
+          namespaceLikeImport,
+          compilerOptions
         );
         newDeclarations = combine(newDeclarations, declarations);
       });
@@ -140142,7 +140202,7 @@ ${lanes.join("\n")}
     if (isForNewImportDeclaration && compilerOptions.importsNotUsedAsValues === 2 /* Error */) {
       return 2 /* Required */;
     }
-    if ((compilerOptions.isolatedModules && compilerOptions.preserveValueImports || compilerOptions.verbatimModuleSyntax) && (!(targetFlags & 111551 /* Value */) || !!checker.getTypeOnlyAliasDeclaration(symbol))) {
+    if (importNameElisionDisabled(compilerOptions) && (!(targetFlags & 111551 /* Value */) || !!checker.getTypeOnlyAliasDeclaration(symbol))) {
       return 2 /* Required */;
     }
     return 1 /* Allowed */;
@@ -140626,7 +140686,14 @@ ${lanes.join("\n")}
         insertImports(
           changes,
           sourceFile,
-          getDeclarations(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport),
+          getDeclarations(
+            moduleSpecifier,
+            quotePreference,
+            defaultImport,
+            namedImports,
+            namespaceLikeImport,
+            compilerOptions
+          ),
           /*blankLineBetween*/
           true,
           preferences
@@ -140650,7 +140717,7 @@ ${lanes.join("\n")}
     return promotedDeclaration.kind === 268 /* ImportEqualsDeclaration */ ? ((_b = tryCast((_a2 = tryCast(promotedDeclaration.moduleReference, isExternalModuleReference)) == null ? void 0 : _a2.expression, isStringLiteralLike)) == null ? void 0 : _b.text) || promotedDeclaration.moduleReference.getText() : cast(promotedDeclaration.parent.moduleSpecifier, isStringLiteral).text;
   }
   function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceFile, preferences) {
-    const convertExistingToTypeOnly = compilerOptions.preserveValueImports && compilerOptions.isolatedModules || compilerOptions.verbatimModuleSyntax;
+    const convertExistingToTypeOnly = importNameElisionDisabled(compilerOptions);
     switch (aliasDeclaration.kind) {
       case 273 /* ImportSpecifier */:
         if (aliasDeclaration.isTypeOnly) {
@@ -140724,7 +140791,7 @@ ${lanes.join("\n")}
     }
     const promoteFromTypeOnly2 = clause.isTypeOnly && some([defaultImport, ...namedImports], (i) => (i == null ? void 0 : i.addAsTypeOnly) === 4 /* NotAllowed */);
     const existingSpecifiers = clause.namedBindings && ((_a2 = tryCast(clause.namedBindings, isNamedImports)) == null ? void 0 : _a2.elements);
-    const convertExistingToTypeOnly = promoteFromTypeOnly2 && (compilerOptions.preserveValueImports && compilerOptions.isolatedModules || compilerOptions.verbatimModuleSyntax);
+    const convertExistingToTypeOnly = promoteFromTypeOnly2 && importNameElisionDisabled(compilerOptions);
     if (defaultImport) {
       Debug.assert(!clause.name, "Cannot add a default import to an import clause that already has one");
       changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), factory.createIdentifier(defaultImport.name), { suffix: ", " });
@@ -140808,11 +140875,11 @@ ${lanes.join("\n")}
   function needsTypeOnly({ addAsTypeOnly }) {
     return addAsTypeOnly === 2 /* Required */;
   }
-  function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport) {
+  function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport, compilerOptions) {
     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);
+      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 */);
       statements = combine(statements, makeImport(
         defaultImport && factory.createIdentifier(defaultImport.name),
         namedImports == null ? void 0 : namedImports.map(({ addAsTypeOnly, name }) => factory.createImportSpecifier(
@@ -141446,7 +141513,7 @@ ${lanes.join("\n")}
   }
   function updateExport(changes, program, sourceFile, node, names) {
     const namedExports = node.exportClause && isNamedExports(node.exportClause) ? node.exportClause.elements : factory.createNodeArray([]);
-    const allowTypeModifier = !node.isTypeOnly && !!(program.getCompilerOptions().isolatedModules || find(namedExports, (e) => e.isTypeOnly));
+    const allowTypeModifier = !node.isTypeOnly && !!(getIsolatedModules(program.getCompilerOptions()) || find(namedExports, (e) => e.isTypeOnly));
     changes.replaceNode(
       sourceFile,
       node,
@@ -141478,7 +141545,7 @@ ${lanes.join("\n")}
         factory.createNamedExports(createExportSpecifiers(
           names,
           /*allowTypeModifier*/
-          !!program.getCompilerOptions().isolatedModules
+          getIsolatedModules(program.getCompilerOptions())
         )),
         /*moduleSpecifier*/
         void 0,
@@ -150202,7 +150269,7 @@ ${lanes.join("\n")}
   function getApparentProperties(type, node, checker) {
     if (!type.isUnion())
       return type.getApparentProperties();
-    return checker.getAllPossiblePropertiesOfTypes(filter(type.types, (memberType) => !(memberType.flags & 131068 /* Primitive */ || checker.isArrayLikeType(memberType) || checker.isTypeInvalidDueToUnionDiscriminant(memberType, node) || typeHasCallOrConstructSignatures(memberType, checker) || memberType.isClass() && containsNonPublicProperties(memberType.getApparentProperties()))));
+    return checker.getAllPossiblePropertiesOfTypes(filter(type.types, (memberType) => !(memberType.flags & 134348796 /* Primitive */ || checker.isArrayLikeType(memberType) || checker.isTypeInvalidDueToUnionDiscriminant(memberType, node) || typeHasCallOrConstructSignatures(memberType, checker) || memberType.isClass() && containsNonPublicProperties(memberType.getApparentProperties()))));
   }
   function containsNonPublicProperties(props) {
     return some(props, (p) => !!(getDeclarationModifierFlagsFromSymbol(p) & 24 /* NonPublicAccessibilityModifier */));
@@ -155090,6 +155157,7 @@ ${lanes.join("\n")}
         "module",
         "name",
         "namespace",
+        "overload",
         "override",
         "package",
         "param",