typescript 4.8.0-dev.20220704 → 4.8.0-dev.20220707

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220704";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220707";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -2774,6 +2774,22 @@ var ts;
             return formatEnum(flags, ts.FlowFlags, /*isFlags*/ true);
         }
         Debug.formatFlowFlags = formatFlowFlags;
+        function formatRelationComparisonResult(result) {
+            return formatEnum(result, ts.RelationComparisonResult, /*isFlags*/ true);
+        }
+        Debug.formatRelationComparisonResult = formatRelationComparisonResult;
+        function formatCheckMode(mode) {
+            return formatEnum(mode, ts.CheckMode, /*isFlags*/ true);
+        }
+        Debug.formatCheckMode = formatCheckMode;
+        function formatSignatureCheckMode(mode) {
+            return formatEnum(mode, ts.SignatureCheckMode, /*isFlags*/ true);
+        }
+        Debug.formatSignatureCheckMode = formatSignatureCheckMode;
+        function formatTypeFacts(facts) {
+            return formatEnum(facts, ts.TypeFacts, /*isFlags*/ true);
+        }
+        Debug.formatTypeFacts = formatTypeFacts;
         var isDebugInfoEnabled = false;
         var extendedDebugModule;
         function extendedDebug() {
@@ -4726,6 +4742,7 @@ var ts;
         NodeBuilderFlags[NodeBuilderFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
         NodeBuilderFlags[NodeBuilderFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
         NodeBuilderFlags[NodeBuilderFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction";
+        NodeBuilderFlags[NodeBuilderFlags["OmitThisParameter"] = 33554432] = "OmitThisParameter";
         // Error handling
         NodeBuilderFlags[NodeBuilderFlags["AllowThisInObjectLiteral"] = 32768] = "AllowThisInObjectLiteral";
         NodeBuilderFlags[NodeBuilderFlags["AllowQualifiedNameInPlaceOfIdentifier"] = 65536] = "AllowQualifiedNameInPlaceOfIdentifier";
@@ -4766,6 +4783,7 @@ var ts;
         TypeFormatFlags[TypeFormatFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
         TypeFormatFlags[TypeFormatFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
         TypeFormatFlags[TypeFormatFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction";
+        TypeFormatFlags[TypeFormatFlags["OmitThisParameter"] = 33554432] = "OmitThisParameter";
         // Error Handling
         TypeFormatFlags[TypeFormatFlags["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
         // TypeFormatFlags exclusive
@@ -4777,7 +4795,7 @@ var ts;
         TypeFormatFlags[TypeFormatFlags["InFirstTypeArgument"] = 4194304] = "InFirstTypeArgument";
         TypeFormatFlags[TypeFormatFlags["InTypeAlias"] = 8388608] = "InTypeAlias";
         /** @deprecated */ TypeFormatFlags[TypeFormatFlags["WriteOwnNameForAnyLike"] = 0] = "WriteOwnNameForAnyLike";
-        TypeFormatFlags[TypeFormatFlags["NodeBuilderFlagsMask"] = 814775659] = "NodeBuilderFlagsMask";
+        TypeFormatFlags[TypeFormatFlags["NodeBuilderFlagsMask"] = 848330091] = "NodeBuilderFlagsMask";
     })(TypeFormatFlags = ts.TypeFormatFlags || (ts.TypeFormatFlags = {}));
     var SymbolFormatFlags;
     (function (SymbolFormatFlags) {
@@ -19509,7 +19527,8 @@ var ts;
     function getDeclarationModifierFlagsFromSymbol(s, isWrite) {
         if (isWrite === void 0) { isWrite = false; }
         if (s.valueDeclaration) {
-            var declaration = (isWrite && s.declarations && ts.find(s.declarations, function (d) { return d.kind === 173 /* SetAccessor */; })) || s.valueDeclaration;
+            var declaration = (isWrite && s.declarations && ts.find(s.declarations, ts.isSetAccessorDeclaration))
+                || (s.flags & 32768 /* GetAccessor */ && ts.find(s.declarations, ts.isGetAccessorDeclaration)) || s.valueDeclaration;
             var flags = ts.getCombinedModifierFlags(declaration);
             return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~28 /* AccessibilityModifier */;
         }
@@ -20184,7 +20203,7 @@ var ts;
         // Excludes declaration files - they still require an explicit `export {}` or the like
         // for back compat purposes. The only non-declaration files _not_ forced to be a module are `.js` files
         // that aren't esm-mode (meaning not in a `type: module` scope).
-        return (file.impliedNodeFormat === ts.ModuleKind.ESNext || (ts.fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */]))) && !file.isDeclarationFile ? true : undefined;
+        return (file.impliedNodeFormat === ts.ModuleKind.ESNext || (ts.fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */, ".mjs" /* Mjs */, ".mts" /* Mts */]))) && !file.isDeclarationFile ? true : undefined;
     }
     function getSetExternalModuleIndicator(options) {
         // TODO: Should this callback be cached?
@@ -20207,10 +20226,7 @@ var ts;
                 if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
                     checks.push(isFileModuleFromUsingJSXTag);
                 }
-                var moduleKind = getEmitModuleKind(options);
-                if (moduleKind === ts.ModuleKind.Node16 || moduleKind === ts.ModuleKind.NodeNext) {
-                    checks.push(isFileForcedToBeModuleByFormat);
-                }
+                checks.push(isFileForcedToBeModuleByFormat);
                 var combined_1 = ts.or.apply(void 0, checks);
                 var callback = function (file) { return void (file.externalModuleIndicator = combined_1(file)); };
                 return callback;
@@ -33930,10 +33946,10 @@ var ts;
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiers();
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 172 /* GetAccessor */, 4 /* Type */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 173 /* SetAccessor */, 4 /* Type */);
             }
             if (isIndexSignature()) {
                 return parseIndexSignatureDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers);
@@ -35979,10 +35995,10 @@ var ts;
             var decorators = parseDecorators();
             var modifiers = parseModifiers();
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */, 0 /* None */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */, 0 /* None */);
             }
             var asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
             var tokenIsIdentifier = isIdentifier();
@@ -36674,9 +36690,15 @@ var ts;
             return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() === 10 /* StringLiteral */);
         }
         function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) {
-            if (token() !== 18 /* OpenBraceToken */ && canParseSemicolon()) {
-                parseSemicolon();
-                return;
+            if (token() !== 18 /* OpenBraceToken */) {
+                if (flags & 4 /* Type */) {
+                    parseTypeMemberSemicolon();
+                    return;
+                }
+                if (canParseSemicolon()) {
+                    parseSemicolon();
+                    return;
+                }
             }
             return parseFunctionBlock(flags, diagnosticMessage);
         }
@@ -36880,12 +36902,12 @@ var ts;
             }
             return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken);
         }
