typescript 4.7.0-dev.20220405 → 4.7.0-dev.20220406

package/lib/tsserver.js

@@ -100,7 +100,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.20220405";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220406";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4415,10 +4415,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.
@@ -4428,25 +4429,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) {
@@ -8888,6 +8889,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}'."),
@@ -14302,24 +14304,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) {
@@ -16126,11 +16128,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) {
@@ -16138,7 +16140,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) {
@@ -16524,7 +16526,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
@@ -20826,7 +20828,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)
@@ -21279,11 +21281,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());
@@ -21595,33 +21606,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)) {
@@ -21647,11 +21816,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 */
@@ -21791,6 +21969,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); }; });
@@ -21798,6 +21978,8 @@ var ts;
         var factory = {
             get parenthesizer() { return parenthesizerRules(); },
             get converters() { return converters(); },
+            baseFactory: baseFactory,
+            flags: flags,
             createNodeArray: createNodeArray,
             createNumericLiteral: createNumericLiteral,
             createBigIntLiteral: createBigIntLiteral,
@@ -22073,10 +22255,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 */); },
@@ -23192,7 +23374,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;
         }
@@ -23205,7 +23387,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;
         }
@@ -23237,7 +23419,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;
         }
@@ -23260,38 +23442,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 */;
@@ -23386,7 +23568,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;
         }
@@ -23399,7 +23583,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;
@@ -25135,8 +25319,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
@@ -25148,6 +25339,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
@@ -30228,7 +30425,7 @@ var ts;
             || ts.isExportDeclaration(node) ? node : undefined;
     }
     function getImportMetaIfNecessary(sourceFile) {
-        return sourceFile.flags & 2097152 /* PossiblyContainsImportMeta */ ?
+        return sourceFile.flags & 4194304 /* PossiblyContainsImportMeta */ ?
             walkTreeForImportMeta(sourceFile) :
             undefined;
     }
@@ -30883,7 +31080,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;
@@ -31167,10 +31364,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 */;
@@ -31205,7 +31402,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.
@@ -31244,7 +31441,7 @@ var ts;
                 node.jsDoc = jsDoc;
             if (hasDeprecatedTag) {
                 hasDeprecatedTag = false;
-                node.flags |= 134217728 /* Deprecated */;
+                node.flags |= 268435456 /* Deprecated */;
             }
             return node;
         }
@@ -31439,6 +31636,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);
         }
@@ -31466,6 +31669,9 @@ var ts;
         function inDisallowInContext() {
             return inContext(4096 /* DisallowInContext */);
         }
+        function inDisallowConditionalTypesContext() {
+            return inContext(65536 /* DisallowConditionalTypesContext */);
+        }
         function inDecoratorContext() {
             return inContext(16384 /* DecoratorContext */);
         }
@@ -31850,7 +32056,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;
         }
@@ -32308,7 +32514,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;
             }
@@ -32833,7 +33039,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();
@@ -32857,7 +33063,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() {
@@ -33029,7 +33235,7 @@ var ts;
         }
         function parseReturnType(returnToken, isType) {
             if (shouldParseReturnType(returnToken, isType)) {
-                return parseTypeOrTypePredicate();
+                return allowConditionalTypesAnd(parseTypeOrTypePredicate);
             }
         }
         function shouldParseReturnType(returnToken, isType) {
@@ -33444,7 +33650,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 */);
@@ -33594,7 +33800,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
@@ -33602,7 +33808,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 */);
@@ -33627,12 +33833,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();
@@ -33649,7 +33863,7 @@ var ts;
                 case 137 /* InferKeyword */:
                     return parseInferType();
             }
-            return parsePostfixTypeOrHigher();
+            return allowConditionalTypesAnd(parsePostfixTypeOrHigher);
         }
         function parseFunctionOrConstructorTypeToError(isInUnionType) {
             // the function type and constructor type shorthand notation
@@ -33779,23 +33993,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;
@@ -34632,7 +34844,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)) {
@@ -34640,7 +34852,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();
@@ -34856,7 +35068,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 */) {
@@ -35134,7 +35346,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;
             }
@@ -35530,7 +35742,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() {
@@ -35905,16 +36117,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);
@@ -36381,9 +36593,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);
@@ -36948,7 +37160,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 */);
                 }
