typescript 4.7.0-dev.20220216 → 4.7.0-dev.20220217

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220216";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220217";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4909,13 +4909,14 @@ var ts;
         // Flags that require TypeFlags.Object
         ObjectFlags[ObjectFlags["ContainsSpread"] = 4194304] = "ContainsSpread";
         ObjectFlags[ObjectFlags["ObjectRestType"] = 8388608] = "ObjectRestType";
+        ObjectFlags[ObjectFlags["InstantiationExpressionType"] = 16777216] = "InstantiationExpressionType";
         /* @internal */
-        ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
+        ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 33554432] = "IsClassInstanceClone";
         // Flags that require TypeFlags.Object and ObjectFlags.Reference
         /* @internal */
-        ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
+        ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 67108864] = "IdenticalBaseTypeCalculated";
         /* @internal */
-        ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
+        ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 134217728] = "IdenticalBaseTypeExists";
         // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution
         /* @internal */
         ObjectFlags[ObjectFlags["IsGenericTypeComputed"] = 4194304] = "IsGenericTypeComputed";
@@ -8133,7 +8134,6 @@ var ts;
         Unexpected_token_Did_you_mean_or_rbrace: diag(1381, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `}`?"),
         Unexpected_token_Did_you_mean_or_gt: diag(1382, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_gt_1382", "Unexpected token. Did you mean `{'>'}` or `>`?"),
         Only_named_exports_may_use_export_type: diag(1383, ts.DiagnosticCategory.Error, "Only_named_exports_may_use_export_type_1383", "Only named exports may use 'export type'."),
-        A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list: diag(1384, ts.DiagnosticCategory.Error, "A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list_1384", "A 'new' expression with type arguments must always be followed by a parenthesized argument list."),
         Function_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1385, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_a_union_type_1385", "Function type notation must be parenthesized when used in a union type."),
         Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1386, ts.DiagnosticCategory.Error, "Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type_1386", "Constructor type notation must be parenthesized when used in a union type."),
         Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1387, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1387", "Function type notation must be parenthesized when used in an intersection type."),
@@ -8519,6 +8519,7 @@ var ts;
         Cannot_assign_to_0_because_it_is_an_import: diag(2632, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_an_import_2632", "Cannot assign to '{0}' because it is an import."),
         JSX_property_access_expressions_cannot_include_JSX_namespace_names: diag(2633, ts.DiagnosticCategory.Error, "JSX_property_access_expressions_cannot_include_JSX_namespace_names_2633", "JSX property access expressions cannot include JSX namespace names"),
         _0_index_signatures_are_incompatible: diag(2634, ts.DiagnosticCategory.Error, "_0_index_signatures_are_incompatible_2634", "'{0}' index signatures are incompatible."),
+        Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: diag(2635, ts.DiagnosticCategory.Error, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."),
         Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."),
         A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."),
         Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."),
@@ -13410,6 +13411,7 @@ var ts;
             case 110 /* TrueKeyword */:
             case 106 /* SuperKeyword */:
             case 229 /* NonNullExpression */:
+            case 227 /* ExpressionWithTypeArguments */:
             case 230 /* MetaProperty */:
             case 100 /* ImportKeyword */: // technically this is only an Expression if it's in a CallExpression
                 return true;
@@ -15123,7 +15125,7 @@ var ts;
             case 114 /* VoidKeyword */:
                 return node.parent.kind !== 216 /* VoidExpression */;
             case 227 /* ExpressionWithTypeArguments */:
-                return !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+                return ts.isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
             case 162 /* TypeParameter */:
                 return node.parent.kind === 194 /* MappedType */ || node.parent.kind === 189 /* InferType */;
             // Identifiers and qualified names may be type nodes, depending on their context. Climb
@@ -15160,7 +15162,7 @@ var ts;
                 }
                 switch (parent.kind) {
                     case 227 /* ExpressionWithTypeArguments */:
-                        return !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
+                        return ts.isHeritageClause(parent.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
                     case 162 /* TypeParameter */:
                         return node === parent.constraint;
                     case 342 /* JSDocTemplateTag */:
@@ -15863,7 +15865,7 @@ var ts;
             case 296 /* SpreadAssignment */:
                 return true;
             case 227 /* ExpressionWithTypeArguments */:
-                return parent.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent);
+                return parent.expression === node && !isPartOfTypeNode(parent);
             case 295 /* ShorthandPropertyAssignment */:
                 return parent.objectAssignmentInitializer === node;
             default:
@@ -22850,16 +22852,18 @@ var ts;
             return updateConstructorTypeNode1(node, node.modifiers, typeParameters, parameters, type);
         }
         // @api
-        function createTypeQueryNode(exprName) {
+        function createTypeQueryNode(exprName, typeArguments) {
             var node = createBaseNode(180 /* TypeQuery */);
             node.exprName = exprName;
+            node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
         }
         // @api
-        function updateTypeQueryNode(node, exprName) {
+        function updateTypeQueryNode(node, exprName, typeArguments) {
             return node.exprName !== exprName
-                ? update(createTypeQueryNode(exprName), node)
+                || node.typeArguments !== typeArguments
+                ? update(createTypeQueryNode(exprName, typeArguments), node)
                 : node;
         }
         // @api
@@ -29983,7 +29987,8 @@ var ts;
                     visitNode(cbNode, node.parameterName) ||
                     visitNode(cbNode, node.type);
             case 180 /* TypeQuery */:
-                return visitNode(cbNode, node.exprName);
+                return visitNode(cbNode, node.exprName) ||
+                    visitNodes(cbNode, cbNodes, node.typeArguments);
             case 181 /* TypeLiteral */:
                 return visitNodes(cbNode, cbNodes, node.members);
             case 182 /* ArrayType */:
@@ -32516,7 +32521,9 @@ var ts;
         function parseTypeQuery() {
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
-            return finishNode(factory.createTypeQueryNode(parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true)), pos);
+            var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
+            var typeArguments = tryParseTypeArguments();
+            return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
             var pos = getNodePos();
@@ -34586,20 +34593,30 @@ var ts;
                     expression = parsePropertyAccessExpressionRest(pos, expression, questionDotToken);
                     continue;
                 }
-                if (!questionDotToken && token() === 53 /* ExclamationToken */ && !scanner.hasPrecedingLineBreak()) {
-                    nextToken();
-                    expression = finishNode(factory.createNonNullExpression(expression), pos);
-                    continue;
-                }
                 // when in the [Decorator] context, we do not parse ElementAccess as it could be part of a ComputedPropertyName
                 if ((questionDotToken || !inDecoratorContext()) && parseOptional(22 /* OpenBracketToken */)) {
                     expression = parseElementAccessExpressionRest(pos, expression, questionDotToken);
                     continue;
                 }
                 if (isTemplateStartOfTaggedTemplate()) {
-                    expression = parseTaggedTemplateRest(pos, expression, questionDotToken, /*typeArguments*/ undefined);
+                    // Absorb type arguments into TemplateExpression when preceding expression is ExpressionWithTypeArguments
+                    expression = !questionDotToken && expression.kind === 227 /* ExpressionWithTypeArguments */ ?
+                        parseTaggedTemplateRest(pos, expression.expression, questionDotToken, expression.typeArguments) :
+                        parseTaggedTemplateRest(pos, expression, questionDotToken, /*typeArguments*/ undefined);
                     continue;
                 }
+                if (!questionDotToken) {
+                    if (token() === 53 /* ExclamationToken */ && !scanner.hasPrecedingLineBreak()) {
+                        nextToken();
+                        expression = finishNode(factory.createNonNullExpression(expression), pos);
+                        continue;
+                    }
+                    var typeArguments = tryParse(parseTypeArgumentsInExpression);
+                    if (typeArguments) {
+                        expression = finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
+                        continue;
+                    }
+                }
                 return expression;
             }
         }
@@ -34619,38 +34636,30 @@ var ts;
         function parseCallExpressionRest(pos, expression) {
             while (true) {
                 expression = parseMemberExpressionRest(pos, expression, /*allowOptionalChain*/ true);
+                var typeArguments = void 0;
                 var questionDotToken = parseOptionalToken(28 /* QuestionDotToken */);
-                // handle 'foo<<T>()'
-                // parse template arguments only in TypeScript files (not in JavaScript files).
-                if ((contextFlags & 131072 /* JavaScriptFile */) === 0 && (token() === 29 /* LessThanToken */ || token() === 47 /* LessThanLessThanToken */)) {
-                    // See if this is the start of a generic invocation.  If so, consume it and
-                    // keep checking for postfix expressions.  Otherwise, it's just a '<' that's
-                    // part of an arithmetic expression.  Break out so we consume it higher in the
-                    // stack.
-                    var typeArguments = tryParse(parseTypeArgumentsInExpression);
-                    if (typeArguments) {
-                        if (isTemplateStartOfTaggedTemplate()) {
-                            expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
-                            continue;
-                        }
-                        var argumentList = parseArgumentList();
-                        var callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
-                            factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
-                            factory.createCallExpression(expression, typeArguments, argumentList);
-                        expression = finishNode(callExpr, pos);
+                if (questionDotToken) {
+                    typeArguments = tryParse(parseTypeArgumentsInExpression);
+                    if (isTemplateStartOfTaggedTemplate()) {
+                        expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
                         continue;
                     }
                 }
-                else if (token() === 20 /* OpenParenToken */) {
+                if (typeArguments || token() === 20 /* OpenParenToken */) {
+                    // Absorb type arguments into CallExpression when preceding expression is ExpressionWithTypeArguments
+                    if (!questionDotToken && expression.kind === 227 /* ExpressionWithTypeArguments */) {
+                        typeArguments = expression.typeArguments;
+                        expression = expression.expression;
+                    }
                     var argumentList = parseArgumentList();
                     var callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
-                        factory.createCallChain(expression, questionDotToken, /*typeArguments*/ undefined, argumentList) :
-                        factory.createCallExpression(expression, /*typeArguments*/ undefined, argumentList);
+                        factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
+                        factory.createCallExpression(expression, typeArguments, argumentList);
                     expression = finishNode(callExpr, pos);
                     continue;
                 }
                 if (questionDotToken) {
-                    // We failed to parse anything, so report a missing identifier here.
+                    // We parsed `?.` but then failed to parse anything, so report a missing identifier here.
                     var name = createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics.Identifier_expected);
                     expression = finishNode(factory.createPropertyAccessChain(expression, questionDotToken, name), pos);
                 }
@@ -34678,21 +34687,25 @@ var ts;
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
-            // If we have a '<', then only parse this as a argument list if the type arguments
-            // are complete and we have an open paren.  if we don't, rewind and return nothing.
-            return typeArguments && canFollowTypeArgumentsInExpression()
-                ? typeArguments
-                : undefined;
+            // We successfully parsed a type argument list. The next token determines whether we want to
+            // treat it as such. If the type argument list is followed by `(` or a template literal, as in
+            // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
+            // it as a relational expression.
+            return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : undefined;
         }
         function canFollowTypeArgumentsInExpression() {
             switch (token()) {
+                // These tokens can follow a type argument list in a call expression.
                 case 20 /* OpenParenToken */: // foo<x>(
                 case 14 /* NoSubstitutionTemplateLiteral */: // foo<T> `...`
                 case 15 /* TemplateHead */: // foo<T> `...${100}...`
-                // these are the only tokens can legally follow a type argument
-                // list. So we definitely want to treat them as type arg lists.
+                // These tokens can't follow in a call expression, nor can they start an
+                // expression. So, consider the type argument list part of an instantiation
+                // expression.
                 // falls through
+                case 27 /* CommaToken */: // foo<x>,
                 case 24 /* DotToken */: // foo<x>.
+                case 28 /* QuestionDotToken */: // foo<x>?.
                 case 21 /* CloseParenToken */: // foo<x>)
                 case 23 /* CloseBracketToken */: // foo<x>]
                 case 58 /* ColonToken */: // foo<x>:
@@ -34710,20 +34723,10 @@ var ts;
                 case 51 /* BarToken */: // foo<x> |
                 case 19 /* CloseBraceToken */: // foo<x> }
                 case 1 /* EndOfFileToken */: // foo<x>
-                    // these cases can't legally follow a type arg list.  However, they're not legal
-                    // expressions either.  The user is probably in the middle of a generic type. So
-                    // treat it as such.
                     return true;
-                case 27 /* CommaToken */: // foo<x>,
-                case 18 /* OpenBraceToken */: // foo<x> {
-                // We don't want to treat these as type arguments.  Otherwise we'll parse this
-                // as an invocation expression.  Instead, we want to parse out the expression
-                // in isolation from the type arguments.
-                // falls through
-                default:
-                    // Anything else treat as an expression.
-                    return false;
             }
+            // Treat anything else as an expression.
+            return false;
         }
         function parsePrimaryExpression() {
             switch (token()) {
@@ -34904,26 +34907,15 @@ var ts;
                 return finishNode(factory.createMetaProperty(103 /* NewKeyword */, name), pos);
             }
             var expressionPos = getNodePos();
-            var expression = parsePrimaryExpression();
+            var expression = parseMemberExpressionRest(expressionPos, parsePrimaryExpression(), /*allowOptionalChain*/ false);
             var typeArguments;
-            while (true) {
-                expression = parseMemberExpressionRest(expressionPos, expression, /*allowOptionalChain*/ false);
-                typeArguments = tryParse(parseTypeArgumentsInExpression);
-                if (isTemplateStartOfTaggedTemplate()) {
-                    ts.Debug.assert(!!typeArguments, "Expected a type argument list; all plain tagged template starts should be consumed in 'parseMemberExpressionRest'");
-                    expression = parseTaggedTemplateRest(expressionPos, expression, /*optionalChain*/ undefined, typeArguments);
-                    typeArguments = undefined;
-                }
-                break;
-            }
-            var argumentsArray;
-            if (token() === 20 /* OpenParenToken */) {
-                argumentsArray = parseArgumentList();
-            }
-            else if (typeArguments) {
-                parseErrorAt(pos, scanner.getStartPos(), ts.Diagnostics.A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list);
+            // Absorb type arguments into NewExpression when preceding expression is ExpressionWithTypeArguments
+            if (expression.kind === 227 /* ExpressionWithTypeArguments */) {
+                typeArguments = expression.typeArguments;
+                expression = expression.expression;
             }
-            return finishNode(factory.createNewExpression(expression, typeArguments, argumentsArray), pos);
+            var argumentList = token() === 20 /* OpenParenToken */ ? parseArgumentList() : undefined;
+            return finishNode(factory.createNewExpression(expression, typeArguments, argumentList), pos);
         }
         // STATEMENTS
         function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) {
@@ -36012,6 +36004,9 @@ var ts;
         function parseExpressionWithTypeArguments() {
             var pos = getNodePos();
             var expression = parseLeftHandSideExpressionOrHigher();
+            if (expression.kind === 227 /* ExpressionWithTypeArguments */) {
+                return expression;
+            }
             var typeArguments = tryParseTypeArguments();
             return finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
         }
@@ -51020,7 +51015,7 @@ var ts;
             // get symbol of the first identifier of the entityName
             var meaning;
             if (entityName.parent.kind === 180 /* TypeQuery */ ||
-                ts.isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent) ||
+                entityName.parent.kind === 227 /* ExpressionWithTypeArguments */ && !ts.isPartOfTypeNode(entityName.parent) ||
                 entityName.parent.kind === 161 /* ComputedPropertyName */) {
                 // Typeof value
                 meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
@@ -51131,7 +51126,7 @@ var ts;
             return flags & 814775659 /* NodeBuilderFlagsMask */;
         }
         function isClassInstanceSide(type) {
-            return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* Object */) && !!(ts.getObjectFlags(type) & 16777216 /* IsClassInstanceClone */)));
+            return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* Object */) && !!(ts.getObjectFlags(type) & 33554432 /* IsClassInstanceClone */)));
         }
         function createNodeBuilder() {
             return {
@@ -55060,7 +55055,7 @@ var ts;
                 members_4, exportedType.callSignatures, exportedType.constructSignatures, exportedType.indexInfos);
                 result.objectFlags |= (ts.getObjectFlags(type) & 8192 /* JSLiteral */); // Propagate JSLiteral flag
                 if (result.symbol && result.symbol.flags & 32 /* Class */ && type === getDeclaredTypeOfClassOrInterface(result.symbol)) {
-                    result.objectFlags |= 16777216 /* IsClassInstanceClone */; // Propagate the knowledge that this type is equivalent to the symbol's class instance type
+                    result.objectFlags |= 33554432 /* IsClassInstanceClone */; // Propagate the knowledge that this type is equivalent to the symbol's class instance type
                 }
                 return result;
             }