-        function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind) {
+        function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind, flags) {
             var name = parsePropertyName();
             var typeParameters = parseTypeParameters();
             var parameters = parseParameters(0 /* None */);
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
-            var body = parseFunctionBlockOrSemicolon(0 /* None */);
+            var body = parseFunctionBlockOrSemicolon(flags);
             var node = kind === 172 /* GetAccessor */
                 ? factory.createGetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, type, body)
                 : factory.createSetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, body);
@@ -37072,10 +37094,10 @@ var ts;
                 return parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers);
             }
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */, 0 /* None */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */, 0 /* None */);
             }
             if (token() === 134 /* ConstructorKeyword */ || token() === 10 /* StringLiteral */) {
                 var constructorDeclaration = tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers);
@@ -48479,7 +48501,7 @@ var ts;
         // Masks
         TypeFacts[TypeFacts["OrFactsMask"] = 8256] = "OrFactsMask";
         TypeFacts[TypeFacts["AndFactsMask"] = 134209471] = "AndFactsMask";
-    })(TypeFacts || (TypeFacts = {}));
+    })(TypeFacts = ts.TypeFacts || (ts.TypeFacts = {}));
     var typeofNEFacts = new ts.Map(ts.getEntries({
         string: 256 /* TypeofNEString */,
         number: 512 /* TypeofNENumber */,
@@ -48514,7 +48536,7 @@ var ts;
         CheckMode[CheckMode["RestBindingElement"] = 64] = "RestBindingElement";
         //   e.g. in `const { a, ...rest } = foo`, when checking the type of `foo` to determine the type of `rest`,
         //   we need to preserve generic types instead of substituting them for constraints
-    })(CheckMode || (CheckMode = {}));
+    })(CheckMode = ts.CheckMode || (ts.CheckMode = {}));
     var SignatureCheckMode;
     (function (SignatureCheckMode) {
         SignatureCheckMode[SignatureCheckMode["BivariantCallback"] = 1] = "BivariantCallback";
@@ -48522,7 +48544,7 @@ var ts;
         SignatureCheckMode[SignatureCheckMode["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
         SignatureCheckMode[SignatureCheckMode["StrictArity"] = 8] = "StrictArity";
         SignatureCheckMode[SignatureCheckMode["Callback"] = 3] = "Callback";
-    })(SignatureCheckMode || (SignatureCheckMode = {}));
+    })(SignatureCheckMode = ts.SignatureCheckMode || (ts.SignatureCheckMode = {}));
     var IntersectionState;
     (function (IntersectionState) {
         IntersectionState[IntersectionState["None"] = 0] = "None";
@@ -48874,7 +48896,7 @@ var ts;
             },
             getContextualTypeForObjectLiteralElement: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike);
-                return node ? getContextualTypeForObjectLiteralElement(node) : undefined;
+                return node ? getContextualTypeForObjectLiteralElement(node, /*contextFlags*/ undefined) : undefined;
             },
             getContextualTypeForArgumentAtIndex: function (nodeIn, argIndex) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -48882,7 +48904,7 @@ var ts;
             },
             getContextualTypeForJsxAttribute: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isJsxAttributeLike);
-                return node && getContextualTypeForJsxAttribute(node);
+                return node && getContextualTypeForJsxAttribute(node, /*contextFlags*/ undefined);
             },
             isContextSensitive: isContextSensitive,
             getTypeOfPropertyOfContextualType: getTypeOfPropertyOfContextualType,
@@ -49088,6 +49110,7 @@ var ts;
         var stringMappingTypes = new ts.Map();
         var substitutionTypes = new ts.Map();
         var subtypeReductionCache = new ts.Map();
+        var cachedTypes = new ts.Map();
         var evolvingArrayTypes = [];
         var undefinedProperties = new ts.Map();
         var markerTypes = new ts.Set();
@@ -49341,6 +49364,14 @@ var ts;
         ];
         initializeTypeChecker();
         return checker;
