typescript 4.6.0-dev.20220211 → 4.7.0-dev.20220217

package/lib/typescriptServices.js

@@ -290,11 +290,11 @@ var ts;
 (function (ts) {
     // WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
     // If changing the text in this section, be sure to test `configurePrerelease` too.
-    ts.versionMajorMinor = "4.6";
+    ts.versionMajorMinor = "4.7";
     // 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.20220211";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220217";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -5034,6 +5034,8 @@ var ts;
         TypeFlags[TypeFlags["ESSymbolLike"] = 12288] = "ESSymbolLike";
         TypeFlags[TypeFlags["VoidLike"] = 49152] = "VoidLike";
         /* @internal */
+        TypeFlags[TypeFlags["DefinitelyNonNullable"] = 470302716] = "DefinitelyNonNullable";
+        /* @internal */
         TypeFlags[TypeFlags["DisjointDomains"] = 469892092] = "DisjointDomains";
         TypeFlags[TypeFlags["UnionOrIntersection"] = 3145728] = "UnionOrIntersection";
         TypeFlags[TypeFlags["StructuredType"] = 3670016] = "StructuredType";
@@ -5112,13 +5114,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";
@@ -5766,6 +5769,8 @@ var ts;
         BundleFileSectionKind["NoDefaultLib"] = "no-default-lib";
         BundleFileSectionKind["Reference"] = "reference";
         BundleFileSectionKind["Type"] = "type";
+        BundleFileSectionKind["TypeResolutionModeRequire"] = "type-require";
+        BundleFileSectionKind["TypeResolutionModeImport"] = "type-import";
         BundleFileSectionKind["Lib"] = "lib";
         BundleFileSectionKind["Prepend"] = "prepend";
         BundleFileSectionKind["Text"] = "text";
@@ -5882,7 +5887,8 @@ var ts;
                 { name: "types", optional: true, captureSpan: true },
                 { name: "lib", optional: true, captureSpan: true },
                 { name: "path", optional: true, captureSpan: true },
-                { name: "no-default-lib", optional: true }
+                { name: "no-default-lib", optional: true },
+                { name: "resolution-mode", optional: true }
             ],
             kind: 1 /* TripleSlashXML */
         },
@@ -7830,18 +7836,6 @@ var ts;
         return getCanonicalFileName(nonCanonicalizedPath);
     }
     ts.toPath = toPath;
-    function normalizePathAndParts(path) {
-        path = normalizeSlashes(path);
-        var _a = reducePathComponents(getPathComponents(path)), root = _a[0], parts = _a.slice(1);
-        if (parts.length) {
-            var joinedParts = root + parts.join(ts.directorySeparator);
-            return { path: hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(joinedParts) : joinedParts, parts: parts };
-        }
-        else {
-            return { path: root, parts: parts };
-        }
-    }
-    ts.normalizePathAndParts = normalizePathAndParts;
     function removeTrailingDirectorySeparator(path) {
         if (hasTrailingDirectorySeparator(path)) {
             return path.substr(0, path.length - 1);
@@ -8275,6 +8269,8 @@ var ts;
         Property_0_cannot_have_an_initializer_because_it_is_marked_abstract: diag(1267, ts.DiagnosticCategory.Error, "Property_0_cannot_have_an_initializer_because_it_is_marked_abstract_1267", "Property '{0}' cannot have an initializer because it is marked abstract."),
         An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type: diag(1268, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268", "An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type."),
         Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided: diag(1269, ts.DiagnosticCategory.Error, "Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided_1269", "Cannot use 'export import' on a type or type-only namespace when the '--isolatedModules' flag is provided."),
+        Decorator_function_return_type_0_is_not_assignable_to_type_1: diag(1270, ts.DiagnosticCategory.Error, "Decorator_function_return_type_0_is_not_assignable_to_type_1_1270", "Decorator function return type '{0}' is not assignable to type '{1}'."),
+        Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any: diag(1271, ts.DiagnosticCategory.Error, "Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any_1271", "Decorator function return type is '{0}' but is expected to be 'void' or 'any'."),
         with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
         await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
         Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: diag(1312, ts.DiagnosticCategory.Error, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."),
@@ -8343,7 +8339,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."),
@@ -8408,6 +8403,8 @@ var ts;
         Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed: diag(1449, ts.DiagnosticCategory.Message, "Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed_1449", "Preserve unused imported values in the JavaScript output that would otherwise be removed."),
         Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments: diag(1450, ts.DiagnosticCategory.Message, "Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments_1450", "Dynamic imports can only accept a module specifier and an optional assertion as arguments"),
         Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression: diag(1451, ts.DiagnosticCategory.Error, "Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member__1451", "Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression"),
+        Resolution_modes_are_only_supported_when_moduleResolution_is_node12_or_nodenext: diag(1452, ts.DiagnosticCategory.Error, "Resolution_modes_are_only_supported_when_moduleResolution_is_node12_or_nodenext_1452", "Resolution modes are only supported when `moduleResolution` is `node12` or `nodenext`."),
+        resolution_mode_should_be_either_require_or_import: diag(1453, ts.DiagnosticCategory.Error, "resolution_mode_should_be_either_require_or_import_1453", "`resolution-mode` should be either `require` or `import`."),
         The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: diag(1470, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."),
         Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead: diag(1471, ts.DiagnosticCategory.Error, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported synchronously. Use dynamic import instead."),
         catch_or_finally_expected: diag(1472, ts.DiagnosticCategory.Error, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."),
@@ -8727,6 +8724,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."),
@@ -13618,6 +13616,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;
@@ -14291,7 +14290,11 @@ var ts;
         ts.Debug.assert(names.length === newResolutions.length);
         for (var i = 0; i < names.length; i++) {
             var newResolution = newResolutions[i];
-            var oldResolution = oldResolutions && oldResolutions.get(names[i], oldSourceFile && ts.getModeForResolutionAtIndex(oldSourceFile, i));
+            var entry = names[i];
+            // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
+            var name = !ts.isString(entry) ? entry.fileName.toLowerCase() : entry;
+            var mode = !ts.isString(entry) ? ts.getModeForFileReference(entry, oldSourceFile === null || oldSourceFile === void 0 ? void 0 : oldSourceFile.impliedNodeFormat) : oldSourceFile && ts.getModeForResolutionAtIndex(oldSourceFile, i);
+            var oldResolution = oldResolutions && oldResolutions.get(name, mode);
             var changed = oldResolution
                 ? !newResolution || !comparer(oldResolution, newResolution)
                 : newResolution;
@@ -15327,7 +15330,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
@@ -15364,7 +15367,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 */:
@@ -16067,7 +16070,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:
@@ -23054,16 +23057,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
@@ -26886,7 +26891,13 @@ var ts;
                     referencedFiles = ts.append(referencedFiles, { pos: -1, end: -1, fileName: section.data });
                     break;
                 case "type" /* Type */:
-                    typeReferenceDirectives = ts.append(typeReferenceDirectives, section.data);
+                    typeReferenceDirectives = ts.append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data });
+                    break;
+                case "type-import" /* TypeResolutionModeImport */:
+                    typeReferenceDirectives = ts.append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data, resolutionMode: ts.ModuleKind.ESNext });
+                    break;
+                case "type-require" /* TypeResolutionModeRequire */:
+                    typeReferenceDirectives = ts.append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data, resolutionMode: ts.ModuleKind.CommonJS });
                     break;
                 case "lib" /* Lib */:
                     libReferenceDirectives = ts.append(libReferenceDirectives, { pos: -1, end: -1, fileName: section.data });
@@ -26945,6 +26956,8 @@ var ts;
                 case "no-default-lib" /* NoDefaultLib */:
                 case "reference" /* Reference */:
                 case "type" /* Type */:
+                case "type-import" /* TypeResolutionModeImport */:
+                case "type-require" /* TypeResolutionModeRequire */:
                 case "lib" /* Lib */:
                     syntheticReferences = ts.append(syntheticReferences, ts.setTextRange(ts.factory.createUnparsedSyntheticReference(section), section));
                     break;
@@ -30179,7 +30192,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 */:
@@ -30858,7 +30872,7 @@ var ts;
             initializeState("", content, languageVersion, /*syntaxCursor*/ undefined, 1 /* JS */);
             // Prime the scanner.
             nextToken();
-            var entityName = parseEntityName(/*allowReservedWords*/ true);
+            var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ false);
             var isInvalid = token() === 1 /* EndOfFileToken */ && !parseDiagnostics.length;
             clearState();
             return isInvalid ? entityName : undefined;
@@ -32435,7 +32449,7 @@ var ts;
             }
             return createMissingList();
         }
-        function parseEntityName(allowReservedWords, diagnosticMessage) {
+        function parseEntityName(allowReservedWords, allowPrivateIdentifiers, diagnosticMessage) {
             var pos = getNodePos();
             var entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage);
             var dotPos = getNodePos();
@@ -32446,7 +32460,7 @@ var ts;
                     break;
                 }
                 dotPos = getNodePos();
-                entity = finishNode(factory.createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, /* allowPrivateIdentifiers */ false)), pos);
+                entity = finishNode(factory.createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, allowPrivateIdentifiers)), pos);
             }
             return entity;
         }
@@ -32579,7 +32593,7 @@ var ts;
         }
         // TYPES
         function parseEntityNameOfTypeReference() {
-            return parseEntityName(/*allowReservedWords*/ true, ts.Diagnostics.Type_expected);
+            return parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ false, ts.Diagnostics.Type_expected);
         }
         function parseTypeArgumentsOfTypeReference() {
             if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29 /* LessThanToken */) {
@@ -32712,7 +32726,9 @@ var ts;
         function parseTypeQuery() {
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
-            return finishNode(factory.createTypeQueryNode(parseEntityName(/*allowReservedWords*/ true)), pos);
+            var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
+            var typeArguments = tryParseTypeArguments();
+            return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
             var pos = getNodePos();
@@ -34782,20 +34798,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;
             }
         }
@@ -34815,38 +34841,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);
                 }
@@ -34874,21 +34892,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>:
@@ -34906,20 +34928,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()) {
@@ -35100,26 +35112,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();
+            // Absorb type arguments into NewExpression when preceding expression is ExpressionWithTypeArguments
+            if (expression.kind === 227 /* ExpressionWithTypeArguments */) {
+                typeArguments = expression.typeArguments;
+                expression = expression.expression;
             }
-            else if (typeArguments) {
-                parseErrorAt(pos, scanner.getStartPos(), ts.Diagnostics.A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list);
-            }
-            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) {
@@ -35283,11 +35284,12 @@ var ts;
         }
         function parseCaseClause() {
             var pos = getNodePos();
+            var hasJSDoc = hasPrecedingJSDocComment();
             parseExpected(82 /* CaseKeyword */);
             var expression = allowInAnd(parseExpression);
             parseExpected(58 /* ColonToken */);
             var statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
-            return finishNode(factory.createCaseClause(expression, statements), pos);
+            return withJSDoc(finishNode(factory.createCaseClause(expression, statements), pos), hasJSDoc);
         }
         function parseDefaultClause() {
             var pos = getNodePos();
@@ -36207,6 +36209,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);
         }
@@ -36450,7 +36455,7 @@ var ts;
         function parseModuleReference() {
             return isExternalModuleReference()
                 ? parseExternalModuleReference()
-                : parseEntityName(/*allowReservedWords*/ false);
+                : parseEntityName(/*allowReservedWords*/ false, /*allowPrivateIdentifiers*/ false);
         }
         function parseExternalModuleReference() {
             var pos = getNodePos();
@@ -36732,7 +36737,7 @@ var ts;
                 var pos = getNodePos();
                 var hasBrace = parseOptional(18 /* OpenBraceToken */);
                 var p2 = getNodePos();
-                var entityName = parseEntityName(/* allowReservedWords*/ false);
+                var entityName = parseEntityName(/* allowReservedWords*/ false, /*allowPrivateIdentifiers*/ false);
                 while (token() === 80 /* PrivateIdentifier */) {
                     reScanHashToken(); // rescan #id as # id
                     nextTokenJSDoc(); // then skip the #
@@ -37175,7 +37180,7 @@ var ts;
                     // parseEntityName logs an error for non-identifier, so create a MissingNode ourselves to avoid the error
                     var p2 = getNodePos();
                     var name = ts.tokenIsIdentifierOrKeyword(token())
-                        ? parseEntityName(/*allowReservedWords*/ true)
+                        ? parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ false)
                         : undefined;
                     if (name) {
                         while (token() === 80 /* PrivateIdentifier */) {
@@ -37200,11 +37205,13 @@ var ts;
                         && nextTokenJSDoc() === 59 /* AtToken */
                         && ts.tokenIsIdentifierOrKeyword(nextTokenJSDoc())) {
                         var kind = scanner.getTokenValue();
-                        if (kind === "link" || kind === "linkcode" || kind === "linkplain") {
+                        if (isJSDocLinkTag(kind))
                             return kind;
-                        }
                     }
                 }
+                function isJSDocLinkTag(kind) {
+                    return kind === "link" || kind === "linkcode" || kind === "linkplain";
+                }
                 function parseUnknownTag(start, tagName, indent, indentText) {
                     return finishNode(factory.createJSDocUnknownTag(tagName, parseTrailingTagComments(start, getNodePos(), indent, indentText)), start);
                 }
@@ -37310,7 +37317,7 @@ var ts;
                 }
                 function parseSeeTag(start, tagName, indent, indentText) {
                     var isMarkdownOrJSDocLink = token() === 22 /* OpenBracketToken */
-                        || lookAhead(function () { return nextTokenJSDoc() === 59 /* AtToken */ && ts.tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && scanner.getTokenValue() === "link"; });
+                        || lookAhead(function () { return nextTokenJSDoc() === 59 /* AtToken */ && ts.tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && isJSDocLinkTag(scanner.getTokenValue()); });
                     var nameExpression = isMarkdownOrJSDocLink ? undefined : parseJSDocNameReference();
                     var comments = indent !== undefined && indentText !== undefined ? parseTrailingTagComments(start, getNodePos(), indent, indentText) : undefined;
                     return finishNode(factory.createJSDocSeeTag(tagName, nameExpression, comments), start);
@@ -38177,6 +38184,19 @@ var ts;
         return ts.fileExtensionIsOneOf(fileName, [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */]);
     }
     ts.isDeclarationFileName = isDeclarationFileName;