@@ -57106,87 +57101,87 @@ var ts;
          * Converts an AnonymousType to a ResolvedType.
          */
         function resolveAnonymousTypeMembers(type) {
-            var symbol = getMergedSymbol(type.symbol);
             if (type.target) {
                 setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                var members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false);
+                var members_6 = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false);
                 var callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0 /* Call */), type.mapper);
                 var constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1 /* Construct */), type.mapper);
-                var indexInfos = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper);
-                setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
+                var indexInfos_1 = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper);
+                setStructuredTypeMembers(type, members_6, callSignatures, constructSignatures, indexInfos_1);
+                return;
             }
-            else if (symbol.flags & 2048 /* TypeLiteral */) {
+            var symbol = getMergedSymbol(type.symbol);
+            if (symbol.flags & 2048 /* TypeLiteral */) {
                 setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                var members = getMembersOfSymbol(symbol);
-                var callSignatures = getSignaturesOfSymbol(members.get("__call" /* Call */));
-                var constructSignatures = getSignaturesOfSymbol(members.get("__new" /* New */));
-                var indexInfos = getIndexInfosOfSymbol(symbol);
-                setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
+                var members_7 = getMembersOfSymbol(symbol);
+                var callSignatures = getSignaturesOfSymbol(members_7.get("__call" /* Call */));
+                var constructSignatures = getSignaturesOfSymbol(members_7.get("__new" /* New */));
+                var indexInfos_2 = getIndexInfosOfSymbol(symbol);
+                setStructuredTypeMembers(type, members_7, callSignatures, constructSignatures, indexInfos_2);
+                return;
             }
-            else {
-                // Combinations of function, class, enum and module
-                var members = emptySymbols;
-                var indexInfos = void 0;
-                if (symbol.exports) {
-                    members = getExportsOfSymbol(symbol);
-                    if (symbol === globalThisSymbol) {
-                        var varsOnly_1 = new ts.Map();
-                        members.forEach(function (p) {
-                            if (!(p.flags & 418 /* BlockScoped */)) {
-                                varsOnly_1.set(p.escapedName, p);
-                            }
-                        });
-                        members = varsOnly_1;
-                    }
+            // Combinations of function, class, enum and module
+            var members = emptySymbols;
+            var indexInfos;
+            if (symbol.exports) {
+                members = getExportsOfSymbol(symbol);
+                if (symbol === globalThisSymbol) {
+                    var varsOnly_1 = new ts.Map();
+                    members.forEach(function (p) {
+                        if (!(p.flags & 418 /* BlockScoped */)) {
+                            varsOnly_1.set(p.escapedName, p);
+                        }
+                    });
+                    members = varsOnly_1;
                 }
-                var baseConstructorIndexInfo = void 0;
-                setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                if (symbol.flags & 32 /* Class */) {
-                    var classType = getDeclaredTypeOfClassOrInterface(symbol);
-                    var baseConstructorType = getBaseConstructorTypeOfClass(classType);
-                    if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 8650752 /* TypeVariable */)) {
-                        members = ts.createSymbolTable(getNamedOrIndexSignatureMembers(members));
-                        addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
-                    }
-                    else if (baseConstructorType === anyType) {
-                        baseConstructorIndexInfo = createIndexInfo(stringType, anyType, /*isReadonly*/ false);
-                    }
+            }
+            var baseConstructorIndexInfo;
+            setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, ts.emptyArray);
+            if (symbol.flags & 32 /* Class */) {
+                var classType = getDeclaredTypeOfClassOrInterface(symbol);
+                var baseConstructorType = getBaseConstructorTypeOfClass(classType);
+                if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 8650752 /* TypeVariable */)) {
+                    members = ts.createSymbolTable(getNamedOrIndexSignatureMembers(members));
+                    addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
                 }