+        function getCachedType(key) {
+            return key ? cachedTypes.get(key) : undefined;
+        }
+        function setCachedType(key, type) {
+            if (key)
+                cachedTypes.set(key, type);
+            return type;
+        }
         function getJsxNamespace(location) {
             if (location) {
                 var file = ts.getSourceFileOfNode(location);
@@ -52596,13 +52627,25 @@ var ts;
                         && isDeclarationVisible(declaration.parent)) {
                         return addVisibleAlias(declaration, declaration);
                     }
-                    else if (symbol.flags & 2097152 /* Alias */ && ts.isBindingElement(declaration) && ts.isInJSFile(declaration) && ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.parent) // exported import-like top-level JS require statement
-                        && ts.isVariableDeclaration(declaration.parent.parent)
-                        && ((_b = declaration.parent.parent.parent) === null || _b === void 0 ? void 0 : _b.parent) && ts.isVariableStatement(declaration.parent.parent.parent.parent)
-                        && !ts.hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */)
-                        && declaration.parent.parent.parent.parent.parent // check if the thing containing the variable statement is visible (ie, the file)
-                        && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
-                        return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
+                    else if (ts.isBindingElement(declaration)) {
+                        if (symbol.flags & 2097152 /* Alias */ && ts.isInJSFile(declaration) && ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.parent) // exported import-like top-level JS require statement
+                            && ts.isVariableDeclaration(declaration.parent.parent)
+                            && ((_b = declaration.parent.parent.parent) === null || _b === void 0 ? void 0 : _b.parent) && ts.isVariableStatement(declaration.parent.parent.parent.parent)
+                            && !ts.hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */)
+                            && declaration.parent.parent.parent.parent.parent // check if the thing containing the variable statement is visible (ie, the file)
+                            && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
+                            return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
+                        }
+                        else if (symbol.flags & 2 /* BlockScopedVariable */) {
+                            var variableStatement = ts.findAncestor(declaration, ts.isVariableStatement);
+                            if (ts.hasSyntacticModifier(variableStatement, 1 /* Export */)) {
+                                return true;
+                            }
+                            if (!isDeclarationVisible(variableStatement.parent)) {
+                                return false;
+                            }
+                            return addVisibleAlias(declaration, variableStatement);
+                        }
                     }
                     // Declaration is not visible
                     return false;
@@ -52735,7 +52778,7 @@ var ts;
         }
         function toNodeBuilderFlags(flags) {
             if (flags === void 0) { flags = 0 /* None */; }
-            return flags & 814775659 /* NodeBuilderFlagsMask */;
+            return flags & 848330091 /* NodeBuilderFlagsMask */;
         }
         function isClassInstanceSide(type) {
             return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* Object */) && !!(ts.getObjectFlags(type) & 16777216 /* IsClassInstanceClone */)));
@@ -53123,6 +53166,10 @@ var ts;
                     }
                     return typeToTypeNodeHelper(type, context);
                 }
+                function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) {
+                    return isMappedTypeWithKeyofConstraintDeclaration(type)
+                        && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */);
+                }
                 function createMappedTypeNodeFromType(type) {
                     ts.Debug.assert(!!(type.flags & 524288 /* Object */));
                     var readonlyToken = type.declaration.readonlyToken ? ts.factory.createToken(type.declaration.readonlyToken.kind) : undefined;
@@ -53132,7 +53179,7 @@ var ts;
                     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
                         // We have a { [P in keyof T]: X }
                         // We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType`
-                        if (!(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                        if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
                             var newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
                             var name = typeParameterToName(newParam, context);
                             newTypeVariable = ts.factory.createTypeReferenceNode(name);
@@ -53148,11 +53195,12 @@ var ts;
                     var mappedTypeNode = ts.factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, /*members*/ undefined);
                     context.approximateLength += 10;
                     var result = ts.setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
-                    if (isMappedTypeWithKeyofConstraintDeclaration(type) && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                    if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
                         // homomorphic mapped type with a non-homomorphic naive inlining
                         // wrap it with a conditional like `SomeModifiersType extends infer U ? {..the mapped type...} : never` to ensure the resulting
                         // type stays homomorphic
-                        return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName))), result, ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
+                        var originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(type.declaration.typeParameter.constraint.type)) || unknownType, type.mapper);
+                        return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName), originalConstraint.flags & 2 /* Unknown */ ? undefined : typeToTypeNodeHelper(originalConstraint, context))), result, ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
                     }
                     return result;
                 }
@@ -53714,7 +53762,7 @@ var ts;
                 var expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768 /* RestParameter */); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 171 /* Constructor */, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
-                var thisParameter = tryGetThisParameterDeclaration(signature, context);
+                var thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? undefined : tryGetThisParameterDeclaration(signature, context);
                 if (thisParameter) {
                     parameters.unshift(thisParameter);
                 }
@@ -54773,12 +54821,11 @@ var ts;
                     if (skipMembershipCheck || (!!ts.length(symbol.declarations) && ts.some(symbol.declarations, function (d) { return !!ts.findAncestor(d, function (n) { return n === enclosingDeclaration; }); }))) {
                         var oldContext = context;
                         context = cloneNodeBuilderContext(context);
-                        var result = serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
+                        serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
                         if (context.reportedDiagnostic) {
                             oldcontext.reportedDiagnostic = context.reportedDiagnostic; // hoist diagnostic result into outer context
                         }
                         context = oldContext;
-                        return result;
                     }
                 }
                 // Synthesize declarations for a symbol - might be an Interface, a Class, a Namespace, a Type, a Variable (const, let, or var), an Alias