+    function parseResolutionMode(mode, pos, end, reportDiagnostic) {
+        if (!mode) {
+            return undefined;
+        }
+        if (mode === "import") {
+            return ts.ModuleKind.ESNext;
+        }
+        if (mode === "require") {
+            return ts.ModuleKind.CommonJS;
+        }
+        reportDiagnostic(pos, end - pos, ts.Diagnostics.resolution_mode_should_be_either_require_or_import);
+        return undefined;
+    }
     /*@internal*/
     function processCommentPragmas(context, sourceText) {
         var pragmas = [];
@@ -38219,12 +38239,13 @@ var ts;
                     var typeReferenceDirectives_1 = context.typeReferenceDirectives;
                     var libReferenceDirectives_1 = context.libReferenceDirectives;
                     ts.forEach(ts.toArray(entryOrList), function (arg) {
-                        var _a = arg.arguments, types = _a.types, lib = _a.lib, path = _a.path;
+                        var _a = arg.arguments, types = _a.types, lib = _a.lib, path = _a.path, res = _a["resolution-mode"];
                         if (arg.arguments["no-default-lib"]) {
                             context.hasNoDefaultLib = true;
                         }
                         else if (types) {
-                            typeReferenceDirectives_1.push({ pos: types.pos, end: types.end, fileName: types.value });
+                            var parsed = parseResolutionMode(res, types.pos, types.end, reportDiagnostic);
+                            typeReferenceDirectives_1.push(__assign({ pos: types.pos, end: types.end, fileName: types.value }, (parsed ? { resolutionMode: parsed } : {})));
                         }
                         else if (lib) {
                             libReferenceDirectives_1.push({ pos: lib.pos, end: lib.end, fileName: lib.value });
@@ -41802,14 +41823,14 @@ var ts;
      * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
      * is assumed to be the same as root directory of the project.
      */
-    function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache) {
+    function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) {
         var traceEnabled = isTraceEnabled(options, host);
         if (redirectedReference) {
             options = redirectedReference.commandLine.options;
         }
         var containingDirectory = containingFile ? ts.getDirectoryPath(containingFile) : undefined;
         var perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : undefined;
-        var result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, /*mode*/ undefined);
+        var result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, /*mode*/ resolutionMode);
         if (result) {
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);
@@ -41844,7 +41865,18 @@ var ts;
         }
         var failedLookupLocations = [];
         var features = getDefaultNodeResolutionFeatures(options);
-        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: ["node", "require", "types"] };
+        // Unlike `import` statements, whose mode-calculating APIs are all guaranteed to return `undefined` if we're in an un-mode-ed module resolution
+        // setting, type references will return their target mode regardless of options because of how the parser works, so we guard against the mode being
+        // set in a non-modal module resolution setting here. Do note that our behavior is not particularly well defined when these mode-overriding imports
+        // are present in a non-modal project; while in theory we'd like to either ignore the mode or provide faithful modern resolution, depending on what we feel is best,
+        // in practice, not every cache has the options available to intelligently make the choice to ignore the mode request, and it's unclear how modern "faithful modern
+        // resolution" should be (`node12`? `nodenext`?). As such, witnessing a mode-overriding triple-slash reference in a non-modal module resolution
+        // context should _probably_ be an error - and that should likely be handled by the `Program` (which is what we do).
+        if (resolutionMode === ts.ModuleKind.ESNext && (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext)) {
+            features |= NodeResolutionFeatures.EsmMode;
+        }
+        var conditions = features & NodeResolutionFeatures.Exports ? features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"] : [];
+        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: conditions };
         var resolved = primaryLookup();
         var primary = true;
         if (!resolved) {
@@ -41864,7 +41896,7 @@ var ts;
             };
         }
         result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations };
-        perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, /*mode*/ undefined, result);
+        perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result);
         if (traceEnabled)
             traceResult(result);
         return result;
@@ -41915,7 +41947,7 @@ var ts;
                     result_4 = searchResult && searchResult.value;
                 }
                 else {
-                    var candidate = ts.normalizePathAndParts(ts.combinePaths(initialLocationForSecondaryLookup, typeReferenceDirectiveName)).path;
+                    var candidate = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName).path;
                     result_4 = nodeLoadModuleByRelativeName(Extensions.DtsOnly, candidate, /*onlyRecordFailures*/ false, moduleResolutionState, /*considerPackageJson*/ true);
                 }
                 return resolvedTypeScriptOnly(result_4);
@@ -42150,7 +42182,11 @@ var ts;
         ts.Debug.assert(keys.length === values.length);
         var map = createModeAwareCache();
         for (var i = 0; i < keys.length; ++i) {
-            map.set(keys[i], ts.getModeForResolutionAtIndex(file, i), values[i]);
+            var entry = keys[i];
+            // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
+            var name = !ts.isString(entry) ? entry.fileName.toLowerCase() : entry;
+            var mode = !ts.isString(entry) ? entry.resolutionMode || file.impliedNodeFormat : ts.getModeForResolutionAtIndex(file, i);
+            map.set(name, mode, values[i]);
         }
         return map;
     }
@@ -42618,13 +42654,25 @@ var ts;
                 return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } };
             }
             else {
-                var _a = ts.normalizePathAndParts(ts.combinePaths(containingDirectory, moduleName)), candidate = _a.path, parts = _a.parts;
+                var _a = normalizePathForCJSResolution(containingDirectory, moduleName), candidate = _a.path, parts = _a.parts;
                 var resolved_2 = nodeLoadModuleByRelativeName(extensions, candidate, /*onlyRecordFailures*/ false, state, /*considerPackageJson*/ true);
                 // Treat explicit "node_modules" import as an external library import.
                 return resolved_2 && toSearchResult({ resolved: resolved_2, isExternalLibraryImport: ts.contains(parts, "node_modules") });
             }
         }
     }
+    // If you import from "." inside a containing directory "/foo", the result of `normalizePath`
+    // would be "/foo", but this loses the information that `foo` is a directory and we intended
+    // to look inside of it. The Node CommonJS resolution algorithm doesn't call this out
+    // (https://nodejs.org/api/modules.html#all-together), but it seems that module paths ending
+    // in `.` are actually normalized to `./` before proceeding with the resolution algorithm.
+    function normalizePathForCJSResolution(containingDirectory, moduleName) {
+        var combined = ts.combinePaths(containingDirectory, moduleName);
+        var parts = ts.getPathComponents(combined);
+        var lastPart = ts.lastOrUndefined(parts);
+        var path = lastPart === "." || lastPart === ".." ? ts.ensureTrailingDirectorySeparator(ts.normalizePath(combined)) : ts.normalizePath(combined);
+        return { path: path, parts: parts };
+    }
     function realPath(path, host, traceEnabled) {
         if (!host.realpath) {
             return path;
@@ -42666,7 +42714,13 @@ var ts;
                 onlyRecordFailures = true;
             }
         }
-        return loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson);
+        // esm mode relative imports shouldn't do any directory lookups (either inside `package.json`
+        // files or implicit `index.js`es). This is a notable depature from cjs norms, where `./foo/pkg`
+        // could have been redirected by `./foo/pkg/package.json` to an arbitrary location!
+        if (!(state.features & NodeResolutionFeatures.EsmMode)) {
+            return loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson);
+        }
+        return undefined;
     }
     /*@internal*/
     ts.nodeModulesPathPart = "/node_modules/";
@@ -43033,7 +43087,16 @@ var ts;
             // Even if extensions is DtsOnly, we can still look up a .ts file as a result of package.json "types"
             var nextExtensions = extensions === Extensions.DtsOnly ? Extensions.TypeScript : extensions;
             // Don't do package.json lookup recursively, because Node.js' package lookup doesn't.
-            return nodeLoadModuleByRelativeName(nextExtensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ false);
+            // Disable `EsmMode` for the resolution of the package path for cjs-mode packages (so the `main` field can omit extensions)
+            // (technically it only emits a deprecation warning in esm packages right now, but that's probably
+            // enough to mean we don't need to support it)
+            var features = state.features;
+            if ((jsonContent === null || jsonContent === void 0 ? void 0 : jsonContent.type) !== "module") {
+                state.features &= ~NodeResolutionFeatures.EsmMode;
+            }
+            var result = nodeLoadModuleByRelativeName(nextExtensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ false);
+            state.features = features;
+            return result;
         };
         var onlyRecordFailuresForPackageFile = packageFile ? !ts.directoryProbablyExists(ts.getDirectoryPath(packageFile), state.host) : undefined;
         var onlyRecordFailuresForIndex = onlyRecordFailures || !ts.directoryProbablyExists(candidate, state.host);
@@ -43378,6 +43441,14 @@ var ts;
             }
             var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) ||
                 loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.packageJsonContent, packageInfo && packageInfo.versionPaths);
+            if (!pathAndExtension && packageInfo
+                && packageInfo.packageJsonContent.exports === undefined
+                && packageInfo.packageJsonContent.main === undefined
+                && state.features & NodeResolutionFeatures.EsmMode) {
+                // EsmMode disables index lookup in `loadNodeModuleFromDirectoryWorker` generally, however non-relative package resolutions still assume
+                // a default `index.js` entrypoint if no `main` or `exports` are present
+                pathAndExtension = loadModuleFromFile(extensions, ts.combinePaths(candidate, "index.js"), onlyRecordFailures, state);
+            }
             return withPackageId(packageInfo, pathAndExtension);
         };
         if (rest !== "") { // If "rest" is empty, we just did this search above.
@@ -47135,8 +47206,7 @@ var ts;
         IntersectionState[IntersectionState["Source"] = 1] = "Source";
         IntersectionState[IntersectionState["Target"] = 2] = "Target";
         IntersectionState[IntersectionState["PropertyCheck"] = 4] = "PropertyCheck";
-        IntersectionState[IntersectionState["UnionIntersectionCheck"] = 8] = "UnionIntersectionCheck";
-        IntersectionState[IntersectionState["InPropertyCheck"] = 16] = "InPropertyCheck";
+        IntersectionState[IntersectionState["InPropertyCheck"] = 8] = "InPropertyCheck";
     })(IntersectionState || (IntersectionState = {}));
     var RecursionFlags;
     (function (RecursionFlags) {
@@ -50595,8 +50665,15 @@ var ts;
                 return res;
             }
             var candidates = ts.mapDefined(symbol.declarations, function (d) {
-                if (!ts.isAmbientModule(d) && d.parent && hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) {
-                    return getSymbolOfNode(d.parent);
+                if (!ts.isAmbientModule(d) && d.parent) {
+                    // direct children of a module
+                    if (hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) {
+                        return getSymbolOfNode(d.parent);
+                    }
+                    // export ='d member of an ambient module
+                    if (ts.isModuleBlock(d.parent) && d.parent.parent && resolveExternalModuleSymbol(getSymbolOfNode(d.parent.parent)) === symbol) {
+                        return getSymbolOfNode(d.parent.parent);
+                    }
                 }
                 if (ts.isClassExpression(d) && ts.isBinaryExpression(d.parent) && d.parent.operatorToken.kind === 63 /* EqualsToken */ && ts.isAccessExpression(d.parent.left) && ts.isEntityNameExpression(d.parent.left.expression)) {
                     if (ts.isModuleExportsAccessExpression(d.parent.left) || ts.isExportsIdentifier(d.parent.left.expression)) {
@@ -51143,7 +51220,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 */;
@@ -51254,7 +51331,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 {
@@ -55183,7 +55260,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;
             }
@@ -57229,87 +57306,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) {
@@ -58310,8 +58387,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;
                 }
@@ -58850,13 +58927,15 @@ var ts;
             return signature;
         }
         function getOrCreateTypeFromSignature(signature) {
+            var _a;
             // There are two ways to declare a construct signature, one is by declaring a class constructor
             // using the constructor keyword, and the other is declaring a bare construct signature in an
             // object type literal or interface (using the new keyword). Each way of declaring a constructor
             // will result in a different declaration kind.
             if (!signature.isolatedSignatureType) {
-                var kind = signature.declaration ? signature.declaration.kind : 0 /* Unknown */;
-                var isConstructor = kind === 170 /* Constructor */ || kind === 174 /* ConstructSignature */ || kind === 179 /* ConstructorType */;
+                var kind = (_a = signature.declaration) === null || _a === void 0 ? void 0 : _a.kind;
+                // If declaration is undefined, it is likely to be the signature of the default constructor.
+                var isConstructor = kind === undefined || kind === 170 /* Constructor */ || kind === 174 /* ConstructSignature */ || kind === 179 /* ConstructorType */;
                 var type = createObjectType(16 /* Anonymous */);
                 type.members = emptySymbols;
                 type.properties = ts.emptyArray;
@@ -58882,14 +58961,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));
                                 }
                             });
                         }