-                var indexSymbol = getIndexSymbolFromSymbolTable(members);
-                if (indexSymbol) {
-                    indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
+                else if (baseConstructorType === anyType) {
+                    baseConstructorIndexInfo = createIndexInfo(stringType, anyType, /*isReadonly*/ false);
                 }
-                else {
-                    if (baseConstructorIndexInfo) {
-                        indexInfos = ts.append(indexInfos, baseConstructorIndexInfo);
-                    }
-                    if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ ||
-                        ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */); }))) {
-                        indexInfos = ts.append(indexInfos, enumNumberIndexInfo);
-                    }
+            }
+            var indexSymbol = getIndexSymbolFromSymbolTable(members);
+            if (indexSymbol) {
+                indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
+            }
+            else {
+                if (baseConstructorIndexInfo) {
+                    indexInfos = ts.append(indexInfos, baseConstructorIndexInfo);
                 }
-                setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos || ts.emptyArray);
-                // We resolve the members before computing the signatures because a signature may use
-                // typeof with a qualified name expression that circularly references the type we are
-                // in the process of resolving (see issue #6072). The temporarily empty signature list
-                // will never be observed because a qualified name can't reference signatures.
-                if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
-                    type.callSignatures = getSignaturesOfSymbol(symbol);
+                if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ ||
+                    ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */); }))) {
+                    indexInfos = ts.append(indexInfos, enumNumberIndexInfo);
                 }