@@ -57835,7 +57882,7 @@ var ts;
                         error(declaration.typeExpression.type, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
                     }
                     else {
-                        error(ts.isNamedDeclaration(declaration) ? declaration.name : declaration || declaration, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
+                        error(ts.isNamedDeclaration(declaration) ? declaration.name || declaration : declaration, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
                     }
                 }
                 links.declaredType = type;
@@ -66103,13 +66150,20 @@ var ts;
                 return result;
             }
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
+                var saveErrorInfo = captureErrorCalculationState();
+                var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo);
+                if (result) {
+                    resetErrorInfo(saveErrorInfo);
+                }
+                return result;
+            }
+            function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo) {
                 if (intersectionState & 4 /* PropertyCheck */) {
                     return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* None */);
                 }
                 var result;
                 var originalErrorInfo;
                 var varianceCheckFailed = false;
-                var saveErrorInfo = captureErrorCalculationState();
                 var sourceFlags = source.flags;
                 var targetFlags = target.flags;
                 if (relation === identityRelation) {
@@ -66173,7 +66227,6 @@ var ts;
                         if (constraint && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
                             // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
                             if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66298,7 +66351,6 @@ var ts;
                             result &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, reportErrors);
                         }
                         if (result) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         if (reportErrors) {
@@ -66401,7 +66453,6 @@ var ts;
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(target, targetStack, targetDepth, 10)) {
-                        resetErrorInfo(saveErrorInfo);
                         return 3 /* Maybe */;
                     }
                     var c = target;
@@ -66416,7 +66467,6 @@ var ts;
                         if (result = skipTrue ? -1 /* True */ : isRelatedTo(source, getTrueTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false)) {
                             result &= skipFalse ? -1 /* True */ : isRelatedTo(source, getFalseTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false);
                             if (result) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66448,12 +66498,10 @@ var ts;
                         var constraint = getConstraintOfType(source) || unknownType;
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
                         if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
                         else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && constraint !== unknownType && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         if (isMappedTypeGenericIndexedAccess(source)) {
@@ -66462,7 +66510,6 @@ var ts;
                             var indexConstraint = getConstraintOfType(source.indexType);
                             if (indexConstraint) {
                                 if (result = isRelatedTo(getIndexedAccessType(source.objectType, indexConstraint), target, 1 /* Source */, reportErrors)) {
-                                    resetErrorInfo(saveErrorInfo);
                                     return result;
                                 }
                             }
@@ -66471,7 +66518,6 @@ var ts;
                 }
                 else if (sourceFlags & 4194304 /* Index */) {
                     if (result = isRelatedTo(keyofConstraintType, target, 1 /* Source */, reportErrors)) {
-                        resetErrorInfo(saveErrorInfo);
                         return result;
                     }
                 }
@@ -66479,7 +66525,6 @@ var ts;
                     if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
                         var constraint = getBaseConstraintOfType(source);
                         if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66490,14 +66535,12 @@ var ts;
                             return 0 /* False */;
                         }
                         if (result = isRelatedTo(source.type, target.type, 3 /* Both */, reportErrors)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
                     else {
                         var constraint = getBaseConstraintOfType(source);
                         if (constraint && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66506,7 +66549,6 @@ var ts;
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(source, sourceStack, sourceDepth, 10)) {
-                        resetErrorInfo(saveErrorInfo);
                         return 3 /* Maybe */;
                     }
                     if (targetFlags & 16777216 /* Conditional */) {
@@ -66529,7 +66571,6 @@ var ts;
                                 result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, reportErrors);
                             }
                             if (result) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66540,7 +66581,6 @@ var ts;
                         var distributiveConstraint = hasNonCircularBaseConstraint(source) ? getConstraintOfDistributiveConditionalType(source) : undefined;
                         if (distributiveConstraint) {
                             if (result = isRelatedTo(distributiveConstraint, target, 1 /* Source */, reportErrors)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66550,7 +66590,6 @@ var ts;
                     var defaultConstraint = getDefaultConstraintOfConditionalType(source);
                     if (defaultConstraint) {
                         if (result = isRelatedTo(defaultConstraint, target, 1 /* Source */, reportErrors)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66563,7 +66602,6 @@ var ts;
                     if (isGenericMappedType(target)) {
                         if (isGenericMappedType(source)) {
                             if (result = mappedTypeRelatedTo(source, target, reportErrors)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -68018,9 +68056,14 @@ var ts;
                     type.flags & 256 /* NumberLiteral */ ? numberType :
                         type.flags & 2048 /* BigIntLiteral */ ? bigintType :
                             type.flags & 512 /* BooleanLiteral */ ? booleanType :
-                                type.flags & 1048576 /* Union */ ? mapType(type, getBaseTypeOfLiteralType) :
+                                type.flags & 1048576 /* Union */ ? getBaseTypeOfLiteralTypeUnion(type) :
                                     type;
         }
+        function getBaseTypeOfLiteralTypeUnion(type) {
+            var _a;
+            var key = "B" + getTypeId(type);
+            return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, mapType(type, getBaseTypeOfLiteralType));
+        }
         function getWidenedLiteralType(type) {
             return type.flags & 1024 /* EnumLiteral */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) :
                 type.flags & 128 /* StringLiteral */ && isFreshLiteralType(type) ? stringType :
@@ -70163,23 +70206,25 @@ var ts;
         // For example, when a variable of type number | string | boolean is assigned a value of type number | boolean,
         // we remove type string.
         function getAssignmentReducedType(declaredType, assignedType) {
-            if (declaredType !== assignedType) {
-                if (assignedType.flags & 131072 /* Never */) {
-                    return assignedType;
-                }
-                var reducedType = filterType(declaredType, function (t) { return typeMaybeAssignableTo(assignedType, t); });
-                if (assignedType.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(assignedType)) {
-                    reducedType = mapType(reducedType, getFreshTypeOfLiteralType); // Ensure that if the assignment is a fresh type, that we narrow to fresh types
-                }
-                // Our crude heuristic produces an invalid result in some cases: see GH#26130.
-                // For now, when that happens, we give up and don't narrow at all.  (This also
-                // means we'll never narrow for erroneous assignments where the assigned type
-                // is not assignable to the declared type.)
-                if (isTypeAssignableTo(assignedType, reducedType)) {
-                    return reducedType;
-                }
+            var _a;
+            if (declaredType === assignedType) {
+                return declaredType;
             }
-            return declaredType;
+            if (assignedType.flags & 131072 /* Never */) {
+                return assignedType;
+            }
+            var key = "A" + getTypeId(declaredType) + "," + getTypeId(assignedType);
+            return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, getAssignmentReducedTypeWorker(declaredType, assignedType));
+        }
+        function getAssignmentReducedTypeWorker(declaredType, assignedType) {
+            var filteredType = filterType(declaredType, function (t) { return typeMaybeAssignableTo(assignedType, t); });
+            // Ensure that we narrow to fresh types if the assignment is a fresh boolean literal type.
+            var reducedType = assignedType.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(assignedType) ? mapType(filteredType, getFreshTypeOfLiteralType) : filteredType;
+            // Our crude heuristic produces an invalid result in some cases: see GH#26130.
+            // For now, when that happens, we give up and don't narrow at all.  (This also
+            // means we'll never narrow for erroneous assignments where the assigned type
+            // is not assignable to the declared type.)
+            return isTypeAssignableTo(assignedType, reducedType) ? reducedType : declaredType;
         }
         function isFunctionObjectType(type) {
             // We do a quick check for a "bind" property before performing the more expensive subtype
@@ -71585,7 +71630,7 @@ var ts;
                 var targetType = ts.hasStaticModifier(ts.Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration"))
                     ? getTypeOfSymbol(classSymbol)
                     : getDeclaredTypeOfSymbol(classSymbol);
-                return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom);
+                return getNarrowedType(type, targetType, assumeTrue, /*checkDerived*/ true);
             }
             function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) {
                 // We are in a branch of obj?.foo === value (or any one of the other equality operators). We narrow obj as follows:
@@ -71836,9 +71881,15 @@ var ts;
                     if (!nonConstructorTypeInUnion)
                         return type;
                 }
-                return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom);
+                return getNarrowedType(type, targetType, assumeTrue, /*checkDerived*/ true);
+            }
+            function getNarrowedType(type, candidate, assumeTrue, checkDerived) {
+                var _a;
+                var key = type.flags & 1048576 /* Union */ ? "N" + getTypeId(type) + "," + getTypeId(candidate) + "," + ((assumeTrue ? 1 : 0) | (checkDerived ? 2 : 0)) : undefined;
+                return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived));
             }
-            function getNarrowedType(type, candidate, assumeTrue, isRelated) {
+            function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) {
+                var isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
                 if (!assumeTrue) {
                     return filterType(type, function (t) { return !isRelated(t, candidate); });
                 }
@@ -71886,7 +71937,7 @@ var ts;
                     var predicateArgument = getTypePredicateArgument(predicate, callExpression);
                     if (predicateArgument) {
                         if (isMatchingReference(reference, predicateArgument)) {
-                            return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);
+                            return getNarrowedType(type, predicate.type, assumeTrue, /*checkDerived*/ false);
                         }
                         if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) &&
                             !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
@@ -71894,7 +71945,7 @@ var ts;
                         }
                         var access = getDiscriminantPropertyAccess(predicateArgument, type);
                         if (access) {
-                            return narrowTypeByDiscriminant(type, access, function (t) { return getNarrowedType(t, predicate.type, assumeTrue, isTypeSubtypeOf); });
+                            return narrowTypeByDiscriminant(type, access, function (t) { return getNarrowedType(t, predicate.type, assumeTrue, /*checkDerived*/ false); });
                         }
                     }
                 }
