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

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230213`;
+var version = `${versionMajorMinor}.0-dev.20230215`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3748,13 +3748,14 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   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";
@@ -12158,7 +12159,7 @@ function isCommonJSContainingModuleKind(kind) {
   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) {
@@ -12179,7 +12180,7 @@ function isEffectiveStrictModeSourceFile(node, compilerOptions) {
   if (startsWithUseStrict(node.statements)) {
     return true;
   }
-  if (isExternalModule(node) || compilerOptions.isolatedModules) {
+  if (isExternalModule(node) || getIsolatedModules(compilerOptions)) {
     if (getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */) {
       return true;
     }
@@ -16235,7 +16236,7 @@ function getEmitDeclarations(compilerOptions) {
   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);
@@ -42519,6 +42520,7 @@ var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
   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 || {});
@@ -42793,15 +42795,14 @@ function createTypeChecker(host) {
     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,
@@ -42995,32 +42996,41 @@ function createTypeChecker(host) {
     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;
   }
@@ -45982,7 +45992,7 @@ function createTypeChecker(host) {
     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) {
@@ -50181,8 +50191,8 @@ function createTypeChecker(host) {
       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])) {
@@ -50466,6 +50476,8 @@ function createTypeChecker(host) {
         return !!target.baseTypesResolved;
       case 8 /* WriteType */:
         return !!getSymbolLinks(target).writeType;
+      case 9 /* ParameterInitializerContainsUndefined */:
+        return getNodeLinks(target).parameterInitializerContainsUndefined !== void 0;
     }
     return Debug.assertNever(propertyName);
   }
@@ -52057,8 +52069,8 @@ function createTypeChecker(host) {
     }
     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);
@@ -52071,7 +52083,7 @@ function createTypeChecker(host) {
               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));
               }
@@ -52085,7 +52097,7 @@ function createTypeChecker(host) {
         symbol,
         /*aliasTypeArguments*/
         void 0
-      ) : createTypeWithSymbol(32 /* Enum */, symbol);
+      ) : createComputedEnumType(symbol);
       if (enumType.flags & 1048576 /* Union */) {
         enumType.flags |= 1024 /* EnumLiteral */;
         enumType.symbol = symbol;
@@ -52094,6 +52106,15 @@ function createTypeChecker(host) {
     }
     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) {
@@ -55782,7 +55803,7 @@ function createTypeChecker(host) {
           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 */) {
@@ -55913,7 +55934,7 @@ function createTypeChecker(host) {
           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);
@@ -56189,7 +56210,7 @@ function createTypeChecker(host) {
     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) {
@@ -57286,7 +57307,7 @@ function createTypeChecker(host) {
     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;
@@ -57297,10 +57318,10 @@ function createTypeChecker(host) {
     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;
@@ -57979,13 +58000,13 @@ function createTypeChecker(host) {
     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) {
@@ -58565,7 +58586,7 @@ function createTypeChecker(host) {
     }
   }
   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);
@@ -58614,7 +58635,7 @@ function createTypeChecker(host) {
     }
   }
   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);
   }
@@ -58637,16 +58658,24 @@ function createTypeChecker(host) {
       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) {
@@ -58864,7 +58893,9 @@ function createTypeChecker(host) {
   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;
@@ -59261,7 +59292,7 @@ function createTypeChecker(host) {
       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 */;
         }
@@ -59325,7 +59356,7 @@ function createTypeChecker(host) {
             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) {
@@ -59387,7 +59418,7 @@ function createTypeChecker(host) {
           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);
@@ -59533,15 +59564,15 @@ function createTypeChecker(host) {
     }
     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);
@@ -60434,7 +60465,7 @@ function createTypeChecker(host) {
           }
           return 0 /* False */;
         }
-        const sourceIsPrimitive = !!(sourceFlags & 131068 /* Primitive */);
+        const sourceIsPrimitive = !!(sourceFlags & 134348796 /* Primitive */);
         if (relation !== identityRelation) {
           source2 = getApparentType(source2);
           sourceFlags = source2.flags;
@@ -61104,10 +61135,11 @@ function createTypeChecker(host) {
       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,
@@ -61232,7 +61264,7 @@ function createTypeChecker(host) {
       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) {
@@ -61777,10 +61809,10 @@ function createTypeChecker(host) {
     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);
@@ -61793,7 +61825,7 @@ function createTypeChecker(host) {
     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;
@@ -61801,7 +61833,7 @@ function createTypeChecker(host) {
     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;
@@ -62334,8 +62366,8 @@ function createTypeChecker(host) {
     }
     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);
@@ -62429,7 +62461,7 @@ function createTypeChecker(host) {
           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;
@@ -62490,10 +62522,10 @@ function createTypeChecker(host) {
     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 */) {
@@ -63188,7 +63220,7 @@ function createTypeChecker(host) {
   }
   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 isObjectLiteralType(type) {
     return !!(getObjectFlags(type) & 128 /* ObjectLiteral */);
@@ -63670,7 +63702,7 @@ function createTypeChecker(host) {
     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) {
@@ -63869,7 +63901,7 @@ function createTypeChecker(host) {
       }
       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);
@@ -64933,7 +64965,7 @@ function createTypeChecker(host) {
       }
       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 */) {
@@ -64983,7 +65015,7 @@ function createTypeChecker(host) {
         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);
             }
@@ -65131,18 +65163,29 @@ function createTypeChecker(host) {
       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]);
@@ -65298,15 +65341,25 @@ function createTypeChecker(host) {
   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 parent = node.parent;
@@ -68472,7 +68525,7 @@ function createTypeChecker(host) {
   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));
@@ -69069,7 +69122,7 @@ function createTypeChecker(host) {
       } 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 */);
       }
@@ -72319,7 +72372,7 @@ function createTypeChecker(host) {
     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))) {
@@ -72905,7 +72958,7 @@ function createTypeChecker(host) {
           return leftType;
         } else {
           checkAssignmentOperator(rightType);
-          return getRegularTypeOfObjectLiteral(rightType);
+          return rightType;
         }
       case 27 /* CommaToken */:
         if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isIndirectCall(left.parent)) {
@@ -74812,6 +74865,9 @@ function createTypeChecker(host) {
         case 273 /* ImportSpecifier */:
         case 79 /* Identifier */:
           return 1 /* ExportValue */;
+        case 170 /* MethodSignature */:
+        case 168 /* PropertySignature */:
+          return 2 /* ExportType */;
         default:
           return Debug.failBadSyntaxKind(d);
       }
@@ -74835,7 +74891,7 @@ function createTypeChecker(host) {
     ))) {
       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");
@@ -74887,7 +74943,7 @@ function createTypeChecker(host) {
     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");
@@ -74936,7 +74992,7 @@ function createTypeChecker(host) {
         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) {
@@ -79195,6 +79251,8 @@ function createTypeChecker(host) {
     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) {
@@ -79202,6 +79260,7 @@ function createTypeChecker(host) {
     if (links.deferredNodes) {
       links.deferredNodes.forEach(checkDeferredNode);
     }
+    links.deferredNodes = void 0;
   }
   function checkDeferredNode(node) {
     var _a2, _b;
@@ -80282,7 +80341,7 @@ function createTypeChecker(host) {
     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 */;
@@ -80314,7 +80373,7 @@ function createTypeChecker(host) {
       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 */,
@@ -80465,7 +80524,7 @@ function createTypeChecker(host) {
     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,
@@ -82026,7 +82085,7 @@ function createTypeChecker(host) {
   }
   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) {
@@ -82428,10 +82487,10 @@ function createTypeChecker(host) {
   }
   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;
@@ -82449,7 +82508,7 @@ function createTypeChecker(host) {
   }
   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;
       }
@@ -87027,7 +87086,7 @@ function transformTypeScript(context) {
     return node;
   }
   function tryGetConstEnumValue(node) {
-    if (compilerOptions.isolatedModules) {
+    if (getIsolatedModules(compilerOptions)) {
       return void 0;
     }
     return isPropertyAccessExpression(node) || isElementAccessExpression(node) ? resolver.getConstantValue(node) : void 0;
@@ -103357,7 +103416,7 @@ function transformECMAScriptModule(context) {
     if (node.isDeclarationFile) {
       return node;
     }
-    if (isExternalModule(node) || compilerOptions.isolatedModules) {
+    if (isExternalModule(node) || getIsolatedModules(compilerOptions)) {
       currentSourceFile = node;
       importRequireStatements = void 0;
       let result = updateExternalModule(node);
@@ -103564,7 +103623,7 @@ function transformECMAScriptModule(context) {
   }
   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);
@@ -114158,7 +114217,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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)];
       }
@@ -114879,12 +114938,12 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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) {
@@ -116291,7 +116350,7 @@ var BuilderState;
       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();
@@ -116704,7 +116763,7 @@ function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile
     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);