-                // And likewise for construct signatures for classes
-                if (symbol.flags & 32 /* Class */) {
-                    var classType_1 = getDeclaredTypeOfClassOrInterface(symbol);
-                    var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : ts.emptyArray;
-                    if (symbol.flags & 16 /* Function */) {
-                        constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ?
-                            createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) :
-                            undefined; }));
-                    }
-                    if (!constructSignatures.length) {
-                        constructSignatures = getDefaultConstructSignatures(classType_1);
-                    }
-                    type.constructSignatures = constructSignatures;
+            }
+            setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos || ts.emptyArray);
+            // We resolve the members before computing the signatures because a signature may use
+            // typeof with a qualified name expression that circularly references the type we are
+            // in the process of resolving (see issue #6072). The temporarily empty signature list
+            // will never be observed because a qualified name can't reference signatures.
+            if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
+                type.callSignatures = getSignaturesOfSymbol(symbol);
+            }
+            // And likewise for construct signatures for classes
+            if (symbol.flags & 32 /* Class */) {
+                var classType_1 = getDeclaredTypeOfClassOrInterface(symbol);
+                var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : ts.emptyArray;
+                if (symbol.flags & 16 /* Function */) {
+                    constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ?
+                        createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) :
+                        undefined; }));
+                }
+                if (!constructSignatures.length) {
+                    constructSignatures = getDefaultConstructSignatures(classType_1);
                 }