@@ -36977,7 +37189,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();
@@ -36988,9 +37200,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 = [];
                     }
@@ -37806,7 +38018,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)) {
@@ -45694,7 +45906,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 {
@@ -45897,8 +46109,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 &&
@@ -46927,7 +47139,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);
@@ -46946,7 +47158,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 */;
                 }
@@ -46961,7 +47173,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 */;
                 }
@@ -46974,7 +47186,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)) {
@@ -47047,7 +47259,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; }));
@@ -47947,7 +48159,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 }));
                         }
                     });
@@ -48398,7 +48610,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);
@@ -48626,7 +48838,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);
@@ -48740,7 +48952,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;
                 }
@@ -48802,7 +49014,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)) {
@@ -49067,7 +49279,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 */)) {
@@ -49390,7 +49602,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));
@@ -49645,7 +49857,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 */) {
@@ -50418,7 +50630,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;
             }
@@ -51886,7 +52098,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 */ &&
@@ -53842,7 +54067,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 */;
@@ -54812,7 +55037,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
@@ -55152,7 +55377,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`
@@ -55268,7 +55493,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.
@@ -56724,7 +56949,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 */:
@@ -59357,7 +59582,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) {
@@ -59369,7 +59594,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) {
@@ -59791,7 +60016,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) {
@@ -61350,7 +61575,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;
         }
@@ -62043,7 +62268,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) {
@@ -62379,7 +62604,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;
             }
@@ -62454,7 +62679,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 */:
@@ -67331,6 +67556,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;
                     }
@@ -67347,6 +67575,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,
@@ -69329,7 +69588,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));
@@ -70733,6 +70992,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)));
@@ -71026,7 +71286,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);
@@ -72034,7 +72294,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;
             }
@@ -72222,7 +72482,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;
             }
@@ -72640,6 +72900,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) {
@@ -72841,6 +73106,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 */) {
@@ -73933,7 +74205,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);
                 }
             }
@@ -74001,7 +74273,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;
                         }
                     }
@@ -74038,7 +74310,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);
             }
@@ -74703,34 +74975,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);
@@ -74742,7 +75016,7 @@ var ts;
                 }
             }
             var thisType = getThisTypeOfSignature(signature);
-            if (thisType) {
+            if (thisType && couldContainTypeVariables(thisType)) {
                 var thisArgumentNode = getThisArgumentOfCall(node);
                 inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType);
             }
@@ -74750,11 +75024,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);
             }
@@ -76334,7 +76610,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));
@@ -76478,7 +76754,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;
         }
@@ -76673,7 +76949,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) {
@@ -78687,6 +78963,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.
@@ -78978,7 +79259,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;
@@ -78990,7 +79271,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;
         }
@@ -79076,7 +79357,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);
                 }
             }
@@ -79769,7 +80050,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);
                         }
@@ -79864,7 +80145,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 */) {
@@ -80024,6 +80305,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) {
@@ -80061,7 +80359,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);
@@ -80070,7 +80368,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 */;
@@ -80203,10 +80501,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
@@ -81058,7 +81356,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);
@@ -81180,7 +81478,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;
@@ -81370,8 +81668,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)));
                     }
                 }
@@ -81413,7 +81711,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) {
@@ -81441,7 +81739,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;
             }
@@ -81580,7 +81878,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);
                 }
             }
@@ -83174,23 +83472,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;
@@ -83258,7 +83556,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);
             }
@@ -83408,7 +83706,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;
@@ -83636,7 +83934,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
@@ -83728,7 +84026,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);
@@ -83865,7 +84163,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.
@@ -83897,7 +84195,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 {
@@ -84065,11 +84363,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;
                     }
                 }
@@ -84100,7 +84398,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);
                 }
@@ -84318,7 +84616,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) {
@@ -84364,7 +84662,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 */))
@@ -84493,7 +84791,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);
                     }
@@ -84519,7 +84817,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);
                     }
@@ -84684,10 +84982,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);
@@ -85120,7 +85418,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);
                             }
                         });
@@ -85220,7 +85518,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 [];
             }
@@ -85570,7 +85868,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;
             }
@@ -85712,7 +86010,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;
             }
@@ -86765,7 +87063,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;
@@ -87018,7 +87316,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)) {
@@ -87064,7 +87362,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 */) {
@@ -87210,7 +87508,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) {
@@ -87421,7 +87719,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) {
@@ -87659,7 +87957,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);
                 }
@@ -87799,7 +88097,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) {
@@ -87915,7 +88213,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) {
@@ -87927,7 +88225,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
@@ -87936,7 +88234,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));
@@ -88113,11 +88411,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
@@ -88163,10 +88461,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))) {
@@ -92284,7 +92582,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, 
@@ -99174,8 +99472,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);
             }
@@ -108218,7 +108516,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:
@@ -109866,6 +110164,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 {
@@ -111078,7 +111379,7 @@ var ts;
             writePunctuation("}");
         }
         function emitArrayType(node) {
-            emit(node.elementType, parenthesizer.parenthesizeElementTypeOfArrayType);
+            emit(node.elementType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType);
             writePunctuation("[");
             writePunctuation("]");
         }
@@ -111089,7 +111390,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) {
@@ -111101,21 +111402,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();
@@ -111141,10 +111442,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("]");
@@ -112878,7 +113182,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
@@ -112997,6 +113301,7 @@ var ts;
                 if (format & 128 /* Indented */) {
                     increaseIndent();
                 }
+                var emitListItem = getEmitListItem(emit, parenthesizerRule);
                 // Emit each child.
                 var previousSibling = void 0;
                 var previousSourceFileTextKind = void 0;
@@ -113047,12 +113352,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;
@@ -114293,6 +114593,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;
@@ -116359,7 +116673,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 */;
                     }
@@ -116523,6 +116837,9 @@ var ts;
             return !!sourceFilesFoundSearchingNodeModules.get(file.path);
         }
         function isSourceFileDefaultLibrary(file) {
+            if (!file.isDeclarationFile) {
+                return false;
+            }
             if (file.hasNoDefaultLib) {
                 return true;
             }
@@ -117034,7 +117351,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;
@@ -117632,7 +117949,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);
                     }
@@ -126499,7 +126816,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 */);
@@ -132815,7 +133132,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;
@@ -135478,17 +135795,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;
@@ -135617,13 +135942,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) {
@@ -135766,7 +136097,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 */:
@@ -136331,15 +136662,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; });
@@ -137341,7 +137678,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));
@@ -137719,7 +138056,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;
                 }
@@ -137878,7 +138215,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); });
@@ -140012,8 +140349,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);
@@ -140021,8 +140358,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);
             }
@@ -140068,6 +140405,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) {
@@ -148028,8 +148399,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));
@@ -155994,7 +156368,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 */:
@@ -157571,6 +157945,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);
             }
@@ -158511,7 +158889,7 @@ var ts;
                     // 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) {
@@ -158637,7 +159015,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)
@@ -160169,6 +160547,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) {
@@ -162199,7 +162578,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 () {
@@ -163655,7 +164034,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);
@@ -163684,7 +164063,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();
@@ -163699,10 +164078,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; }
@@ -164175,7 +164552,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);
@@ -164623,7 +165000,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
@@ -173543,6 +173920,7 @@ var ts;
                 logger.info("Finding references to " + location.fileName + " position " + location.pos + " in project " + project.getProjectName());
                 var projectOutputs = project.getLanguageService().findReferences(location.fileName, location.pos);
                 if (projectOutputs) {
+                    var clearIsDefinition = projectOutputs[0].references[0].isDefinition === undefined;
                     var _loop_9 = function (referencedSymbol) {
                         var mappedDefinitionFile = getMappedLocation(project, documentSpanLocation(referencedSymbol.definition));
                         var definition = mappedDefinitionFile === undefined ?
@@ -173556,6 +173934,9 @@ var ts;
                             var ref = _b[_a];
                             // If it's in a mapped file, that is added to the todo list by `getMappedLocation`.
                             if (!ts.contains(symbolToAddTo.references, ref, ts.documentSpansEqual) && !getMappedLocation(project, documentSpanLocation(ref))) {
+                                if (clearIsDefinition) {
+                                    delete ref.isDefinition;
+                                }
                                 symbolToAddTo.references.push(ref);
                             }
                         }