@@ -58899,7 +58978,7 @@ var ts;
                     var declaration = _a[_i];
                     _loop_14(declaration);
                 }
-                return indexInfos_2;
+                return indexInfos_4;
             }
             return ts.emptyArray;
         }
@@ -59447,7 +59526,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;
@@ -59784,7 +59863,7 @@ var ts;
                 }
             }
             var fixedLength = properties.length;
-            var lengthSymbol = createSymbol(4 /* Property */, "length");
+            var lengthSymbol = createSymbol(4 /* Property */, "length", readonly ? 8 /* Readonly */ : 0);
             if (combinedFlags & 12 /* Variable */) {
                 lengthSymbol.type = numberType;
             }
@@ -62151,7 +62230,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;
@@ -62167,8 +62248,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;
@@ -62340,6 +62421,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;
@@ -63331,9 +63415,11 @@ var ts;
                     isEnumTypeRelatedTo(getParentOfSymbol(source.symbol), getParentOfSymbol(target.symbol), errorReporter))
                     return true;
             }
-            if (s & 32768 /* Undefined */ && (!strictNullChecks || t & (32768 /* Undefined */ | 16384 /* Void */)))
+            // In non-strictNullChecks mode, `undefined` and `null` are assignable to anything except `never`.
+            // Since unions and intersections may reduce to `never`, we exclude them here.
+            if (s & 32768 /* Undefined */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & (32768 /* Undefined */ | 16384 /* Void */)))
                 return true;
-            if (s & 65536 /* Null */ && (!strictNullChecks || t & 65536 /* Null */))
+            if (s & 65536 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 65536 /* Null */))
                 return true;
             if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */)
                 return true;
@@ -63422,11 +63508,11 @@ var ts;
             var overflow = false;
             var overrideNextErrorInfo = 0; // How many `reportRelationError` calls should be skipped in the elaboration pyramid
             var lastSkippedInfo;
-            var incompatibleStack = [];
+            var incompatibleStack;
             var inPropertyCheck = false;
             ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
             var result = isRelatedTo(source, target, 3 /* Both */, /*reportErrors*/ !!errorNode, headMessage);
-            if (incompatibleStack.length) {
+            if (incompatibleStack) {
                 reportIncompatibleStack();
             }
             if (overflow) {
@@ -63483,19 +63569,19 @@ var ts;
                 return {
                     errorInfo: errorInfo,
                     lastSkippedInfo: lastSkippedInfo,
-                    incompatibleStack: incompatibleStack.slice(),
+                    incompatibleStack: incompatibleStack === null || incompatibleStack === void 0 ? void 0 : incompatibleStack.slice(),
                     overrideNextErrorInfo: overrideNextErrorInfo,
-                    relatedInfo: !relatedInfo ? undefined : relatedInfo.slice()
+                    relatedInfo: relatedInfo === null || relatedInfo === void 0 ? void 0 : relatedInfo.slice(),
                 };
             }
             function reportIncompatibleError(message, arg0, arg1, arg2, arg3) {
                 overrideNextErrorInfo++; // Suppress the next relation error
                 lastSkippedInfo = undefined; // Reset skipped info cache
-                incompatibleStack.push([message, arg0, arg1, arg2, arg3]);
+                (incompatibleStack || (incompatibleStack = [])).push([message, arg0, arg1, arg2, arg3]);
             }
             function reportIncompatibleStack() {
-                var stack = incompatibleStack;
-                incompatibleStack = [];
+                var stack = incompatibleStack || [];
+                incompatibleStack = undefined;
                 var info = lastSkippedInfo;
                 lastSkippedInfo = undefined;
                 if (stack.length === 1) {
@@ -63601,7 +63687,7 @@ var ts;
             }
             function reportError(message, arg0, arg1, arg2, arg3) {
                 ts.Debug.assert(!!errorNode);
-                if (incompatibleStack.length)
+                if (incompatibleStack)
                     reportIncompatibleStack();
                 if (message.elidedInCompatabilityPyramid)
                     return;
@@ -63617,7 +63703,7 @@ var ts;
                 }
             }
             function reportRelationError(message, source, target) {
-                if (incompatibleStack.length)
+                if (incompatibleStack)
                     reportIncompatibleStack();
                 var _a = getTypeNamesForErrorDisplay(source, target), sourceType = _a[0], targetType = _a[1];
                 var generalizedSource = source;
@@ -63729,7 +63815,9 @@ var ts;
                     if (isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors ? reportError : undefined)) {
                         return -1 /* True */;
                     }
-                    reportErrorResults(originalSource, originalTarget, 0 /* False */, !!(ts.getObjectFlags(originalSource) & 2048 /* JsxAttributes */));
+                    if (reportErrors) {
+                        reportErrorResults(originalSource, originalTarget, originalSource, originalTarget, headMessage);
+                    }
                     return 0 /* False */;
                 }
                 // Normalize the source and target types: Turn fresh literal types into regular literal types,
@@ -63741,7 +63829,12 @@ var ts;
                 if (source === target)
                     return -1 /* True */;
                 if (relation === identityRelation) {
-                    return isIdenticalTo(source, target, recursionFlags);
+                    if (source.flags !== target.flags)
+                        return 0 /* False */;
+                    if (source.flags & 67358815 /* Singleton */)
+                        return -1 /* True */;
+                    traceUnionsOrIntersectionsTooLarge(source, target);
+                    return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false, 0 /* None */, recursionFlags);
                 }
                 // We fastpath comparing a type parameter to exactly its constraint, as this is _super_ common,
                 // and otherwise, for type parameters in large unions, causes us to need to compare the union to itself,
@@ -63751,163 +63844,130 @@ var ts;
                 if (source.flags & 262144 /* TypeParameter */ && getConstraintOfType(source) === target) {
                     return -1 /* True */;
                 }
-                // Try to see if we're relating something like `Foo` -> `Bar | null | undefined`.
-                // If so, reporting the `null` and `undefined` in the type is hardly useful.
-                // First, see if we're even relating an object type to a union.
-                // Then see if the target is stripped down to a single non-union type.
-                // Note
-                //  * We actually want to remove null and undefined naively here (rather than using getNonNullableType),
-                //    since we don't want to end up with a worse error like "`Foo` is not assignable to `NonNullable<T>`"
-                //    when dealing with generics.
-                //  * We also don't deal with primitive source types, since we already halt elaboration below.
-                if (target.flags & 1048576 /* Union */ && source.flags & 524288 /* Object */ &&
-                    target.types.length <= 3 && maybeTypeOfKind(target, 98304 /* Nullable */)) {
-                    var nullStrippedTarget = extractTypesOfKind(target, ~98304 /* Nullable */);
-                    if (!(nullStrippedTarget.flags & (1048576 /* Union */ | 131072 /* Never */))) {
-                        target = getNormalizedType(nullStrippedTarget, /*writing*/ true);
-                    }
-                    if (source === nullStrippedTarget)
-                        return -1 /* True */;
+                // See if we're relating a definitely non-nullable type to a union that includes null and/or undefined
+                // plus a single non-nullable type. If so, remove null and/or undefined from the target type.
+                if (source.flags & 470302716 /* DefinitelyNonNullable */ && target.flags & 1048576 /* Union */) {
+                    var types = target.types;
+                    var candidate = types.length === 2 && types[0].flags & 98304 /* Nullable */ ? types[1] :
+                        types.length === 3 && types[0].flags & 98304 /* Nullable */ && types[1].flags & 98304 /* Nullable */ ? types[2] :
+                            undefined;
+                    if (candidate && !(candidate.flags & 98304 /* Nullable */)) {
+                        target = getNormalizedType(candidate, /*writing*/ true);
+                        if (source === target)
+                            return -1 /* True */;
+                    }
                 }
                 if (relation === comparableRelation && !(target.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(target, source, relation) ||
                     isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined))
                     return -1 /* True */;
-                var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 2048 /* JsxAttributes */);
-                var isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType(source) && ts.getObjectFlags(source) & 16384 /* FreshLiteral */);
-                if (isPerformingExcessPropertyChecks) {
-                    if (hasExcessProperties(source, target, reportErrors)) {
+                if (source.flags & 469499904 /* StructuredOrInstantiable */ || target.flags & 469499904 /* StructuredOrInstantiable */) {
+                    var isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType(source) && ts.getObjectFlags(source) & 16384 /* FreshLiteral */);
+                    if (isPerformingExcessPropertyChecks) {
+                        if (hasExcessProperties(source, target, reportErrors)) {
+                            if (reportErrors) {
+                                reportRelationError(headMessage, source, originalTarget.aliasSymbol ? originalTarget : target);
+                            }
+                            return 0 /* False */;
+                        }
+                    }
+                    var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2 /* Target */) &&
+                        source.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source !== globalObjectType &&
+                        target.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target) &&
+                        (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source));
+                    var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 2048 /* JsxAttributes */);
+                    if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) {
                         if (reportErrors) {
-                            reportRelationError(headMessage, source, originalTarget.aliasSymbol ? originalTarget : target);
+                            var sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source);
+                            var targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target);
+                            var calls = getSignaturesOfType(source, 0 /* Call */);
+                            var constructs = getSignaturesOfType(source, 1 /* Construct */);
+                            if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, 1 /* Source */, /*reportErrors*/ false) ||
+                                constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, 1 /* Source */, /*reportErrors*/ false)) {
+                                reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString);
+                            }
+                            else {
+                                reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, sourceString, targetString);
+                            }
                         }
                         return 0 /* False */;
                     }
-                }
-                var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2 /* Target */) &&
-                    source.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source !== globalObjectType &&
-                    target.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target) &&
-                    (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source));
-                if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) {
-                    if (reportErrors) {
-                        var sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source);
-                        var targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target);
-                        var calls = getSignaturesOfType(source, 0 /* Call */);
-                        var constructs = getSignaturesOfType(source, 1 /* Construct */);
-                        if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, 1 /* Source */, /*reportErrors*/ false) ||
-                            constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, 1 /* Source */, /*reportErrors*/ false)) {
-                            reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString);
-                        }
-                        else {
-                            reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, sourceString, targetString);
-                        }
+                    traceUnionsOrIntersectionsTooLarge(source, target);
+                    var skipCaching = source.flags & 1048576 /* Union */ && source.types.length < 4 && !(target.flags & 1048576 /* Union */) ||
+                        target.flags & 1048576 /* Union */ && target.types.length < 4 && !(source.flags & 469499904 /* StructuredOrInstantiable */);
+                    var result_7 = skipCaching ?
+                        unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) :
+                        recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags);
+                    // For certain combinations involving intersections and optional, excess, or mismatched properties we need
+                    // an extra property check where the intersection is viewed as a single object. The following are motivating
+                    // examples that all should be errors, but aren't without this extra property check:
+                    //
+                    //   let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 };  // Nested excess property
+                    //
+                    //   declare let wrong: { a: { y: string } };
+                    //   let weak: { a?: { x?: number } } & { c?: string } = wrong;  // Nested weak object type
+                    //
+                    //   function foo<T extends object>(x: { a?: string }, y: T & { a: boolean }) {
+                    //     x = y;  // Mismatched property in source intersection
+                    //   }
+                    //
+                    // We suppress recursive intersection property checks because they can generate lots of work when relating
+                    // recursive intersections that are structurally similar but not exactly identical. See #37854.
+                    if (result_7 && !inPropertyCheck && (target.flags & 2097152 /* Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
+                        isNonGenericObjectType(target) && !isArrayType(target) && !isTupleType(target) && source.flags & 2097152 /* Intersection */ && getApparentType(source).flags & 3670016 /* StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 524288 /* NonInferrableType */); }))) {
+                        inPropertyCheck = true;
+                        result_7 &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* PropertyCheck */, recursionFlags);
+                        inPropertyCheck = false;
+                    }
+                    if (result_7) {
+                        return result_7;
                     }
-                    return 0 /* False */;
-                }
-                traceUnionsOrIntersectionsTooLarge(source, target);
-                var result = 0 /* False */;
-                var saveErrorInfo = captureErrorCalculationState();
-                if ((source.flags & 1048576 /* Union */ || target.flags & 1048576 /* Union */) && getConstituentCount(source) * getConstituentCount(target) < 4) {
-                    // We skip caching when source or target is a union with no more than three constituents.
-                    result = structuredTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */);
                 }
-                else if (source.flags & 3145728 /* UnionOrIntersection */ || target.flags & 3145728 /* UnionOrIntersection */) {
-                    result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */, recursionFlags);
+                if (reportErrors) {
+                    reportErrorResults(originalSource, originalTarget, source, target, headMessage);
                 }