@@ -72071,7 +72122,7 @@ var ts;
                 !((ts.isJsxOpeningElement(node.parent) || ts.isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) &&
                 (checkMode && checkMode & 64 /* RestBindingElement */ ?
                     getContextualType(node, 8 /* SkipBindingPatterns */)
-                    : getContextualType(node));
+                    : getContextualType(node, /*contextFlags*/ undefined));
             return contextualType && !isGenericType(contextualType);
         }
         function getNarrowableTypeForReference(type, reference, checkMode) {
@@ -72233,9 +72284,7 @@ var ts;
                 getNodeLinks(container).flags |= 8192 /* CaptureArguments */;
                 return getTypeOfSymbol(symbol);
             }
-            // We should only mark aliases as referenced if there isn't a local value declaration
-            // for the symbol. Also, don't mark any property access expression LHS - checkPropertyAccessExpression will handle that
-            if (!(node.parent && ts.isPropertyAccessExpression(node.parent) && node.parent.expression === node)) {
+            if (shouldMarkIdentifierAliasReferenced(node)) {
                 markAliasReferenced(symbol, node);
             }
             var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
@@ -72369,6 +72418,25 @@ var ts;
             }
             return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
         }
+        function shouldMarkIdentifierAliasReferenced(node) {
+            var _a;
+            var parent = node.parent;
+            if (parent) {
+                // A property access expression LHS? checkPropertyAccessExpression will handle that.
+                if (ts.isPropertyAccessExpression(parent) && parent.expression === node) {
+                    return false;
+                }
+                // Next two check for an identifier inside a type only export.
+                if (ts.isExportSpecifier(parent) && parent.isTypeOnly) {
+                    return false;
+                }
+                var greatGrandparent = (_a = parent.parent) === null || _a === void 0 ? void 0 : _a.parent;
+                if (greatGrandparent && ts.isExportDeclaration(greatGrandparent) && greatGrandparent.isTypeOnly) {
+                    return false;
+                }
+            }
+            return true;
+        }
         function isInsideFunctionOrInstancePropertyInitializer(node, threshold) {
             return !!ts.findAncestor(node, function (n) { return n === threshold ? "quit" : ts.isFunctionLike(n) || (n.parent && ts.isPropertyDeclaration(n.parent) && !ts.hasStaticModifier(n.parent) && n.parent.initializer === n); });
         }