+                type.constructSignatures = constructSignatures;
             }
         }
         function replaceIndexedAccess(instantiable, type, replacement) {
@@ -58187,8 +58182,8 @@ var ts;
             var stringIndexInfo;
             var applicableInfo;
             var applicableInfos;
-            for (var _i = 0, indexInfos_1 = indexInfos; _i < indexInfos_1.length; _i++) {
-                var info = indexInfos_1[_i];
+            for (var _i = 0, indexInfos_3 = indexInfos; _i < indexInfos_3.length; _i++) {
+                var info = indexInfos_3[_i];
                 if (info.keyType === stringType) {
                     stringIndexInfo = info;
                 }
@@ -58761,14 +58756,14 @@ var ts;
         }
         function getIndexInfosOfIndexSymbol(indexSymbol) {
             if (indexSymbol.declarations) {
-                var indexInfos_2 = [];
+                var indexInfos_4 = [];
                 var _loop_14 = function (declaration) {
                     if (declaration.parameters.length === 1) {
                         var parameter = declaration.parameters[0];
                         if (parameter.type) {
                             forEachType(getTypeFromTypeNode(parameter.type), function (keyType) {
-                                if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos_2, keyType)) {
-                                    indexInfos_2.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasEffectiveModifier(declaration, 64 /* Readonly */), declaration));
+                                if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos_4, keyType)) {
+                                    indexInfos_4.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasEffectiveModifier(declaration, 64 /* Readonly */), declaration));
                                 }
                             });
                         }
@@ -58778,7 +58773,7 @@ var ts;
                     var declaration = _a[_i];
                     _loop_14(declaration);
                 }
-                return indexInfos_2;
+                return indexInfos_4;
             }
             return ts.emptyArray;
         }
@@ -59326,7 +59321,7 @@ var ts;
                 // The expression is processed as an identifier expression (section 4.3)
                 // or property access expression(section 4.10),
                 // the widened type(section 3.9) of which becomes the result.
-                var type = ts.isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) : checkExpression(node.exprName);
+                var type = checkExpressionWithTypeArguments(node);
                 links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(type));
             }
             return links.resolvedType;
@@ -62030,7 +62025,9 @@ var ts;
             return result;
         }
         function getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
-            var declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.symbol.declarations[0];
+            var declaration = type.objectFlags & 4 /* Reference */ ? type.node :
+                type.objectFlags & 16777216 /* InstantiationExpressionType */ ? type.node :
+                    type.symbol.declarations[0];
             var links = getNodeLinks(declaration);
             var target = type.objectFlags & 4 /* Reference */ ? links.resolvedType :
                 type.objectFlags & 64 /* Instantiated */ ? type.target : type;