-                if (!result && !(source.flags & 1048576 /* Union */) && (source.flags & (469499904 /* StructuredOrInstantiable */) || target.flags & 469499904 /* StructuredOrInstantiable */)) {
-                    if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags)) {
-                        resetErrorInfo(saveErrorInfo);
+                return 0 /* False */;
+            }
+            function reportErrorResults(originalSource, originalTarget, source, target, headMessage) {
+                var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
+                var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
+                source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
+                target = (originalTarget.aliasSymbol || targetHasBase) ? originalTarget : target;
+                var maybeSuppress = overrideNextErrorInfo > 0;
+                if (maybeSuppress) {
+                    overrideNextErrorInfo--;
+                }
+                if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
+                    var currentError = errorInfo;
+                    tryElaborateArrayLikeErrors(source, target, /*reportErrors*/ true);
+                    if (errorInfo !== currentError) {
+                        maybeSuppress = !!errorInfo;
+                    }
+                }
+                if (source.flags & 524288 /* Object */ && target.flags & 131068 /* Primitive */) {
+                    tryElaborateErrorsForPrimitivesAndObjects(source, target);
+                }
+                else if (source.symbol && source.flags & 524288 /* Object */ && globalObjectType === source) {
+                    reportError(ts.Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
+                }
+                else if (ts.getObjectFlags(source) & 2048 /* JsxAttributes */ && target.flags & 2097152 /* Intersection */) {
+                    var targetTypes = target.types;
+                    var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
+                    var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
+                    if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) &&
+                        (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) {
+                        // do not report top error
+                        return;
                     }
                 }
-                if (!result && source.flags & (2097152 /* Intersection */ | 262144 /* TypeParameter */)) {
-                    // The combined constraint of an intersection type is the intersection of the constraints of
-                    // the constituents. When an intersection type contains instantiable types with union type
-                    // constraints, there are situations where we need to examine the combined constraint. One is
-                    // when the target is a union type. Another is when the intersection contains types belonging
-                    // to one of the disjoint domains. For example, given type variables T and U, each with the
-                    // constraint 'string | number', the combined constraint of 'T & U' is 'string | number' and
-                    // we need to check this constraint against a union on the target side. Also, given a type
-                    // variable V constrained to 'string | number', 'V & number' has a combined constraint of
-                    // 'string & number | number & number' which reduces to just 'number'.
-                    // This also handles type parameters, as a type parameter with a union constraint compared against a union
-                    // needs to have its constraint hoisted into an intersection with said type parameter, this way
-                    // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
-                    // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
-                    var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* Union */));
-                    if (constraint && (source.flags & 2097152 /* Intersection */ || target.flags & 1048576 /* Union */)) {
-                        if (everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
-                            // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
-                            if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                                resetErrorInfo(saveErrorInfo);
-                            }
-                        }
-                    }
+                else {
+                    errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
                 }
-                // For certain combinations involving intersections and optional, excess, or mismatched properties we need
-                // an extra property check where the intersection is viewed as a single object. The following are motivating
-                // examples that all should be errors, but aren't without this extra property check:
-                //
-                //   let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 };  // Nested excess property
-                //
-                //   declare let wrong: { a: { y: string } };
-                //   let weak: { a?: { x?: number } } & { c?: string } = wrong;  // Nested weak object type
-                //
-                //   function foo<T extends object>(x: { a?: string }, y: T & { a: boolean }) {
-                //     x = y;  // Mismatched property in source intersection
-                //   }
-                //
-                // We suppress recursive intersection property checks because they can generate lots of work when relating
-                // recursive intersections that are structurally similar but not exactly identical. See #37854.
-                if (result && !inPropertyCheck && (target.flags & 2097152 /* Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
-                    isNonGenericObjectType(target) && !isArrayType(target) && !isTupleType(target) && source.flags & 2097152 /* Intersection */ && getApparentType(source).flags & 3670016 /* StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 524288 /* NonInferrableType */); }))) {
-                    inPropertyCheck = true;
-                    result &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* PropertyCheck */, recursionFlags);
-                    inPropertyCheck = false;
-                }
-                reportErrorResults(source, target, result, isComparingJsxAttributes);
-                return result;
-                function reportErrorResults(source, target, result, isComparingJsxAttributes) {
-                    if (!result && reportErrors) {
-                        var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
-                        var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
-                        source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
-                        target = (originalTarget.aliasSymbol || targetHasBase) ? originalTarget : target;
-                        var maybeSuppress = overrideNextErrorInfo > 0;
-                        if (maybeSuppress) {
-                            overrideNextErrorInfo--;
-                        }
-                        if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
-                            var currentError = errorInfo;
-                            tryElaborateArrayLikeErrors(source, target, reportErrors);
-                            if (errorInfo !== currentError) {
-                                maybeSuppress = !!errorInfo;
-                            }
-                        }
-                        if (source.flags & 524288 /* Object */ && target.flags & 131068 /* Primitive */) {
-                            tryElaborateErrorsForPrimitivesAndObjects(source, target);
-                        }
-                        else if (source.symbol && source.flags & 524288 /* Object */ && globalObjectType === source) {
-                            reportError(ts.Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
-                        }
-                        else if (isComparingJsxAttributes && target.flags & 2097152 /* Intersection */) {
-                            var targetTypes = target.types;
-                            var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
-                            var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
-                            if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) &&
-                                (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) {
-                                // do not report top error
-                                return result;
-                            }
-                        }
-                        else {
-                            errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
-                        }
-                        if (!headMessage && maybeSuppress) {
-                            lastSkippedInfo = [source, target];
-                            // Used by, eg, missing property checking to replace the top-level message with a more informative one
-                            return result;
-                        }
-                        reportRelationError(headMessage, source, target);
-                    }
+                if (!headMessage && maybeSuppress) {
+                    lastSkippedInfo = [source, target];
+                    // Used by, eg, missing property checking to replace the top-level message with a more informative one
+                    return;
                 }
+                reportRelationError(headMessage, source, target);
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
                 if (!ts.tracing) {
@@ -63934,21 +63994,6 @@ var ts;
                     }
                 }
             }
-            function isIdenticalTo(source, target, recursionFlags) {
-                if (source.flags !== target.flags)
-                    return 0 /* False */;
-                if (source.flags & 67358815 /* Singleton */)
-                    return -1 /* True */;
-                traceUnionsOrIntersectionsTooLarge(source, target);
-                if (source.flags & 3145728 /* UnionOrIntersection */) {
-                    var result_7 = eachTypeRelatedToSomeType(source, target);
-                    if (result_7) {
-                        result_7 &= eachTypeRelatedToSomeType(target, source);
-                    }
-                    return result_7;
-                }
-                return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false, 0 /* None */, recursionFlags);
-            }
             function getTypeOfPropertyInTypes(types, name) {
                 var appendPropType = function (propTypes, type) {
                     var _a;
@@ -64047,6 +64092,41 @@ var ts;
             function shouldCheckAsExcessProperty(prop, container) {
                 return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration;
             }
+            function unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) {
+                // Note that these checks are specifically ordered to produce correct results. In particular,
+                // we need to deconstruct unions before intersections (because unions are always at the top),
+                // and we need to handle "each" relations before "some" relations for the same kind of type.
+                if (source.flags & 1048576 /* Union */) {
+                    return relation === comparableRelation ?
+                        someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState) :
+                        eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState);
+                }
+                if (target.flags & 1048576 /* Union */) {
+                    return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* Primitive */) && !(target.flags & 131068 /* Primitive */));
+                }
+                if (target.flags & 2097152 /* Intersection */) {
+                    return typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2 /* Target */);
+                }
+                // Source is an intersection. For the comparable relation, if the target is a primitive type we hoist the
+                // constraints of all non-primitive types in the source into a new intersection. We do this because the
+                // intersection may further constrain the constraints of the non-primitive types. For example, given a type
+                // parameter 'T extends 1 | 2', the intersection 'T & 1' should be reduced to '1' such that it doesn't
+                // appear to be comparable to '2'.
+                if (relation === comparableRelation && target.flags & 131068 /* Primitive */) {
+                    var constraints = ts.sameMap(source.types, getBaseConstraintOrType);
+                    if (constraints !== source.types) {
+                        source = getIntersectionType(constraints);
+                        if (!(source.flags & 2097152 /* Intersection */)) {
+                            return isRelatedTo(source, target, 1 /* Source */, /*reportErrors*/ false);
+                        }
+                    }
+                }
+                // Check to see if any constituents of the intersection are immediately related to the target.
+                // Don't report errors though. Elaborating on whether a source constituent is related to the target is
+                // not actually useful and leads to some confusing error messages. Instead, we rely on the caller
+                // checking whether the full intersection viewed as an object is related to the target.
+                return someTypeRelatedToType(source, target, /*reportErrors*/ false, 1 /* Source */);
+            }
             function eachTypeRelatedToSomeType(source, target) {
                 var result = -1 /* True */;
                 var sourceTypes = source.types;
@@ -64082,8 +64162,11 @@ var ts;
                     }
                 }
                 if (reportErrors) {
+                    // Elaborate only if we can find a best matching type in the target union
                     var bestMatchingType = getBestMatchingType(source, target, isRelatedTo);
-                    isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], 2 /* Target */, /*reportErrors*/ true);
+                    if (bestMatchingType) {
+                        isRelatedTo(source, bestMatchingType, 2 /* Target */, /*reportErrors*/ true);
+                    }
                 }
                 return 0 /* False */;
             }
@@ -64219,7 +64302,7 @@ var ts;
                 if (overflow) {
                     return 0 /* False */;
                 }
-                var keyIntersectionState = intersectionState | (inPropertyCheck ? 16 /* InPropertyCheck */ : 0);
+                var keyIntersectionState = intersectionState | (inPropertyCheck ? 8 /* InPropertyCheck */ : 0);
                 var id = getRelationKey(source, target, keyIntersectionState, relation, /*ingnoreConstraints*/ false);
                 var entry = relation.get(id);
                 if (entry !== undefined) {
@@ -64287,6 +64370,7 @@ var ts;
                         return originalHandler(onlyUnreliable);
                     };
                 }
+                var result;
                 if (expandingFlags === 3 /* Both */) {
                     ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "recursiveTypeRelatedTo_DepthLimit", {
                         sourceId: source.id,
@@ -64296,8 +64380,13 @@ var ts;
                         depth: sourceDepth,
                         targetDepth: targetDepth
                     });
+                    result = 3 /* Maybe */;
+                }
+                else {
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id });
+                    result = structuredTypeRelatedTo(source, target, reportErrors, intersectionState);
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
                 }
-                var result = expandingFlags !== 3 /* Both */ ? structuredTypeRelatedTo(source, target, reportErrors, intersectionState) : 3 /* Maybe */;
                 if (outofbandVarianceMarkerHandler) {
                     outofbandVarianceMarkerHandler = originalHandler;
                 }
@@ -64329,98 +64418,97 @@ var ts;
                 return result;
             }
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
-                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id });
-                var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState);
-                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
-                return result;
-            }
-            function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState) {
                 if (intersectionState & 4 /* PropertyCheck */) {
                     return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* None */);
                 }