@@ -72918,7 +72986,7 @@ var ts;
                     // We have an object literal method. Check if the containing object literal has a contextual type
                     // that includes a ThisType<T>. If so, T is the contextual type for 'this'. We continue looking in
                     // any directly enclosing object literals.
-                    var contextualType = getApparentTypeOfContextualType(containingLiteral);
+                    var contextualType = getApparentTypeOfContextualType(containingLiteral, /*contextFlags*/ undefined);
                     var literal = containingLiteral;
                     var type = contextualType;
                     while (type) {
@@ -72930,7 +72998,7 @@ var ts;
                             break;
                         }
                         literal = literal.parent.parent;
-                        type = getApparentTypeOfContextualType(literal);
+                        type = getApparentTypeOfContextualType(literal, /*contextFlags*/ undefined);
                     }
                     // There was no contextual ThisType<T> for the containing object literal, so the contextual type
                     // for 'this' is the non-null form of the contextual type for the containing object literal or
@@ -72987,7 +73055,7 @@ var ts;
                     tryGetTypeAtPosition(contextualSignature, index);
             }
         }
-        function getContextualTypeForVariableLikeDeclaration(declaration) {
+        function getContextualTypeForVariableLikeDeclaration(declaration, contextFlags) {
             var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
             if (typeNode) {
                 return getTypeFromTypeNode(typeNode);
@@ -72996,18 +73064,18 @@ var ts;
                 case 164 /* Parameter */:
                     return getContextuallyTypedParameterType(declaration);
                 case 203 /* BindingElement */:
-                    return getContextualTypeForBindingElement(declaration);
+                    return getContextualTypeForBindingElement(declaration, contextFlags);
                 case 167 /* PropertyDeclaration */:
                     if (ts.isStatic(declaration)) {
-                        return getContextualTypeForStaticPropertyDeclaration(declaration);
+                        return getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags);
                     }
                 // By default, do nothing and return undefined - only the above cases have context implied by a parent
             }
         }
-        function getContextualTypeForBindingElement(declaration) {
+        function getContextualTypeForBindingElement(declaration, contextFlags) {
             var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
-            var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
+            var parentType = getContextualTypeForVariableLikeDeclaration(parent, contextFlags) ||
                 parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
             if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
                 return undefined;
@@ -73023,8 +73091,8 @@ var ts;
                 return getTypeOfPropertyOfType(parentType, text);
             }
         }