@@ -62046,8 +62043,8 @@ var ts;
                     outerTypeParameters = ts.addRange(outerTypeParameters, templateTagParameters);
                 }
                 typeParameters = outerTypeParameters || ts.emptyArray;
-                var allDeclarations_1 = type.objectFlags & 4 /* Reference */ ? [declaration] : type.symbol.declarations;
-                typeParameters = (target.objectFlags & 4 /* Reference */ || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ?
+                var allDeclarations_1 = type.objectFlags & (4 /* Reference */ | 16777216 /* InstantiationExpressionType */) ? [declaration] : type.symbol.declarations;
+                typeParameters = (target.objectFlags & (4 /* Reference */ | 16777216 /* InstantiationExpressionType */) || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ?
                     ts.filter(typeParameters, function (tp) { return ts.some(allDeclarations_1, function (d) { return isTypeParameterPossiblyReferenced(tp, d); }); }) :
                     typeParameters;
                 links.outerTypeParameters = typeParameters;
@@ -62219,6 +62216,9 @@ var ts;
                 mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper);
                 freshTypeParameter.mapper = mapper;
             }
+            if (type.objectFlags & 16777216 /* InstantiationExpressionType */) {
+                result.node = type.node;
+            }
             result.target = type;
             result.mapper = mapper;
             result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -65412,8 +65412,8 @@ var ts;
                 var indexInfos = getIndexInfosOfType(target);
                 var targetHasStringIndex = ts.some(indexInfos, function (info) { return info.keyType === stringType; });
                 var result = -1 /* True */;
-                for (var _i = 0, indexInfos_3 = indexInfos; _i < indexInfos_3.length; _i++) {
-                    var targetInfo = indexInfos_3[_i];
+                for (var _i = 0, indexInfos_5 = indexInfos; _i < indexInfos_5.length; _i++) {
+                    var targetInfo = indexInfos_5[_i];
                     var related = !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* Any */ ? -1 /* True */ :
                         isGenericMappedType(source) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source), targetInfo.type, 3 /* Both */, reportErrors) :
                             typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState);
@@ -66020,10 +66020,10 @@ var ts;
             if (!(ts.getObjectFlags(type) & 4 /* Reference */) || !(ts.getObjectFlags(type.target) & 3 /* ClassOrInterface */)) {
                 return undefined;
             }