-                if (intersectionState & 8 /* UnionIntersectionCheck */) {
-                    // Note that these checks are specifically ordered to produce correct results. In particular,
-                    // we need to deconstruct unions before intersections (because unions are always at the top),
-                    // and we need to handle "each" relations before "some" relations for the same kind of type.
-                    if (source.flags & 1048576 /* Union */) {
-                        return relation === comparableRelation ?
-                            someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState & ~8 /* UnionIntersectionCheck */) :
-                            eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState & ~8 /* UnionIntersectionCheck */);
-                    }
-                    if (target.flags & 1048576 /* Union */) {
-                        return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* Primitive */) && !(target.flags & 131068 /* Primitive */));
-                    }
-                    if (target.flags & 2097152 /* Intersection */) {
-                        return typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2 /* Target */);
-                    }
-                    // Source is an intersection. For the comparable relation, if the target is a primitive type we hoist the
-                    // constraints of all non-primitive types in the source into a new intersection. We do this because the
-                    // intersection may further constrain the constraints of the non-primitive types. For example, given a type
-                    // parameter 'T extends 1 | 2', the intersection 'T & 1' should be reduced to '1' such that it doesn't
-                    // appear to be comparable to '2'.
-                    if (relation === comparableRelation && target.flags & 131068 /* Primitive */) {
-                        var constraints = ts.sameMap(source.types, getBaseConstraintOrType);
-                        if (constraints !== source.types) {
-                            source = getIntersectionType(constraints);
-                            if (!(source.flags & 2097152 /* Intersection */)) {
-                                return isRelatedTo(source, target, 1 /* Source */, /*reportErrors*/ false);
-                            }
+                var result;
+                var originalErrorInfo;
+                var varianceCheckFailed = false;
+                var saveErrorInfo = captureErrorCalculationState();
+                var sourceFlags = source.flags;
+                var targetFlags = target.flags;
+                if (relation === identityRelation) {
+                    // We've already checked that source.flags and target.flags are identical
+                    if (sourceFlags & 3145728 /* UnionOrIntersection */) {
+                        var result_8 = eachTypeRelatedToSomeType(source, target);
+                        if (result_8) {
+                            result_8 &= eachTypeRelatedToSomeType(target, source);
                         }
+                        return result_8;
                     }
-                    // Check to see if any constituents of the intersection are immediately related to the target.
-                    //
-                    // Don't report errors though. Checking whether a constituent is related to the source is not actually
-                    // useful and leads to some confusing error messages. Instead it is better to let the below checks
-                    // take care of this, or to not elaborate at all. For instance,
-                    //
-                    //    - For an object type (such as 'C = A & B'), users are usually more interested in structural errors.
-                    //
-                    //    - For a union type (such as '(A | B) = (C & D)'), it's better to hold onto the whole intersection
-                    //          than to report that 'D' is not assignable to 'A' or 'B'.
-                    //
-                    //    - For a primitive type or type parameter (such as 'number = A & B') there is no point in
-                    //          breaking the intersection apart.
-                    return someTypeRelatedToType(source, target, /*reportErrors*/ false, 1 /* Source */);
-                }
-                var flags = source.flags & target.flags;
-                if (relation === identityRelation && !(flags & 524288 /* Object */)) {
-                    if (flags & 4194304 /* Index */) {
+                    if (sourceFlags & 4194304 /* Index */) {
                         return isRelatedTo(source.type, target.type, 3 /* Both */, /*reportErrors*/ false);
                     }
-                    var result_8 = 0 /* False */;
-                    if (flags & 8388608 /* IndexedAccess */) {
-                        if (result_8 = isRelatedTo(source.objectType, target.objectType, 3 /* Both */, /*reportErrors*/ false)) {
-                            if (result_8 &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, /*reportErrors*/ false)) {
-                                return result_8;
+                    if (sourceFlags & 8388608 /* IndexedAccess */) {
+                        if (result = isRelatedTo(source.objectType, target.objectType, 3 /* Both */, /*reportErrors*/ false)) {
+                            if (result &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, /*reportErrors*/ false)) {
+                                return result;
                             }
                         }
                     }
-                    if (flags & 16777216 /* Conditional */) {
+                    if (sourceFlags & 16777216 /* Conditional */) {
                         if (source.root.isDistributive === target.root.isDistributive) {
-                            if (result_8 = isRelatedTo(source.checkType, target.checkType, 3 /* Both */, /*reportErrors*/ false)) {
-                                if (result_8 &= isRelatedTo(source.extendsType, target.extendsType, 3 /* Both */, /*reportErrors*/ false)) {
-                                    if (result_8 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
-                                        if (result_8 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
-                                            return result_8;
+                            if (result = isRelatedTo(source.checkType, target.checkType, 3 /* Both */, /*reportErrors*/ false)) {
+                                if (result &= isRelatedTo(source.extendsType, target.extendsType, 3 /* Both */, /*reportErrors*/ false)) {
+                                    if (result &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
+                                        if (result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
+                                            return result;
                                         }
                                     }
                                 }
                             }
                         }
                     }
-                    if (flags & 33554432 /* Substitution */) {
+                    if (sourceFlags & 33554432 /* Substitution */) {
                         return isRelatedTo(source.substitute, target.substitute, 3 /* Both */, /*reportErrors*/ false);
                     }
-                    return 0 /* False */;
+                    if (!(sourceFlags & 524288 /* Object */)) {
+                        return 0 /* False */;
+                    }
+                }
+                else if (sourceFlags & 3145728 /* UnionOrIntersection */ || targetFlags & 3145728 /* UnionOrIntersection */) {
+                    if (result = unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState)) {
+                        return result;
+                    }
+                    if (source.flags & 2097152 /* Intersection */ || source.flags & 262144 /* TypeParameter */ && target.flags & 1048576 /* Union */) {
+                        // The combined constraint of an intersection type is the intersection of the constraints of
+                        // the constituents. When an intersection type contains instantiable types with union type
+                        // constraints, there are situations where we need to examine the combined constraint. One is
+                        // when the target is a union type. Another is when the intersection contains types belonging
+                        // to one of the disjoint domains. For example, given type variables T and U, each with the
+                        // constraint 'string | number', the combined constraint of 'T & U' is 'string | number' and
+                        // we need to check this constraint against a union on the target side. Also, given a type
+                        // variable V constrained to 'string | number', 'V & number' has a combined constraint of
+                        // 'string & number | number & number' which reduces to just 'number'.
+                        // This also handles type parameters, as a type parameter with a union constraint compared against a union
+                        // needs to have its constraint hoisted into an intersection with said type parameter, this way
+                        // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
+                        // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
+                        var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* Union */));
+                        if (constraint && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
+                            // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
+                            if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
+                                resetErrorInfo(saveErrorInfo);
+                                return result;
+                            }
+                        }
+                    }
+                    // The ordered decomposition above doesn't handle all cases. Specifically, we also need to handle:
+                    // Source is instantiable (e.g. source has union or intersection constraint).
+                    // Source is an object, target is a union (e.g. { a, b: boolean } <=> { a, b: true } | { a, b: false }).
+                    // Source is an intersection, target is an object (e.g. { a } & { b } <=> { a, b }).
+                    // Source is an intersection, target is a union (e.g. { a } & { b: boolean } <=> { a, b: true } | { a, b: false }).
+                    // Source is an intersection, target instantiable (e.g. string & { tag } <=> T["a"] constrained to string & { tag }).
+                    if (!(sourceFlags & 465829888 /* Instantiable */ ||
+                        sourceFlags & 524288 /* Object */ && targetFlags & 1048576 /* Union */ ||
+                        sourceFlags & 2097152 /* Intersection */ && targetFlags & (524288 /* Object */ | 1048576 /* Union */ | 465829888 /* Instantiable */))) {
+                        return 0 /* False */;
+                    }
                 }
-                var result;
-                var originalErrorInfo;
-                var varianceCheckFailed = false;
-                var saveErrorInfo = captureErrorCalculationState();
                 // We limit alias variance probing to only object and conditional types since their alias behavior
                 // is more predictable than other, interned types, which may or may not have an alias depending on
                 // the order in which things were checked.
-                if (source.flags & (524288 /* Object */ | 16777216 /* Conditional */) && source.aliasSymbol &&
+                if (sourceFlags & (524288 /* Object */ | 16777216 /* Conditional */) && source.aliasSymbol &&
                     source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol &&
                     !(source.aliasTypeArgumentsContainsMarker || target.aliasTypeArgumentsContainsMarker)) {
                     var variances = getAliasVariances(source.aliasSymbol);
@@ -64438,7 +64526,7 @@ var ts;
                     isSingleElementGenericTupleType(target) && (target.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source) || source)) && (result = isRelatedTo(source, getTypeArguments(target)[0], 2 /* Target */))) {
                     return result;
                 }
-                if (target.flags & 262144 /* TypeParameter */) {
+                if (targetFlags & 262144 /* TypeParameter */) {
                     // A source type { [P in Q]: X } is related to a target type T if keyof T is related to Q and X is related to T[Q].
                     if (ts.getObjectFlags(source) & 32 /* Mapped */ && !source.declaration.nameType && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source), 3 /* Both */)) {
                         if (!(getMappedTypeModifiers(source) & 4 /* IncludeOptional */)) {
@@ -64450,10 +64538,10 @@ var ts;
                         }
                     }
                 }
-                else if (target.flags & 4194304 /* Index */) {
+                else if (targetFlags & 4194304 /* Index */) {
                     var targetType_1 = target.type;
                     // A keyof S is related to a keyof T if T is related to S.
-                    if (source.flags & 4194304 /* Index */) {
+                    if (sourceFlags & 4194304 /* Index */) {
                         if (result = isRelatedTo(targetType_1, source.type, 3 /* Both */, /*reportErrors*/ false)) {
                             return result;
                         }
@@ -64504,8 +64592,8 @@ var ts;
                         }
                     }
                 }
-                else if (target.flags & 8388608 /* IndexedAccess */) {
-                    if (source.flags & 8388608 /* IndexedAccess */) {
+                else if (targetFlags & 8388608 /* IndexedAccess */) {
+                    if (sourceFlags & 8388608 /* IndexedAccess */) {
                         // Relate components directly before falling back to constraint relationships
                         // A type S[K] is related to a type T[J] if S is related to T and K is related to J.
                         if (result = isRelatedTo(source.objectType, target.objectType, 3 /* Both */, reportErrors)) {
@@ -64611,7 +64699,7 @@ var ts;
                         }
                     }
                 }
-                else if (target.flags & 16777216 /* Conditional */) {
+                else if (targetFlags & 16777216 /* Conditional */) {
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(target, targetStack, targetDepth, 10)) {
@@ -64636,8 +64724,8 @@ var ts;
                         }
                     }
                 }
-                else if (target.flags & 134217728 /* TemplateLiteral */) {
-                    if (source.flags & 134217728 /* TemplateLiteral */) {
+                else if (targetFlags & 134217728 /* TemplateLiteral */) {
+                    if (sourceFlags & 134217728 /* TemplateLiteral */) {
                         if (relation === comparableRelation) {
                             return templateLiteralTypesDefinitelyUnrelated(source, target) ? 0 /* False */ : -1 /* True */;
                         }
@@ -64649,11 +64737,11 @@ var ts;
                         return -1 /* True */;
                     }
                 }
-                if (source.flags & 8650752 /* TypeVariable */) {
-                    // IndexedAccess comparisons are handled above in the `target.flags & TypeFlage.IndexedAccess` branch
-                    if (!(source.flags & 8388608 /* IndexedAccess */ && target.flags & 8388608 /* IndexedAccess */)) {
+                if (sourceFlags & 8650752 /* TypeVariable */) {
+                    // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
+                    if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
                         var constraint = getConstraintOfType(source);
-                        if (!constraint || (source.flags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
+                        if (!constraint || (sourceFlags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
                             // A type variable with no constraint is not related to the non-primitive object type.
                             if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */), 3 /* Both */)) {
                                 resetErrorInfo(saveErrorInfo);
@@ -64666,7 +64754,7 @@ var ts;
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
-                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && !(target.flags & source.flags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
+                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -64683,14 +64771,14 @@ var ts;
                         }
                     }
                 }
-                else if (source.flags & 4194304 /* Index */) {
+                else if (sourceFlags & 4194304 /* Index */) {
                     if (result = isRelatedTo(keyofConstraintType, target, 1 /* Source */, reportErrors)) {
                         resetErrorInfo(saveErrorInfo);
                         return result;
                     }
                 }
-                else if (source.flags & 134217728 /* TemplateLiteral */ && !(target.flags & 524288 /* Object */)) {
-                    if (!(target.flags & 134217728 /* TemplateLiteral */)) {
+                else if (sourceFlags & 134217728 /* TemplateLiteral */ && !(targetFlags & 524288 /* Object */)) {
+                    if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
                         var constraint = getBaseConstraintOfType(source);
                         if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
                             resetErrorInfo(saveErrorInfo);
@@ -64698,8 +64786,8 @@ var ts;
                         }
                     }
                 }
-                else if (source.flags & 268435456 /* StringMapping */) {
-                    if (target.flags & 268435456 /* StringMapping */ && source.symbol === target.symbol) {
+                else if (sourceFlags & 268435456 /* StringMapping */) {
+                    if (targetFlags & 268435456 /* StringMapping */ && source.symbol === target.symbol) {
                         if (result = isRelatedTo(source.type, target.type, 3 /* Both */, reportErrors)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
@@ -64713,14 +64801,14 @@ var ts;
                         }
                     }
                 }
-                else if (source.flags & 16777216 /* Conditional */) {
+                else if (sourceFlags & 16777216 /* Conditional */) {
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(source, sourceStack, sourceDepth, 10)) {
                         resetErrorInfo(saveErrorInfo);
                         return 3 /* Maybe */;
                     }
-                    if (target.flags & 16777216 /* Conditional */) {
+                    if (targetFlags & 16777216 /* Conditional */) {
                         // Two conditional types 'T1 extends U1 ? X1 : Y1' and 'T2 extends U2 ? X2 : Y2' are related if
                         // one of T1 and T2 is related to the other, U1 and U2 are identical types, X1 is related to X2,
                         // and Y1 is related to Y2.
@@ -64780,15 +64868,21 @@ var ts;
                         }
                         return 0 /* False */;
                     }
-                    var sourceIsPrimitive = !!(source.flags & 131068 /* Primitive */);
+                    var sourceIsPrimitive = !!(sourceFlags & 131068 /* Primitive */);
                     if (relation !== identityRelation) {
                         source = getApparentType(source);
+                        sourceFlags = source.flags;
                     }
                     else if (isGenericMappedType(source)) {
                         return 0 /* False */;
                     }
                     if (ts.getObjectFlags(source) & 4 /* Reference */ && ts.getObjectFlags(target) & 4 /* Reference */ && source.target === target.target &&
                         !isTupleType(source) && !(ts.getObjectFlags(source) & 4096 /* MarkerType */ || ts.getObjectFlags(target) & 4096 /* MarkerType */)) {
+                        // When strictNullChecks is disabled, the element type of the empty array literal is undefinedWideningType,
+                        // and an empty array literal wouldn't be assignable to a `never[]` without this check.
+                        if (isEmptyArrayLiteralType(source)) {
+                            return -1 /* True */;
+                        }
                         // We have type references to the same generic type, and the type references are not marker
                         // type references (which are intended by be compared structurally). Obtain the variance
                         // information for the type parameters and relate the type arguments accordingly.
@@ -64824,7 +64918,7 @@ var ts;
                     // In a check of the form X = A & B, we will have previously checked if A relates to X or B relates
                     // to X. Failing both of those we want to check if the aggregation of A and B's members structurally
                     // relates to X. Thus, we include intersection types on the source side here.
-                    if (source.flags & (524288 /* Object */ | 2097152 /* Intersection */) && target.flags & 524288 /* Object */) {
+                    if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 524288 /* Object */) {
                         // Report structural errors only if we haven't reported any errors yet
                         var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive;
                         result = propertiesRelatedTo(source, target, reportStructuralErrors, /*excludedProperties*/ undefined, intersectionState);
@@ -64848,7 +64942,7 @@ var ts;
                     // there exists a constituent of T for every combination of the discriminants of S
                     // with respect to T. We do not report errors here, as we will use the existing
                     // error result from checking each constituent of the union.
-                    if (source.flags & (524288 /* Object */ | 2097152 /* Intersection */) && target.flags & 1048576 /* Union */) {
+                    if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 1048576 /* Union */) {
                         var objectOnlyTarget = extractTypesOfKind(target, 524288 /* Object */ | 2097152 /* Intersection */ | 33554432 /* Substitution */);
                         if (objectOnlyTarget.flags & 1048576 /* Union */) {
                             var result_9 = typeRelatedToDiscriminatedType(source, objectOnlyTarget);
@@ -65095,6 +65189,15 @@ var ts;
                     }
                     return 0 /* False */;
                 }
+                // Ensure {readonly a: whatever} is not a subtype of {a: whatever},
+                // while {a: whatever} is a subtype of {readonly a: whatever}.
+                // This ensures the subtype relationship is ordered, and preventing declaration order
+                // from deciding which type "wins" in union subtype reduction.
+                // They're still assignable to one another, since `readonly` doesn't affect assignability.
+                if ((relation === subtypeRelation || relation === strictSubtypeRelation) &&
+                    !!(sourcePropFlags & 64 /* Readonly */) && !(targetPropFlags & 64 /* Readonly */)) {
+                    return 0 /* False */;
+                }
                 // If the target comes from a partial union prop, allow `undefined` in the target type
                 var related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState);
                 if (!related) {
@@ -65363,7 +65466,6 @@ var ts;
                     }
                 }
                 var result = -1 /* True */;
-                var saveErrorInfo = captureErrorCalculationState();
                 var incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
                 var sourceObjectFlags = ts.getObjectFlags(source);
                 var targetObjectFlags = ts.getObjectFlags(target);
@@ -65404,6 +65506,7 @@ var ts;
                 else {
                     outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
                         var t = targetSignatures_1[_i];
+                        var saveErrorInfo = captureErrorCalculationState();
                         // Only elaborate errors from the first failure
                         var shouldElaborateErrors = reportErrors;
                         for (var _c = 0, sourceSignatures_1 = sourceSignatures; _c < sourceSignatures_1.length; _c++) {
@@ -65514,8 +65617,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);
@@ -66122,10 +66225,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);
@@ -66146,7 +66249,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) {
@@ -66810,7 +66913,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);
@@ -67727,8 +67830,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];
@@ -67748,8 +67851,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);
@@ -68574,9 +68677,6 @@ var ts;
                 getUnionType(ts.map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) :
                 mapType(type, mapper);
         }
-        function getConstituentCount(type) {
-            return type.flags & 1048576 /* Union */ ? type.types.length : 1;
-        }
         function extractTypesOfKind(type, kind) {
             return filterType(type, function (t) { return (t.flags & kind) !== 0; });
         }
@@ -73297,6 +73397,9 @@ 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 */) {
+                    addDeprecatedSuggestion(right, [indexInfo.declaration], right.escapedText);
+                }
             }
             else {
                 if (isDeprecatedSymbol(prop) && isUncalledFunctionReference(node, prop) && prop.declarations) {
@@ -75913,6 +76016,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 */) {
@@ -76242,21 +76411,22 @@ var ts;
                     if (links.type === unknownType) {
                         links.type = getTypeFromBindingPattern(declaration.name);
                     }
-                    assignBindingElementTypes(declaration.name);
+                    assignBindingElementTypes(declaration.name, links.type);
                 }
             }
         }
         // When contextual typing assigns a type to a parameter that contains a binding pattern, we also need to push
         // the destructured type into the contained binding elements.
-        function assignBindingElementTypes(pattern) {
+        function assignBindingElementTypes(pattern, parentType) {
             for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
                 var element = _a[_i];
                 if (!ts.isOmittedExpression(element)) {
+                    var type = getBindingElementTypeFromParentType(element, parentType);
                     if (element.name.kind === 79 /* Identifier */) {
-                        getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
+                        getSymbolLinks(getSymbolOfNode(element)).type = type;
                     }
                     else {
-                        assignBindingElementTypes(element.name);
+                        assignBindingElementTypes(element.name, type);
                     }
                 }
             }
@@ -78428,6 +78598,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 */:
@@ -79631,12 +79803,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 */:
@@ -79997,28 +80169,24 @@ var ts;
             if (returnType.flags & 1 /* Any */) {
                 return;
             }
+            var headMessage;
             var expectedReturnType;
-            var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
-            var errorInfo;
             switch (node.parent.kind) {
                 case 256 /* ClassDeclaration */:
+                    headMessage = ts.Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
                     var classSymbol = getSymbolOfNode(node.parent);
                     var classConstructorType = getTypeOfSymbol(classSymbol);
                     expectedReturnType = getUnionType([classConstructorType, voidType]);
                     break;
-                case 163 /* Parameter */:
-                    expectedReturnType = voidType;
-                    errorInfo = ts.chainDiagnosticMessages(
-                    /*details*/ undefined, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any);
-                    break;
                 case 166 /* PropertyDeclaration */:
+                case 163 /* Parameter */:
+                    headMessage = ts.Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any;
                     expectedReturnType = voidType;
-                    errorInfo = ts.chainDiagnosticMessages(
-                    /*details*/ undefined, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any);
                     break;
                 case 168 /* MethodDeclaration */:
                 case 171 /* GetAccessor */:
                 case 172 /* SetAccessor */:
+                    headMessage = ts.Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
                     var methodType = getTypeOfNode(node.parent);
                     var descriptorType = createTypedPropertyDescriptorType(methodType);
                     expectedReturnType = getUnionType([descriptorType, voidType]);
@@ -80026,7 +80194,7 @@ var ts;
                 default:
                     return ts.Debug.fail();
             }
-            checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, function () { return errorInfo; });
+            checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage);
         }
         /**
          * If a TypeNode can be resolved to a value symbol imported from an external module, it is
@@ -82199,8 +82367,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);
                 }
             }
@@ -82226,8 +82394,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);
             }
         }
@@ -82249,8 +82417,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);
             }
         }
@@ -85574,7 +85742,7 @@ var ts;
             if (resolvedTypeReferenceDirectives) {
                 // populate reverse mapping: file path -> type reference directive that was resolved to this file
                 fileToDirective = new ts.Map();
-                resolvedTypeReferenceDirectives.forEach(function (resolvedDirective, key) {
+                resolvedTypeReferenceDirectives.forEach(function (resolvedDirective, key, mode) {
                     if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
                         return;
                     }
@@ -85582,7 +85750,7 @@ var ts;
                     if (file) {
                         // Add the transitive closure of path references loaded by this file (as long as they are not)
                         // part of an existing type reference.
-                        addReferencedFilesToTypeDirective(file, key);
+                        addReferencedFilesToTypeDirective(file, key, mode);
                     }
                 });
             }
@@ -85776,16 +85944,16 @@ var ts;
                 }
                 return false;
             }
-            function addReferencedFilesToTypeDirective(file, key) {
+            function addReferencedFilesToTypeDirective(file, key, mode) {
                 if (fileToDirective.has(file.path))
                     return;
-                fileToDirective.set(file.path, key);
+                fileToDirective.set(file.path, [key, mode]);
                 for (var _i = 0, _a = file.referencedFiles; _i < _a.length; _i++) {
-                    var fileName = _a[_i].fileName;
+                    var _b = _a[_i], fileName = _b.fileName, resolutionMode = _b.resolutionMode;
                     var resolvedFile = ts.resolveTripleslashReference(fileName, file.fileName);
                     var referencedFile = host.getSourceFile(resolvedFile);
                     if (referencedFile) {
-                        addReferencedFilesToTypeDirective(referencedFile, key);
+                        addReferencedFilesToTypeDirective(referencedFile, key, resolutionMode || file.impliedNodeFormat);
                     }
                 }
             }
@@ -87490,28 +87658,27 @@ var ts;
         }
         function findMostOverlappyType(source, unionTarget) {
             var bestMatch;
-            var matchingCount = 0;
-            for (var _i = 0, _a = unionTarget.types; _i < _a.length; _i++) {
-                var target = _a[_i];
-                var overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
-                if (overlap.flags & 4194304 /* Index */) {
-                    // perfect overlap of keys
-                    bestMatch = target;
-                    matchingCount = Infinity;
-                }
-                else if (overlap.flags & 1048576 /* Union */) {
-                    // We only want to account for literal types otherwise.
-                    // If we have a union of index types, it seems likely that we
-                    // needed to elaborate between two generic mapped types anyway.
-                    var len = ts.length(ts.filter(overlap.types, isUnitType));
-                    if (len >= matchingCount) {
-                        bestMatch = target;
-                        matchingCount = len;
-                    }
-                }
-                else if (isUnitType(overlap) && 1 >= matchingCount) {
-                    bestMatch = target;
-                    matchingCount = 1;
+            if (!(source.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
+                var matchingCount = 0;
+                for (var _i = 0, _a = unionTarget.types; _i < _a.length; _i++) {
+                    var target = _a[_i];
+                    if (!(target.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
+                        var overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
+                        if (overlap.flags & 4194304 /* Index */) {
+                            // perfect overlap of keys
+                            return target;
+                        }
+                        else if (isUnitType(overlap) || overlap.flags & 1048576 /* Union */) {
+                            // We only want to account for literal types otherwise.
+                            // If we have a union of index types, it seems likely that we
+                            // needed to elaborate between two generic mapped types anyway.
+                            var len = overlap.flags & 1048576 /* Union */ ? ts.countWhere(overlap.types, isUnitType) : 1;
+                            if (len >= matchingCount) {
+                                bestMatch = target;
+                                matchingCount = len;
+                            }
+                        }
+                    }
                 }
             }
             return bestMatch;
@@ -87884,7 +88051,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));
@@ -90776,8 +90943,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) {
@@ -96122,8 +96289,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;
@@ -106554,7 +106721,7 @@ var ts;
                         var sourceFile = ts.createUnparsedSourceFile(prepend, "dts", stripInternal);
                         hasNoDefaultLib_1 = hasNoDefaultLib_1 || !!sourceFile.hasNoDefaultLib;
                         collectReferences(sourceFile, refs);
-                        recordTypeReferenceDirectivesIfNecessary(sourceFile.typeReferenceDirectives);
+                        recordTypeReferenceDirectivesIfNecessary(ts.map(sourceFile.typeReferenceDirectives, function (ref) { return [ref.fileName, ref.resolutionMode]; }));
                         collectLibs(sourceFile, libs);
                         return sourceFile;
                     }
@@ -106609,9 +106776,10 @@ var ts;
                 return ts.map(ts.arrayFrom(libs.keys()), function (lib) { return ({ fileName: lib, pos: -1, end: -1 }); });
             }
             function getFileReferencesForUsedTypeReferences() {
-                return necessaryTypeReferences ? ts.mapDefined(ts.arrayFrom(necessaryTypeReferences.keys()), getFileReferenceForTypeName) : [];
+                return necessaryTypeReferences ? ts.mapDefined(ts.arrayFrom(necessaryTypeReferences.keys()), getFileReferenceForSpecifierModeTuple) : [];
             }
-            function getFileReferenceForTypeName(typeName) {
+            function getFileReferenceForSpecifierModeTuple(_a) {
+                var typeName = _a[0], mode = _a[1];
                 // Elide type references for which we have imports
                 if (emittedImports) {
                     for (var _i = 0, emittedImports_1 = emittedImports; _i < emittedImports_1.length; _i++) {
@@ -106627,7 +106795,7 @@ var ts;
                         }
                     }
                 }
-                return { fileName: typeName, pos: -1, end: -1 };
+                return __assign({ fileName: typeName, pos: -1, end: -1 }, (mode ? { resolutionMode: mode } : undefined));
             }
             function mapReferencesIntoArray(references, outputFilePath) {
                 return function (file) {
@@ -106647,7 +106815,7 @@ var ts;
                             // If some compiler option/symlink/whatever allows access to the file containing the ambient module declaration
                             // via a non-relative name, emit a type reference directive to that non-relative name, rather than
                             // a relative path to the declaration file
-                            recordTypeReferenceDirectivesIfNecessary([specifier]);
+                            recordTypeReferenceDirectivesIfNecessary([[specifier, /*mode*/ undefined]]);
                             return;
                         }
                         var fileName = ts.getRelativePathToDirectoryOrUrl(outputFilePath, declFileName, host.getCurrentDirectory(), host.getCanonicalFileName, 
@@ -109760,6 +109928,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 */:
@@ -110204,6 +110374,7 @@ var ts;
             writeKeyword("typeof");
             writeSpace();
             emit(node.exprName);
+            emitTypeArguments(node, node.typeArguments);
         }
         function emitTypeLiteral(node) {
             writePunctuation("{");
@@ -111759,9 +111930,12 @@ var ts;
             for (var _d = 0, types_24 = types; _d < types_24.length; _d++) {
                 var directive = types_24[_d];
                 var pos = writer.getTextPos();
-                writeComment("/// <reference types=\"" + directive.fileName + "\" />");
+                var resolutionMode = directive.resolutionMode && directive.resolutionMode !== (currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.impliedNodeFormat)
+                    ? "resolution-mode=\"" + (directive.resolutionMode === ts.ModuleKind.ESNext ? "import" : "require") + "\""
+                    : "";
+                writeComment("/// <reference types=\"" + directive.fileName + "\" " + resolutionMode + "/>");
                 if (bundleFileInfo)
-                    bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "type" /* Type */, data: directive.fileName });
+                    bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: !directive.resolutionMode ? "type" /* Type */ : directive.resolutionMode === ts.ModuleKind.ESNext ? "type-import" /* TypeResolutionModeImport */ : "type-require" /* TypeResolutionModeRequire */, data: directive.fileName });
                 writeLine();
             }
             for (var _e = 0, libs_1 = libs; _e < libs_1.length; _e++) {
@@ -114368,7 +114542,7 @@ var ts;
     }
     ts.flattenDiagnosticMessageText = flattenDiagnosticMessageText;
     /* @internal */
-    function loadWithLocalCache(names, containingFile, redirectedReference, loader) {
+    function loadWithTypeDirectiveCache(names, containingFile, redirectedReference, containingFileMode, loader) {
         if (names.length === 0) {
             return [];
         }
@@ -114377,19 +114551,28 @@ var ts;
         for (var _i = 0, names_2 = names; _i < names_2.length; _i++) {
             var name = names_2[_i];
             var result = void 0;
-            if (cache.has(name)) {
-                result = cache.get(name);
+            var mode = getModeForFileReference(name, containingFileMode);
+            // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
+            var strName = ts.isString(name) ? name : name.fileName.toLowerCase();
+            var cacheKey = mode !== undefined ? mode + "|" + strName : strName;
+            if (cache.has(cacheKey)) {
+                result = cache.get(cacheKey);
             }
             else {
-                cache.set(name, result = loader(name, containingFile, redirectedReference));
+                cache.set(cacheKey, result = loader(strName, containingFile, redirectedReference, mode));
             }
             resolutions.push(result);
         }
         return resolutions;
     }
-    ts.loadWithLocalCache = loadWithLocalCache;
+    ts.loadWithTypeDirectiveCache = loadWithTypeDirectiveCache;
     ;
     /* @internal */
+    function getModeForFileReference(ref, containingFileMode) {
+        return (ts.isString(ref) ? containingFileMode : ref.resolutionMode) || containingFileMode;
+    }
+    ts.getModeForFileReference = getModeForFileReference;
+    /* @internal */
     function getModeForResolutionAtIndex(file, index) {
         if (file.impliedNodeFormat === undefined)
             return undefined;
@@ -114492,7 +114675,7 @@ var ts;
         var _d, _e, _f, _g;
         var file = ts.Debug.checkDefined(getSourceFileByPath(ref.file));
         var kind = ref.kind, index = ref.index;
-        var pos, end, packageId;
+        var pos, end, packageId, resolutionMode;
         switch (kind) {
             case ts.FileIncludeKind.Import:
                 var importLiteral = getModuleNameStringLiteralAt(file, index);
@@ -114506,8 +114689,8 @@ var ts;
                 (_a = file.referencedFiles[index], pos = _a.pos, end = _a.end);
                 break;
             case ts.FileIncludeKind.TypeReferenceDirective:
-                (_b = file.typeReferenceDirectives[index], pos = _b.pos, end = _b.end);
-                packageId = (_g = (_f = file.resolvedTypeReferenceDirectiveNames) === null || _f === void 0 ? void 0 : _f.get(ts.toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), file.impliedNodeFormat)) === null || _g === void 0 ? void 0 : _g.packageId;
+                (_b = file.typeReferenceDirectives[index], pos = _b.pos, end = _b.end, resolutionMode = _b.resolutionMode);
+                packageId = (_g = (_f = file.resolvedTypeReferenceDirectiveNames) === null || _f === void 0 ? void 0 : _f.get(ts.toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) === null || _g === void 0 ? void 0 : _g.packageId;
                 break;
             case ts.FileIncludeKind.LibReferenceDirective:
                 (_c = file.libReferenceDirectives[index], pos = _c.pos, end = _c.end);
@@ -114751,7 +114934,7 @@ var ts;
         var fileReasons = ts.createMultiMap();
         var cachedBindAndCheckDiagnosticsForFile = {};
         var cachedDeclarationDiagnosticsForFile = {};
-        var resolvedTypeReferenceDirectives = new ts.Map();
+        var resolvedTypeReferenceDirectives = ts.createModeAwareCache();
         var fileProcessingDiagnostics;
         // The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules.
         // This works as imported modules are discovered recursively in a depth first manner, specifically:
@@ -114804,12 +114987,12 @@ var ts;
         }
         var actualResolveTypeReferenceDirectiveNamesWorker;
         if (host.resolveTypeReferenceDirectives) {
-            actualResolveTypeReferenceDirectiveNamesWorker = function (typeDirectiveNames, containingFile, redirectedReference) { return host.resolveTypeReferenceDirectives(ts.Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options); };
+            actualResolveTypeReferenceDirectiveNamesWorker = function (typeDirectiveNames, containingFile, redirectedReference, containingFileMode) { return host.resolveTypeReferenceDirectives(ts.Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode); };
         }
         else {
             typeReferenceDirectiveResolutionCache = ts.createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, /*options*/ undefined, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
-            var loader_2 = function (typesRef, containingFile, redirectedReference) { return ts.resolveTypeReferenceDirective(typesRef, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache).resolvedTypeReferenceDirective; }; // TODO: GH#18217
-            actualResolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile, redirectedReference) { return loadWithLocalCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, loader_2); };
+            var loader_2 = function (typesRef, containingFile, redirectedReference, resolutionMode) { return ts.resolveTypeReferenceDirective(typesRef, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode).resolvedTypeReferenceDirective; }; // TODO: GH#18217
+            actualResolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) { return loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_2); };
         }
         // Map from a stringified PackageId to the source file with that id.
         // Only one source file may have a given packageId. Others become redirects (see createRedirectSourceFile).
@@ -114906,7 +115089,8 @@ var ts;
                 var containingFilename = ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile);
                 var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
                 for (var i = 0; i < typeReferences.length; i++) {
-                    processTypeReferenceDirective(typeReferences[i], resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_c = resolutions[i]) === null || _c === void 0 ? void 0 : _c.packageId });
+                    // under node12/nodenext module resolution, load `types`/ata include names as cjs resolution results by passing an `undefined` mode
+                    processTypeReferenceDirective(typeReferences[i], /*mode*/ undefined, resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_c = resolutions[i]) === null || _c === void 0 ? void 0 : _c.packageId });
                 }
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             }
@@ -115066,9 +115250,10 @@ var ts;
                 return [];
             var containingFileName = !ts.isString(containingFile) ? ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
             var redirectedReference = !ts.isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined;