-        function getContextualTypeForStaticPropertyDeclaration(declaration) {
-            var parentType = ts.isExpression(declaration.parent) && getContextualType(declaration.parent);
+        function getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags) {
+            var parentType = ts.isExpression(declaration.parent) && getContextualType(declaration.parent, contextFlags);
             if (!parentType)
                 return undefined;
             return getTypeOfPropertyOfContextualType(parentType, getSymbolOfNode(declaration).escapedName);
@@ -73040,7 +73108,7 @@ var ts;
         function getContextualTypeForInitializerExpression(node, contextFlags) {
             var declaration = node.parent;
             if (ts.hasInitializer(declaration) && node === declaration.initializer) {
-                var result = getContextualTypeForVariableLikeDeclaration(declaration);
+                var result = getContextualTypeForVariableLikeDeclaration(declaration, contextFlags);
                 if (result) {
                     return result;
                 }
@@ -73050,10 +73118,10 @@ var ts;
             }
             return undefined;
         }
-        function getContextualTypeForReturnExpression(node) {
+        function getContextualTypeForReturnExpression(node, contextFlags) {
             var func = ts.getContainingFunction(node);
             if (func) {
-                var contextualReturnType = getContextualReturnType(func);
+                var contextualReturnType = getContextualReturnType(func, contextFlags);
                 if (contextualReturnType) {
                     var functionFlags = ts.getFunctionFlags(func);
                     if (functionFlags & 1 /* Generator */) { // Generator or AsyncGenerator function
@@ -73083,11 +73151,11 @@ var ts;
             }
             return undefined;
         }
-        function getContextualTypeForYieldOperand(node) {
+        function getContextualTypeForYieldOperand(node, contextFlags) {
             var func = ts.getContainingFunction(node);
             if (func) {
                 var functionFlags = ts.getFunctionFlags(func);
-                var contextualReturnType = getContextualReturnType(func);
+                var contextualReturnType = getContextualReturnType(func, contextFlags);
                 if (contextualReturnType) {
                     return node.asteriskToken
                         ? contextualReturnType
@@ -73111,14 +73179,14 @@ var ts;
         }
         function getContextualIterationType(kind, functionDecl) {
             var isAsync = !!(ts.getFunctionFlags(functionDecl) & 2 /* Async */);
-            var contextualReturnType = getContextualReturnType(functionDecl);
+            var contextualReturnType = getContextualReturnType(functionDecl, /*contextFlags*/ undefined);
             if (contextualReturnType) {
                 return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync)
                     || undefined;
             }
             return undefined;
         }
-        function getContextualReturnType(functionDecl) {
+        function getContextualReturnType(functionDecl, contextFlags) {
             // If the containing function has a return type annotation, is a constructor, or is a get accessor whose
             // corresponding set accessor has a type annotation, return statements in the function are contextually typed
             var returnType = getReturnTypeFromAnnotation(functionDecl);
@@ -73133,7 +73201,7 @@ var ts;
             }
             var iife = ts.getImmediatelyInvokedFunctionExpression(functionDecl);
             if (iife) {
-                return getContextualType(iife);
+                return getContextualType(iife, contextFlags);
             }
             return undefined;
         }
@@ -73386,7 +73454,7 @@ var ts;
         }
         function getContextualTypeForObjectLiteralElement(element, contextFlags) {
             var objectLiteral = element.parent;
-            var propertyAssignmentType = ts.isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element);
+            var propertyAssignmentType = ts.isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element, contextFlags);
             if (propertyAssignmentType) {
                 return propertyAssignmentType;
             }
@@ -73581,9 +73649,9 @@ var ts;
                     return getContextualTypeForInitializerExpression(node, contextFlags);
                 case 214 /* ArrowFunction */:
                 case 247 /* ReturnStatement */:
-                    return getContextualTypeForReturnExpression(node);
+                    return getContextualTypeForReturnExpression(node, contextFlags);
                 case 224 /* YieldExpression */:
-                    return getContextualTypeForYieldOperand(parent);
+                    return getContextualTypeForYieldOperand(parent, contextFlags);
                 case 218 /* AwaitExpression */:
                     return getContextualTypeForAwaitOperand(parent, contextFlags);
                 case 208 /* CallExpression */:
@@ -73631,7 +73699,7 @@ var ts;
             }
             return undefined;
             function tryFindWhenConstTypeReference(node) {
-                return getContextualType(node);
+                return getContextualType(node, contextFlags);
             }
         }
         function getInferenceContext(node) {
@@ -73933,7 +74001,7 @@ var ts;
             var elementCount = elements.length;
             var elementTypes = [];
             var elementFlags = [];
-            var contextualType = getApparentTypeOfContextualType(node);
+            var contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined);
             var inDestructuringPattern = ts.isAssignmentTarget(node);
             var inConstContext = isConstContext(node);
             var hasOmittedExpression = false;
@@ -74104,7 +74172,7 @@ var ts;
             var propertiesTable = ts.createSymbolTable();
             var propertiesArray = [];
             var spread = emptyObjectType;
-            var contextualType = getApparentTypeOfContextualType(node);
+            var contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined);
             var contextualTypeHasPattern = contextualType && contextualType.pattern &&
                 (contextualType.pattern.kind === 201 /* ObjectBindingPattern */ || contextualType.pattern.kind === 205 /* ObjectLiteralExpression */);
             var inConstContext = isConstContext(node);
@@ -74443,7 +74511,7 @@ var ts;
                     if (explicitlySpecifyChildrenAttribute) {
                         error(attributes, ts.Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName));
                     }
-                    var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes);
+                    var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes, /*contextFlags*/ undefined);
                     var childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName);
                     // If there are children in the body of JSX element, create dummy attribute "children" with the union of children types so that it will pass the attribute checking process
                     var childrenPropSymbol = createSymbol(4 /* Property */, jsxChildrenPropertyName);
@@ -76906,7 +76974,7 @@ var ts;
                         argCheckMode = checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
                         if (inferenceContext) {
                             var typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
-                            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
+                            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
                             // If the original signature has a generic rest type, instantiation may produce a
                             // signature with different arity and we need to perform another arity check.
                             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
@@ -78283,17 +78351,6 @@ var ts;
                     }
                 }
             }
-            var restType = getEffectiveRestType(context);
-            if (restType && restType.flags & 262144 /* TypeParameter */) {
-                // The contextual signature has a generic rest parameter. We first instantiate the contextual
-                // signature (without fixing type parameters) and assign types to contextually typed parameters.
-                var instantiatedContext = instantiateSignature(context, inferenceContext.nonFixingMapper);
-                assignContextualParameterTypes(signature, instantiatedContext);
-                // We then infer from a tuple type representing the parameters that correspond to the contextual
-                // rest parameter.
-                var restPos = getParameterCount(context) - 1;
-                inferTypes(inferenceContext.inferences, getRestTypeAtPosition(signature, restPos), restType);
-            }
         }
         function assignContextualParameterTypes(signature, context) {
             if (context.typeParameters) {
@@ -78486,7 +78543,7 @@ var ts;
                     var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
                     var contextualType = !contextualSignature ? undefined :
                         contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType :
-                            instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func);
+                            instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func, /*contextFlags*/ undefined);
                     if (isGenerator) {
                         yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0 /* Yield */, isAsync);
                         returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1 /* Return */, isAsync);
@@ -78557,7 +78614,7 @@ var ts;
                     nextType = iterationTypes && iterationTypes.nextType;
                 }
                 else {
-                    nextType = getContextualType(yieldExpression);
+                    nextType = getContextualType(yieldExpression, /*contextFlags*/ undefined);
                 }
                 if (nextType)
                     ts.pushIfUnique(nextTypes, nextType);
