typescript 4.7.0-dev.20220404 → 4.7.0-dev.20220408

package/lib/typescript.js

@@ -294,7 +294,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.20220404";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220408";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4609,10 +4609,11 @@ var ts;
         NodeFlags[NodeFlags["YieldContext"] = 8192] = "YieldContext";
         NodeFlags[NodeFlags["DecoratorContext"] = 16384] = "DecoratorContext";
         NodeFlags[NodeFlags["AwaitContext"] = 32768] = "AwaitContext";
-        NodeFlags[NodeFlags["ThisNodeHasError"] = 65536] = "ThisNodeHasError";
-        NodeFlags[NodeFlags["JavaScriptFile"] = 131072] = "JavaScriptFile";
-        NodeFlags[NodeFlags["ThisNodeOrAnySubNodesHasError"] = 262144] = "ThisNodeOrAnySubNodesHasError";
-        NodeFlags[NodeFlags["HasAggregatedChildData"] = 524288] = "HasAggregatedChildData";
+        NodeFlags[NodeFlags["DisallowConditionalTypesContext"] = 65536] = "DisallowConditionalTypesContext";
+        NodeFlags[NodeFlags["ThisNodeHasError"] = 131072] = "ThisNodeHasError";
+        NodeFlags[NodeFlags["JavaScriptFile"] = 262144] = "JavaScriptFile";
+        NodeFlags[NodeFlags["ThisNodeOrAnySubNodesHasError"] = 524288] = "ThisNodeOrAnySubNodesHasError";
+        NodeFlags[NodeFlags["HasAggregatedChildData"] = 1048576] = "HasAggregatedChildData";
         // These flags will be set when the parser encounters a dynamic import expression or 'import.meta' to avoid
         // walking the tree if the flags are not set. However, these flags are just a approximation
         // (hence why it's named "PossiblyContainsDynamicImport") because once set, the flags never get cleared.
@@ -4622,25 +4623,25 @@ var ts;
         // removal, it is likely that users will add the import anyway.
         // The advantage of this approach is its simplicity. For the case of batch compilation,
         // we guarantee that users won't have to pay the price of walking the tree if a dynamic import isn't used.
-        /* @internal */ NodeFlags[NodeFlags["PossiblyContainsDynamicImport"] = 1048576] = "PossiblyContainsDynamicImport";
-        /* @internal */ NodeFlags[NodeFlags["PossiblyContainsImportMeta"] = 2097152] = "PossiblyContainsImportMeta";
-        NodeFlags[NodeFlags["JSDoc"] = 4194304] = "JSDoc";
-        /* @internal */ NodeFlags[NodeFlags["Ambient"] = 8388608] = "Ambient";
-        /* @internal */ NodeFlags[NodeFlags["InWithStatement"] = 16777216] = "InWithStatement";
-        NodeFlags[NodeFlags["JsonFile"] = 33554432] = "JsonFile";
-        /* @internal */ NodeFlags[NodeFlags["TypeCached"] = 67108864] = "TypeCached";
-        /* @internal */ NodeFlags[NodeFlags["Deprecated"] = 134217728] = "Deprecated";
+        /* @internal */ NodeFlags[NodeFlags["PossiblyContainsDynamicImport"] = 2097152] = "PossiblyContainsDynamicImport";
+        /* @internal */ NodeFlags[NodeFlags["PossiblyContainsImportMeta"] = 4194304] = "PossiblyContainsImportMeta";
+        NodeFlags[NodeFlags["JSDoc"] = 8388608] = "JSDoc";
+        /* @internal */ NodeFlags[NodeFlags["Ambient"] = 16777216] = "Ambient";
+        /* @internal */ NodeFlags[NodeFlags["InWithStatement"] = 33554432] = "InWithStatement";
+        NodeFlags[NodeFlags["JsonFile"] = 67108864] = "JsonFile";
+        /* @internal */ NodeFlags[NodeFlags["TypeCached"] = 134217728] = "TypeCached";
+        /* @internal */ NodeFlags[NodeFlags["Deprecated"] = 268435456] = "Deprecated";
         NodeFlags[NodeFlags["BlockScoped"] = 3] = "BlockScoped";
         NodeFlags[NodeFlags["ReachabilityCheckFlags"] = 768] = "ReachabilityCheckFlags";
         NodeFlags[NodeFlags["ReachabilityAndEmitFlags"] = 2816] = "ReachabilityAndEmitFlags";
         // Parsing context flags
-        NodeFlags[NodeFlags["ContextFlags"] = 25358336] = "ContextFlags";
+        NodeFlags[NodeFlags["ContextFlags"] = 50720768] = "ContextFlags";
         // Exclude these flags when parsing a Type
         NodeFlags[NodeFlags["TypeExcludesFlags"] = 40960] = "TypeExcludesFlags";
         // Represents all flags that are potentially set once and
         // never cleared on SourceFiles which get re-used in between incremental parses.
         // See the comment above on `PossiblyContainsDynamicImport` and `PossiblyContainsImportMeta`.