+            var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName });
             ts.performance.mark("beforeResolveTypeReference");
-            var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference);
+            var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode);
             ts.performance.mark("afterResolveTypeReference");
             ts.performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
@@ -115163,15 +115348,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
@@ -115460,8 +115645,7 @@ var ts;
                 else {
                     newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
                 }
-                // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
-                var typesReferenceDirectives = ts.map(newSourceFile.typeReferenceDirectives, function (ref) { return ts.toFileNameLowerCase(ref.fileName); });
+                var typesReferenceDirectives = newSourceFile.typeReferenceDirectives;
                 var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile);
                 // ensure that types resolutions are still correct
                 var typeReferenceResolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, ts.typeDirectiveIsEqualTo);
@@ -116540,8 +116724,7 @@ var ts;
             });
         }
         function processTypeReferenceDirectives(file) {
-            // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
-            var typeDirectives = ts.map(file.typeReferenceDirectives, function (ref) { return ts.toFileNameLowerCase(ref.fileName); });
+            var typeDirectives = file.typeReferenceDirectives;
             if (!typeDirectives) {
                 return;
             }
@@ -116552,17 +116735,21 @@ var ts;
                 // store resolved type directive on the file
                 var fileName = ts.toFileNameLowerCase(ref.fileName);
                 ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective);