@@ -78766,11 +78823,16 @@ var ts;
                     if (isContextSensitive(node)) {
                         if (contextualSignature) {
                             var inferenceContext = getInferenceContext(node);
+                            var instantiatedContextualSignature = void 0;
                             if (checkMode && checkMode & 2 /* Inferential */) {
                                 inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext);
+                                var restType = getEffectiveRestType(contextualSignature);
+                                if (restType && restType.flags & 262144 /* TypeParameter */) {
+                                    instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper);
+                                }
                             }
-                            var instantiatedContextualSignature = inferenceContext ?
-                                instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature;
+                            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ?
+                                instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature);
                             assignContextualParameterTypes(signature, instantiatedContextualSignature);
                         }
                         else {
@@ -80012,7 +80074,7 @@ var ts;
                 type = anyType;
                 addLazyDiagnostic(function () {
                     if (noImplicitAny && !ts.expressionResultIsUnused(node)) {
-                        var contextualType = getContextualType(node);
+                        var contextualType = getContextualType(node, /*contextFlags*/ undefined);
                         if (!contextualType || isTypeAny(contextualType)) {
                             error(node, ts.Diagnostics.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation);
                         }
@@ -80053,7 +80115,7 @@ var ts;
                 texts.push(span.literal.text);
                 types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
             }
-            return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(node) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
+            return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(node, /*contextFlags*/ undefined) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
         }
         function isTemplateLiteralContextualType(type) {
             return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) ||
@@ -80081,7 +80143,7 @@ var ts;
                 // We strip literal freshness when an appropriate contextual type is present such that contextually typed
                 // literals always preserve their literal types (otherwise they might widen during type inference). An alternative
                 // here would be to not mark contextually typed literals as fresh in the first place.
-                var result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node)) ?
+                var result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ?
                     getRegularTypeOfLiteralType(type) : type;
                 return result;
             }
@@ -80196,7 +80258,7 @@ var ts;
             var type = checkExpression(node, checkMode, forceTuple);
             return isConstContext(node) || ts.isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) :
                 isTypeAssertion(node) ? type :
-                    getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
+                    getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node, /*contextFlags*/ undefined) : contextualType, node, /*contextFlags*/ undefined));
         }
         function checkPropertyAssignment(node, checkMode) {
             // Do not use hasDynamicName here, because that returns false for well known symbols.
@@ -86178,7 +86240,9 @@ var ts;
                     error(exportedName, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, ts.idText(exportedName));
                 }
                 else {
-                    markExportAsReferenced(node);
+                    if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) {
+                        markExportAsReferenced(node);
+                    }
                     var target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
                     if (!target || target === unknownSymbol || target.flags & 111551 /* Value */) {
                         checkExpressionCached(node.propertyName || node.name);
@@ -89539,9 +89603,6 @@ var ts;
                 else {
                     return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
                 }
-                if (!isConstOrReadonly || isInvalidInitializer) {
-                    return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
-                }
             }
         }
         function checkGrammarVariableDeclaration(node) {
@@ -111326,7 +111387,7 @@ var ts;
                 return;
             }
             // Make sure not to write js file and source map file if any of them cannot be written
-            if ((jsFilePath && host.isEmitBlocked(jsFilePath)) || compilerOptions.noEmit) {
+            if (host.isEmitBlocked(jsFilePath) || compilerOptions.noEmit) {
                 emitSkipped = true;
                 return;
             }
@@ -124588,7 +124649,6 @@ var ts;
         var parsedConfigs; // Parsed commandline and watching cached for referenced projects
         var sharedExtendedConfigFileWatchers; // Map of file watchers for extended files, shared between different referenced projects
         var extendedConfigCache = host.extendedConfigCache; // Cache for extended config evaluation
-        var changesAffectResolution = false; // Flag for indicating non-config changes affect module resolution
         var reportFileChangeDetectedOnCreateProgram = false; // True if synchronizeProgram should report "File change detected..." when a new program is created
         var sourceFilesCache = new ts.Map(); // Cache that stores the source file and version info
         var missingFilePathsRequestedForRelease; // These paths are held temporarily so that we can remove the entry from source file cache if the file is not tracked by missing files
@@ -124741,12 +124801,12 @@ var ts;
             var program = getCurrentBuilderProgram();
             if (hasChangedCompilerOptions) {
                 newLine = updateNewLine();
-                if (program && (changesAffectResolution || ts.changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions))) {
+                if (program && ts.changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) {
                     resolutionCache.clear();
                 }
             }
             // All resolutions are invalid if user provided resolutions
-            var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution || changesAffectResolution);
+            var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution);
             if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
                 if (hasChangedConfigFileParsingErrors) {
                     if (reportFileChangeDetectedOnCreateProgram) {
@@ -124762,7 +124822,6 @@ var ts;
                 }
                 createNewProgram(hasInvalidatedResolution);
             }
-            changesAffectResolution = false; // reset for next sync
             reportFileChangeDetectedOnCreateProgram = false;
             if (host.afterProgramCreate && program !== builderProgram) {
                 host.afterProgramCreate(builderProgram);
@@ -126143,7 +126202,7 @@ var ts;
     }
     function afterProgramDone(state, program, config) {
         if (program) {
-            if (program && state.write)
+            if (state.write)
                 ts.listFiles(program, state.write);
             if (state.host.afterProgramEmitAndDiagnostics) {
                 state.host.afterProgramEmitAndDiagnostics(program);