-            if (ts.getObjectFlags(type) & 33554432 /* IdenticalBaseTypeCalculated */) {
-                return ts.getObjectFlags(type) & 67108864 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : undefined;
+            if (ts.getObjectFlags(type) & 67108864 /* IdenticalBaseTypeCalculated */) {
+                return ts.getObjectFlags(type) & 134217728 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : undefined;
             }
-            type.objectFlags |= 33554432 /* IdenticalBaseTypeCalculated */;
+            type.objectFlags |= 67108864 /* IdenticalBaseTypeCalculated */;
             var target = type.target;
             if (ts.getObjectFlags(target) & 1 /* Class */) {
                 var baseTypeNode = getBaseTypeNodeOfClass(target);
@@ -66044,7 +66044,7 @@ var ts;
             if (ts.length(getTypeArguments(type)) > ts.length(target.typeParameters)) {
                 instantiatedBase = getTypeWithThisArgument(instantiatedBase, ts.last(getTypeArguments(type)));
             }
-            type.objectFlags |= 67108864 /* IdenticalBaseTypeExists */;
+            type.objectFlags |= 134217728 /* IdenticalBaseTypeExists */;
             return type.cachedEquivalentBaseType = instantiatedBase;
         }
         function isEmptyLiteralType(type) {
@@ -66708,7 +66708,7 @@ var ts;
             var result = !!(type.flags & 465829888 /* Instantiable */ ||
                 type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || ts.forEach(getTypeArguments(type), couldContainTypeVariables)) ||
                     objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations ||
-                    objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 8388608 /* ObjectRestType */)) ||
+                    objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 8388608 /* ObjectRestType */ | 16777216 /* InstantiationExpressionType */)) ||
                 type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && ts.some(type.types, couldContainTypeVariables));
             if (type.flags & 3899393 /* ObjectFlagsType */) {
                 type.objectFlags |= 1048576 /* CouldContainTypeVariablesComputed */ | (result ? 2097152 /* CouldContainTypeVariables */ : 0);
@@ -67625,8 +67625,8 @@ var ts;
                 var priority = (ts.getObjectFlags(source) & ts.getObjectFlags(target) & 32 /* Mapped */) ? 8 /* HomomorphicMappedType */ : 0;
                 var indexInfos = getIndexInfosOfType(target);
                 if (isObjectTypeWithInferableIndex(source)) {
-                    for (var _i = 0, indexInfos_4 = indexInfos; _i < indexInfos_4.length; _i++) {
-                        var targetInfo = indexInfos_4[_i];
+                    for (var _i = 0, indexInfos_6 = indexInfos; _i < indexInfos_6.length; _i++) {
+                        var targetInfo = indexInfos_6[_i];
                         var propTypes = [];
                         for (var _a = 0, _b = getPropertiesOfType(source); _a < _b.length; _a++) {
                             var prop = _b[_a];
@@ -67646,8 +67646,8 @@ var ts;
                         }
                     }
                 }
-                for (var _e = 0, indexInfos_5 = indexInfos; _e < indexInfos_5.length; _e++) {
-                    var targetInfo = indexInfos_5[_e];
+                for (var _e = 0, indexInfos_7 = indexInfos; _e < indexInfos_7.length; _e++) {
+                    var targetInfo = indexInfos_7[_e];
                     var sourceInfo = getApplicableIndexInfo(source, targetInfo.keyType);
                     if (sourceInfo) {
                         inferWithPriority(sourceInfo.type, targetInfo.type, priority);
@@ -75811,6 +75811,72 @@ var ts;
             return node.flags & 32 /* OptionalChain */ ? checkNonNullChain(node) :
                 getNonNullableType(checkExpression(node.expression));
         }
+        function checkExpressionWithTypeArguments(node) {
+            checkGrammarExpressionWithTypeArguments(node);
+            var exprType = node.kind === 227 /* ExpressionWithTypeArguments */ ? checkExpression(node.expression) :
+                ts.isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) :
+                    checkExpression(node.exprName);
+            var typeArguments = node.typeArguments;
+            if (exprType === silentNeverType || isErrorType(exprType) || !ts.some(typeArguments)) {
+                return exprType;
+            }
+            var hasSomeApplicableSignature = false;
+            var nonApplicableType;
+            var result = getInstantiatedType(exprType);
+            var errorType = hasSomeApplicableSignature ? nonApplicableType : exprType;
+            if (errorType) {
+                diagnostics.add(ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, typeToString(errorType)));
+            }
+            return result;
+            function getInstantiatedType(type) {
+                var hasSignatures = false;
+                var hasApplicableSignature = false;
+                var result = getInstantiatedTypePart(type);
+                hasSomeApplicableSignature || (hasSomeApplicableSignature = hasApplicableSignature);
+                if (hasSignatures && !hasApplicableSignature) {
+                    nonApplicableType !== null && nonApplicableType !== void 0 ? nonApplicableType : (nonApplicableType = type);
+                }
+                return result;
+                function getInstantiatedTypePart(type) {
+                    if (type.flags & 524288 /* Object */) {
+                        var resolved = resolveStructuredTypeMembers(type);
+                        var callSignatures = getInstantiatedSignatures(resolved.callSignatures);
+                        var constructSignatures = getInstantiatedSignatures(resolved.constructSignatures);
+                        hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0);
+                        hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
+                        if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
+                            var result_11 = createAnonymousType(undefined, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
+                            result_11.objectFlags |= 16777216 /* InstantiationExpressionType */;
+                            result_11.node = node;
+                            return result_11;
+                        }
+                    }
+                    else if (type.flags & 58982400 /* InstantiableNonPrimitive */) {
+                        var constraint = getBaseConstraintOfType(type);
+                        if (constraint) {
+                            var instantiated = getInstantiatedTypePart(constraint);
+                            if (instantiated !== constraint) {
+                                return instantiated;
+                            }
+                        }
+                    }
+                    else if (type.flags & 1048576 /* Union */) {
+                        return mapType(type, getInstantiatedType);
+                    }
+                    else if (type.flags & 2097152 /* Intersection */) {
+                        return getIntersectionType(ts.sameMap(type.types, getInstantiatedTypePart));
+                    }
+                    return type;
+                }
+            }
+            function getInstantiatedSignatures(signatures) {
+                var applicableSignatures = ts.filter(signatures, function (sig) { return !!sig.typeParameters && hasCorrectTypeArgumentArity(sig, typeArguments); });
+                return ts.sameMap(applicableSignatures, function (sig) {
+                    var typeArgumentTypes = checkTypeArguments(sig, typeArguments, /*reportErrors*/ true);
+                    return typeArgumentTypes ? getSignatureInstantiation(sig, typeArgumentTypes, ts.isInJSFile(sig.declaration)) : sig;
+                });
+            }
+        }
         function checkMetaProperty(node) {
             checkGrammarMetaProperty(node);
             if (node.keywordToken === 103 /* NewKeyword */) {
@@ -78327,6 +78393,8 @@ var ts;
                     return checkAssertion(node);
                 case 229 /* NonNullExpression */:
                     return checkNonNullAssertion(node);
+                case 227 /* ExpressionWithTypeArguments */:
+                    return checkExpressionWithTypeArguments(node);
                 case 230 /* MetaProperty */:
                     return checkMetaProperty(node);
                 case 214 /* DeleteExpression */:
@@ -79530,12 +79598,12 @@ var ts;
                     case 264 /* ImportEqualsDeclaration */:
                     case 267 /* NamespaceImport */:
                     case 266 /* ImportClause */:
-                        var result_11 = 0 /* None */;
+                        var result_12 = 0 /* None */;
                         var target = resolveAlias(getSymbolOfNode(d));
                         ts.forEach(target.declarations, function (d) {
-                            result_11 |= getDeclarationSpaces(d);
+                            result_12 |= getDeclarationSpaces(d);
                         });
-                        return result_11;
+                        return result_12;
                     case 253 /* VariableDeclaration */:
                     case 202 /* BindingElement */:
                     case 255 /* FunctionDeclaration */:
@@ -82094,8 +82162,8 @@ var ts;
                 }
             }
             if (indexInfos.length > 1) {
-                for (var _d = 0, indexInfos_6 = indexInfos; _d < indexInfos_6.length; _d++) {
-                    var info = indexInfos_6[_d];
+                for (var _d = 0, indexInfos_8 = indexInfos; _d < indexInfos_8.length; _d++) {
+                    var info = indexInfos_8[_d];
                     checkIndexConstraintForIndexSignature(type, info);
                 }
             }
@@ -82121,8 +82189,8 @@ var ts;
                     error(errorNode, ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, symbolToString(prop), typeToString(propType), typeToString(info.keyType), typeToString(info.type));
                 }
             };