-                processTypeReferenceDirective(fileName, resolvedTypeReferenceDirective, { kind: ts.FileIncludeKind.TypeReferenceDirective, file: file.path, index: index, });
+                var mode = ref.resolutionMode || file.impliedNodeFormat;
+                if (mode && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node12 && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) {
+                    programDiagnostics.add(ts.createDiagnosticForRange(file, ref, ts.Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node12_or_nodenext));
+                }
+                processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: ts.FileIncludeKind.TypeReferenceDirective, file: file.path, index: index, });
             }
         }
-        function processTypeReferenceDirective(typeReferenceDirective, resolvedTypeReferenceDirective, reason) {
+        function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
-            processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, reason);
+            processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }
-        function processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, reason) {
+        function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
             // If we already found this library as a primary reference - nothing to do
-            var previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective);
+            var previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode);
             if (previousResolution && previousResolution.primary) {
                 return;
             }
@@ -116601,7 +116788,7 @@ var ts;
                 addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]);
             }
             if (saveResolution) {
-                resolvedTypeReferenceDirectives.set(typeReferenceDirective, resolvedTypeReferenceDirective);
+                resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolvedTypeReferenceDirective);
             }
         }
         function pathForLibFile(libFileName) {
@@ -119419,9 +119606,9 @@ var ts;
             });
             hasChangedAutomaticTypeDirectiveNames = false;
         }
-        function resolveModuleName(moduleName, containingFile, compilerOptions, host, redirectedReference) {
+        function resolveModuleName(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) {
             var _a;
-            var primaryResult = ts.resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference);
+            var primaryResult = ts.resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
             // return result immediately only if global cache support is not enabled or if it is .ts, .tsx or .d.ts
             if (!resolutionHost.getGlobalCache) {
                 return primaryResult;
@@ -119442,12 +119629,12 @@ var ts;
             // Default return the result from the first pass
             return primaryResult;
         }
-        function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference) {
-            return ts.resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache);
+        function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, _containingSourceFile, resolutionMode) {
+            return ts.resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode);
         }
         function resolveNamesWithLocalCache(_a) {
             var _b, _c, _d;
-            var names = _a.names, containingFile = _a.containingFile, redirectedReference = _a.redirectedReference, cache = _a.cache, perDirectoryCacheWithRedirects = _a.perDirectoryCacheWithRedirects, loader = _a.loader, getResolutionWithResolvedFileName = _a.getResolutionWithResolvedFileName, shouldRetryResolution = _a.shouldRetryResolution, reusedNames = _a.reusedNames, logChanges = _a.logChanges, containingSourceFile = _a.containingSourceFile;
+            var names = _a.names, containingFile = _a.containingFile, redirectedReference = _a.redirectedReference, cache = _a.cache, perDirectoryCacheWithRedirects = _a.perDirectoryCacheWithRedirects, loader = _a.loader, getResolutionWithResolvedFileName = _a.getResolutionWithResolvedFileName, shouldRetryResolution = _a.shouldRetryResolution, reusedNames = _a.reusedNames, logChanges = _a.logChanges, containingSourceFile = _a.containingSourceFile, containingSourceFileMode = _a.containingSourceFileMode;
             var path = resolutionHost.toPath(containingFile);
             var resolutionsInFile = cache.get(path) || cache.set(path, ts.createModeAwareCache()).get(path);
             var dirPath = ts.getDirectoryPath(path);
@@ -119469,8 +119656,15 @@ var ts;
             var seenNamesInFile = ts.createModeAwareCache();
             var i = 0;
             for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
-                var name = names_4[_i];
-                var mode = containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, i) : undefined;
+                var entry = names_4[_i];
+                var name = ts.isString(entry) ? entry : entry.fileName.toLowerCase();
+                // Imports supply a `containingSourceFile` but no `containingSourceFileMode` - it would be redundant
+                // they require calculating the mode for a given import from it's position in the resolution table, since a given
+                // import's syntax may override the file's default mode.
+                // Type references instead supply a `containingSourceFileMode` and a non-string entry which contains
+                // a default file mode override if applicable.
+                var mode = !ts.isString(entry) ? ts.getModeForFileReference(entry, containingSourceFileMode) :
+                    containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, i) : undefined;
                 i++;
                 var resolution = resolutionsInFile.get(name, mode);
                 // Resolution is valid if it is present and not invalidated
@@ -119499,7 +119693,7 @@ var ts;
                         }
                     }
                     else {
-                        resolution = loader(name, containingFile, compilerOptions, ((_c = resolutionHost.getCompilerHost) === null || _c === void 0 ? void 0 : _c.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile);
+                        resolution = loader(name, containingFile, compilerOptions, ((_c = resolutionHost.getCompilerHost) === null || _c === void 0 ? void 0 : _c.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile, mode);
                         perDirectoryResolution.set(name, mode, resolution);
                         if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
                             resolutionHost.onDiscoveredSymlink();
@@ -119563,7 +119757,7 @@ var ts;
                 return oldResult.resolvedFileName === newResult.resolvedFileName;
             }
         }
-        function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference) {
+        function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode) {
             return resolveNamesWithLocalCache({
                 names: typeDirectiveNames,
                 containingFile: containingFile,
@@ -119573,6 +119767,7 @@ var ts;
                 loader: resolveTypeReferenceDirective,
                 getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
                 shouldRetryResolution: function (resolution) { return resolution.resolvedTypeReferenceDirective === undefined; },
+                containingSourceFileMode: containingFileMode
             });
         }
         function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile) {
@@ -120279,9 +120474,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);
@@ -120301,10 +120496,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;
                     }
                 });
             });