-        /* @internal */ NodeFlags[NodeFlags["PermanentlySetIncrementalFlags"] = 3145728] = "PermanentlySetIncrementalFlags";
+        /* @internal */ NodeFlags[NodeFlags["PermanentlySetIncrementalFlags"] = 6291456] = "PermanentlySetIncrementalFlags";
     })(NodeFlags = ts.NodeFlags || (ts.NodeFlags = {}));
     var ModifierFlags;
     (function (ModifierFlags) {
@@ -8910,6 +8911,7 @@ var ts;
         _0_index_signatures_are_incompatible: diag(2634, ts.DiagnosticCategory.Error, "_0_index_signatures_are_incompatible_2634", "'{0}' index signatures are incompatible."),
         Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: diag(2635, ts.DiagnosticCategory.Error, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."),
         Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation: diag(2636, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation_2636", "Type '{0}' is not assignable to type '{1}' as implied by variance annotation."),
+        Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types: diag(2637, ts.DiagnosticCategory.Error, "Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_t_2637", "Variance annotations are only supported in type aliases for object, function, constructor, and mapped types."),
         Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."),
         A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."),
         Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."),
@@ -9082,6 +9084,7 @@ var ts;
         Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0: diag(2835, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Did you mean '{0}'?"),
         Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, ts.DiagnosticCategory.Error, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."),
         Import_assertion_values_must_be_string_literal_expressions: diag(2837, ts.DiagnosticCategory.Error, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."),
+        All_declarations_of_0_must_have_identical_constraints: diag(2838, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -14496,24 +14499,24 @@ var ts;
     // Returns true if this node contains a parse error anywhere underneath it.
     function containsParseError(node) {
         aggregateChildData(node);
-        return (node.flags & 262144 /* ThisNodeOrAnySubNodesHasError */) !== 0;
+        return (node.flags & 524288 /* ThisNodeOrAnySubNodesHasError */) !== 0;
     }
     ts.containsParseError = containsParseError;
     function aggregateChildData(node) {
-        if (!(node.flags & 524288 /* HasAggregatedChildData */)) {
+        if (!(node.flags & 1048576 /* HasAggregatedChildData */)) {
             // A node is considered to contain a parse error if:
             //  a) the parser explicitly marked that it had an error
             //  b) any of it's children reported that it had an error.
-            var thisNodeOrAnySubNodesHasError = ((node.flags & 65536 /* ThisNodeHasError */) !== 0) ||
+            var thisNodeOrAnySubNodesHasError = ((node.flags & 131072 /* ThisNodeHasError */) !== 0) ||
                 ts.forEachChild(node, containsParseError);
             // If so, mark ourselves accordingly.
             if (thisNodeOrAnySubNodesHasError) {
-                node.flags |= 262144 /* ThisNodeOrAnySubNodesHasError */;
+                node.flags |= 524288 /* ThisNodeOrAnySubNodesHasError */;
             }
             // Also mark that we've propagated the child information to this node.  This way we can
             // always consult the bit directly on this node without needing to check its children
             // again.
-            node.flags |= 524288 /* HasAggregatedChildData */;
+            node.flags |= 1048576 /* HasAggregatedChildData */;
         }
     }
     function getSourceFileOfNode(node) {
@@ -16320,11 +16323,11 @@ var ts;
     }
     ts.isSourceFileNotJS = isSourceFileNotJS;
     function isInJSFile(node) {
-        return !!node && !!(node.flags & 131072 /* JavaScriptFile */);
+        return !!node && !!(node.flags & 262144 /* JavaScriptFile */);
     }
     ts.isInJSFile = isInJSFile;
     function isInJsonFile(node) {
-        return !!node && !!(node.flags & 33554432 /* JsonFile */);
+        return !!node && !!(node.flags & 67108864 /* JsonFile */);
     }
     ts.isInJsonFile = isInJsonFile;
     function isSourceFileNotJson(file) {
@@ -16332,7 +16335,7 @@ var ts;
     }
     ts.isSourceFileNotJson = isSourceFileNotJson;
     function isInJSDoc(node) {
-        return !!node && !!(node.flags & 4194304 /* JSDoc */);
+        return !!node && !!(node.flags & 8388608 /* JSDoc */);
     }
     ts.isInJSDoc = isInJSDoc;
     function isJSDocIndexSignature(node) {
@@ -16718,7 +16721,7 @@ var ts;
     function setValueDeclaration(symbol, node) {
         var valueDeclaration = symbol.valueDeclaration;
         if (!valueDeclaration ||
-            !(node.flags & 8388608 /* Ambient */ && !(valueDeclaration.flags & 8388608 /* Ambient */)) &&
+            !(node.flags & 16777216 /* Ambient */ && !(valueDeclaration.flags & 16777216 /* Ambient */)) &&
                 (isAssignmentDeclaration(valueDeclaration) && !isAssignmentDeclaration(node)) ||
             (valueDeclaration.kind !== node.kind && isEffectiveModuleDeclaration(valueDeclaration))) {
             // other kinds of value declarations take precedence over modules and assignment declarations
@@ -16991,7 +16994,11 @@ var ts;
     ts.getEffectiveContainerForJSDocTemplateTag = getEffectiveContainerForJSDocTemplateTag;
     function getHostSignatureFromJSDoc(node) {
         var host = getEffectiveJSDocHost(node);
-        return host && ts.isFunctionLike(host) ? host : undefined;
+        if (host) {
+            return ts.isPropertySignature(host) && host.type && ts.isFunctionLike(host.type) ? host.type :
+                ts.isFunctionLike(host) ? host : undefined;
+        }
+        return undefined;
     }
     ts.getHostSignatureFromJSDoc = getHostSignatureFromJSDoc;
     function getEffectiveJSDocHost(node) {
@@ -21016,7 +21023,7 @@ var ts;
     }
     ts.pseudoBigIntToString = pseudoBigIntToString;
     function isValidTypeOnlyAliasUseSite(useSite) {
-        return !!(useSite.flags & 8388608 /* Ambient */)
+        return !!(useSite.flags & 16777216 /* Ambient */)
             || isPartOfTypeQuery(useSite)
             || isIdentifierInNonEmittingHeritageClause(useSite)
             || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite)
@@ -21469,11 +21476,20 @@ var ts;
             parenthesizeExpressionForDisallowedComma: parenthesizeExpressionForDisallowedComma,
             parenthesizeExpressionOfExpressionStatement: parenthesizeExpressionOfExpressionStatement,
             parenthesizeConciseBodyOfArrowFunction: parenthesizeConciseBodyOfArrowFunction,
-            parenthesizeMemberOfConditionalType: parenthesizeMemberOfConditionalType,
-            parenthesizeMemberOfElementType: parenthesizeMemberOfElementType,
-            parenthesizeElementTypeOfArrayType: parenthesizeElementTypeOfArrayType,
-            parenthesizeConstituentTypesOfUnionOrIntersectionType: parenthesizeConstituentTypesOfUnionOrIntersectionType,
+            parenthesizeCheckTypeOfConditionalType: parenthesizeCheckTypeOfConditionalType,
+            parenthesizeExtendsTypeOfConditionalType: parenthesizeExtendsTypeOfConditionalType,
+            parenthesizeConstituentTypesOfUnionType: parenthesizeConstituentTypesOfUnionType,
+            parenthesizeConstituentTypeOfUnionType: parenthesizeConstituentTypeOfUnionType,
+            parenthesizeConstituentTypesOfIntersectionType: parenthesizeConstituentTypesOfIntersectionType,
+            parenthesizeConstituentTypeOfIntersectionType: parenthesizeConstituentTypeOfIntersectionType,
+            parenthesizeOperandOfTypeOperator: parenthesizeOperandOfTypeOperator,
+            parenthesizeOperandOfReadonlyTypeOperator: parenthesizeOperandOfReadonlyTypeOperator,
+            parenthesizeNonArrayTypeOfPostfixType: parenthesizeNonArrayTypeOfPostfixType,
+            parenthesizeElementTypesOfTupleType: parenthesizeElementTypesOfTupleType,
+            parenthesizeElementTypeOfTupleType: parenthesizeElementTypeOfTupleType,
+            parenthesizeTypeOfOptionalType: parenthesizeTypeOfOptionalType,
             parenthesizeTypeArguments: parenthesizeTypeArguments,
+            parenthesizeLeadingTypeArgument: parenthesizeLeadingTypeArgument,
         };
         function getParenthesizeLeftSideOfBinaryForOperator(operatorKind) {
             binaryLeftOperandParenthesizerCache || (binaryLeftOperandParenthesizerCache = new ts.Map());
@@ -21785,33 +21801,191 @@ var ts;
             }
             return body;
         }
-        function parenthesizeMemberOfConditionalType(member) {
-            return member.kind === 189 /* ConditionalType */ ? factory.createParenthesizedType(member) : member;
+        // Type[Extends] :
+        //     FunctionOrConstructorType
+        //     ConditionalType[?Extends]
+        // ConditionalType[Extends] :
+        //     UnionType[?Extends]
+        //     [~Extends] UnionType[~Extends] `extends` Type[+Extends] `?` Type[~Extends] `:` Type[~Extends]
+        //
+        // - The check type (the `UnionType`, above) does not allow function, constructor, or conditional types (they must be parenthesized)
+        // - The extends type (the first `Type`, above) does not allow conditional types (they must be parenthesized). Function and constructor types are fine.
+        // - The true and false branch types (the second and third `Type` non-terminals, above) allow any type
+        function parenthesizeCheckTypeOfConditionalType(checkType) {
+            switch (checkType.kind) {
+                case 179 /* FunctionType */:
+                case 180 /* ConstructorType */:
+                case 189 /* ConditionalType */:
+                    return factory.createParenthesizedType(checkType);
+            }
+            return checkType;
         }
-        function parenthesizeMemberOfElementType(member) {
-            switch (member.kind) {
+        function parenthesizeExtendsTypeOfConditionalType(extendsType) {
+            switch (extendsType.kind) {
+                case 189 /* ConditionalType */:
+                    return factory.createParenthesizedType(extendsType);
+            }
+            return extendsType;
+        }
+        // UnionType[Extends] :
+        //     `|`? IntersectionType[?Extends]
+        //     UnionType[?Extends] `|` IntersectionType[?Extends]
+        //
+        // - A union type constituent has the same precedence as the check type of a conditional type
+        function parenthesizeConstituentTypeOfUnionType(type) {
+            switch (type.kind) {
+                case 187 /* UnionType */: // Not strictly necessary, but a union containing a union should have been flattened
+                case 188 /* IntersectionType */: // Not strictly necessary, but makes generated output more readable and avoids breaks in DT tests
+                    return factory.createParenthesizedType(type);
+            }
+            return parenthesizeCheckTypeOfConditionalType(type);
+        }
+        function parenthesizeConstituentTypesOfUnionType(members) {
+            return factory.createNodeArray(ts.sameMap(members, parenthesizeConstituentTypeOfUnionType));
+        }
+        // IntersectionType[Extends] :
+        //     `&`? TypeOperator[?Extends]
+        //     IntersectionType[?Extends] `&` TypeOperator[?Extends]
+        //
+        // - An intersection type constituent does not allow function, constructor, conditional, or union types (they must be parenthesized)
+        function parenthesizeConstituentTypeOfIntersectionType(type) {
+            switch (type.kind) {
                 case 187 /* UnionType */:
+                case 188 /* IntersectionType */: // Not strictly necessary, but an intersection containing an intersection should have been flattened
+                    return factory.createParenthesizedType(type);
+            }
+            return parenthesizeConstituentTypeOfUnionType(type);
+        }
+        function parenthesizeConstituentTypesOfIntersectionType(members) {
+            return factory.createNodeArray(ts.sameMap(members, parenthesizeConstituentTypeOfIntersectionType));
+        }
+        // TypeOperator[Extends] :
+        //     PostfixType
+        //     InferType[?Extends]
+        //     `keyof` TypeOperator[?Extends]
+        //     `unique` TypeOperator[?Extends]
+        //     `readonly` TypeOperator[?Extends]
+        //
+        function parenthesizeOperandOfTypeOperator(type) {
+            switch (type.kind) {
                 case 188 /* IntersectionType */:
-                case 179 /* FunctionType */:
-                case 180 /* ConstructorType */:
-                    return factory.createParenthesizedType(member);
+                    return factory.createParenthesizedType(type);
             }
-            return parenthesizeMemberOfConditionalType(member);
+            return parenthesizeConstituentTypeOfIntersectionType(type);
         }
-        function parenthesizeElementTypeOfArrayType(member) {
-            switch (member.kind) {
-                case 181 /* TypeQuery */:
+        function parenthesizeOperandOfReadonlyTypeOperator(type) {
+            switch (type.kind) {
                 case 193 /* TypeOperator */:
+                    return factory.createParenthesizedType(type);
+            }
+            return parenthesizeOperandOfTypeOperator(type);
+        }
+        // PostfixType :
+        //     NonArrayType
+        //     NonArrayType [no LineTerminator here] `!` // JSDoc
+        //     NonArrayType [no LineTerminator here] `?` // JSDoc
+        //     IndexedAccessType
+        //     ArrayType
+        //
+        // IndexedAccessType :
+        //     NonArrayType `[` Type[~Extends] `]`
+        //
+        // ArrayType :
+        //     NonArrayType `[` `]`
+        //
+        function parenthesizeNonArrayTypeOfPostfixType(type) {
+            switch (type.kind) {
                 case 190 /* InferType */:
-                    return factory.createParenthesizedType(member);
+                case 193 /* TypeOperator */:
+                case 181 /* TypeQuery */: // Not strictly necessary, but makes generated output more readable and avoids breaks in DT tests
+                    return factory.createParenthesizedType(type);
             }
-            return parenthesizeMemberOfElementType(member);
+            return parenthesizeOperandOfTypeOperator(type);
+        }
+        // TupleType :
+        //     `[` Elision? `]`
+        //     `[` NamedTupleElementTypes `]`
+        //     `[` NamedTupleElementTypes `,` Elision? `]`
+        //     `[` TupleElementTypes `]`
+        //     `[` TupleElementTypes `,` Elision? `]`
+        //
+        // NamedTupleElementTypes :
+        //     Elision? NamedTupleMember
+        //     NamedTupleElementTypes `,` Elision? NamedTupleMember
+        //
+        // NamedTupleMember :
+        //     Identifier `?`? `:` Type[~Extends]
+        //     `...` Identifier `:` Type[~Extends]
+        //
+        // TupleElementTypes :
+        //     Elision? TupleElementType
+        //     TupleElementTypes `,` Elision? TupleElementType
+        //
+        // TupleElementType :
+        //     Type[~Extends] // NOTE: Needs cover grammar to disallow JSDoc postfix-optional
+        //     OptionalType
+        //     RestType
+        //
+        // OptionalType :
+        //     Type[~Extends] `?` // NOTE: Needs cover grammar to disallow JSDoc postfix-optional
+        //
+        // RestType :
+        //     `...` Type[~Extends]
+        //
+        function parenthesizeElementTypesOfTupleType(types) {
+            return factory.createNodeArray(ts.sameMap(types, parenthesizeElementTypeOfTupleType));
         }
-        function parenthesizeConstituentTypesOfUnionOrIntersectionType(members) {
-            return factory.createNodeArray(ts.sameMap(members, parenthesizeMemberOfElementType));
+        function parenthesizeElementTypeOfTupleType(type) {
+            if (hasJSDocPostfixQuestion(type))
+                return factory.createParenthesizedType(type);
+            return type;
+        }
+        function hasJSDocPostfixQuestion(type) {
+            if (ts.isJSDocNullableType(type))
+                return type.postfix;
+            if (ts.isNamedTupleMember(type))
+                return hasJSDocPostfixQuestion(type.type);
+            if (ts.isFunctionTypeNode(type) || ts.isConstructorTypeNode(type) || ts.isTypeOperatorNode(type))
+                return hasJSDocPostfixQuestion(type.type);
+            if (ts.isConditionalTypeNode(type))
+                return hasJSDocPostfixQuestion(type.falseType);
+            if (ts.isUnionTypeNode(type))
+                return hasJSDocPostfixQuestion(ts.last(type.types));
+            if (ts.isIntersectionTypeNode(type))
+                return hasJSDocPostfixQuestion(ts.last(type.types));
+            if (ts.isInferTypeNode(type))
+                return !!type.typeParameter.constraint && hasJSDocPostfixQuestion(type.typeParameter.constraint);
+            return false;
+        }
+        function parenthesizeTypeOfOptionalType(type) {
+            if (hasJSDocPostfixQuestion(type))
+                return factory.createParenthesizedType(type);
+            return parenthesizeNonArrayTypeOfPostfixType(type);
+        }
+        // function parenthesizeMemberOfElementType(member: TypeNode): TypeNode {
+        //     switch (member.kind) {
+        //         case SyntaxKind.UnionType:
+        //         case SyntaxKind.IntersectionType:
+        //         case SyntaxKind.FunctionType:
+        //         case SyntaxKind.ConstructorType:
+        //             return factory.createParenthesizedType(member);
+        //     }
+        //     return parenthesizeMemberOfConditionalType(member);
+        // }
+        // function parenthesizeElementTypeOfArrayType(member: TypeNode): TypeNode {
+        //     switch (member.kind) {
+        //         case SyntaxKind.TypeQuery:
+        //         case SyntaxKind.TypeOperator:
+        //         case SyntaxKind.InferType:
+        //             return factory.createParenthesizedType(member);
+        //     }
+        //     return parenthesizeMemberOfElementType(member);
+        // }
+        function parenthesizeLeadingTypeArgument(node) {
+            return ts.isFunctionOrConstructorTypeNode(node) && node.typeParameters ? factory.createParenthesizedType(node) : node;
         }
         function parenthesizeOrdinalTypeArgument(node, i) {
-            return i === 0 && ts.isFunctionOrConstructorTypeNode(node) && node.typeParameters ? factory.createParenthesizedType(node) : node;
+            return i === 0 ? parenthesizeLeadingTypeArgument(node) : node;
         }
         function parenthesizeTypeArguments(typeArguments) {
             if (ts.some(typeArguments)) {
@@ -21837,11 +22011,20 @@ var ts;
         parenthesizeExpressionForDisallowedComma: ts.identity,
         parenthesizeExpressionOfExpressionStatement: ts.identity,
         parenthesizeConciseBodyOfArrowFunction: ts.identity,
-        parenthesizeMemberOfConditionalType: ts.identity,
-        parenthesizeMemberOfElementType: ts.identity,
-        parenthesizeElementTypeOfArrayType: ts.identity,
-        parenthesizeConstituentTypesOfUnionOrIntersectionType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
+        parenthesizeCheckTypeOfConditionalType: ts.identity,
+        parenthesizeExtendsTypeOfConditionalType: ts.identity,
+        parenthesizeConstituentTypesOfUnionType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
+        parenthesizeConstituentTypeOfUnionType: ts.identity,
+        parenthesizeConstituentTypesOfIntersectionType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
+        parenthesizeConstituentTypeOfIntersectionType: ts.identity,
+        parenthesizeOperandOfTypeOperator: ts.identity,
+        parenthesizeOperandOfReadonlyTypeOperator: ts.identity,
+        parenthesizeNonArrayTypeOfPostfixType: ts.identity,
+        parenthesizeElementTypesOfTupleType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
+        parenthesizeElementTypeOfTupleType: ts.identity,
+        parenthesizeTypeOfOptionalType: ts.identity,
         parenthesizeTypeArguments: function (nodes) { return nodes && ts.cast(nodes, ts.isNodeArray); },
+        parenthesizeLeadingTypeArgument: ts.identity,
     };
 })(ts || (ts = {}));
 /* @internal */
@@ -21981,6 +22164,8 @@ var ts;
         var getJSDocPrimaryTypeCreateFunction = ts.memoizeOne(function (kind) { return function () { return createJSDocPrimaryTypeWorker(kind); }; });
         var getJSDocUnaryTypeCreateFunction = ts.memoizeOne(function (kind) { return function (type) { return createJSDocUnaryTypeWorker(kind, type); }; });
         var getJSDocUnaryTypeUpdateFunction = ts.memoizeOne(function (kind) { return function (node, type) { return updateJSDocUnaryTypeWorker(kind, node, type); }; });
+        var getJSDocPrePostfixUnaryTypeCreateFunction = ts.memoizeOne(function (kind) { return function (type, postfix) { return createJSDocPrePostfixUnaryTypeWorker(kind, type, postfix); }; });
+        var getJSDocPrePostfixUnaryTypeUpdateFunction = ts.memoizeOne(function (kind) { return function (node, type) { return updateJSDocPrePostfixUnaryTypeWorker(kind, node, type); }; });
         var getJSDocSimpleTagCreateFunction = ts.memoizeOne(function (kind) { return function (tagName, comment) { return createJSDocSimpleTagWorker(kind, tagName, comment); }; });
         var getJSDocSimpleTagUpdateFunction = ts.memoizeOne(function (kind) { return function (node, tagName, comment) { return updateJSDocSimpleTagWorker(kind, node, tagName, comment); }; });
         var getJSDocTypeLikeTagCreateFunction = ts.memoizeOne(function (kind) { return function (tagName, typeExpression, comment) { return createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment); }; });
@@ -21988,6 +22173,8 @@ var ts;
         var factory = {
             get parenthesizer() { return parenthesizerRules(); },
             get converters() { return converters(); },
+            baseFactory: baseFactory,
+            flags: flags,
             createNodeArray: createNodeArray,
             createNumericLiteral: createNumericLiteral,
             createBigIntLiteral: createBigIntLiteral,
@@ -22263,10 +22450,10 @@ var ts;
             // lazily load factory members for JSDoc types with similar structure
             get createJSDocAllType() { return getJSDocPrimaryTypeCreateFunction(312 /* JSDocAllType */); },
             get createJSDocUnknownType() { return getJSDocPrimaryTypeCreateFunction(313 /* JSDocUnknownType */); },
-            get createJSDocNonNullableType() { return getJSDocUnaryTypeCreateFunction(315 /* JSDocNonNullableType */); },
-            get updateJSDocNonNullableType() { return getJSDocUnaryTypeUpdateFunction(315 /* JSDocNonNullableType */); },
-            get createJSDocNullableType() { return getJSDocUnaryTypeCreateFunction(314 /* JSDocNullableType */); },
-            get updateJSDocNullableType() { return getJSDocUnaryTypeUpdateFunction(314 /* JSDocNullableType */); },
+            get createJSDocNonNullableType() { return getJSDocPrePostfixUnaryTypeCreateFunction(315 /* JSDocNonNullableType */); },
+            get updateJSDocNonNullableType() { return getJSDocPrePostfixUnaryTypeUpdateFunction(315 /* JSDocNonNullableType */); },
+            get createJSDocNullableType() { return getJSDocPrePostfixUnaryTypeCreateFunction(314 /* JSDocNullableType */); },
+            get updateJSDocNullableType() { return getJSDocPrePostfixUnaryTypeUpdateFunction(314 /* JSDocNullableType */); },
             get createJSDocOptionalType() { return getJSDocUnaryTypeCreateFunction(316 /* JSDocOptionalType */); },
             get updateJSDocOptionalType() { return getJSDocUnaryTypeUpdateFunction(316 /* JSDocOptionalType */); },
             get createJSDocVariadicType() { return getJSDocUnaryTypeCreateFunction(318 /* JSDocVariadicType */); },
@@ -23382,7 +23569,7 @@ var ts;
         // @api
         function createArrayTypeNode(elementType) {
             var node = createBaseNode(183 /* ArrayType */);
-            node.elementType = parenthesizerRules().parenthesizeElementTypeOfArrayType(elementType);
+            node.elementType = parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(elementType);
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
         }
@@ -23395,7 +23582,7 @@ var ts;
         // @api
         function createTupleTypeNode(elements) {
             var node = createBaseNode(184 /* TupleType */);
-            node.elements = createNodeArray(elements);
+            node.elements = createNodeArray(parenthesizerRules().parenthesizeElementTypesOfTupleType(elements));
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
         }
@@ -23427,7 +23614,7 @@ var ts;
         // @api
         function createOptionalTypeNode(type) {
             var node = createBaseNode(185 /* OptionalType */);
-            node.type = parenthesizerRules().parenthesizeElementTypeOfArrayType(type);
+            node.type = parenthesizerRules().parenthesizeTypeOfOptionalType(type);
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
         }
@@ -23450,38 +23637,38 @@ var ts;
                 ? update(createRestTypeNode(type), node)
                 : node;
         }
-        function createUnionOrIntersectionTypeNode(kind, types) {
+        function createUnionOrIntersectionTypeNode(kind, types, parenthesize) {
             var node = createBaseNode(kind);
-            node.types = parenthesizerRules().parenthesizeConstituentTypesOfUnionOrIntersectionType(types);
+            node.types = factory.createNodeArray(parenthesize(types));
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
         }
-        function updateUnionOrIntersectionTypeNode(node, types) {
+        function updateUnionOrIntersectionTypeNode(node, types, parenthesize) {
             return node.types !== types
-                ? update(createUnionOrIntersectionTypeNode(node.kind, types), node)
+                ? update(createUnionOrIntersectionTypeNode(node.kind, types, parenthesize), node)
                 : node;
         }
         // @api
         function createUnionTypeNode(types) {
-            return createUnionOrIntersectionTypeNode(187 /* UnionType */, types);
+            return createUnionOrIntersectionTypeNode(187 /* UnionType */, types, parenthesizerRules().parenthesizeConstituentTypesOfUnionType);
         }
         // @api
         function updateUnionTypeNode(node, types) {
-            return updateUnionOrIntersectionTypeNode(node, types);
+            return updateUnionOrIntersectionTypeNode(node, types, parenthesizerRules().parenthesizeConstituentTypesOfUnionType);
         }
         // @api
         function createIntersectionTypeNode(types) {
-            return createUnionOrIntersectionTypeNode(188 /* IntersectionType */, types);
+            return createUnionOrIntersectionTypeNode(188 /* IntersectionType */, types, parenthesizerRules().parenthesizeConstituentTypesOfIntersectionType);
         }
         // @api
         function updateIntersectionTypeNode(node, types) {
-            return updateUnionOrIntersectionTypeNode(node, types);
+            return updateUnionOrIntersectionTypeNode(node, types, parenthesizerRules().parenthesizeConstituentTypesOfIntersectionType);
         }
         // @api
         function createConditionalTypeNode(checkType, extendsType, trueType, falseType) {
             var node = createBaseNode(189 /* ConditionalType */);
-            node.checkType = parenthesizerRules().parenthesizeMemberOfConditionalType(checkType);
-            node.extendsType = parenthesizerRules().parenthesizeMemberOfConditionalType(extendsType);
+            node.checkType = parenthesizerRules().parenthesizeCheckTypeOfConditionalType(checkType);
+            node.extendsType = parenthesizerRules().parenthesizeExtendsTypeOfConditionalType(extendsType);
             node.trueType = trueType;
             node.falseType = falseType;
             node.transformFlags = 1 /* ContainsTypeScript */;
@@ -23576,7 +23763,9 @@ var ts;
         function createTypeOperatorNode(operator, type) {
             var node = createBaseNode(193 /* TypeOperator */);
             node.operator = operator;
-            node.type = parenthesizerRules().parenthesizeMemberOfElementType(type);
+            node.type = operator === 145 /* ReadonlyKeyword */ ?
+                parenthesizerRules().parenthesizeOperandOfReadonlyTypeOperator(type) :
+                parenthesizerRules().parenthesizeOperandOfTypeOperator(type);
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
         }
@@ -23589,7 +23778,7 @@ var ts;
         // @api
         function createIndexedAccessTypeNode(objectType, indexType) {
             var node = createBaseNode(194 /* IndexedAccessType */);
-            node.objectType = parenthesizerRules().parenthesizeMemberOfElementType(objectType);
+            node.objectType = parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(objectType);
             node.indexType = indexType;
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
@@ -25325,8 +25514,15 @@ var ts;
             return createBaseNode(kind);
         }
         // @api
-        // createJSDocNonNullableType
         // createJSDocNullableType
+        // createJSDocNonNullableType
+        function createJSDocPrePostfixUnaryTypeWorker(kind, type, postfix) {
+            if (postfix === void 0) { postfix = false; }
+            var node = createJSDocUnaryTypeWorker(kind, postfix ? type && parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(type) : type);
+            node.postfix = postfix;
+            return node;
+        }
+        // @api
         // createJSDocOptionalType
         // createJSDocVariadicType
         // createJSDocNamepathType
@@ -25338,6 +25534,12 @@ var ts;
         // @api
         // updateJSDocNonNullableType
         // updateJSDocNullableType
+        function updateJSDocPrePostfixUnaryTypeWorker(kind, node, type) {
+            return node.type !== type
+                ? update(createJSDocPrePostfixUnaryTypeWorker(kind, type, node.postfix), node)
+                : node;
+        }
+        // @api
         // updateJSDocOptionalType
         // updateJSDocVariadicType
         // updateJSDocNamepathType
@@ -30418,7 +30620,7 @@ var ts;
             || ts.isExportDeclaration(node) ? node : undefined;
     }
     function getImportMetaIfNecessary(sourceFile) {
-        return sourceFile.flags & 2097152 /* PossiblyContainsImportMeta */ ?
+        return sourceFile.flags & 4194304 /* PossiblyContainsImportMeta */ ?
             walkTreeForImportMeta(sourceFile) :
             undefined;
     }
@@ -31073,7 +31275,7 @@ var ts;
         var newSourceFile = IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
         // Because new source file node is created, it may not have the flag PossiblyContainDynamicImport. This is the case if there is no new edit to add dynamic import.
         // We will manually port the flag to the new source file.
-        newSourceFile.flags |= (sourceFile.flags & 3145728 /* PermanentlySetIncrementalFlags */);
+        newSourceFile.flags |= (sourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */);
         return newSourceFile;
     }
     ts.updateSourceFile = updateSourceFile;
@@ -31357,10 +31559,10 @@ var ts;
             switch (scriptKind) {
                 case 1 /* JS */:
                 case 2 /* JSX */:
-                    contextFlags = 131072 /* JavaScriptFile */;
+                    contextFlags = 262144 /* JavaScriptFile */;
                     break;
                 case 6 /* JSON */:
-                    contextFlags = 131072 /* JavaScriptFile */ | 33554432 /* JsonFile */;
+                    contextFlags = 262144 /* JavaScriptFile */ | 67108864 /* JsonFile */;
                     break;
                 default:
                     contextFlags = 0 /* None */;
@@ -31395,7 +31597,7 @@ var ts;
         function parseSourceFileWorker(languageVersion, setParentNodes, scriptKind, setExternalModuleIndicator) {
             var isDeclarationFile = isDeclarationFileName(fileName);
             if (isDeclarationFile) {
-                contextFlags |= 8388608 /* Ambient */;
+                contextFlags |= 16777216 /* Ambient */;
             }
             sourceFlags = contextFlags;
             // Prime the scanner.
@@ -31434,7 +31636,7 @@ var ts;
                 node.jsDoc = jsDoc;
             if (hasDeprecatedTag) {
                 hasDeprecatedTag = false;
-                node.flags |= 134217728 /* Deprecated */;
+                node.flags |= 268435456 /* Deprecated */;
             }
             return node;
         }
@@ -31629,6 +31831,12 @@ var ts;
         function disallowInAnd(func) {
             return doInsideOfContext(4096 /* DisallowInContext */, func);
         }
+        function allowConditionalTypesAnd(func) {
+            return doOutsideOfContext(65536 /* DisallowConditionalTypesContext */, func);
+        }
+        function disallowConditionalTypesAnd(func) {
+            return doInsideOfContext(65536 /* DisallowConditionalTypesContext */, func);
+        }
         function doInYieldContext(func) {
             return doInsideOfContext(8192 /* YieldContext */, func);
         }
@@ -31656,6 +31864,9 @@ var ts;
         function inDisallowInContext() {
             return inContext(4096 /* DisallowInContext */);
         }
+        function inDisallowConditionalTypesContext() {
+            return inContext(65536 /* DisallowConditionalTypesContext */);
+        }
         function inDecoratorContext() {
             return inContext(16384 /* DecoratorContext */);
         }
@@ -32040,7 +32251,7 @@ var ts;
             // flag so that we don't mark any subsequent nodes.
             if (parseErrorBeforeNextFinishedNode) {
                 parseErrorBeforeNextFinishedNode = false;
-                node.flags |= 65536 /* ThisNodeHasError */;
+                node.flags |= 131072 /* ThisNodeHasError */;
             }
             return node;
         }
@@ -32498,7 +32709,7 @@ var ts;
             // differently depending on what mode it is in.
             //
             // This also applies to all our other context flags as well.
-            var nodeContextFlags = node.flags & 25358336 /* ContextFlags */;
+            var nodeContextFlags = node.flags & 50720768 /* ContextFlags */;
             if (nodeContextFlags !== contextFlags) {
                 return undefined;
             }
@@ -32757,7 +32968,6 @@ var ts;
                 default: return [undefined]; // TODO: GH#18217 `default: Debug.assertNever(context);`
             }
         }
-        // Parses a comma-delimited list of elements
         function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
             var saveParsingContext = parsingContext;
             parsingContext |= 1 << kind;
@@ -32767,7 +32977,11 @@ var ts;
             while (true) {
                 if (isListElement(kind, /*inErrorRecovery*/ false)) {
                     var startPos = scanner.getStartPos();
-                    list.push(parseListElement(kind, parseElement));
+                    var result = parseListElement(kind, parseElement);
+                    if (!result) {
+                        return undefined;
+                    }
+                    list.push(result);
                     commaStart = scanner.getTokenPos();
                     if (parseOptional(27 /* CommaToken */)) {
                         // No need to check for a zero length node since we know we parsed a comma
@@ -33020,7 +33234,7 @@ var ts;
         function parseJSDocNonNullableType() {
             var pos = getNodePos();
             nextToken();
-            return finishNode(factory.createJSDocNonNullableType(parseNonArrayType()), pos);
+            return finishNode(factory.createJSDocNonNullableType(parseNonArrayType(), /*postfix*/ false), pos);
         }
         function parseJSDocUnknownOrNullableType() {
             var pos = getNodePos();
@@ -33044,7 +33258,7 @@ var ts;
                 return finishNode(factory.createJSDocUnknownType(), pos);
             }
             else {
-                return finishNode(factory.createJSDocNullableType(parseType()), pos);
+                return finishNode(factory.createJSDocNullableType(parseType(), /*postfix*/ false), pos);
             }
         }
         function parseJSDocFunctionType() {
@@ -33172,13 +33386,20 @@ var ts;
             }
             return name;
         }
-        function parseParameterInOuterAwaitContext() {
-            return parseParameterWorker(/*inOuterAwaitContext*/ true);
+        function isParameterNameStart() {
+            // Be permissive about await and yield by calling isBindingIdentifier instead of isIdentifier; disallowing
+            // them during a speculative parse leads to many more follow-on errors than allowing the function to parse then later
+            // complaining about the use of the keywords.
+            return isBindingIdentifier() || token() === 22 /* OpenBracketToken */ || token() === 18 /* OpenBraceToken */;
+        }
+        function parseParameter(inOuterAwaitContext) {
+            return parseParameterWorker(inOuterAwaitContext);
         }
-        function parseParameter() {
-            return parseParameterWorker(/*inOuterAwaitContext*/ false);
+        function parseParameterForSpeculation(inOuterAwaitContext) {
+            return parseParameterWorker(inOuterAwaitContext, /*allowAmbiguity*/ false);
         }
-        function parseParameterWorker(inOuterAwaitContext) {
+        function parseParameterWorker(inOuterAwaitContext, allowAmbiguity) {
+            if (allowAmbiguity === void 0) { allowAmbiguity = true; }
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             // FormalParameter [Yield,Await]:
@@ -33199,13 +33420,17 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var modifiers = parseModifiers();
-            var node = withJSDoc(finishNode(factory.createParameterDeclaration(decorators, modifiers, parseOptionalToken(25 /* DotDotDotToken */), parseNameOfParameter(modifiers), parseOptionalToken(57 /* QuestionToken */), parseTypeAnnotation(), parseInitializer()), pos), hasJSDoc);
+            var dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
+            if (!allowAmbiguity && !isParameterNameStart()) {
+                return undefined;
+            }
+            var node = withJSDoc(finishNode(factory.createParameterDeclaration(decorators, modifiers, dotDotDotToken, parseNameOfParameter(modifiers), parseOptionalToken(57 /* QuestionToken */), parseTypeAnnotation(), parseInitializer()), pos), hasJSDoc);
             topLevel = savedTopLevel;
             return node;
         }
         function parseReturnType(returnToken, isType) {
             if (shouldParseReturnType(returnToken, isType)) {
-                return parseTypeOrTypePredicate();
+                return allowConditionalTypesAnd(parseTypeOrTypePredicate);
             }
         }
         function shouldParseReturnType(returnToken, isType) {
@@ -33224,7 +33449,7 @@ var ts;
             }
             return false;
         }
-        function parseParametersWorker(flags) {
+        function parseParametersWorker(flags, allowAmbiguity) {
             // FormalParameters [Yield,Await]: (modified)
             //      [empty]
             //      FormalParameterList[?Yield,Await]
@@ -33244,7 +33469,7 @@ var ts;
             setAwaitContext(!!(flags & 2 /* Await */));
             var parameters = flags & 32 /* JSDoc */ ?
                 parseDelimitedList(17 /* JSDocParameters */, parseJSDocParameter) :
-                parseDelimitedList(16 /* Parameters */, savedAwaitContext ? parseParameterInOuterAwaitContext : parseParameter);
+                parseDelimitedList(16 /* Parameters */, function () { return allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext); });
             setYieldContext(savedYieldContext);
             setAwaitContext(savedAwaitContext);
             return parameters;
@@ -33266,7 +33491,7 @@ var ts;
             if (!parseExpected(20 /* OpenParenToken */)) {
                 return createMissingList();
             }
-            var parameters = parseParametersWorker(flags);
+            var parameters = parseParametersWorker(flags, /*allowAmbiguity*/ true);
             parseExpected(21 /* CloseParenToken */);
             return parameters;
         }
@@ -33348,7 +33573,7 @@ var ts;
             return token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 23 /* CloseBracketToken */;
         }
         function parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers) {
-            var parameters = parseBracketedList(16 /* Parameters */, parseParameter, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */);
+            var parameters = parseBracketedList(16 /* Parameters */, function () { return parseParameter(/*inOuterAwaitContext*/ false); }, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */);
             var type = parseTypeAnnotation();
             parseTypeMemberSemicolon();
             var node = factory.createIndexSignature(decorators, modifiers, parameters, type);
@@ -33620,7 +33845,7 @@ var ts;
             return finishNode(factory.createImportTypeAssertionContainer(clause, multiLine), pos);
         }
         function parseImportType() {
-            sourceFlags |= 1048576 /* PossiblyContainsDynamicImport */;
+            sourceFlags |= 2097152 /* PossiblyContainsDynamicImport */;
             var pos = getNodePos();
             var isTypeOf = parseOptional(112 /* TypeOfKeyword */);
             parseExpected(100 /* ImportKeyword */);
@@ -33770,7 +33995,7 @@ var ts;
                 switch (token()) {
                     case 53 /* ExclamationToken */:
                         nextToken();
-                        type = finishNode(factory.createJSDocNonNullableType(type), pos);
+                        type = finishNode(factory.createJSDocNonNullableType(type, /*postfix*/ true), pos);
                         break;
                     case 57 /* QuestionToken */:
                         // If next token is start of a type we have a conditional type
@@ -33778,7 +34003,7 @@ var ts;
                             return type;
                         }
                         nextToken();
-                        type = finishNode(factory.createJSDocNullableType(type), pos);
+                        type = finishNode(factory.createJSDocNullableType(type, /*postfix*/ true), pos);
                         break;
                     case 22 /* OpenBracketToken */:
                         parseExpected(22 /* OpenBracketToken */);
@@ -33803,12 +34028,20 @@ var ts;
             parseExpected(operator);
             return finishNode(factory.createTypeOperatorNode(operator, parseTypeOperatorOrHigher()), pos);
         }
+        function tryParseConstraintOfInferType() {
+            if (parseOptional(94 /* ExtendsKeyword */)) {
+                var constraint = disallowConditionalTypesAnd(parseType);
+                if (inDisallowConditionalTypesContext() || token() !== 57 /* QuestionToken */) {
+                    return constraint;
+                }
+            }
+        }
         function parseTypeParameterOfInferType() {
             var pos = getNodePos();
-            return finishNode(factory.createTypeParameterDeclaration(
-            /*modifiers*/ undefined, parseIdentifier(), 
-            /*constraint*/ undefined, 
-            /*defaultType*/ undefined), pos);
+            var name = parseIdentifier();
+            var constraint = tryParse(tryParseConstraintOfInferType);
+            var node = factory.createTypeParameterDeclaration(/*modifiers*/ undefined, name, constraint);
+            return finishNode(node, pos);
         }
         function parseInferType() {
             var pos = getNodePos();
@@ -33825,7 +34058,7 @@ var ts;
                 case 137 /* InferKeyword */:
                     return parseInferType();
             }
-            return parsePostfixTypeOrHigher();
+            return allowConditionalTypesAnd(parsePostfixTypeOrHigher);
         }
         function parseFunctionOrConstructorTypeToError(isInUnionType) {
             // the function type and constructor type shorthand notation
@@ -33955,23 +34188,21 @@ var ts;
             return finishNode(factory.createTypePredicateNode(assertsModifier, parameterName, type), pos);
         }
         function parseType() {
-            // The rules about 'yield' only apply to actual code/expression contexts.  They don't
-            // apply to 'type' contexts.  So we disable these parameters here before moving on.
-            return doOutsideOfContext(40960 /* TypeExcludesFlags */, parseTypeWorker);
-        }
-        function parseTypeWorker(noConditionalTypes) {
+            if (contextFlags & 40960 /* TypeExcludesFlags */) {
+                return doOutsideOfContext(40960 /* TypeExcludesFlags */, parseType);
+            }
             if (isStartOfFunctionTypeOrConstructorType()) {
                 return parseFunctionOrConstructorType();
             }
             var pos = getNodePos();
             var type = parseUnionTypeOrHigher();
-            if (!noConditionalTypes && !scanner.hasPrecedingLineBreak() && parseOptional(94 /* ExtendsKeyword */)) {
+            if (!inDisallowConditionalTypesContext() && !scanner.hasPrecedingLineBreak() && parseOptional(94 /* ExtendsKeyword */)) {
                 // The type following 'extends' is not permitted to be another conditional type
-                var extendsType = parseTypeWorker(/*noConditionalTypes*/ true);
+                var extendsType = disallowConditionalTypesAnd(parseType);
                 parseExpected(57 /* QuestionToken */);
-                var trueType = parseTypeWorker();
+                var trueType = allowConditionalTypesAnd(parseType);
                 parseExpected(58 /* ColonToken */);
-                var falseType = parseTypeWorker();
+                var falseType = allowConditionalTypesAnd(parseType);
                 return finishNode(factory.createConditionalTypeNode(type, extendsType, trueType, falseType), pos);
             }
             return type;
@@ -34398,7 +34629,16 @@ var ts;
                 parameters = createMissingList();
             }
             else {
-                parameters = parseParametersWorker(isAsync);
+                if (!allowAmbiguity) {
+                    var maybeParameters = parseParametersWorker(isAsync, allowAmbiguity);
+                    if (!maybeParameters) {
+                        return undefined;
+                    }
+                    parameters = maybeParameters;
+                }
+                else {
+                    parameters = parseParametersWorker(isAsync, allowAmbiguity);
+                }
                 if (!parseExpected(21 /* CloseParenToken */) && !allowAmbiguity) {
                     return undefined;
                 }
@@ -34799,7 +35039,7 @@ var ts;
                     //      var foo3 = require("subfolder
                     //      import * as foo1 from "module-from-node
                     // We want this import to be a statement rather than import call expression
-                    sourceFlags |= 1048576 /* PossiblyContainsDynamicImport */;
+                    sourceFlags |= 2097152 /* PossiblyContainsDynamicImport */;
                     expression = parseTokenNode();
                 }
                 else if (lookAhead(nextTokenIsDot)) {
@@ -34807,7 +35047,7 @@ var ts;
                     nextToken(); // advance past the 'import'
                     nextToken(); // advance past the dot
                     expression = finishNode(factory.createMetaProperty(100 /* ImportKeyword */, parseIdentifierName()), pos);
-                    sourceFlags |= 2097152 /* PossiblyContainsImportMeta */;
+                    sourceFlags |= 4194304 /* PossiblyContainsImportMeta */;
                 }
                 else {
                     expression = parseMemberExpressionOrHigher();
@@ -35023,7 +35263,7 @@ var ts;
                 return finishNode(factory.createJsxOpeningFragment(), pos);
             }
             var tagName = parseJsxElementName();
-            var typeArguments = (contextFlags & 131072 /* JavaScriptFile */) === 0 ? tryParseTypeArguments() : undefined;
+            var typeArguments = (contextFlags & 262144 /* JavaScriptFile */) === 0 ? tryParseTypeArguments() : undefined;
             var attributes = parseJsxAttributes();
             var node;
             if (token() === 31 /* GreaterThanToken */) {
@@ -35301,7 +35541,7 @@ var ts;
             return result;
         }
         function parseTypeArgumentsInExpression() {
-            if ((contextFlags & 131072 /* JavaScriptFile */) !== 0) {
+            if ((contextFlags & 262144 /* JavaScriptFile */) !== 0) {
                 // TypeArguments must not be parsed in JavaScript files to avoid ambiguity with binary operators.
                 return undefined;
             }
@@ -35697,7 +35937,7 @@ var ts;
             var openParenParsed = parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
             parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
-            var statement = doInsideOfContext(16777216 /* InWithStatement */, parseStatement);
+            var statement = doInsideOfContext(33554432 /* InWithStatement */, parseStatement);
             return withJSDoc(finishNode(factory.createWithStatement(expression, statement), pos), hasJSDoc);
         }
         function parseCaseClause() {
@@ -36072,16 +36312,16 @@ var ts;
             if (isAmbient) {
                 for (var _i = 0, _a = modifiers; _i < _a.length; _i++) {
                     var m = _a[_i];
-                    m.flags |= 8388608 /* Ambient */;
+                    m.flags |= 16777216 /* Ambient */;
                 }
-                return doInsideOfContext(8388608 /* Ambient */, function () { return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers); });
+                return doInsideOfContext(16777216 /* Ambient */, function () { return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers); });
             }
             else {
                 return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers);
             }
         }
         function tryReuseAmbientDeclaration() {
-            return doInsideOfContext(8388608 /* Ambient */, function () {
+            return doInsideOfContext(16777216 /* Ambient */, function () {
                 var node = currentNode(parsingContext);
                 if (node) {
                     return consumeNode(node);
@@ -36548,9 +36788,9 @@ var ts;
                 if (isAmbient) {
                     for (var _i = 0, _a = modifiers; _i < _a.length; _i++) {
                         var m = _a[_i];
-                        m.flags |= 8388608 /* Ambient */;
+                        m.flags |= 16777216 /* Ambient */;
                     }
-                    return doInsideOfContext(8388608 /* Ambient */, function () { return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers); });
+                    return doInsideOfContext(16777216 /* Ambient */, function () { return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers); });
                 }
                 else {
                     return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers);
@@ -37115,7 +37355,7 @@ var ts;
             function parseJSDocTypeExpression(mayOmitBraces) {
                 var pos = getNodePos();
                 var hasBrace = (mayOmitBraces ? parseOptional : parseExpected)(18 /* OpenBraceToken */);
-                var type = doInsideOfContext(4194304 /* JSDoc */, parseJSDocType);
+                var type = doInsideOfContext(8388608 /* JSDoc */, parseJSDocType);
                 if (!mayOmitBraces || hasBrace) {
                     parseExpectedJSDoc(19 /* CloseBraceToken */);
                 }
@@ -37144,7 +37384,7 @@ var ts;
             JSDocParser.parseJSDocNameReference = parseJSDocNameReference;
             function parseIsolatedJSDocComment(content, start, length) {
                 initializeState("", content, 99 /* Latest */, /*_syntaxCursor:*/ undefined, 1 /* JS */);
-                var jsDoc = doInsideOfContext(4194304 /* JSDoc */, function () { return parseJSDocCommentWorker(start, length); });
+                var jsDoc = doInsideOfContext(8388608 /* JSDoc */, function () { return parseJSDocCommentWorker(start, length); });
                 var sourceFile = { languageVariant: 0 /* Standard */, text: content };
                 var diagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile);
                 clearState();
@@ -37155,9 +37395,9 @@ var ts;
                 var saveToken = currentToken;
                 var saveParseDiagnosticsLength = parseDiagnostics.length;
                 var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
-                var comment = doInsideOfContext(4194304 /* JSDoc */, function () { return parseJSDocCommentWorker(start, length); });
+                var comment = doInsideOfContext(8388608 /* JSDoc */, function () { return parseJSDocCommentWorker(start, length); });
                 ts.setParent(comment, parent);
-                if (contextFlags & 131072 /* JavaScriptFile */) {
+                if (contextFlags & 262144 /* JavaScriptFile */) {
                     if (!jsDocDiagnostics) {
                         jsDocDiagnostics = [];
                     }
@@ -37973,7 +38213,7 @@ var ts;
                     if (isBracketed) {
                         skipWhitespace();
                         parseExpected(63 /* EqualsToken */);
-                        defaultType = doInsideOfContext(4194304 /* JSDoc */, parseJSDocType);
+                        defaultType = doInsideOfContext(8388608 /* JSDoc */, parseJSDocType);
                         parseExpected(23 /* CloseBracketToken */);
                     }
                     if (ts.nodeIsMissing(name)) {
@@ -45727,6 +45967,7 @@ var ts;
                 case 261 /* ModuleDeclaration */:
                 case 259 /* TypeAliasDeclaration */:
                 case 195 /* MappedType */:
+                case 176 /* IndexSignature */:
                     return 1 /* IsContainer */ | 32 /* HasLocals */;
                 case 305 /* SourceFile */:
                     return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */;
@@ -45745,7 +45986,6 @@ var ts;
                 case 317 /* JSDocFunctionType */:
                 case 179 /* FunctionType */:
                 case 175 /* ConstructSignature */:
-                case 176 /* IndexSignature */:
                 case 180 /* ConstructorType */:
                 case 170 /* ClassStaticBlockDeclaration */:
                     return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */;
@@ -45861,7 +46101,7 @@ var ts;
         function setExportContextFlag(node) {
             // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular
             // declarations with export modifiers) is an export context in which declarations are implicitly exported.
-            if (node.flags & 8388608 /* Ambient */ && !hasExportDeclarations(node)) {
+            if (node.flags & 16777216 /* Ambient */ && !hasExportDeclarations(node)) {
                 node.flags |= 64 /* ExportContext */;
             }
             else {
@@ -46064,8 +46304,8 @@ var ts;
         function checkContextualIdentifier(node) {
             // Report error only if there are no parse errors in file
             if (!file.parseDiagnostics.length &&
-                !(node.flags & 8388608 /* Ambient */) &&
-                !(node.flags & 4194304 /* JSDoc */) &&
+                !(node.flags & 16777216 /* Ambient */) &&
+                !(node.flags & 8388608 /* JSDoc */) &&
                 !ts.isIdentifierName(node)) {
                 // strict mode identifiers
                 if (inStrictMode &&
@@ -47094,7 +47334,7 @@ var ts;
             if (node.kind === 340 /* JSDocParameterTag */ && container.kind !== 323 /* JSDocSignature */) {
                 return;
             }
-            if (inStrictMode && !(node.flags & 8388608 /* Ambient */)) {
+            if (inStrictMode && !(node.flags & 16777216 /* Ambient */)) {
                 // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a
                 // strict mode FunctionLikeDeclaration or FunctionExpression(13.1)
                 checkStrictModeEvalOrArguments(node, node.name);
@@ -47113,7 +47353,7 @@ var ts;
             }
         }
         function bindFunctionDeclaration(node) {
-            if (!file.isDeclarationFile && !(node.flags & 8388608 /* Ambient */)) {
+            if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */)) {
                 if (ts.isAsyncFunction(node)) {
                     emitFlags |= 2048 /* HasAsyncFunctions */;
                 }
@@ -47128,7 +47368,7 @@ var ts;
             }
         }
         function bindFunctionExpression(node) {
-            if (!file.isDeclarationFile && !(node.flags & 8388608 /* Ambient */)) {
+            if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */)) {
                 if (ts.isAsyncFunction(node)) {
                     emitFlags |= 2048 /* HasAsyncFunctions */;
                 }
@@ -47141,7 +47381,7 @@ var ts;
             return bindAnonymousDeclaration(node, 16 /* Function */, bindingName);
         }
         function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) {
-            if (!file.isDeclarationFile && !(node.flags & 8388608 /* Ambient */) && ts.isAsyncFunction(node)) {
+            if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */) && ts.isAsyncFunction(node)) {
                 emitFlags |= 2048 /* HasAsyncFunctions */;
             }
             if (currentFlow && ts.isObjectLiteralOrClassExpressionMethodOrAccessor(node)) {
@@ -47214,7 +47454,7 @@ var ts;
                         //   Rationale: we don't want to report errors on non-initialized var's since they are hoisted
                         //   On the other side we do want to report errors on non-initialized 'lets' because of TDZ
                         var isError_1 = ts.unreachableCodeIsError(options) &&
-                            !(node.flags & 8388608 /* Ambient */) &&
+                            !(node.flags & 16777216 /* Ambient */) &&
                             (!ts.isVariableStatement(node) ||
                                 !!(ts.getCombinedNodeFlags(node.declarationList) & 3 /* BlockScoped */) ||
                                 node.declarationList.declarations.some(function (d) { return !!d.initializer; }));
@@ -48114,7 +48354,7 @@ var ts;
                     ts.Debug.assert(!!(getNodeLinks(file).flags & 1 /* TypeChecked */));
                     diagnostics = ts.addRange(diagnostics, suggestionDiagnostics.getDiagnostics(file.fileName));
                     checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), function (containingNode, kind, diag) {
-                        if (!ts.containsParseError(containingNode) && !unusedIsError(kind, !!(containingNode.flags & 8388608 /* Ambient */))) {
+                        if (!ts.containsParseError(containingNode) && !unusedIsError(kind, !!(containingNode.flags & 16777216 /* Ambient */))) {
                             (diagnostics || (diagnostics = [])).push(__assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion }));
                         }
                     });
@@ -48565,7 +48805,7 @@ var ts;
             return diagnostic;
         }
         function isDeprecatedSymbol(symbol) {
-            return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 134217728 /* Deprecated */);
+            return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
         }
         function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
             var diagnostic = ts.createDiagnosticForNode(location, ts.Diagnostics._0_is_deprecated, deprecatedEntity);
@@ -48793,7 +49033,7 @@ var ts;
             else {
                 // find a module that about to be augmented
                 // do not validate names of augmentations that are defined in ambient context
-                var moduleNotFoundError = !(moduleName.parent.parent.flags & 8388608 /* Ambient */)
+                var moduleNotFoundError = !(moduleName.parent.parent.flags & 16777216 /* Ambient */)
                     ? ts.Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found
                     : undefined;
                 var mainModule_1 = resolveExternalModuleNameWorker(moduleName, moduleName, moduleNotFoundError, /*isForAugmentation*/ true);
@@ -48907,7 +49147,7 @@ var ts;
                 if ((moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator)) ||
                     (!ts.outFile(compilerOptions)) ||
                     isInTypeQuery(usage) ||
-                    declaration.flags & 8388608 /* Ambient */) {
+                    declaration.flags & 16777216 /* Ambient */) {
                     // nodes are in different files and order cannot be determined
                     return true;
                 }
@@ -48969,7 +49209,7 @@ var ts;
             if (usage.kind === 271 /* ExportAssignment */ && usage.isExportEquals) {
                 return true;
             }
-            if (!!(usage.flags & 4194304 /* JSDoc */) || isInTypeQuery(usage) || usageInTypeDeclaration()) {
+            if (!!(usage.flags & 8388608 /* JSDoc */) || isInTypeQuery(usage) || usageInTypeDeclaration()) {
                 return true;
             }
             if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
@@ -49234,7 +49474,7 @@ var ts;
                     // falls through
                     case 261 /* ModuleDeclaration */:
                         var moduleExports = ((_a = getSymbolOfNode(location)) === null || _a === void 0 ? void 0 : _a.exports) || emptySymbols;
-                        if (location.kind === 305 /* SourceFile */ || (ts.isModuleDeclaration(location) && location.flags & 8388608 /* Ambient */ && !ts.isGlobalScopeAugmentation(location))) {
+                        if (location.kind === 305 /* SourceFile */ || (ts.isModuleDeclaration(location) && location.flags & 16777216 /* Ambient */ && !ts.isGlobalScopeAugmentation(location))) {
                             // It's an external module. First see if the module has an export default and if the local
                             // name of that export default matches.
                             if (result = moduleExports.get("default" /* Default */)) {
@@ -49557,7 +49797,7 @@ var ts;
                         }
                     }
                     // If we're in an external module, we can't reference value symbols created from UMD export declarations
-                    if (result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */ && !(originalLocation.flags & 4194304 /* JSDoc */)) {
+                    if (result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */ && !(originalLocation.flags & 8388608 /* JSDoc */)) {
                         var merged = getMergedSymbol(result);
                         if (ts.length(merged.declarations) && ts.every(merged.declarations, function (d) { return ts.isNamespaceExportDeclaration(d) || ts.isSourceFile(d) && !!d.symbol.globalExports; })) {
                             errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, ts.unescapeLeadingUnderscores(name));
@@ -49812,7 +50052,7 @@ var ts;
             var declaration = (_a = result.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return ts.isBlockOrCatchScoped(d) || ts.isClassLike(d) || (d.kind === 260 /* EnumDeclaration */); });
             if (declaration === undefined)
                 return ts.Debug.fail("checkResolvedBlockScopedVariable could not find block-scoped declaration");
-            if (!(declaration.flags & 8388608 /* Ambient */) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) {
+            if (!(declaration.flags & 16777216 /* Ambient */) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) {
                 var diagnosticMessage = void 0;
                 var declarationName = ts.declarationNameToString(ts.getNameOfDeclaration(declaration));
                 if (result.flags & 2 /* BlockScopedVariable */) {
@@ -50323,27 +50563,27 @@ var ts;
         function resolveAlias(symbol) {
             ts.Debug.assert((symbol.flags & 2097152 /* Alias */) !== 0, "Should only get Alias here.");
             var links = getSymbolLinks(symbol);
-            if (!links.target) {
-                links.target = resolvingSymbol;
+            if (!links.aliasTarget) {
+                links.aliasTarget = resolvingSymbol;
                 var node = getDeclarationOfAliasSymbol(symbol);
                 if (!node)
                     return ts.Debug.fail();
                 var target = getTargetOfAliasDeclaration(node);
-                if (links.target === resolvingSymbol) {
-                    links.target = target || unknownSymbol;
+                if (links.aliasTarget === resolvingSymbol) {
+                    links.aliasTarget = target || unknownSymbol;
                 }
                 else {
                     error(node, ts.Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol));
                 }
             }
-            else if (links.target === resolvingSymbol) {
-                links.target = unknownSymbol;
+            else if (links.aliasTarget === resolvingSymbol) {
+                links.aliasTarget = unknownSymbol;
             }
-            return links.target;
+            return links.aliasTarget;
         }
         function tryResolveAlias(symbol) {
             var links = getSymbolLinks(symbol);
-            if (links.target !== resolvingSymbol) {
+            if (links.aliasTarget !== resolvingSymbol) {
                 return resolveAlias(symbol);
             }
             return undefined;
@@ -50585,7 +50825,7 @@ var ts;
             }
         }
         function getAssignmentDeclarationLocation(node) {
-            var typeAlias = ts.findAncestor(node, function (node) { return !(ts.isJSDocNode(node) || node.flags & 4194304 /* JSDoc */) ? "quit" : ts.isJSDocTypeAlias(node); });
+            var typeAlias = ts.findAncestor(node, function (node) { return !(ts.isJSDocNode(node) || node.flags & 8388608 /* JSDoc */) ? "quit" : ts.isJSDocTypeAlias(node); });
             if (typeAlias) {
                 return;
             }
@@ -52053,7 +52293,20 @@ var ts;
                 if (type.flags & 262144 /* TypeParameter */ || objectFlags & 3 /* ClassOrInterface */) {
                     if (type.flags & 262144 /* TypeParameter */ && ts.contains(context.inferTypeParameters, type)) {
                         context.approximateLength += (ts.symbolName(type.symbol).length + 6);
-                        return ts.factory.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, /*constraintNode*/ undefined));
+                        var constraintNode = void 0;
+                        var constraint = getConstraintOfTypeParameter(type);
+                        if (constraint) {
+                            // If the infer type has a constraint that is not the same as the constraint
+                            // we would have normally inferred based on context, we emit the constraint
+                            // using `infer T extends ?`. We omit inferred constraints from type references
+                            // as they may be elided.
+                            var inferredConstraint = getInferredTypeParameterConstraint(type, /*omitTypeReferences*/ true);
+                            if (!(inferredConstraint && isTypeIdenticalTo(constraint, inferredConstraint))) {
+                                context.approximateLength += 9;
+                                constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
+                            }
+                        }
+                        return ts.factory.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, constraintNode));
                     }
                     if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ &&
                         type.flags & 262144 /* TypeParameter */ &&
@@ -52127,13 +52380,37 @@ var ts;
                 return ts.Debug.fail("Should be unreachable.");
                 function conditionalTypeToTypeNode(type) {
                     var checkTypeNode = typeToTypeNodeHelper(type.checkType, context);
+                    context.approximateLength += 15;
+                    if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && type.root.isDistributive && !(type.checkType.flags & 262144 /* TypeParameter */)) {
+                        var newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
+                        var name = typeParameterToName(newParam, context);
+                        var newTypeVariable = ts.factory.createTypeReferenceNode(name);
+                        context.approximateLength += 37; // 15 each for two added conditionals, 7 for an added infer type
+                        var newMapper = prependTypeMapping(type.root.checkType, newParam, type.combinedMapper || type.mapper);
+                        var saveInferTypeParameters_1 = context.inferTypeParameters;
+                        context.inferTypeParameters = type.root.inferTypeParameters;
+                        var extendsTypeNode_1 = typeToTypeNodeHelper(instantiateType(type.root.extendsType, newMapper), context);
+                        context.inferTypeParameters = saveInferTypeParameters_1;
+                        var trueTypeNode_1 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type.root.node.trueType), newMapper));
+                        var falseTypeNode_1 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type.root.node.falseType), newMapper));
+                        // outermost conditional makes `T` a type parameter, allowing the inner conditionals to be distributive
+                        // second conditional makes `T` have `T & checkType` substitution, so it is correctly usable as the checkType
+                        // inner conditional runs the check the user provided on the check type (distributively) and returns the result
+                        // checkType extends infer T ? T extends checkType ? T extends extendsType<T> ? trueType<T> : falseType<T> : never : never;
+                        // this is potentially simplifiable to
+                        // checkType extends infer T ? T extends checkType & extendsType<T> ? trueType<T> : falseType<T> : never;
+                        // but that may confuse users who read the output more.
+                        // On the other hand,
+                        // checkType extends infer T extends checkType ? T extends extendsType<T> ? trueType<T> : falseType<T> : never;
+                        // may also work with `infer ... extends ...` in, but would produce declarations only compatible with the latest TS.
+                        return ts.factory.createConditionalTypeNode(checkTypeNode, ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName))), ts.factory.createConditionalTypeNode(ts.factory.createTypeReferenceNode(ts.factory.cloneNode(name)), typeToTypeNodeHelper(type.checkType, context), ts.factory.createConditionalTypeNode(newTypeVariable, extendsTypeNode_1, trueTypeNode_1, falseTypeNode_1), ts.factory.createKeywordTypeNode(143 /* NeverKeyword */)), ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
+                    }
                     var saveInferTypeParameters = context.inferTypeParameters;
                     context.inferTypeParameters = type.root.inferTypeParameters;
                     var extendsTypeNode = typeToTypeNodeHelper(type.extendsType, context);
                     context.inferTypeParameters = saveInferTypeParameters;
                     var trueTypeNode = typeToTypeNodeOrCircularityElision(getTrueTypeFromConditionalType(type));
                     var falseTypeNode = typeToTypeNodeOrCircularityElision(getFalseTypeFromConditionalType(type));
-                    context.approximateLength += 15;
                     return ts.factory.createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);
                 }
                 function typeToTypeNodeOrCircularityElision(type) {
@@ -54009,7 +54286,7 @@ var ts;
                             newModifierFlags |= 1 /* Export */;
                         }
                         if (addingDeclare && !(newModifierFlags & 1 /* Export */) &&
-                            (!enclosingDeclaration_1 || !(enclosingDeclaration_1.flags & 8388608 /* Ambient */)) &&
+                            (!enclosingDeclaration_1 || !(enclosingDeclaration_1.flags & 16777216 /* Ambient */)) &&
                             (ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isModuleDeclaration(node))) {
                             // Classes, namespaces, variables, enums, and functions all need `declare` modifiers to be valid in a declaration file top-level scope
                             newModifierFlags |= 2 /* Ambient */;
@@ -54979,7 +55256,7 @@ var ts;
                         var parent = getDeclarationContainer(node);
                         // If the node is not exported or it is not ambient module element (except import declaration)
                         if (!(ts.getCombinedModifierFlags(node) & 1 /* Export */) &&
-                            !(node.kind !== 265 /* ImportEqualsDeclaration */ && parent.kind !== 305 /* SourceFile */ && parent.flags & 8388608 /* Ambient */)) {
+                            !(node.kind !== 265 /* ImportEqualsDeclaration */ && parent.kind !== 305 /* SourceFile */ && parent.flags & 16777216 /* Ambient */)) {
                             return isGlobalSourceFile(parent);
                         }
                         // Exported members/ambient module elements (exception import declaration) are visible if parent is visible
@@ -55319,7 +55596,7 @@ var ts;
             }
             var pattern = declaration.parent;
             // Relax null check on ambient destructuring parameters, since the parameters have no implementation and are just documentation
-            if (strictNullChecks && declaration.flags & 8388608 /* Ambient */ && ts.isParameterDeclaration(declaration)) {
+            if (strictNullChecks && declaration.flags & 16777216 /* Ambient */ && ts.isParameterDeclaration(declaration)) {
                 parentType = getNonNullableType(parentType);
             }
             // Filter `undefined` from the type we check against if the parent has an initializer and that initializer is not possibly `undefined`
@@ -55435,7 +55712,7 @@ var ts;
             }
             if ((noImplicitAny || ts.isInJSFile(declaration)) &&
                 ts.isVariableDeclaration(declaration) && !ts.isBindingPattern(declaration.name) &&
-                !(ts.getCombinedModifierFlags(declaration) & 1 /* Export */) && !(declaration.flags & 8388608 /* Ambient */)) {
+                !(ts.getCombinedModifierFlags(declaration) & 1 /* Export */) && !(declaration.flags & 16777216 /* Ambient */)) {
                 // If --noImplicitAny is on or the declaration is in a Javascript file,
                 // use control flow tracked 'any' type for non-ambient, non-exported var or let variables with no
                 // initializer or a 'null' or 'undefined' initializer.
@@ -56891,7 +57168,7 @@ var ts;
         function isLiteralEnumMember(member) {
             var expr = member.initializer;
             if (!expr) {
-                return !(member.flags & 8388608 /* Ambient */);
+                return !(member.flags & 16777216 /* Ambient */);
             }
             switch (expr.kind) {
                 case 10 /* StringLiteral */:
@@ -59524,7 +59801,7 @@ var ts;
         function getConstraintDeclaration(type) {
             return ts.mapDefined(ts.filter(type.symbol && type.symbol.declarations, ts.isTypeParameterDeclaration), ts.getEffectiveConstraintOfTypeParameter)[0];
         }
-        function getInferredTypeParameterConstraint(typeParameter) {
+        function getInferredTypeParameterConstraint(typeParameter, omitTypeReferences) {
             var _a;
             var inferences;
             if ((_a = typeParameter.symbol) === null || _a === void 0 ? void 0 : _a.declarations) {
@@ -59536,7 +59813,7 @@ var ts;
                         // corresponding type parameter in 'Foo'. When multiple 'infer T' declarations are
                         // present, we form an intersection of the inferred constraint types.
                         var _c = ts.walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent), _d = _c[0], childTypeParameter = _d === void 0 ? declaration.parent : _d, grandParent = _c[1];
-                        if (grandParent.kind === 178 /* TypeReference */) {
+                        if (grandParent.kind === 178 /* TypeReference */ && !omitTypeReferences) {
                             var typeReference = grandParent;
                             var typeParameters = getTypeParametersForTypeReference(typeReference);
                             if (typeParameters) {
@@ -59958,7 +60235,7 @@ var ts;
             return constraints ? getSubstitutionType(type, getIntersectionType(ts.append(constraints, type))) : type;
         }
         function isJSDocTypeReference(node) {
-            return !!(node.flags & 4194304 /* JSDoc */) && (node.kind === 178 /* TypeReference */ || node.kind === 200 /* ImportType */);
+            return !!(node.flags & 8388608 /* JSDoc */) && (node.kind === 178 /* TypeReference */ || node.kind === 200 /* ImportType */);
         }
         function checkNoTypeArguments(node, symbol) {
             if (node.typeArguments) {
@@ -61517,7 +61794,7 @@ var ts;
                 if (ts.isCallLikeExpression(parent)) {
                     return ts.isCallOrNewExpression(parent) && ts.isIdentifier(node) && hasMatchingArgument(parent, node);
                 }
-                return ts.every(symbol.declarations, function (d) { return !ts.isFunctionLike(d) || !!(ts.getCombinedNodeFlags(d) & 134217728 /* Deprecated */); });
+                return ts.every(symbol.declarations, function (d) { return !ts.isFunctionLike(d) || !!(ts.getCombinedNodeFlags(d) & 268435456 /* Deprecated */); });
             }
             return true;
         }
@@ -61958,7 +62235,11 @@ var ts;
             return !root.isDistributive && isSingletonTupleType(root.node.checkType) && isSingletonTupleType(root.node.extendsType);
         }
         function isSingletonTupleType(node) {
-            return ts.isTupleTypeNode(node) && ts.length(node.elements) === 1 && !ts.isOptionalTypeNode(node.elements[0]) && !ts.isRestTypeNode(node.elements[0]);
+            return ts.isTupleTypeNode(node) &&
+                ts.length(node.elements) === 1 &&
+                !ts.isOptionalTypeNode(node.elements[0]) &&
+                !ts.isRestTypeNode(node.elements[0]) &&
+                !(ts.isNamedTupleMember(node.elements[0]) && (node.elements[0].questionToken || node.elements[0].dotDotDotToken));
         }
         /**
          * We syntactually check for common nondistributive conditional shapes and unwrap them into
@@ -62206,7 +62487,7 @@ var ts;
                     links.resolvedSymbol = unknownSymbol;
                     return links.resolvedType = errorType;
                 }
-                var targetMeaning = node.isTypeOf ? 111551 /* Value */ : node.flags & 4194304 /* JSDoc */ ? 111551 /* Value */ | 788968 /* Type */ : 788968 /* Type */;
+                var targetMeaning = node.isTypeOf ? 111551 /* Value */ : node.flags & 8388608 /* JSDoc */ ? 111551 /* Value */ | 788968 /* Type */ : 788968 /* Type */;
                 // TODO: Future work: support unions/generics/whatever via a deferred import-type
                 var innerModuleSymbol = resolveExternalModuleName(node, node.argument.literal);
                 if (!innerModuleSymbol) {
@@ -62542,7 +62823,7 @@ var ts;
             }
             // /** @return {this} */
             // x.prototype.m = function() { ... }
-            var host = node.flags & 4194304 /* JSDoc */ ? ts.getHostSignatureFromJSDoc(node) : undefined;
+            var host = node.flags & 8388608 /* JSDoc */ ? ts.getHostSignatureFromJSDoc(node) : undefined;
             if (host && ts.isFunctionExpression(host) && ts.isBinaryExpression(host.parent) && ts.getAssignmentDeclarationKind(host.parent) === 3 /* PrototypeProperty */) {
                 return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(host.parent.left).parent).thisType;
             }
@@ -62617,7 +62898,7 @@ var ts;
                 case 143 /* NeverKeyword */:
                     return neverType;
                 case 148 /* ObjectKeyword */:
-                    return node.flags & 131072 /* JavaScriptFile */ && !noImplicitAny ? anyType : nonPrimitiveType;
+                    return node.flags & 262144 /* JavaScriptFile */ && !noImplicitAny ? anyType : nonPrimitiveType;
                 case 138 /* IntrinsicKeyword */:
                     return intrinsicMarkerType;
                 case 192 /* ThisType */:
@@ -66478,6 +66759,9 @@ var ts;
         function createMarkerType(symbol, source, target) {
             var mapper = makeUnaryTypeMapper(source, target);
             var type = getDeclaredTypeOfSymbol(symbol);
+            if (isErrorType(type)) {
+                return type;
+            }
             var result = symbol.flags & 524288 /* TypeAlias */ ?
                 getTypeAliasInstantiation(symbol, instantiateTypes(getSymbolLinks(symbol).typeParameters, mapper)) :
                 createTypeReference(type, instantiateTypes(type.typeParameters, mapper));
@@ -67491,6 +67775,9 @@ var ts;
                 var inference = inferences[i];
                 if (t === inference.typeParameter) {
                     if (fix && !inference.isFixed) {
+                        // Before we commit to a particular inference (and thus lock out any further inferences),
+                        // we infer from any intra-expression inference sites we have collected.
+                        inferFromIntraExpressionSites(context);
                         clearCachedInferences(inferences);
                         inference.isFixed = true;
                     }
@@ -67507,6 +67794,37 @@ var ts;
                 }
             }
         }
+        function addIntraExpressionInferenceSite(context, node, type) {
+            var _a;
+            ((_a = context.intraExpressionInferenceSites) !== null && _a !== void 0 ? _a : (context.intraExpressionInferenceSites = [])).push({ node: node, type: type });
+        }
+        // We collect intra-expression inference sites within object and array literals to handle cases where
+        // inferred types flow between context sensitive element expressions. For example:
+        //
+        //   declare function foo<T>(arg: [(n: number) => T, (x: T) => void]): void;
+        //   foo([_a => 0, n => n.toFixed()]);
+        //
+        // Above, both arrow functions in the tuple argument are context sensitive, thus both are omitted from the
+        // pass that collects inferences from the non-context sensitive parts of the arguments. In the subsequent
+        // pass where nothing is omitted, we need to commit to an inference for T in order to contextually type the
+        // parameter in the second arrow function, but we want to first infer from the return type of the first
+        // arrow function. This happens automatically when the arrow functions are discrete arguments (because we
+        // infer from each argument before processing the next), but when the arrow functions are elements of an
+        // object or array literal, we need to perform intra-expression inferences early.
+        function inferFromIntraExpressionSites(context) {
+            if (context.intraExpressionInferenceSites) {
+                for (var _i = 0, _a = context.intraExpressionInferenceSites; _i < _a.length; _i++) {
+                    var _b = _a[_i], node = _b.node, type = _b.type;
+                    var contextualType = node.kind === 169 /* MethodDeclaration */ ?
+                        getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) :
+                        getContextualType(node, 2 /* NoConstraints */);
+                    if (contextualType) {
+                        inferTypes(context.inferences, type, contextualType);
+                    }
+                }
+                context.intraExpressionInferenceSites = undefined;
+            }
+        }
         function createInferenceInfo(typeParameter) {
             return {
                 typeParameter: typeParameter,
@@ -69489,7 +69807,7 @@ var ts;
         // parameter symbols with declarations that have explicit type annotations. Such references are
         // resolvable with no possibility of triggering circularities in control flow analysis.
         function getTypeOfDottedName(node, diagnostic) {
-            if (!(node.flags & 16777216 /* InWithStatement */)) {
+            if (!(node.flags & 33554432 /* InWithStatement */)) {
                 switch (node.kind) {
                     case 79 /* Identifier */:
                         var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
@@ -70893,6 +71211,7 @@ var ts;
             // a generic type without a nullable constraint and x is a generic type. This is because when both obj
             // and x are of generic types T and K, we want the resulting type to be T[K].
             return parent.kind === 206 /* PropertyAccessExpression */ ||
+                parent.kind === 161 /* QualifiedName */ ||
                 parent.kind === 208 /* CallExpression */ && parent.expression === node ||
                 parent.kind === 207 /* ElementAccessExpression */ && parent.expression === node &&
                     !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression)));
@@ -71186,7 +71505,7 @@ var ts;
                     isInTypeQuery(node) || node.parent.kind === 275 /* ExportSpecifier */) ||
                 node.parent.kind === 230 /* NonNullExpression */ ||
                 declaration.kind === 254 /* VariableDeclaration */ && declaration.exclamationToken ||
-                declaration.flags & 8388608 /* Ambient */;
+                declaration.flags & 16777216 /* Ambient */;
             var initialType = assumeInitialized ? (isParameter ? removeOptionalityFromDeclaredType(type, declaration) : type) :
                 type === autoType || type === autoArrayType ? undefinedType :
                     getOptionalType(type);
@@ -72194,7 +72513,7 @@ var ts;
         // exists. Otherwise, it is the type of the string index signature in T, if one exists.
         function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
             ts.Debug.assert(ts.isObjectLiteralMethod(node));
-            if (node.flags & 16777216 /* InWithStatement */) {
+            if (node.flags & 33554432 /* InWithStatement */) {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return undefined;
             }
@@ -72382,7 +72701,7 @@ var ts;
          * @returns the contextual type of an expression.
          */
         function getContextualType(node, contextFlags) {
-            if (node.flags & 16777216 /* InWithStatement */) {
+            if (node.flags & 33554432 /* InWithStatement */) {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return undefined;
             }
@@ -72800,6 +73119,11 @@ var ts;
                     var type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple);
                     elementTypes.push(addOptionality(type, /*isProperty*/ true, hasOmittedExpression));
                     elementFlags.push(hasOmittedExpression ? 2 /* Optional */ : 1 /* Required */);
+                    if (contextualType && someType(contextualType, isTupleLikeType) && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(e)) {
+                        var inferenceContext = getInferenceContext(node);
+                        ts.Debug.assert(inferenceContext); // In CheckMode.Inferential we should always have an inference context
+                        addIntraExpressionInferenceSite(inferenceContext, e, type);
+                    }
                 }
             }
             if (inDestructuringPattern) {
@@ -73001,6 +73325,13 @@ var ts;
                     prop.target = member;
                     member = prop;
                     allPropertiesTable === null || allPropertiesTable === void 0 ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
+                    if (contextualType && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) &&
+                        (memberDecl.kind === 296 /* PropertyAssignment */ || memberDecl.kind === 169 /* MethodDeclaration */) && isContextSensitive(memberDecl)) {
+                        var inferenceContext = getInferenceContext(node);
+                        ts.Debug.assert(inferenceContext); // In CheckMode.Inferential we should always have an inference context
+                        var inferenceNode = memberDecl.kind === 296 /* PropertyAssignment */ ? memberDecl.initializer : memberDecl;
+                        addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type);
+                    }
                 }
                 else if (memberDecl.kind === 298 /* SpreadAssignment */) {
                     if (languageVersion < 2 /* ES2015 */) {
@@ -74093,7 +74424,7 @@ var ts;
                 if (compilerOptions.noPropertyAccessFromIndexSignature && ts.isPropertyAccessExpression(node)) {
                     error(right, ts.Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, ts.unescapeLeadingUnderscores(right.escapedText));
                 }
-                if (indexInfo.declaration && ts.getCombinedNodeFlags(indexInfo.declaration) & 134217728 /* Deprecated */) {
+                if (indexInfo.declaration && ts.getCombinedNodeFlags(indexInfo.declaration) & 268435456 /* Deprecated */) {
                     addDeprecatedSuggestion(right, [indexInfo.declaration], right.escapedText);
                 }
             }
@@ -74161,7 +74492,7 @@ var ts;
                 if (declaration && isPropertyWithoutInitializer(declaration)) {
                     if (!ts.isStatic(declaration)) {
                         var flowContainer = getControlFlowContainer(node);
-                        if (flowContainer.kind === 171 /* Constructor */ && flowContainer.parent === declaration.parent && !(declaration.flags & 8388608 /* Ambient */)) {
+                        if (flowContainer.kind === 171 /* Constructor */ && flowContainer.parent === declaration.parent && !(declaration.flags & 16777216 /* Ambient */)) {
                             assumeUninitialized = true;
                         }
                     }
@@ -74198,7 +74529,7 @@ var ts;
             }
             else if (valueDeclaration.kind === 257 /* ClassDeclaration */ &&
                 node.parent.kind !== 178 /* TypeReference */ &&
-                !(valueDeclaration.flags & 8388608 /* Ambient */) &&
+                !(valueDeclaration.flags & 16777216 /* Ambient */) &&
                 !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)) {
                 diagnosticMessage = error(right, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName);
             }
@@ -74863,34 +75194,36 @@ var ts;
             if (node.kind !== 165 /* Decorator */) {
                 var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 /* SkipBindingPatterns */ : 0 /* None */);
                 if (contextualType) {
-                    // We clone the inference context to avoid disturbing a resolution in progress for an
-                    // outer call expression. Effectively we just want a snapshot of whatever has been
-                    // inferred for any outer call expression so far.
-                    var outerContext = getInferenceContext(node);
-                    var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
-                    var instantiatedType = instantiateType(contextualType, outerMapper);
-                    // If the contextual type is a generic function type with a single call signature, we
-                    // instantiate the type with its own type parameters and type arguments. This ensures that
-                    // the type parameters are not erased to type any during type inference such that they can
-                    // be inferred as actual types from the contextual type. For example:
-                    //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
-                    //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
-                    // Above, the type of the 'value' parameter is inferred to be 'A'.
-                    var contextualSignature = getSingleCallSignature(instantiatedType);
-                    var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
-                        getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
-                        instantiatedType;
                     var inferenceTargetType = getReturnTypeOfSignature(signature);
-                    // Inferences made from return types have lower priority than all other inferences.
-                    inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
-                    // Create a type mapper for instantiating generic contextual types using the inferences made
-                    // from the return type. We need a separate inference pass here because (a) instantiation of
-                    // the source type uses the outer context's return mapper (which excludes inferences made from
-                    // outer arguments), and (b) we don't want any further inferences going into this context.
-                    var returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
-                    var returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
-                    inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
-                    context.returnMapper = ts.some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : undefined;
+                    if (couldContainTypeVariables(inferenceTargetType)) {
+                        // We clone the inference context to avoid disturbing a resolution in progress for an
+                        // outer call expression. Effectively we just want a snapshot of whatever has been
+                        // inferred for any outer call expression so far.
+                        var outerContext = getInferenceContext(node);
+                        var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
+                        var instantiatedType = instantiateType(contextualType, outerMapper);
+                        // If the contextual type is a generic function type with a single call signature, we
+                        // instantiate the type with its own type parameters and type arguments. This ensures that
+                        // the type parameters are not erased to type any during type inference such that they can
+                        // be inferred as actual types from the contextual type. For example:
+                        //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
+                        //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
+                        // Above, the type of the 'value' parameter is inferred to be 'A'.
+                        var contextualSignature = getSingleCallSignature(instantiatedType);
+                        var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
+                            getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
+                            instantiatedType;
+                        // Inferences made from return types have lower priority than all other inferences.
+                        inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        // Create a type mapper for instantiating generic contextual types using the inferences made
+                        // from the return type. We need a separate inference pass here because (a) instantiation of
+                        // the source type uses the outer context's return mapper (which excludes inferences made from
+                        // outer arguments), and (b) we don't want any further inferences going into this context.
+                        var returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
+                        var returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
+                        inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
+                        context.returnMapper = ts.some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : undefined;
+                    }
                 }
             }
             var restType = getNonArrayRestType(signature);
@@ -74902,7 +75235,7 @@ var ts;
                 }
             }
             var thisType = getThisTypeOfSignature(signature);
-            if (thisType) {
+            if (thisType && couldContainTypeVariables(thisType)) {
                 var thisArgumentNode = getThisArgumentOfCall(node);
                 inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType);
             }
@@ -74910,11 +75243,13 @@ var ts;
                 var arg = args[i];
                 if (arg.kind !== 227 /* OmittedExpression */ && !(checkMode & 32 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
                     var paramType = getTypeAtPosition(signature, i);
-                    var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
-                    inferTypes(context.inferences, argType, paramType);
+                    if (couldContainTypeVariables(paramType)) {
+                        var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
+                        inferTypes(context.inferences, argType, paramType);
+                    }
                 }
             }
-            if (restType) {
+            if (restType && couldContainTypeVariables(restType)) {
                 var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode);
                 inferTypes(context.inferences, spreadType, restType);
             }
@@ -76494,7 +76829,7 @@ var ts;
             return returnType;
         }
         function checkDeprecatedSignature(signature, node) {
-            if (signature.declaration && signature.declaration.flags & 134217728 /* Deprecated */) {
+            if (signature.declaration && signature.declaration.flags & 268435456 /* Deprecated */) {
                 var suggestionNode = getDeprecatedSuggestionNode(node);
                 var name = ts.tryGetPropertyAccessOrIdentifierToString(ts.getInvokedExpression(node));
                 addDeprecatedSuggestionWithSignature(suggestionNode, signature.declaration, name, signatureToString(signature));
@@ -76578,7 +76913,7 @@ var ts;
             var newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
             newSymbol.parent = originalSymbol;
             newSymbol.nameType = getStringLiteralType("default");
-            newSymbol.target = resolveSymbol(symbol);
+            newSymbol.aliasTarget = resolveSymbol(symbol);
             memberTable.set("default" /* Default */, newSymbol);
             return createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, ts.emptyArray);
         }
@@ -76638,7 +76973,7 @@ var ts;
             if (targetDeclarationKind !== 0 /* Unknown */) {
                 var decl = ts.getDeclarationOfKind(resolvedRequire, targetDeclarationKind);
                 // function/variable declaration should be ambient
-                return !!decl && !!(decl.flags & 8388608 /* Ambient */);
+                return !!decl && !!(decl.flags & 16777216 /* Ambient */);
             }
             return false;
         }
@@ -76833,7 +77168,7 @@ var ts;
                 error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node12_or_nodenext);
             }
             var file = ts.getSourceFileOfNode(node);
-            ts.Debug.assert(!!(file.flags & 2097152 /* PossiblyContainsImportMeta */), "Containing file is missing import meta node flag.");
+            ts.Debug.assert(!!(file.flags & 4194304 /* PossiblyContainsImportMeta */), "Containing file is missing import meta node flag.");
             return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType;
         }
         function getTypeOfParameter(symbol) {
@@ -78847,6 +79182,11 @@ var ts;
                 context.contextualType = contextualType;
                 context.inferenceContext = inferenceContext;
                 var type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
+                // In CheckMode.Inferential we collect intra-expression inference sites to process before fixing any type
+                // parameters. This information is no longer needed after the call to checkExpression.
+                if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
+                    inferenceContext.intraExpressionInferenceSites = undefined;
+                }
                 // 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.
@@ -79138,7 +79478,7 @@ var ts;
                 return quickType;
             }
             // If a type has been cached for the node, return it.
-            if (node.flags & 67108864 /* TypeCached */ && flowTypeCache) {
+            if (node.flags & 134217728 /* TypeCached */ && flowTypeCache) {
                 var cachedType = flowTypeCache[getNodeId(node)];
                 if (cachedType) {
                     return cachedType;
@@ -79150,7 +79490,7 @@ var ts;
             if (flowInvocationCount !== startInvocationCount) {
                 var cache = flowTypeCache || (flowTypeCache = []);
                 cache[getNodeId(node)] = type;
-                ts.setNodeFlags(node, node.flags | 67108864 /* TypeCached */);
+                ts.setNodeFlags(node, node.flags | 134217728 /* TypeCached */);
             }
             return type;
         }
@@ -79236,7 +79576,7 @@ var ts;
             if (compilerOptions.isolatedModules) {
                 ts.Debug.assert(!!(type.symbol.flags & 128 /* ConstEnum */));
                 var constEnumDeclaration = type.symbol.valueDeclaration;
-                if (constEnumDeclaration.flags & 8388608 /* Ambient */) {
+                if (constEnumDeclaration.flags & 16777216 /* Ambient */) {
                     error(node, ts.Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided);
                 }
             }
@@ -79387,14 +79727,19 @@ var ts;
             }
             if (node.parent.kind === 258 /* InterfaceDeclaration */ || node.parent.kind === 257 /* ClassDeclaration */ || node.parent.kind === 259 /* TypeAliasDeclaration */) {
                 var modifiers = getVarianceModifiers(typeParameter);
-                if (modifiers === 32768 /* In */ || modifiers === 65536 /* Out */) {
+                if (modifiers) {
                     var symbol = getSymbolOfNode(node.parent);
-                    var source = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSubType : markerSuperType);
-                    var target = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSuperType : markerSubType);
-                    var saveVarianceTypeParameter = typeParameter;
-                    varianceTypeParameter = typeParameter;
-                    checkTypeAssignableTo(source, target, node, ts.Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation);
-                    varianceTypeParameter = saveVarianceTypeParameter;
+                    if (node.parent.kind === 259 /* TypeAliasDeclaration */ && !(ts.getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
+                        error(node, ts.Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types);
+                    }
+                    else if (modifiers === 32768 /* In */ || modifiers === 65536 /* Out */) {
+                        var source = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSubType : markerSuperType);
+                        var target = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSuperType : markerSubType);
+                        var saveVarianceTypeParameter = typeParameter;
+                        varianceTypeParameter = typeParameter;
+                        checkTypeAssignableTo(source, target, node, ts.Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation);
+                        varianceTypeParameter = saveVarianceTypeParameter;
+                    }
                 }
             }
             addLazyDiagnostic(function () { return checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); });
@@ -79929,7 +80274,7 @@ var ts;
                 checkDecorators(node);
                 checkSignatureDeclaration(node);
                 if (node.kind === 172 /* GetAccessor */) {
-                    if (!(node.flags & 8388608 /* Ambient */) && ts.nodeIsPresent(node.body) && (node.flags & 256 /* HasImplicitReturn */)) {
+                    if (!(node.flags & 16777216 /* Ambient */) && ts.nodeIsPresent(node.body) && (node.flags & 256 /* HasImplicitReturn */)) {
                         if (!(node.flags & 512 /* HasExplicitReturn */)) {
                             error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value);
                         }
@@ -80024,7 +80369,7 @@ var ts;
                 }
                 var symbol = getNodeLinks(node).resolvedSymbol;
                 if (symbol) {
-                    if (ts.some(symbol.declarations, function (d) { return isTypeDeclaration(d) && !!(d.flags & 134217728 /* Deprecated */); })) {
+                    if (ts.some(symbol.declarations, function (d) { return isTypeDeclaration(d) && !!(d.flags & 268435456 /* Deprecated */); })) {
                         addDeprecatedSuggestion(getDeprecatedSuggestionNode(node), symbol.declarations, symbol.escapedName);
                     }
                     if (type.flags & 32 /* Enum */ && symbol.flags & 8 /* EnumMember */) {
@@ -80184,6 +80529,23 @@ var ts;
                 grammarErrorOnNode(node, ts.Diagnostics.infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type);
             }
             checkSourceElement(node.typeParameter);
+            var symbol = getSymbolOfNode(node.typeParameter);
+            if (symbol.declarations && symbol.declarations.length > 1) {
+                var links = getSymbolLinks(symbol);
+                if (!links.typeParametersChecked) {
+                    links.typeParametersChecked = true;
+                    var typeParameter = getDeclaredTypeOfTypeParameter(symbol);
+                    var declarations = ts.getDeclarationsOfKind(symbol, 163 /* TypeParameter */);
+                    if (!areTypeParametersIdentical(declarations, [typeParameter], function (decl) { return [decl]; })) {
+                        // Report an error on every conflicting declaration.
+                        var name = symbolToString(symbol);
+                        for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
+                            var declaration = declarations_4[_i];
+                            error(declaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_constraints, name);
+                        }
+                    }
+                }
+            }
             registerForUnusedIdentifiersCheck(node);
         }
         function checkTemplateLiteralType(node) {
@@ -80221,7 +80583,7 @@ var ts;
             getTypeFromTypeNode(node);
         }
         function isPrivateWithinAmbient(node) {
-            return (ts.hasEffectiveModifier(node, 8 /* Private */) || ts.isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 8388608 /* Ambient */);
+            return (ts.hasEffectiveModifier(node, 8 /* Private */) || ts.isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 16777216 /* Ambient */);
         }
         function getEffectiveDeclarationFlags(n, flagsToCheck) {
             var flags = ts.getCombinedModifierFlags(n);
@@ -80230,7 +80592,7 @@ var ts;
             if (n.parent.kind !== 258 /* InterfaceDeclaration */ &&
                 n.parent.kind !== 257 /* ClassDeclaration */ &&
                 n.parent.kind !== 226 /* ClassExpression */ &&
-                n.flags & 8388608 /* Ambient */) {
+                n.flags & 16777216 /* Ambient */) {
                 if (!(flags & 2 /* Ambient */) && !(ts.isModuleBlock(n.parent) && ts.isModuleDeclaration(n.parent.parent) && ts.isGlobalScopeAugmentation(n.parent.parent))) {
                     // It is nested in an ambient context, which means it is automatically exported
                     flags |= 1 /* Export */;
@@ -80363,10 +80725,10 @@ var ts;
             var hasNonAmbientClass = false;
             var functionDeclarations = [];
             if (declarations) {
-                for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
-                    var current = declarations_4[_i];
+                for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
+                    var current = declarations_5[_i];
                     var node = current;
-                    var inAmbientContext = node.flags & 8388608 /* Ambient */;
+                    var inAmbientContext = node.flags & 16777216 /* Ambient */;
                     var inAmbientContextOrInterface = node.parent && (node.parent.kind === 258 /* InterfaceDeclaration */ || node.parent.kind === 182 /* TypeLiteral */) || inAmbientContext;
                     if (inAmbientContextOrInterface) {
                         // check if declarations are consecutive only if they are non-ambient
@@ -81218,7 +81580,7 @@ var ts;
                 // checkFunctionOrConstructorSymbol wouldn't be called if we didnt ignore javascript function.
                 var firstDeclaration = (_a = localSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(
                 // Get first non javascript function declaration
-                function (declaration) { return declaration.kind === node.kind && !(declaration.flags & 131072 /* JavaScriptFile */); });
+                function (declaration) { return declaration.kind === node.kind && !(declaration.flags & 262144 /* JavaScriptFile */); });
                 // Only type check the symbol once
                 if (node === firstDeclaration) {
                     checkFunctionOrConstructorSymbol(localSymbol);
@@ -81340,7 +81702,7 @@ var ts;
                         var symbol = getSymbolOfNode(member);
                         if (!symbol.isReferenced
                             && (ts.hasEffectiveModifier(member, 8 /* Private */) || ts.isNamedDeclaration(member) && ts.isPrivateIdentifier(member.name))
-                            && !(member.flags & 8388608 /* Ambient */)) {
+                            && !(member.flags & 16777216 /* Ambient */)) {
                             addDiagnostic(member, 0 /* Local */, ts.createDiagnosticForNode(member.name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol)));
                         }
                         break;
@@ -81530,8 +81892,8 @@ var ts;
                         : ts.createDiagnosticForNode(declarationList.parent.kind === 237 /* VariableStatement */ ? declarationList.parent : declarationList, ts.Diagnostics.All_variables_are_unused));
                 }
                 else {
-                    for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
-                        var decl = declarations_5[_i];
+                    for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+                        var decl = declarations_6[_i];
                         addDiagnostic(decl, 0 /* Local */, ts.createDiagnosticForNode(decl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(decl.name)));
                     }
                 }
@@ -81573,7 +81935,7 @@ var ts;
         }
         function checkCollisionWithArgumentsInGeneratedCode(node) {
             // no rest parameters \ declaration context \ overload - no codegen impact
-            if (languageVersion >= 2 /* ES2015 */ || !ts.hasRestParameter(node) || node.flags & 8388608 /* Ambient */ || ts.nodeIsMissing(node.body)) {
+            if (languageVersion >= 2 /* ES2015 */ || !ts.hasRestParameter(node) || node.flags & 16777216 /* Ambient */ || ts.nodeIsMissing(node.body)) {
                 return;
             }
             ts.forEach(node.parameters, function (p) {
@@ -81601,7 +81963,7 @@ var ts;
                 // it is ok to have member named '_super', '_this', `Promise`, etc. - member access is always qualified
                 return false;
             }
-            if (node.flags & 8388608 /* Ambient */) {
+            if (node.flags & 16777216 /* Ambient */) {
                 // ambient context - no codegen impact
                 return false;
             }
@@ -81740,7 +82102,7 @@ var ts;
             recordPotentialCollisionWithReflectInGeneratedCode(node, name);
             if (ts.isClassLike(node)) {
                 checkTypeNameIsReserved(name, ts.Diagnostics.Class_name_cannot_be_0);
-                if (!(node.flags & 8388608 /* Ambient */)) {
+                if (!(node.flags & 16777216 /* Ambient */)) {
                     checkClassNameCollisionWithObject(name);
                 }
             }
@@ -83334,23 +83696,23 @@ var ts;
                     return;
                 }
                 var type = getDeclaredTypeOfSymbol(symbol);
-                if (!areTypeParametersIdentical(declarations, type.localTypeParameters)) {
+                if (!areTypeParametersIdentical(declarations, type.localTypeParameters, ts.getEffectiveTypeParameterDeclarations)) {
                     // Report an error on every conflicting declaration.
                     var name = symbolToString(symbol);
-                    for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
-                        var declaration = declarations_6[_i];
+                    for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
+                        var declaration = declarations_7[_i];
                         error(declaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_type_parameters, name);
                     }
                 }
             }
         }
-        function areTypeParametersIdentical(declarations, targetParameters) {
+        function areTypeParametersIdentical(declarations, targetParameters, getTypeParameterDeclarations) {
             var maxTypeArgumentCount = ts.length(targetParameters);
             var minTypeArgumentCount = getMinTypeArgumentCount(targetParameters);
-            for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
-                var declaration = declarations_7[_i];
+            for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
+                var declaration = declarations_8[_i];
                 // If this declaration has too few or too many type parameters, we report an error
-                var sourceParameters = ts.getEffectiveTypeParameterDeclarations(declaration);
+                var sourceParameters = getTypeParameterDeclarations(declaration);
                 var numTypeParameters = sourceParameters.length;
                 if (numTypeParameters < minTypeArgumentCount || numTypeParameters > maxTypeArgumentCount) {
                     return false;
@@ -83418,7 +83780,7 @@ var ts;
             checkFunctionOrConstructorSymbol(symbol);
             checkClassForDuplicateDeclarations(node);
             // Only check for reserved static identifiers on non-ambient context.
-            var nodeInAmbientContext = !!(node.flags & 8388608 /* Ambient */);
+            var nodeInAmbientContext = !!(node.flags & 16777216 /* Ambient */);
             if (!nodeInAmbientContext) {
                 checkClassForStaticPropertyNameConflicts(node);
             }
@@ -83568,7 +83930,7 @@ var ts;
          */
         function checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, memberHasAbstractModifier, memberIsStatic, memberIsParameterProperty, memberName, errorNode) {
             var isJs = ts.isInJSFile(node);
-            var nodeInAmbientContext = !!(node.flags & 8388608 /* Ambient */);
+            var nodeInAmbientContext = !!(node.flags & 16777216 /* Ambient */);
             if (baseWithThis && (memberHasOverrideModifier || compilerOptions.noImplicitOverride)) {
                 var memberEscapedName = ts.escapeLeadingUnderscores(memberName);
                 var thisType = memberIsStatic ? staticType : typeWithThis;
@@ -83796,7 +84158,7 @@ var ts;
                                 && !(derived.flags & 33554432 /* Transient */)
                                 && !(baseDeclarationFlags & 128 /* Abstract */)
                                 && !(derivedDeclarationFlags & 128 /* Abstract */)
-                                && !((_b = derived.declarations) === null || _b === void 0 ? void 0 : _b.some(function (d) { return !!(d.flags & 8388608 /* Ambient */); }))) {
+                                && !((_b = derived.declarations) === null || _b === void 0 ? void 0 : _b.some(function (d) { return !!(d.flags & 16777216 /* Ambient */); }))) {
                                 var constructor = findConstructorDeclaration(ts.getClassLikeDeclarationOfSymbol(type.symbol));
                                 var propName = uninitialized.name;
                                 if (uninitialized.exclamationToken
@@ -83888,7 +84250,7 @@ var ts;
             return ok;
         }
         function checkPropertyInitialization(node) {
-            if (!strictNullChecks || !strictPropertyInitialization || node.flags & 8388608 /* Ambient */) {
+            if (!strictNullChecks || !strictPropertyInitialization || node.flags & 16777216 /* Ambient */) {
                 return;
             }
             var constructor = findConstructorDeclaration(node);
@@ -84025,7 +84387,7 @@ var ts;
             }
             // In ambient non-const numeric enum declarations, enum members without initializers are
             // considered computed members (as opposed to having auto-incremented values).
-            if (member.parent.flags & 8388608 /* Ambient */ && !ts.isEnumConst(member.parent) && getEnumKind(getSymbolOfNode(member.parent)) === 0 /* Numeric */) {
+            if (member.parent.flags & 16777216 /* Ambient */ && !ts.isEnumConst(member.parent) && getEnumKind(getSymbolOfNode(member.parent)) === 0 /* Numeric */) {
                 return undefined;
             }
             // If the member declaration specifies no value, the member is considered a constant enum member.
@@ -84057,7 +84419,7 @@ var ts;
             else if (isConstEnum) {
                 error(initializer, ts.Diagnostics.const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values);
             }
-            else if (member.parent.flags & 8388608 /* Ambient */) {
+            else if (member.parent.flags & 16777216 /* Ambient */) {
                 error(initializer, ts.Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
             }
             else {
@@ -84225,11 +84587,11 @@ var ts;
         function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
             var declarations = symbol.declarations;
             if (declarations) {
-                for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
-                    var declaration = declarations_8[_i];
+                for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) {
+                    var declaration = declarations_9[_i];
                     if ((declaration.kind === 257 /* ClassDeclaration */ ||
                         (declaration.kind === 256 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) &&
-                        !(declaration.flags & 8388608 /* Ambient */)) {
+                        !(declaration.flags & 16777216 /* Ambient */)) {
                         return declaration;
                     }
                 }
@@ -84260,7 +84622,7 @@ var ts;
             function checkModuleDeclarationDiagnostics() {
                 // Grammar checking
                 var isGlobalAugmentation = ts.isGlobalScopeAugmentation(node);
-                var inAmbientContext = node.flags & 8388608 /* Ambient */;
+                var inAmbientContext = node.flags & 16777216 /* Ambient */;
                 if (isGlobalAugmentation && !inAmbientContext) {
                     error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context);
                 }
@@ -84478,7 +84840,7 @@ var ts;
                 }
                 if (compilerOptions.isolatedModules
                     && !ts.isTypeOnlyImportOrExportDeclaration(node)
-                    && !(node.flags & 8388608 /* Ambient */)) {
+                    && !(node.flags & 16777216 /* Ambient */)) {
                     var typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol);
                     var isType = !(target.flags & 111551 /* Value */);
                     if (isType || typeOnlyAlias) {
@@ -84524,7 +84886,7 @@ var ts;
             }
         }
         function isDeprecatedAliasedSymbol(symbol) {
-            return !!symbol.declarations && ts.every(symbol.declarations, function (d) { return !!(ts.getCombinedNodeFlags(d) & 134217728 /* Deprecated */); });
+            return !!symbol.declarations && ts.every(symbol.declarations, function (d) { return !!(ts.getCombinedNodeFlags(d) & 268435456 /* Deprecated */); });
         }
         function checkDeprecatedAliasedSymbol(symbol, location) {
             if (!(symbol.flags & 2097152 /* Alias */))
@@ -84653,7 +85015,7 @@ var ts;
                     }
                 }
                 else {
-                    if (moduleKind >= ts.ModuleKind.ES2015 && ts.getSourceFileOfNode(node).impliedNodeFormat === undefined && !node.isTypeOnly && !(node.flags & 8388608 /* Ambient */)) {
+                    if (moduleKind >= ts.ModuleKind.ES2015 && ts.getSourceFileOfNode(node).impliedNodeFormat === undefined && !node.isTypeOnly && !(node.flags & 16777216 /* Ambient */)) {
                         // Import equals declaration is deprecated in es6 or above
                         grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
                     }
@@ -84679,7 +85041,7 @@ var ts;
                     ts.forEach(node.exportClause.elements, checkExportSpecifier);
                     var inAmbientExternalModule = node.parent.kind === 262 /* ModuleBlock */ && ts.isAmbientModule(node.parent.parent);
                     var inAmbientNamespaceDeclaration = !inAmbientExternalModule && node.parent.kind === 262 /* ModuleBlock */ &&
-                        !node.moduleSpecifier && node.flags & 8388608 /* Ambient */;
+                        !node.moduleSpecifier && node.flags & 16777216 /* Ambient */;
                     if (node.parent.kind !== 305 /* SourceFile */ && !inAmbientExternalModule && !inAmbientNamespaceDeclaration) {
                         error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace);
                     }
@@ -84844,10 +85206,10 @@ var ts;
                 checkExpressionCached(node.expression);
             }
             checkExternalModuleExports(container);
-            if ((node.flags & 8388608 /* Ambient */) && !ts.isEntityNameExpression(node.expression)) {
+            if ((node.flags & 16777216 /* Ambient */) && !ts.isEntityNameExpression(node.expression)) {
                 grammarErrorOnNode(node.expression, ts.Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context);
             }
-            if (node.isExportEquals && !(node.flags & 8388608 /* Ambient */)) {
+            if (node.isExportEquals && !(node.flags & 16777216 /* Ambient */)) {
                 if (moduleKind >= ts.ModuleKind.ES2015 && ts.getSourceFileOfNode(node).impliedNodeFormat !== ts.ModuleKind.CommonJS) {
                     // export assignment is not supported in es6 modules
                     grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead);
@@ -85280,7 +85642,7 @@ var ts;
                     // This relies on the results of other lazy diagnostics, so must be computed after them
                     if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) {
                         checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), function (containingNode, kind, diag) {
-                            if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 8388608 /* Ambient */))) {
+                            if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 16777216 /* Ambient */))) {
                                 diagnostics.add(diag);
                             }
                         });
@@ -85380,7 +85742,7 @@ var ts;
         }
         // Language service support
         function getSymbolsInScope(location, meaning) {
-            if (location.flags & 16777216 /* InWithStatement */) {
+            if (location.flags & 33554432 /* InWithStatement */) {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return [];
             }
@@ -85730,7 +86092,7 @@ var ts;
             }
             var parent = node.parent;
             var grandParent = parent.parent;
-            if (node.flags & 16777216 /* InWithStatement */) {
+            if (node.flags & 33554432 /* InWithStatement */) {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return undefined;
             }
@@ -85872,7 +86234,7 @@ var ts;
             if (ts.isSourceFile(node) && !ts.isExternalModule(node)) {
                 return errorType;
             }
-            if (node.flags & 16777216 /* InWithStatement */) {
+            if (node.flags & 33554432 /* InWithStatement */) {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return errorType;
             }
@@ -86037,11 +86399,11 @@ var ts;
                 var _a = symbol, leftSpread = _a.leftSpread, rightSpread = _a.rightSpread, syntheticOrigin = _a.syntheticOrigin;
                 return leftSpread ? [leftSpread, rightSpread]
                     : syntheticOrigin ? [syntheticOrigin]
-                        : ts.singleElementArray(tryGetAliasTarget(symbol));
+                        : ts.singleElementArray(tryGetTarget(symbol));
             }
             return undefined;
         }
-        function tryGetAliasTarget(symbol) {
+        function tryGetTarget(symbol) {
             var target;
             var next = symbol;
             while (next = getSymbolLinks(next).target) {
@@ -86271,7 +86633,7 @@ var ts;
                 if (links === null || links === void 0 ? void 0 : links.referenced) {
                     return true;
                 }
-                var target = getSymbolLinks(symbol).target; // TODO: GH#18217
+                var target = getSymbolLinks(symbol).aliasTarget; // TODO: GH#18217
                 if (target && ts.getEffectiveModifierFlags(node) & 1 /* Export */ &&
                     target.flags & 111551 /* Value */ &&
                     (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
@@ -86925,7 +87287,7 @@ var ts;
         function checkExternalEmitHelpers(location, helpers) {
             if ((requestedExternalEmitHelpers & helpers) !== helpers && compilerOptions.importHelpers) {
                 var sourceFile = ts.getSourceFileOfNode(location);
-                if (ts.isEffectiveExternalModule(sourceFile, compilerOptions) && !(location.flags & 8388608 /* Ambient */)) {
+                if (ts.isEffectiveExternalModule(sourceFile, compilerOptions) && !(location.flags & 16777216 /* Ambient */)) {
                     var helpersModule = resolveHelpersModule(sourceFile, location);
                     if (helpersModule !== unknownSymbol) {
                         var uncheckedHelpers = helpers & ~requestedExternalEmitHelpers;
@@ -87178,7 +87540,7 @@ var ts;
                         else if (node.kind === 164 /* Parameter */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare");
                         }
-                        else if ((node.parent.flags & 8388608 /* Ambient */) && node.parent.kind === 262 /* ModuleBlock */) {
+                        else if ((node.parent.flags & 16777216 /* Ambient */) && node.parent.kind === 262 /* ModuleBlock */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
                         }
                         else if (ts.isPrivateIdentifierClassElementDeclaration(node)) {
@@ -87224,7 +87586,7 @@ var ts;
                         if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async");
                         }
-                        else if (flags & 2 /* Ambient */ || node.parent.flags & 8388608 /* Ambient */) {
+                        else if (flags & 2 /* Ambient */ || node.parent.flags & 16777216 /* Ambient */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.kind === 164 /* Parameter */) {
@@ -87370,7 +87732,7 @@ var ts;
                     if (i !== (parameterCount - 1)) {
                         return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
                     }
-                    if (!(parameter.flags & 8388608 /* Ambient */)) { // Allow `...foo,` in ambient declarations; see GH#23070
+                    if (!(parameter.flags & 16777216 /* Ambient */)) { // Allow `...foo,` in ambient declarations; see GH#23070
                         checkGrammarForDisallowedTrailingComma(parameters, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
                     }
                     if (parameter.questionToken) {
@@ -87581,7 +87943,7 @@ var ts;
                 ts.Debug.assert(node.kind === 256 /* FunctionDeclaration */ ||
                     node.kind === 213 /* FunctionExpression */ ||
                     node.kind === 169 /* MethodDeclaration */);
-                if (node.flags & 8388608 /* Ambient */) {
+                if (node.flags & 16777216 /* Ambient */) {
                     return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context);
                 }
                 if (!node.body) {
@@ -87819,7 +88181,7 @@ var ts;
             return false;
         }
         function checkGrammarAccessor(accessor) {
-            if (!(accessor.flags & 8388608 /* Ambient */) && (accessor.parent.kind !== 182 /* TypeLiteral */) && (accessor.parent.kind !== 258 /* InterfaceDeclaration */)) {
+            if (!(accessor.flags & 16777216 /* Ambient */) && (accessor.parent.kind !== 182 /* TypeLiteral */) && (accessor.parent.kind !== 258 /* InterfaceDeclaration */)) {
                 if (languageVersion < 1 /* ES5 */) {
                     return grammarErrorOnNode(accessor.name, ts.Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
                 }
@@ -87959,7 +88321,7 @@ var ts;
                 // However, property declarations disallow computed names in general,
                 // and accessors are not allowed in ambient contexts in general,
                 // so this error only really matters for methods.
-                if (node.flags & 8388608 /* Ambient */) {
+                if (node.flags & 16777216 /* Ambient */) {
                     return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
                 }
                 else if (node.kind === 169 /* MethodDeclaration */ && !node.body) {
@@ -88075,7 +88437,7 @@ var ts;
         }
         function checkGrammarVariableDeclaration(node) {
             if (node.parent.parent.kind !== 243 /* ForInStatement */ && node.parent.parent.kind !== 244 /* ForOfStatement */) {
-                if (node.flags & 8388608 /* Ambient */) {
+                if (node.flags & 16777216 /* Ambient */) {
                     checkAmbientInitializer(node);
                 }
                 else if (!node.initializer) {
@@ -88087,7 +88449,7 @@ var ts;
                     }
                 }
             }
-            if (node.exclamationToken && (node.parent.parent.kind !== 237 /* VariableStatement */ || !node.type || node.initializer || node.flags & 8388608 /* Ambient */)) {
+            if (node.exclamationToken && (node.parent.parent.kind !== 237 /* VariableStatement */ || !node.type || node.initializer || node.flags & 16777216 /* Ambient */)) {
                 var message = node.initializer
                     ? ts.Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions
                     : !node.type
@@ -88096,7 +88458,7 @@ var ts;
                 return grammarErrorOnNode(node.exclamationToken, message);
             }
             if ((moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS) && moduleKind !== ts.ModuleKind.System &&
-                !(node.parent.parent.flags & 8388608 /* Ambient */) && ts.hasSyntacticModifier(node.parent.parent, 1 /* Export */)) {
+                !(node.parent.parent.flags & 16777216 /* Ambient */) && ts.hasSyntacticModifier(node.parent.parent, 1 /* Export */)) {
                 checkESModuleMarker(node.name);
             }
             var checkLetConstNames = (ts.isLet(node) || ts.isVarConst(node));
@@ -88273,11 +88635,11 @@ var ts;
                     return grammarErrorOnNode(node.initializer, ts.Diagnostics.A_type_literal_property_cannot_have_an_initializer);
                 }
             }
-            if (node.flags & 8388608 /* Ambient */) {
+            if (node.flags & 16777216 /* Ambient */) {
                 checkAmbientInitializer(node);
             }
             if (ts.isPropertyDeclaration(node) && node.exclamationToken && (!ts.isClassLike(node.parent) || !node.type || node.initializer ||
-                node.flags & 8388608 /* Ambient */ || ts.isStatic(node) || ts.hasAbstractModifier(node))) {
+                node.flags & 16777216 /* Ambient */ || ts.isStatic(node) || ts.hasAbstractModifier(node))) {
                 var message = node.initializer
                     ? ts.Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions
                     : !node.type
@@ -88323,10 +88685,10 @@ var ts;
             return false;
         }
         function checkGrammarSourceFile(node) {
-            return !!(node.flags & 8388608 /* Ambient */) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node);
+            return !!(node.flags & 16777216 /* Ambient */) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node);
         }
         function checkGrammarStatementInAmbientContext(node) {
-            if (node.flags & 8388608 /* Ambient */) {
+            if (node.flags & 16777216 /* Ambient */) {
                 // Find containing block which is either Block, ModuleBlock, SourceFile
                 var links = getNodeLinks(node);
                 if (!links.hasReportedStatementInAmbientContext && (ts.isFunctionLike(node.parent) || ts.isAccessor(node.parent))) {
@@ -92444,7 +92806,7 @@ var ts;
             return !ts.nodeIsMissing(node.body);
         }
         function visitPropertyDeclaration(node) {
-            if (node.flags & 8388608 /* Ambient */ || ts.hasSyntacticModifier(node, 128 /* Abstract */)) {
+            if (node.flags & 16777216 /* Ambient */ || ts.hasSyntacticModifier(node, 128 /* Abstract */)) {
                 return undefined;
             }
             var updated = factory.updatePropertyDeclaration(node, 
@@ -99334,8 +99696,8 @@ var ts;
             // declarations may not be sorted by position.
             // pos should be the minimum* position over all nodes (that's not -1), end should be the maximum end over all nodes.
             var pos = -1, end = -1;
-            for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) {
-                var node = declarations_9[_i];
+            for (var _i = 0, declarations_10 = declarations; _i < declarations_10.length; _i++) {
+                var node = declarations_10[_i];
                 pos = pos === -1 ? node.pos : node.pos === -1 ? pos : Math.min(pos, node.pos);
                 end = Math.max(end, node.end);
             }
@@ -108267,6 +108629,10 @@ var ts;
             return factory.updateModifiers(statement, modifiers);
         }
         function transformTopLevelDeclaration(input) {
+            if (lateMarkedStatements) {
+                while (ts.orderedRemoveItem(lateMarkedStatements, input))
+                    ;
+            }
             if (shouldStripInternal(input))
                 return;
             switch (input.kind) {
@@ -108378,7 +108744,7 @@ var ts;
                         needsScopeFixMarker = false;
                         var statements = ts.visitNodes(inner.statements, visitDeclarationStatements);
                         var lateStatements = transformAndReplaceLatePaintedStatements(statements);
-                        if (input.flags & 8388608 /* Ambient */) {
+                        if (input.flags & 16777216 /* Ambient */) {
                             needsScopeFixMarker = false; // If it was `declare`'d everything is implicitly exported already, ignore late printed "privates"
                         }
                         // With the final list of statements, there are 3 possibilities:
@@ -110026,6 +110392,9 @@ var ts;
         var currentParenthesizerRule;
         var _c = ts.performance.createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment"), enterComment = _c.enter, exitComment = _c.exit;
         var parenthesizer = ts.factory.parenthesizer;
+        var typeArgumentParenthesizerRuleSelector = {
+            select: function (index) { return index === 0 ? parenthesizer.parenthesizeLeadingTypeArgument : undefined; }
+        };
         var emitBinaryExpression = createEmitBinaryExpression();
         reset();
         return {
@@ -111238,7 +111607,7 @@ var ts;
             writePunctuation("}");
         }
         function emitArrayType(node) {
-            emit(node.elementType, parenthesizer.parenthesizeElementTypeOfArrayType);
+            emit(node.elementType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType);
             writePunctuation("[");
             writePunctuation("]");
         }
@@ -111249,7 +111618,7 @@ var ts;
         function emitTupleType(node) {
             emitTokenWithComment(22 /* OpenBracketToken */, node.pos, writePunctuation, node);
             var flags = ts.getEmitFlags(node) & 1 /* SingleLine */ ? 528 /* SingleLineTupleTypeElements */ : 657 /* MultiLineTupleTypeElements */;
-            emitList(node, node.elements, flags | 524288 /* NoSpaceIfEmpty */);
+            emitList(node, node.elements, flags | 524288 /* NoSpaceIfEmpty */, parenthesizer.parenthesizeElementTypeOfTupleType);
             emitTokenWithComment(23 /* CloseBracketToken */, node.elements.end, writePunctuation, node);
         }
         function emitNamedTupleMember(node) {
@@ -111261,21 +111630,21 @@ var ts;
             emit(node.type);
         }
         function emitOptionalType(node) {
-            emit(node.type, parenthesizer.parenthesizeElementTypeOfArrayType);
+            emit(node.type, parenthesizer.parenthesizeTypeOfOptionalType);
             writePunctuation("?");
         }
         function emitUnionType(node) {
-            emitList(node, node.types, 516 /* UnionTypeConstituents */, parenthesizer.parenthesizeMemberOfElementType);
+            emitList(node, node.types, 516 /* UnionTypeConstituents */, parenthesizer.parenthesizeConstituentTypeOfUnionType);
         }
         function emitIntersectionType(node) {
-            emitList(node, node.types, 520 /* IntersectionTypeConstituents */, parenthesizer.parenthesizeMemberOfElementType);
+            emitList(node, node.types, 520 /* IntersectionTypeConstituents */, parenthesizer.parenthesizeConstituentTypeOfIntersectionType);
         }
         function emitConditionalType(node) {
-            emit(node.checkType, parenthesizer.parenthesizeMemberOfConditionalType);
+            emit(node.checkType, parenthesizer.parenthesizeCheckTypeOfConditionalType);
             writeSpace();
             writeKeyword("extends");
             writeSpace();
-            emit(node.extendsType, parenthesizer.parenthesizeMemberOfConditionalType);
+            emit(node.extendsType, parenthesizer.parenthesizeExtendsTypeOfConditionalType);
             writeSpace();
             writePunctuation("?");
             writeSpace();
@@ -111301,10 +111670,13 @@ var ts;
         function emitTypeOperator(node) {
             writeTokenText(node.operator, writeKeyword);
             writeSpace();
-            emit(node.type, parenthesizer.parenthesizeMemberOfElementType);
+            var parenthesizerRule = node.operator === 145 /* ReadonlyKeyword */ ?
+                parenthesizer.parenthesizeOperandOfReadonlyTypeOperator :
+                parenthesizer.parenthesizeOperandOfTypeOperator;
+            emit(node.type, parenthesizerRule);
         }
         function emitIndexedAccessType(node) {
-            emit(node.objectType, parenthesizer.parenthesizeMemberOfElementType);
+            emit(node.objectType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType);
             writePunctuation("[");
             emit(node.indexType);
             writePunctuation("]");
@@ -113038,7 +113410,7 @@ var ts;
             emitList(parentNode, decorators, 2146305 /* Decorators */);
         }
         function emitTypeArguments(parentNode, typeArguments) {
-            emitList(parentNode, typeArguments, 53776 /* TypeArguments */, parenthesizer.parenthesizeMemberOfElementType);
+            emitList(parentNode, typeArguments, 53776 /* TypeArguments */, typeArgumentParenthesizerRuleSelector);
         }
         function emitTypeParameters(parentNode, typeParameters) {
             if (ts.isFunctionLike(parentNode) && parentNode.typeArguments) { // Quick info uses type arguments in place of type parameters on instantiated signatures
@@ -113157,6 +113529,7 @@ var ts;
                 if (format & 128 /* Indented */) {
                     increaseIndent();
                 }
+                var emitListItem = getEmitListItem(emit, parenthesizerRule);
                 // Emit each child.
                 var previousSibling = void 0;
                 var previousSourceFileTextKind = void 0;
@@ -113207,12 +113580,7 @@ var ts;
                         shouldEmitInterveningComments = mayEmitInterveningComments;
                     }
                     nextListElementPos = child.pos;
-                    if (emit.length === 1) {
-                        emit(child);
-                    }
-                    else {
-                        emit(child, parenthesizerRule);
-                    }
+                    emitListItem(child, emit, parenthesizerRule, i);
                     if (shouldDecreaseIndentAfterEmit) {
                         decreaseIndent();
                         shouldDecreaseIndentAfterEmit = false;
@@ -114453,6 +114821,20 @@ var ts;
         TempFlags[TempFlags["CountMask"] = 268435455] = "CountMask";
         TempFlags[TempFlags["_i"] = 268435456] = "_i";
     })(TempFlags || (TempFlags = {}));
+    function emitListItemNoParenthesizer(node, emit, _parenthesizerRule, _index) {
+        emit(node);
+    }
+    function emitListItemWithParenthesizerRuleSelector(node, emit, parenthesizerRuleSelector, index) {
+        emit(node, parenthesizerRuleSelector.select(index));
+    }
+    function emitListItemWithParenthesizerRule(node, emit, parenthesizerRule, _index) {
+        emit(node, parenthesizerRule);
+    }
+    function getEmitListItem(emit, parenthesizerRule) {
+        return emit.length === 1 ? emitListItemNoParenthesizer :
+            typeof parenthesizerRule === "object" ? emitListItemWithParenthesizerRuleSelector :
+                emitListItemWithParenthesizerRule;
+    }
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -116519,7 +116901,7 @@ var ts;
                         // moduleAugmentations has changed
                         structureIsReused = 1 /* SafeModules */;
                     }
-                    if ((oldSourceFile.flags & 3145728 /* PermanentlySetIncrementalFlags */) !== (newSourceFile.flags & 3145728 /* PermanentlySetIncrementalFlags */)) {
+                    if ((oldSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */) !== (newSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */)) {
                         // dynamicImport has changed
                         structureIsReused = 1 /* SafeModules */;
                     }
@@ -116683,6 +117065,9 @@ var ts;
             return !!sourceFilesFoundSearchingNodeModules.get(file.path);
         }
         function isSourceFileDefaultLibrary(file) {
+            if (!file.isDeclarationFile) {
+                return false;
+            }
             if (file.hasNoDefaultLib) {
                 return true;
             }
@@ -117194,7 +117579,7 @@ var ts;
                 var node = _a[_i];
                 collectModuleReferences(node, /*inAmbientModule*/ false);
             }
-            if ((file.flags & 1048576 /* PossiblyContainsDynamicImport */) || isJavaScriptFile) {
+            if ((file.flags & 2097152 /* PossiblyContainsDynamicImport */) || isJavaScriptFile) {
                 collectDynamicImportOrRequireCalls(file);
             }
             file.imports = imports || ts.emptyArray;
@@ -117792,7 +118177,7 @@ var ts;
                         && index < file.imports.length
                         && !elideImport
                         && !(isJsFile && !ts.getAllowJSCompilerOption(optionsForFile))
-                        && (ts.isInJSFile(file.imports[index]) || !(file.imports[index].flags & 4194304 /* JSDoc */));
+                        && (ts.isInJSFile(file.imports[index]) || !(file.imports[index].flags & 8388608 /* JSDoc */));
                     if (elideImport) {
                         modulesWithElidedImports.set(file.path, true);
                     }
@@ -117873,21 +118258,6 @@ var ts;
             return resolvedRef;
         }
         function verifyCompilerOptions() {
-            var isNightly = ts.stringContains(ts.version, "-dev") || ts.stringContains(ts.version, "-insiders");
-            if (!isNightly) {
-                if (ts.getEmitModuleKind(options) === ts.ModuleKind.Node12) {
-                    createOptionValueDiagnostic("module", ts.Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "module", "node12");
-                }
-                else if (ts.getEmitModuleKind(options) === ts.ModuleKind.NodeNext) {
-                    createOptionValueDiagnostic("module", ts.Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "module", "nodenext");
-                }
-                else if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12) {
-                    createOptionValueDiagnostic("moduleResolution", ts.Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "moduleResolution", "node12");
-                }
-                else if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
-                    createOptionValueDiagnostic("moduleResolution", ts.Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "moduleResolution", "nodenext");
-                }
-            }
             if (options.strictPropertyInitialization && !ts.getStrictOptionValue(options, "strictNullChecks")) {
                 createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks");
             }
@@ -127091,7 +127461,7 @@ var ts;
             result.push("export" /* exportedModifier */);
         if (flags & 8192 /* Deprecated */)
             result.push("deprecated" /* deprecatedModifier */);
-        if (node.flags & 8388608 /* Ambient */)
+        if (node.flags & 16777216 /* Ambient */)
             result.push("declare" /* ambientModifier */);
         if (node.kind === 271 /* ExportAssignment */)
             result.push("export" /* exportedModifier */);
@@ -133407,7 +133777,7 @@ var ts;
                     var instantiatedType = tryGetObjectLiteralContextualType(objectLikeContainer, typeChecker);
                     // Check completions for Object property value shorthand
                     if (instantiatedType === undefined) {
-                        if (objectLikeContainer.flags & 16777216 /* InWithStatement */) {
+                        if (objectLikeContainer.flags & 33554432 /* InWithStatement */) {
                             return 2 /* Fail */;
                         }
                         isNonContextualObjectLiteral = true;
@@ -136070,17 +136440,25 @@ var ts;
             var options = { use: 1 /* References */ };
             var referencedSymbols = Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options);
             var checker = program.getTypeChecker();
-            var symbol = checker.getSymbolAtLocation(ts.getAdjustedReferenceLocation(Core.getAdjustedNode(node, options)));
+            // Unless the starting node is a declaration (vs e.g. JSDoc), don't attempt to compute isDefinition
+            var adjustedNode = Core.getAdjustedNode(node, options);
+            var symbol = isDefinitionForReference(adjustedNode) ? checker.getSymbolAtLocation(adjustedNode) : undefined;
             return !referencedSymbols || !referencedSymbols.length ? undefined : ts.mapDefined(referencedSymbols, function (_a) {
                 var definition = _a.definition, references = _a.references;
                 // Only include referenced symbols that have a valid definition.
                 return definition && {
                     definition: checker.runWithCancellationToken(cancellationToken, function (checker) { return definitionToReferencedSymbolDefinitionInfo(definition, checker, node); }),
-                    references: references.map(function (r) { return toReferenceEntry(r, symbol); })
+                    references: references.map(function (r) { return toReferencedSymbolEntry(r, symbol); })
                 };
             });
         }
         FindAllReferences.findReferencedSymbols = findReferencedSymbols;
+        function isDefinitionForReference(node) {
+            return node.kind === 88 /* DefaultKeyword */
+                || !!ts.getDeclarationFromName(node)
+                || ts.isLiteralComputedPropertyDeclarationName(node)
+                || (node.kind === 134 /* ConstructorKeyword */ && ts.isConstructorDeclaration(node.parent));
+        }
         function getImplementationsAtPosition(program, cancellationToken, sourceFiles, sourceFile, position) {
             var node = ts.getTouchingPropertyName(sourceFile, position);
             var referenceEntries;
@@ -136209,13 +136587,19 @@ var ts;
             return __assign(__assign({}, entryToDocumentSpan(entry)), (providePrefixAndSuffixText && getPrefixAndSuffixText(entry, originalNode, checker)));
         }
         FindAllReferences.toRenameLocation = toRenameLocation;
-        function toReferenceEntry(entry, symbol) {
+        function toReferencedSymbolEntry(entry, symbol) {
+            var referenceEntry = toReferenceEntry(entry);
+            if (!symbol)
+                return referenceEntry;
+            return __assign(__assign({}, referenceEntry), { isDefinition: entry.kind !== 0 /* Span */ && isDeclarationOfSymbol(entry.node, symbol) });
+        }
+        function toReferenceEntry(entry) {
             var documentSpan = entryToDocumentSpan(entry);
             if (entry.kind === 0 /* Span */) {
-                return __assign(__assign({}, documentSpan), { isWriteAccess: false, isDefinition: false });
+                return __assign(__assign({}, documentSpan), { isWriteAccess: false });
             }
             var kind = entry.kind, node = entry.node;
-            return __assign(__assign({}, documentSpan), { isWriteAccess: isWriteAccessForReference(node), isDefinition: isDeclarationOfSymbol(node, symbol), isInString: kind === 2 /* StringLiteral */ ? true : undefined });
+            return __assign(__assign({}, documentSpan), { isWriteAccess: isWriteAccessForReference(node), isInString: kind === 2 /* StringLiteral */ ? true : undefined });
         }
         FindAllReferences.toReferenceEntry = toReferenceEntry;
         function entryToDocumentSpan(entry) {
@@ -136358,7 +136742,7 @@ var ts;
          */
         function declarationIsWriteAccess(decl) {
             // Consider anything in an ambient declaration to be a write access since it may be coming from JS.
-            if (!!(decl.flags & 8388608 /* Ambient */))
+            if (!!(decl.flags & 16777216 /* Ambient */))
                 return true;
             switch (decl.kind) {
                 case 221 /* BinaryExpression */:
@@ -136923,15 +137307,21 @@ var ts;
             }
             function eachExportReference(sourceFiles, checker, cancellationToken, exportSymbol, exportingModuleSymbol, exportName, isDefaultExport, cb) {
                 var importTracker = FindAllReferences.createImportTracker(sourceFiles, new ts.Set(sourceFiles.map(function (f) { return f.fileName; })), checker, cancellationToken);
-                var _a = importTracker(exportSymbol, { exportKind: isDefaultExport ? 1 /* Default */ : 0 /* Named */, exportingModuleSymbol: exportingModuleSymbol }, /*isForRename*/ false), importSearches = _a.importSearches, indirectUsers = _a.indirectUsers;
+                var _a = importTracker(exportSymbol, { exportKind: isDefaultExport ? 1 /* Default */ : 0 /* Named */, exportingModuleSymbol: exportingModuleSymbol }, /*isForRename*/ false), importSearches = _a.importSearches, indirectUsers = _a.indirectUsers, singleReferences = _a.singleReferences;
                 for (var _i = 0, importSearches_2 = importSearches; _i < importSearches_2.length; _i++) {
                     var importLocation = importSearches_2[_i][0];
                     cb(importLocation);
                 }
-                for (var _b = 0, indirectUsers_2 = indirectUsers; _b < indirectUsers_2.length; _b++) {
-                    var indirectUser = indirectUsers_2[_b];
-                    for (var _c = 0, _d = getPossibleSymbolReferenceNodes(indirectUser, isDefaultExport ? "default" : exportName); _c < _d.length; _c++) {
-                        var node = _d[_c];
+                for (var _b = 0, singleReferences_2 = singleReferences; _b < singleReferences_2.length; _b++) {
+                    var singleReference = singleReferences_2[_b];
+                    if (ts.isIdentifier(singleReference) && ts.isImportTypeNode(singleReference.parent)) {
+                        cb(singleReference);
+                    }
+                }
+                for (var _c = 0, indirectUsers_2 = indirectUsers; _c < indirectUsers_2.length; _c++) {
+                    var indirectUser = indirectUsers_2[_c];
+                    for (var _d = 0, _e = getPossibleSymbolReferenceNodes(indirectUser, isDefaultExport ? "default" : exportName); _d < _e.length; _d++) {
+                        var node = _e[_d];
                         // Import specifiers should be handled by importSearches
                         var symbol = checker.getSymbolAtLocation(node);
                         var hasExportAssignmentDeclaration = ts.some(symbol === null || symbol === void 0 ? void 0 : symbol.declarations, function (d) { return ts.tryCast(d, ts.isExportAssignment) ? true : false; });
@@ -137933,7 +138323,7 @@ var ts;
             }
             Core.getIntersectingMeaningFromDeclarations = getIntersectingMeaningFromDeclarations;
             function isImplementation(node) {
-                return !!(node.flags & 8388608 /* Ambient */) ? !(ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) :
+                return !!(node.flags & 16777216 /* Ambient */) ? !(ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) :
                     (ts.isVariableLike(node) ? ts.hasInitializer(node) :
                         ts.isFunctionLikeDeclaration(node) ? !!node.body :
                             ts.isClassLike(node) || ts.isModuleOrEnumDeclaration(node));
@@ -138311,7 +138701,7 @@ var ts;
             function collect(node) {
                 if (!node)
                     return;
-                if (node.flags & 8388608 /* Ambient */) {
+                if (node.flags & 16777216 /* Ambient */) {
                     // do not descend into ambient nodes.
                     return;
                 }
@@ -138470,7 +138860,7 @@ var ts;
         }
         /** Gets the call sites that call out of the provided call hierarchy declaration. */
         function getOutgoingCalls(program, declaration) {
-            if (declaration.flags & 8388608 /* Ambient */ || ts.isMethodSignature(declaration)) {
+            if (declaration.flags & 16777216 /* Ambient */ || ts.isMethodSignature(declaration)) {
                 return [];
             }
             return ts.group(collectCallSites(program, declaration), getCallSiteGroupKey, function (entries) { return convertCallSiteGroupToOutgoingCall(program, entries); });
@@ -140604,8 +140994,8 @@ var ts;
             var changeTracker = ts.textChanges.ChangeTracker.fromContext({ host: host, formatContext: formatContext, preferences: preferences });
             var coalesceAndOrganizeImports = function (importGroup) { return ts.stableSort(coalesceImports(removeUnusedImports(importGroup, sourceFile, program, skipDestructiveCodeActions)), function (s1, s2) { return compareImportsOrRequireStatements(s1, s2); }); };
             // All of the old ImportDeclarations in the file, in syntactic order.
-            var topLevelImportDecls = sourceFile.statements.filter(ts.isImportDeclaration);
-            organizeImportsWorker(topLevelImportDecls, coalesceAndOrganizeImports);
+            var topLevelImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, sourceFile.statements.filter(ts.isImportDeclaration));
+            topLevelImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports); });
             // All of the old ExportDeclarations in the file, in syntactic order.
             var topLevelExportDecls = sourceFile.statements.filter(ts.isExportDeclaration);
             organizeImportsWorker(topLevelExportDecls, coalesceExports);
@@ -140613,8 +141003,8 @@ var ts;
                 var ambientModule = _a[_i];
                 if (!ambientModule.body)
                     continue;
-                var ambientModuleImportDecls = ambientModule.body.statements.filter(ts.isImportDeclaration);
-                organizeImportsWorker(ambientModuleImportDecls, coalesceAndOrganizeImports);
+                var ambientModuleImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, ambientModule.body.statements.filter(ts.isImportDeclaration));
+                ambientModuleImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports); });
                 var ambientModuleExportDecls = ambientModule.body.statements.filter(ts.isExportDeclaration);
                 organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
             }
@@ -140660,6 +141050,40 @@ var ts;
             }
         }
         OrganizeImports.organizeImports = organizeImports;
+        function groupImportsByNewlineContiguous(sourceFile, importDecls) {
+            var scanner = ts.createScanner(sourceFile.languageVersion, /*skipTrivia*/ false, sourceFile.languageVariant);
+            var groupImports = [];
+            var groupIndex = 0;
+            for (var _i = 0, importDecls_1 = importDecls; _i < importDecls_1.length; _i++) {
+                var topLevelImportDecl = importDecls_1[_i];
+                if (isNewGroup(sourceFile, topLevelImportDecl, scanner)) {
+                    groupIndex++;
+                }
+                if (!groupImports[groupIndex]) {
+                    groupImports[groupIndex] = [];
+                }
+                groupImports[groupIndex].push(topLevelImportDecl);
+            }
+            return groupImports;
+        }
+        // a new group is created if an import includes at least two new line
+        // new line from multi-line comment doesn't count
+        function isNewGroup(sourceFile, topLevelImportDecl, scanner) {
+            var startPos = topLevelImportDecl.getFullStart();
+            var endPos = topLevelImportDecl.getStart();
+            scanner.setText(sourceFile.text, startPos, endPos - startPos);
+            var numberOfNewLines = 0;
+            while (scanner.getTokenPos() < endPos) {
+                var tokenKind = scanner.scan();
+                if (tokenKind === 4 /* NewLineTrivia */) {
+                    numberOfNewLines++;
+                    if (numberOfNewLines >= 2) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
         function removeUnusedImports(oldImports, sourceFile, program, skipDestructiveCodeActions) {
             // As a precaution, consider unused import detection to be destructive (GH #43051)
             if (skipDestructiveCodeActions) {
@@ -142895,10 +143319,13 @@ var ts;
             var contextualType = info.contextualType, argumentIndex = info.argumentIndex, argumentCount = info.argumentCount, argumentsSpan = info.argumentsSpan;
             // for optional function condition.
             var nonNullableContextualType = contextualType.getNonNullableType();
-            var signatures = nonNullableContextualType.getCallSignatures();
-            if (signatures.length !== 1)
+            var symbol = nonNullableContextualType.symbol;
+            if (symbol === undefined)
                 return undefined;
-            var invocation = { kind: 2 /* Contextual */, signature: ts.first(signatures), node: startingToken, symbol: chooseBetterSymbol(nonNullableContextualType.symbol) };
+            var signature = ts.lastOrUndefined(nonNullableContextualType.getCallSignatures());
+            if (signature === undefined)
+                return undefined;
+            var invocation = { kind: 2 /* Contextual */, signature: signature, node: startingToken, symbol: chooseBetterSymbol(symbol) };
             return { isTypeParameterList: false, invocation: invocation, argumentsSpan: argumentsSpan, argumentIndex: argumentIndex, argumentCount: argumentCount };
         }
         function getContextualSignatureLocationInfo(startingToken, sourceFile, position, checker) {
@@ -147068,9 +147495,9 @@ var ts;
                 // for block indentation, we should look for a line which contains something that's not
                 // whitespace.
                 var currentToken = ts.getTokenAtPosition(sourceFile, position);
-                // for object literal, we want to the indentation work like block
-                // if { starts in any position (can be in the middle of line)
-                // the following indentation should treat { as starting of that line (including leading whitespace)
+                // For object literals, we want indentation to work just like with blocks.
+                // If the `{` starts in any position (even in the middle of a line), then
+                // the following indentation should treat `{` as the start of that line (including leading whitespace).
                 // ```
                 //     const a: { x: undefined, y: undefined } = {}       // leading 4 whitespaces and { starts in the middle of line
                 // ->
@@ -147088,7 +147515,8 @@ var ts;
                 //          y: undefined,
                 //      }
                 // ```
-                if (options.indentStyle === ts.IndentStyle.Block || currentToken.kind === 18 /* OpenBraceToken */) {
+                var isObjectLiteral = currentToken.kind === 18 /* OpenBraceToken */ && currentToken.parent.kind === 205 /* ObjectLiteralExpression */;
+                if (options.indentStyle === ts.IndentStyle.Block || isObjectLiteral) {
                     return getBlockIndent(sourceFile, position, options);
                 }
                 if (precedingToken.kind === 27 /* CommaToken */ && precedingToken.parent.kind !== 221 /* BinaryExpression */) {
@@ -147101,7 +147529,9 @@ var ts;
                 var containerList = getListByPosition(position, precedingToken.parent, sourceFile);
                 // use list position if the preceding token is before any list items
                 if (containerList && !ts.rangeContainsRange(containerList, precedingToken)) {
-                    return getActualIndentationForListStartLine(containerList, sourceFile, options) + options.indentSize; // TODO: GH#18217
+                    var useTheSameBaseIndentation = [213 /* FunctionExpression */, 214 /* ArrowFunction */].indexOf(currentToken.parent.kind) !== -1;
+                    var indentSize = useTheSameBaseIndentation ? 0 : options.indentSize;
+                    return getActualIndentationForListStartLine(containerList, sourceFile, options) + indentSize; // TODO: GH#18217
                 }
                 return getSmartIndent(sourceFile, position, precedingToken, lineAtPosition, assumeNewLineBeforeCloseBrace, options);
             }
@@ -148614,8 +149044,11 @@ var ts;
         function isTrivia(s) {
             return ts.skipTrivia(s, 0) === s.length;
         }
+        // A transformation context that won't perform parenthesization, as some parenthesization rules
+        // are more aggressive than is strictly necessary.
+        var textChangesTransformationContext = __assign(__assign({}, ts.nullTransformationContext), { factory: ts.createNodeFactory(ts.nullTransformationContext.factory.flags | 1 /* NoParenthesizerRules */, ts.nullTransformationContext.factory.baseFactory) });
         function assignPositionsToNode(node) {
-            var visited = ts.visitEachChild(node, assignPositionsToNode, ts.nullTransformationContext, assignPositionsToNodeArray, assignPositionsToNode);
+            var visited = ts.visitEachChild(node, assignPositionsToNode, textChangesTransformationContext, assignPositionsToNodeArray, assignPositionsToNode);
             // create proxy node for non synthesized nodes
             var newNode = ts.nodeIsSynthesized(visited) ? visited : Object.create(visited);
             ts.setTextRangePosEnd(newNode, getPos(node), getEnd(node));
@@ -156580,7 +157013,7 @@ var ts;
             var modifiers = visibilityModifier ? ts.factory.createNodeArray([visibilityModifier]) : undefined;
             var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
             var optional = !!(symbol.flags & 16777216 /* Optional */);
-            var ambient = !!(enclosingDeclaration.flags & 8388608 /* Ambient */) || isAmbient;
+            var ambient = !!(enclosingDeclaration.flags & 16777216 /* Ambient */) || isAmbient;
             var quotePreference = ts.getQuotePreference(sourceFile, preferences);
             switch (declaration.kind) {
                 case 166 /* PropertySignature */:
@@ -156675,7 +157108,11 @@ var ts;
             var program = context.program;
             var checker = program.getTypeChecker();
             var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
-            var flags = 1 /* NoTruncation */ | 1073741824 /* NoUndefinedOptionalParameterType */ | 256 /* SuppressAnyReturnType */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0);
+            var flags = 1 /* NoTruncation */
+                | 1073741824 /* NoUndefinedOptionalParameterType */
+                | 256 /* SuppressAnyReturnType */
+                | 524288 /* AllowEmptyTuple */
+                | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
             var signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
             if (!signatureDeclaration) {
                 return undefined;
@@ -158153,6 +158590,10 @@ var ts;
                     }
                     break;
                 }
+                case 200 /* ImportType */:
+                    var importTypeNode = parent;
+                    changes.replaceNode(importingSourceFile, parent, ts.factory.createImportTypeNode(importTypeNode.argument, ts.factory.createIdentifier(exportName), importTypeNode.typeArguments, importTypeNode.isTypeOf));
+                    break;
                 default:
                     ts.Debug.failBadSyntaxKind(parent);
             }
@@ -159047,6 +159488,7 @@ var ts;
                 Messages.cannotAccessVariablesFromNestedScopes = createMessage("Cannot access variables from nested scopes");
                 Messages.cannotExtractToJSClass = createMessage("Cannot extract constant to a class scope in JS");
                 Messages.cannotExtractToExpressionArrowFunction = createMessage("Cannot extract constant to an arrow function without a block");
+                Messages.cannotExtractFunctionsContainingThisToMethod = createMessage("Cannot extract functions containing this to method");
             })(Messages = extractSymbol.Messages || (extractSymbol.Messages = {}));
             var RangeFacts;
             (function (RangeFacts) {
@@ -159055,10 +159497,11 @@ var ts;
                 RangeFacts[RangeFacts["IsGenerator"] = 2] = "IsGenerator";
                 RangeFacts[RangeFacts["IsAsyncFunction"] = 4] = "IsAsyncFunction";
                 RangeFacts[RangeFacts["UsesThis"] = 8] = "UsesThis";
+                RangeFacts[RangeFacts["UsesThisInFunction"] = 16] = "UsesThisInFunction";
                 /**
                  * The range is in a function which needs the 'static' modifier in a class
                  */
-                RangeFacts[RangeFacts["InStaticRegion"] = 16] = "InStaticRegion";
+                RangeFacts[RangeFacts["InStaticRegion"] = 32] = "InStaticRegion";
             })(RangeFacts || (RangeFacts = {}));
             /**
              * getRangeToExtract takes a span inside a text file and returns either an expression or an array
@@ -159089,11 +159532,12 @@ var ts;
                 // We'll modify these flags as we walk the tree to collect data
                 // about what things need to be done as part of the extraction.
                 var rangeFacts = RangeFacts.None;
+                var thisNode;
                 if (!start || !end) {
                     // cannot find either start or end node
                     return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
                 }
-                if (start.flags & 4194304 /* JSDoc */) {
+                if (start.flags & 8388608 /* JSDoc */) {
                     return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractJSDoc)] };
                 }
                 if (start.parent !== end.parent) {
@@ -159127,7 +159571,7 @@ var ts;
                         // the expression.
                         return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
                     }
-                    return { targetRange: { range: statements, facts: rangeFacts, declarations: declarations } };
+                    return { targetRange: { range: statements, facts: rangeFacts, declarations: declarations, thisNode: thisNode } };
                 }
                 if (ts.isReturnStatement(start) && !start.expression) {
                     // Makes no sense to extract an expression-less return statement.
@@ -159139,7 +159583,7 @@ var ts;
                 if (errors) {
                     return { errors: errors };
                 }
-                return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, declarations: declarations } }; // TODO: GH#18217
+                return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, declarations: declarations, thisNode: thisNode } }; // TODO: GH#18217
                 /**
                  * Attempt to refine the extraction node (generally, by shrinking it) to produce better results.
                  * @param node The unrefined extraction node.
@@ -159219,7 +159663,7 @@ var ts;
                     if (!ts.isStatement(nodeToCheck) && !(ts.isExpressionNode(nodeToCheck) && isExtractableExpression(nodeToCheck)) && !isStringLiteralJsxAttribute(nodeToCheck)) {
                         return [ts.createDiagnosticForNode(nodeToCheck, Messages.statementOrExpressionExpected)];
                     }
-                    if (nodeToCheck.flags & 8388608 /* Ambient */) {
+                    if (nodeToCheck.flags & 16777216 /* Ambient */) {
                         return [ts.createDiagnosticForNode(nodeToCheck, Messages.cannotExtractAmbientBlock)];
                     }
                     // If we're in a class, see whether we're in a static region (static property initializer, static method, class constructor parameter default)
@@ -159231,6 +159675,14 @@ var ts;
                     var permittedJumps = 4 /* Return */;
                     var seenLabels;
                     visit(nodeToCheck);
+                    if (rangeFacts & RangeFacts.UsesThis) {
+                        var container = ts.getThisContainer(nodeToCheck, /** includeArrowFunctions */ false);
+                        if (container.kind === 256 /* FunctionDeclaration */ ||
+                            (container.kind === 169 /* MethodDeclaration */ && container.parent.kind === 205 /* ObjectLiteralExpression */) ||
+                            container.kind === 213 /* FunctionExpression */) {
+                            rangeFacts |= RangeFacts.UsesThisInFunction;
+                        }
+                    }
                     return errors;
                     function visit(node) {
                         if (errors) {
@@ -159269,6 +159721,7 @@ var ts;
                                 }
                                 else {
                                     rangeFacts |= RangeFacts.UsesThis;
+                                    thisNode = node;
                                 }
                                 break;
                             case 214 /* ArrowFunction */:
@@ -159276,6 +159729,7 @@ var ts;
                                 ts.forEachChild(node, function check(n) {
                                     if (ts.isThis(n)) {
                                         rangeFacts |= RangeFacts.UsesThis;
+                                        thisNode = node;
                                     }
                                     else if (ts.isClassLike(n) || (ts.isFunctionLike(n) && !ts.isArrowFunction(n))) {
                                         return false;
@@ -159332,6 +159786,7 @@ var ts;
                             case 192 /* ThisType */:
                             case 108 /* ThisKeyword */:
                                 rangeFacts |= RangeFacts.UsesThis;
+                                thisNode = node;
                                 break;
                             case 250 /* LabeledStatement */: {
                                 var label = node.label;
@@ -159409,7 +159864,8 @@ var ts;
                 return undefined;
             }
             function isScope(node) {
-                return ts.isFunctionLikeDeclaration(node) || ts.isSourceFile(node) || ts.isModuleBlock(node) || ts.isClassLike(node);
+                return ts.isArrowFunction(node) ? ts.isFunctionBody(node.body) :
+                    ts.isFunctionLikeDeclaration(node) || ts.isSourceFile(node) || ts.isModuleBlock(node) || ts.isClassLike(node);
             }
             /**
              * Computes possible places we could extract the function into. For example,
@@ -159418,7 +159874,7 @@ var ts;
              */
             function collectEnclosingScopes(range) {
                 var current = isReadonlyArray(range.range) ? ts.first(range.range) : range.range;
-                if (range.facts & RangeFacts.UsesThis) {
+                if (range.facts & RangeFacts.UsesThis && !(range.facts & RangeFacts.UsesThisInFunction)) {
                     // if range uses this as keyword or as type inside the class then it can only be extracted to a method of the containing class
                     var containingClass = ts.getContainingClass(current);
                     if (containingClass) {
@@ -159624,6 +160080,7 @@ var ts;
                 var _b = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & RangeFacts.HasReturn)), body = _b.body, returnValueProperty = _b.returnValueProperty;
                 ts.suppressLeadingAndTrailingTrivia(body);
                 var newFunction;
+                var callThis = !!(range.facts & RangeFacts.UsesThisInFunction);
                 if (ts.isClassLike(scope)) {
                     // always create private method in TypeScript files
                     var modifiers = isJS ? [] : [ts.factory.createModifier(121 /* PrivateKeyword */)];
@@ -159638,6 +160095,15 @@ var ts;
                     /*questionToken*/ undefined, typeParameters, parameters, returnType, body);
                 }
                 else {
+                    if (callThis) {
+                        parameters.unshift(ts.factory.createParameterDeclaration(
+                        /*decorators*/ undefined, 
+                        /*modifiers*/ undefined, 
+                        /*dotDotDotToken*/ undefined, 
+                        /*name*/ "this", 
+                        /*questionToken*/ undefined, checker.typeToTypeNode(checker.getTypeAtLocation(range.thisNode), scope, 1 /* NoTruncation */), 
+                        /*initializer*/ undefined));
+                    }
                     newFunction = ts.factory.createFunctionDeclaration(
                     /*decorators*/ undefined, range.facts & RangeFacts.IsAsyncFunction ? [ts.factory.createToken(131 /* AsyncKeyword */)] : undefined, range.facts & RangeFacts.IsGenerator ? ts.factory.createToken(41 /* AsteriskToken */) : undefined, functionName, typeParameters, parameters, returnType, body);
                 }
@@ -159654,7 +160120,10 @@ var ts;
                 var newNodes = [];
                 // replace range with function call
                 var called = getCalledExpression(scope, range, functionNameText);
-                var call = ts.factory.createCallExpression(called, callTypeArguments, // Note that no attempt is made to take advantage of type argument inference
+                if (callThis) {
+                    callArguments.unshift(ts.factory.createIdentifier("this"));
+                }
+                var call = ts.factory.createCallExpression(callThis ? ts.factory.createPropertyAccessExpression(called, "call") : called, callTypeArguments, // Note that no attempt is made to take advantage of type argument inference
                 callArguments);
                 if (range.facts & RangeFacts.IsGenerator) {
                     call = ts.factory.createYieldExpression(ts.factory.createToken(41 /* AsteriskToken */), call);
@@ -160265,6 +160734,9 @@ var ts;
                         var errorNode = isReadonlyArray(targetRange.range) ? targetRange.range[0] : targetRange.range;
                         constantErrorsPerScope[i].push(ts.createDiagnosticForNode(errorNode, Messages.cannotAccessVariablesFromNestedScopes));
                     }
+                    if (targetRange.facts & RangeFacts.UsesThisInFunction && ts.isClassLike(scopes[i])) {
+                        functionErrorsPerScope[i].push(ts.createDiagnosticForNode(targetRange.thisNode, Messages.cannotExtractFunctionsContainingThisToMethod));
+                    }
                     var hasWrite = false;
                     var readonlyClassPropertyWrite;
                     usagesPerScope[i].usages.forEach(function (value) {
@@ -160750,6 +161222,7 @@ var ts;
         }
         function doTypedefChange(changes, file, name, info) {
             var firstStatement = info.firstStatement, selection = info.selection, typeParameters = info.typeParameters;
+            ts.setEmitFlags(selection, 1536 /* NoComments */ | 2048 /* NoNestedComments */);
             var node = ts.factory.createJSDocTypedefTag(ts.factory.createIdentifier("typedef"), ts.factory.createJSDocTypeExpression(selection), ts.factory.createIdentifier(name));
             var templates = [];
             ts.forEach(typeParameters, function (typeParameter) {
@@ -162780,7 +163253,7 @@ var ts;
                 kind === 80 /* PrivateIdentifier */ ? new PrivateIdentifierObject(80 /* PrivateIdentifier */, pos, end) :
                     new TokenObject(kind, pos, end);
         node.parent = parent;
-        node.flags = parent.flags & 25358336 /* ContextFlags */;
+        node.flags = parent.flags & 50720768 /* ContextFlags */;
         return node;
     }
     var NodeObject = /** @class */ (function () {
@@ -164236,7 +164709,7 @@ var ts;
         }
         /// References and Occurrences
         function getOccurrencesAtPosition(fileName, position) {
-            return ts.flatMap(getDocumentHighlights(fileName, position, [fileName]), function (entry) { return entry.highlightSpans.map(function (highlightSpan) { return (__assign(__assign({ fileName: entry.fileName, textSpan: highlightSpan.textSpan, isWriteAccess: highlightSpan.kind === "writtenReference" /* writtenReference */, isDefinition: false }, highlightSpan.isInString && { isInString: true }), highlightSpan.contextSpan && { contextSpan: highlightSpan.contextSpan })); }); });
+            return ts.flatMap(getDocumentHighlights(fileName, position, [fileName]), function (entry) { return entry.highlightSpans.map(function (highlightSpan) { return (__assign(__assign({ fileName: entry.fileName, textSpan: highlightSpan.textSpan, isWriteAccess: highlightSpan.kind === "writtenReference" /* writtenReference */ }, highlightSpan.isInString && { isInString: true }), highlightSpan.contextSpan && { contextSpan: highlightSpan.contextSpan })); }); });
         }
         function getDocumentHighlights(fileName, position, filesToSearch) {
             var normalizedFileName = ts.normalizePath(fileName);
@@ -164265,7 +164738,7 @@ var ts;
         }
         function getReferencesAtPosition(fileName, position) {
             synchronizeHostData();
-            return getReferencesWorker(ts.getTouchingPropertyName(getValidSourceFile(fileName), position), position, { use: 1 /* References */ }, function (entry, node, checker) { return ts.FindAllReferences.toReferenceEntry(entry, checker.getSymbolAtLocation(node)); });
+            return getReferencesWorker(ts.getTouchingPropertyName(getValidSourceFile(fileName), position), position, { use: 1 /* References */ }, ts.FindAllReferences.toReferenceEntry);
         }
         function getReferencesWorker(node, position, options, cb) {
             synchronizeHostData();
@@ -164280,10 +164753,8 @@ var ts;
             return ts.FindAllReferences.findReferencedSymbols(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
         }
         function getFileReferences(fileName) {
-            var _a;
             synchronizeHostData();
-            var moduleSymbol = (_a = program.getSourceFile(fileName)) === null || _a === void 0 ? void 0 : _a.symbol;
-            return ts.FindAllReferences.Core.getReferencesForFileName(fileName, program, program.getSourceFiles()).map(function (r) { return ts.FindAllReferences.toReferenceEntry(r, moduleSymbol); });
+            return ts.FindAllReferences.Core.getReferencesForFileName(fileName, program, program.getSourceFiles()).map(ts.FindAllReferences.toReferenceEntry);
         }
         function getNavigateToItems(searchValue, maxResultCount, fileName, excludeDtsFiles) {
             if (excludeDtsFiles === void 0) { excludeDtsFiles = false; }
@@ -164756,7 +165227,7 @@ var ts;
         }
         function isUnclosedFragment(_a) {
             var closingFragment = _a.closingFragment, parent = _a.parent;
-            return !!(closingFragment.flags & 65536 /* ThisNodeHasError */) || (ts.isJsxFragment(parent) && isUnclosedFragment(parent));
+            return !!(closingFragment.flags & 131072 /* ThisNodeHasError */) || (ts.isJsxFragment(parent) && isUnclosedFragment(parent));
         }
         function getSpanOfEnclosingComment(fileName, position, onlyMultiLine) {
             var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
@@ -165204,7 +165675,7 @@ var ts;
                 tokenAtLocation = preceding;
             }
             // Cannot set breakpoint in ambient declarations
-            if (tokenAtLocation.flags & 8388608 /* Ambient */) {
+            if (tokenAtLocation.flags & 16777216 /* Ambient */) {
                 return undefined;
             }
             // Get the span in the node based on its syntax