-            for (var _i = 0, indexInfos_7 = indexInfos; _i < indexInfos_7.length; _i++) {
-                var info = indexInfos_7[_i];
+            for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
+                var info = indexInfos_9[_i];
                 _loop_27(info);
             }
         }
@@ -82144,8 +82212,8 @@ var ts;
                     error(errorNode, ts.Diagnostics._0_index_type_1_is_not_assignable_to_2_index_type_3, typeToString(checkInfo.keyType), typeToString(checkInfo.type), typeToString(info.keyType), typeToString(info.type));
                 }
             };
-            for (var _i = 0, indexInfos_8 = indexInfos; _i < indexInfos_8.length; _i++) {
-                var info = indexInfos_8[_i];
+            for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
+                var info = indexInfos_10[_i];
                 _loop_28(info);
             }
         }
@@ -87778,7 +87846,7 @@ var ts;
                 return factory.updateConstructorTypeNode(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 180 /* TypeQuery */:
                 ts.Debug.type(node);
-                return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName));
+                return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
             case 181 /* TypeLiteral */:
                 ts.Debug.type(node);
                 return factory.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement));
@@ -90670,8 +90738,8 @@ var ts;
         function generateClassElementDecorationExpressions(node, isStatic) {
             var members = getDecoratedClassElements(node, isStatic);
             var expressions;
-            for (var _i = 0, members_6 = members; _i < members_6.length; _i++) {
-                var member = members_6[_i];
+            for (var _i = 0, members_8 = members; _i < members_8.length; _i++) {
+                var member = members_8[_i];
                 var expression = generateClassElementDecorationExpression(node, member);
                 if (expression) {
                     if (!expressions) {
@@ -96016,8 +96084,8 @@ var ts;
         function convertJsxChildrenToChildrenPropAssignment(children) {
             var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
             if (ts.length(nonWhitespaceChildren) === 1 && !nonWhitespaceChildren[0].dotDotDotToken) {
-                var result_12 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
-                return result_12 && factory.createPropertyAssignment("children", result_12);
+                var result_13 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
+                return result_13 && factory.createPropertyAssignment("children", result_13);
             }
             var result = ts.mapDefined(children, transformJsxChildToExpression);
             return ts.length(result) ? factory.createPropertyAssignment("children", factory.createArrayLiteralExpression(result)) : undefined;
@@ -109655,6 +109723,8 @@ var ts;
                         return emitAsExpression(node);
                     case 229 /* NonNullExpression */:
                         return emitNonNullExpression(node);
+                    case 227 /* ExpressionWithTypeArguments */:
+                        return emitExpressionWithTypeArguments(node);
                     case 230 /* MetaProperty */:
                         return emitMetaProperty(node);
                     case 231 /* SyntheticExpression */:
@@ -110099,6 +110169,7 @@ var ts;
             writeKeyword("typeof");
             writeSpace();
             emit(node.exprName);
+            emitTypeArguments(node, node.typeArguments);
         }
         function emitTypeLiteral(node) {
             writePunctuation("{");
@@ -115072,15 +115143,15 @@ var ts;
                 // which per above occurred during the current program creation.
                 // Since we assume the filesystem does not change during program creation,
                 // it is safe to reuse resolutions from the earlier call.
-                var result_13 = [];
+                var result_14 = [];
                 var i = 0;
                 for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
                     var moduleName = moduleNames_1[_i];
                     var resolvedModule = file.resolvedModules.get(moduleName, getModeForResolutionAtIndex(file, i));
                     i++;
-                    result_13.push(resolvedModule);
+                    result_14.push(resolvedModule);
                 }
-                return result_13;
+                return result_14;
             }
             // At this point, we know at least one of the following hold:
             // - file has local declarations for ambient modules
@@ -120198,9 +120269,9 @@ var ts;
             if (!preferSymlinks) {
                 // Symlinks inside ignored paths are already filtered out of the symlink cache,
                 // so we only need to remove them from the realpath filenames.
-                var result_14 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_14)
-                    return result_14;
+                var result_15 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_15)
+                    return result_15;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -120220,10 +120291,10 @@ var ts;
                     for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) {
                         var symlinkDirectory = symlinkDirectories_1[_i];
                         var option = ts.resolvePath(symlinkDirectory, relative);
-                        var result_15 = cb(option, target === referenceRedirect);
+                        var result_16 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
-                        if (result_15)
-                            return result_15;
+                        if (result_16)
+                            return result_16;
                     }
                 });
             });