@@ -121481,7 +121676,7 @@ var ts;
                 }
                 return host.resolveTypeReferenceDirectives.apply(host, args);
             }) :
-            (function (typeDirectiveNames, containingFile, redirectedReference) { return resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference); });
+            (function (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) { return resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode); });
         var userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
         builderProgram = readBuilderProgram(compilerOptions, compilerHost);
         synchronizeProgram();
@@ -122217,9 +122412,9 @@ var ts;
             compilerHost.getModuleResolutionCache = function () { return moduleResolutionCache; };
         }
         if (!compilerHost.resolveTypeReferenceDirectives) {
-            var loader_4 = function (moduleName, containingFile, redirectedReference) { return ts.resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache).resolvedTypeReferenceDirective; };
-            compilerHost.resolveTypeReferenceDirectives = function (typeReferenceDirectiveNames, containingFile, redirectedReference) {
-                return ts.loadWithLocalCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, loader_4);
+            var loader_4 = function (moduleName, containingFile, redirectedReference, containingFileMode) { return ts.resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode).resolvedTypeReferenceDirective; };
+            compilerHost.resolveTypeReferenceDirectives = function (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) {
+                return ts.loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_4);
             };
         }
         var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog;
@@ -124562,7 +124757,7 @@ var ts;
             case 199 /* ImportType */:
                 return !node.parent.isTypeOf;
             case 227 /* ExpressionWithTypeArguments */:
-                return !ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent);
+                return ts.isPartOfTypeNode(node.parent);
         }
         return false;
     }
@@ -127545,6 +127740,10 @@ var ts;
         return __assign(__assign({}, options), { semicolons: shouldRemoveSemicolons ? ts.SemicolonPreference.Remove : ts.SemicolonPreference.Ignore });
     }
     ts.getFormatCodeSettingsForWriting = getFormatCodeSettingsForWriting;
+    function jsxModeNeedsExplicitImport(jsx) {
+        return jsx === 2 /* React */ || jsx === 3 /* ReactNative */;
+    }
+    ts.jsxModeNeedsExplicitImport = jsxModeNeedsExplicitImport;
     // #endregion
 })(ts || (ts = {}));
 /*@internal*/
@@ -129489,9 +129688,18 @@ var ts;
                     return getCompletionEntriesForDirectoryFragment(literalValue, scriptDirectory, extensionOptions, host, scriptPath);
                 }
             }
+            function isEmitResolutionKindUsingNodeModules(compilerOptions) {
+                return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs ||
+                    ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node12 ||
+                    ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext;
+            }
+            function isEmitModuleResolutionRespectingExportMaps(compilerOptions) {
+                return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node12 ||
+                    ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext;
+            }
             function getSupportedExtensionsForModuleResolution(compilerOptions) {
                 var extensions = ts.getSupportedExtensions(compilerOptions);
-                return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs ?
+                return isEmitResolutionKindUsingNodeModules(compilerOptions) ?
                     ts.getSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, extensions) :
                     extensions;
             }
@@ -129654,7 +129862,7 @@ var ts;
                     result.push(nameAndKind(ambientName, "external module name" /* externalModuleName */, /*extension*/ undefined));
                 }
                 getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, fragmentDirectory, extensionOptions, result);
-                if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs) {
+                if (isEmitResolutionKindUsingNodeModules(compilerOptions)) {
                     // If looking for a global package name, don't just include everything in `node_modules` because that includes dependencies' own dependencies.
                     // (But do if we didn't find anything, e.g. 'package.json' missing.)
                     var foundGlobal = false;
@@ -129671,12 +129879,68 @@ var ts;
                         }
                     }
                     if (!foundGlobal) {
-                        ts.forEachAncestorDirectory(scriptPath, function (ancestor) {
+                        var ancestorLookup = function (ancestor) {
                             var nodeModules = ts.combinePaths(ancestor, "node_modules");
                             if (ts.tryDirectoryExists(host, nodeModules)) {
                                 getCompletionEntriesForDirectoryFragment(fragment, nodeModules, extensionOptions, host, /*exclude*/ undefined, result);
                             }
-                        });
+                        };
+                        if (fragmentDirectory && isEmitModuleResolutionRespectingExportMaps(compilerOptions)) {
+                            var nodeModulesDirectoryLookup_1 = ancestorLookup;
+                            ancestorLookup = function (ancestor) {
+                                var components = ts.getPathComponents(fragment);
+                                components.shift(); // shift off empty root
+                                var packagePath = components.shift();
+                                if (!packagePath) {
+                                    return nodeModulesDirectoryLookup_1(ancestor);
+                                }
+                                if (ts.startsWith(packagePath, "@")) {
+                                    var subName = components.shift();
+                                    if (!subName) {
+                                        return nodeModulesDirectoryLookup_1(ancestor);
+                                    }
+                                    packagePath = ts.combinePaths(packagePath, subName);
+                                }
+                                var packageFile = ts.combinePaths(ancestor, "node_modules", packagePath, "package.json");
+                                if (ts.tryFileExists(host, packageFile)) {
+                                    var packageJson = ts.readJson(packageFile, host);
+                                    var exports = packageJson.exports;
+                                    if (exports) {
+                                        if (typeof exports !== "object" || exports === null) { // eslint-disable-line no-null/no-null
+                                            return; // null exports or entrypoint only, no sub-modules available
+                                        }
+                                        var keys = ts.getOwnKeys(exports);
+                                        var fragmentSubpath_1 = components.join("/");
+                                        var processedKeys = ts.mapDefined(keys, function (k) {
+                                            if (k === ".")
+                                                return undefined;
+                                            if (!ts.startsWith(k, "./"))
+                                                return undefined;
+                                            var subpath = k.substring(2);
+                                            if (!ts.startsWith(subpath, fragmentSubpath_1))
+                                                return undefined;
+                                            // subpath is a valid export (barring conditions, which we don't currently check here)
+                                            if (!ts.stringContains(subpath, "*")) {
+                                                return subpath;
+                                            }
+                                            // pattern export - only return everything up to the `*`, so the user can autocomplete, then
+                                            // keep filling in the pattern (we could speculatively return a list of options by hitting disk,
+                                            // but conditions will make that somewhat awkward, as each condition may have a different set of possible
+                                            // options for the `*`.
+                                            return subpath.slice(0, subpath.indexOf("*"));
+                                        });
+                                        ts.forEach(processedKeys, function (k) {
+                                            if (k) {
+                                                result.push(nameAndKind(k, "external module name" /* externalModuleName */, /*extension*/ undefined));
+                                            }
+                                        });
+                                        return;
+                                    }
+                                }
+                                return nodeModulesDirectoryLookup_1(ancestor);
+                            };
+                        }
+                        ts.forEachAncestorDirectory(scriptPath, ancestorLookup);
                     }
                 }
                 return result;
@@ -131118,14 +131382,15 @@ var ts;
                     if (tag.tagName.pos <= position && position <= tag.tagName.end) {
                         return { kind: 1 /* JsDocTagName */ };
                     }
-                    if (isTagWithTypeExpression(tag) && tag.typeExpression && tag.typeExpression.kind === 307 /* JSDocTypeExpression */) {
+                    var typeExpression = tryGetTypeExpressionFromTag(tag);
+                    if (typeExpression) {
                         currentToken = ts.getTokenAtPosition(sourceFile, position);
                         if (!currentToken ||
                             (!ts.isDeclarationName(currentToken) &&
                                 (currentToken.parent.kind !== 345 /* JSDocPropertyTag */ ||
                                     currentToken.parent.name !== currentToken))) {
                             // Use as type location if inside tag's type expression
-                            insideJsDocTagTypeExpression = isCurrentlyEditingNode(tag.typeExpression);
+                            insideJsDocTagTypeExpression = isCurrentlyEditingNode(typeExpression);
                         }
                     }
                     if (!insideJsDocTagTypeExpression && ts.isJSDocParameterTag(tag) && (ts.nodeIsMissing(tag.name) || tag.name.pos <= position && position <= tag.name.end)) {
@@ -131382,10 +131647,19 @@ var ts;
                     case 341 /* JSDocTypeTag */:
                     case 343 /* JSDocTypedefTag */:
                         return true;
+                    case 342 /* JSDocTemplateTag */:
+                        return !!tag.constraint;
                     default:
                         return false;
                 }
             }
+            function tryGetTypeExpressionFromTag(tag) {
+                if (isTagWithTypeExpression(tag)) {
+                    var typeExpression = ts.isJSDocTemplateTag(tag) ? tag.constraint : tag.typeExpression;
+                    return typeExpression && typeExpression.kind === 307 /* JSDocTypeExpression */ ? typeExpression : undefined;
+                }
+                return undefined;
+            }
             function getTypeScriptMemberSymbols() {
                 // Right of dot member completion list
                 completionKind = 2 /* PropertyAccess */;
@@ -134141,7 +134415,7 @@ var ts;
                     }
                     for (var _c = 0, _d = referencingFile.typeReferenceDirectives; _c < _d.length; _c++) {
                         var ref = _d[_c];
-                        var referenced = program.getResolvedTypeReferenceDirectives().get(ref.fileName);
+                        var referenced = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat);
                         if (referenced !== undefined && referenced.resolvedFileName === searchSourceFile.fileName) {
                             refs.push({ kind: "reference", referencingFile: referencingFile, ref: ref });
                         }
@@ -137363,7 +137637,7 @@ var ts;
             }
             var typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
             if (typeReferenceDirective) {
-                var reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName);
+                var reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat);
                 var file = reference && program.getSourceFile(reference.resolvedFileName); // TODO:GH#18217
                 return file && { reference: typeReferenceDirective, fileName: file.fileName, file: file, unverified: false };
             }
@@ -139169,6 +139443,7 @@ var ts;
                 return oldImports;
             }
             var typeChecker = program.getTypeChecker();
+            var compilerOptions = program.getCompilerOptions();
             var jsxNamespace = typeChecker.getJsxNamespace(sourceFile);
             var jsxFragmentFactory = typeChecker.getJsxFragmentFactory(sourceFile);
             var jsxElementsPresent = !!(sourceFile.transformFlags & 2 /* ContainsJsx */);
@@ -139225,7 +139500,7 @@ var ts;
             return usedImports;
             function isDeclarationUsed(identifier) {
                 // The JSX factory symbol is always used if JSX elements are present - even if they are not allowed.
-                return jsxElementsPresent && (identifier.text === jsxNamespace || jsxFragmentFactory && identifier.text === jsxFragmentFactory) ||
+                return jsxElementsPresent && (identifier.text === jsxNamespace || jsxFragmentFactory && identifier.text === jsxFragmentFactory) && ts.jsxModeNeedsExplicitImport(compilerOptions.jsx) ||
                     ts.FindAllReferences.Core.isSymbolReferencedInFile(identifier, typeChecker, sourceFile);
             }
         }
@@ -150916,12 +151191,9 @@ var ts;
                 return undefined;
             return { kind: 4 /* PromoteTypeOnly */, typeOnlyAliasDeclaration: typeOnlyAliasDeclaration };
         }
-        function jsxModeNeedsExplicitImport(jsx) {
-            return jsx === 2 /* React */ || jsx === 3 /* ReactNative */;
-        }
         function getSymbolName(sourceFile, checker, symbolToken, compilerOptions) {
             var parent = symbolToken.parent;
-            if ((ts.isJsxOpeningLikeElement(parent) || ts.isJsxClosingElement(parent)) && parent.tagName === symbolToken && jsxModeNeedsExplicitImport(compilerOptions.jsx)) {
+            if ((ts.isJsxOpeningLikeElement(parent) || ts.isJsxClosingElement(parent)) && parent.tagName === symbolToken && ts.jsxModeNeedsExplicitImport(compilerOptions.jsx)) {
                 var jsxNamespace = checker.getJsxNamespace(sourceFile);
                 if (needsJsxNamespaceFix(jsxNamespace, symbolToken, checker)) {
                     return jsxNamespace;
@@ -157428,7 +157700,7 @@ var ts;
                     // cannot find either start or end node
                     return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
                 }
-                if (ts.isJSDoc(start)) {
+                if (start.flags & 4194304 /* JSDoc */) {
                     return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractJSDoc)] };
                 }
                 if (start.parent !== end.parent) {
@@ -164187,7 +164459,7 @@ var ts;
             if ("getTypeReferenceDirectiveResolutionsForFile" in this.shimHost) {
                 this.resolveTypeReferenceDirectives = function (typeDirectiveNames, containingFile) {
                     var typeDirectivesForFile = JSON.parse(_this.shimHost.getTypeReferenceDirectiveResolutionsForFile(containingFile)); // TODO: GH#18217
-                    return ts.map(typeDirectiveNames, function (name) { return ts.getProperty(typeDirectivesForFile, name); });
+                    return ts.map(typeDirectiveNames, function (name) { return ts.getProperty(typeDirectivesForFile, ts.isString(name) ? name : name.fileName.toLowerCase()); });
                 };
             }
         }