typescript 4.5.0-dev.20211031 → 4.6.0-dev.20211103

package/lib/lib.es5.d.ts

@@ -116,7 +116,7 @@ interface PropertyDescriptor {
 }
 
 interface PropertyDescriptorMap {
-    [s: string]: PropertyDescriptor;
+    [key: PropertyKey]: PropertyDescriptor;
 }
 
 interface Object {

package/lib/tsc.js

@@ -68,8 +68,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 var ts;
 (function (ts) {
-    ts.versionMajorMinor = "4.5";
-    ts.version = ts.versionMajorMinor + ".0-dev.20211031";
+    ts.versionMajorMinor = "4.6";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211103";
     var NativeCollections;
     (function (NativeCollections) {
         function tryGetNativeMap() {
@@ -5307,7 +5307,7 @@ var ts;
         Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts.DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."),
         Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts.DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."),
         Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node12', or 'nodenext'."),
-        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext'."),
+        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext' or 'nodenext'."),
         Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
         Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments."),
         String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
@@ -5907,11 +5907,12 @@ var ts;
         Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers: diag(2818, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializer_2818", "Duplicate identifier '{0}'. Compiler reserves name '{1}' when emitting 'super' references in static initializers."),
         Namespace_name_cannot_be_0: diag(2819, ts.DiagnosticCategory.Error, "Namespace_name_cannot_be_0_2819", "Namespace name cannot be '{0}'."),
         Type_0_is_not_assignable_to_type_1_Did_you_mean_2: diag(2820, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_Did_you_mean_2_2820", "Type '{0}' is not assignable to type '{1}'. Did you mean '{2}'?"),
-        Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext'."),
+        Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext' or 'nodenext'."),
         Import_assertions_cannot_be_used_with_type_only_imports_or_exports: diag(2822, ts.DiagnosticCategory.Error, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."),
         Cannot_find_namespace_0_Did_you_mean_1: diag(2833, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"),
         Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Consider adding an extension to the import path."),
         Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0: diag(2835, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Did you mean '{0}'?"),
+        Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, ts.DiagnosticCategory.Error, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -8720,6 +8721,7 @@ var ts;
                     tokenValue = tokenValue.slice(0, -1);
                     pos--;
                 }
+                return getIdentifierToken();
             }
             return token;
         }
@@ -44623,11 +44625,14 @@ var ts;
             return type.flags & (128 | 256) ? "" + type.value : undefined;
         }
         function getTypeForBindingElement(declaration) {
-            var pattern = declaration.parent;
-            var parentType = getTypeForBindingElementParent(pattern.parent);
-            if (!parentType || isTypeAny(parentType)) {
+            var parentType = getTypeForBindingElementParent(declaration.parent.parent);
+            return parentType && getBindingElementTypeFromParentType(declaration, parentType);
+        }
+        function getBindingElementTypeFromParentType(declaration, parentType) {
+            if (isTypeAny(parentType)) {
                 return parentType;
             }
+            var pattern = declaration.parent;
             if (strictNullChecks && declaration.flags & 8388608 && ts.isParameterDeclaration(declaration)) {
                 parentType = getNonNullableType(parentType);
             }
@@ -49208,6 +49213,8 @@ var ts;
             }
             if (!(flags & 131072)) {
                 includes |= flags & 205258751;
+                if (flags & 465829888)
+                    includes |= 33554432;
                 if (type === wildcardType)
                     includes |= 8388608;
                 if (!strictNullChecks && flags & 98304) {
@@ -49400,7 +49407,7 @@ var ts;
                     origin = createOriginUnionOrIntersectionType(1048576, reducedTypes);
                 }
             }
-            var objectFlags = (includes & 468598819 ? 0 : 65536) |
+            var objectFlags = (includes & 36323363 ? 0 : 65536) |
                 (includes & 2097152 ? 33554432 : 0);
             return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
         }
@@ -52260,7 +52267,7 @@ var ts;
                     return true;
             }
             if (source.flags & 524288 && target.flags & 524288) {
-                var related = relation.get(getRelationKey(source, target, 0, relation));
+                var related = relation.get(getRelationKey(source, target, 0, relation, false));
                 if (related !== undefined) {
                     return !!(related & 1);
                 }
@@ -52974,7 +52981,8 @@ var ts;
                 if (overflow) {
                     return 0;
                 }
-                var id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? 16 : 0), relation);
+                var keyIntersectionState = intersectionState | (inPropertyCheck ? 16 : 0);
+                var id = getRelationKey(source, target, keyIntersectionState, relation, false);
                 var entry = relation.get(id);
                 if (entry !== undefined) {
                     if (reportErrors && entry & 2 && !(entry & 4)) {
@@ -52998,12 +53006,9 @@ var ts;
                     targetStack = [];
                 }
                 else {
-                    var broadestEquivalentId = id.split(",").map(function (i) { return i.replace(/-\d+/g, function (_match, offset) {
-                        var index = ts.length(id.slice(0, offset).match(/[-=]/g) || undefined);
-                        return "=" + index;
-                    }); }).join(",");
+                    var broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, keyIntersectionState, relation, true) : undefined;
                     for (var i = 0; i < maybeCount; i++) {
-                        if (id === maybeKeys[i] || broadestEquivalentId === maybeKeys[i]) {
+                        if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
                             return 3;
                         }
                     }
@@ -53245,7 +53250,7 @@ var ts;
                         originalErrorInfo = undefined;
                     }
                 }
-                else if (isGenericMappedType(target)) {
+                else if (isGenericMappedType(target) && relation !== identityRelation) {
                     var keysRemapped = !!target.declaration.nameType;
                     var templateType = getTemplateTypeFromMappedType(target);
                     var modifiers = getMappedTypeModifiers(target);
@@ -54277,40 +54282,48 @@ var ts;
         function isTypeReferenceWithGenericArguments(type) {
             return isNonDeferredTypeReference(type) && ts.some(getTypeArguments(type), function (t) { return !!(t.flags & 262144) || isTypeReferenceWithGenericArguments(t); });
         }
-        function getTypeReferenceId(type, typeParameters, depth) {
-            if (depth === void 0) { depth = 0; }
-            var result = "" + type.target.id;
-            for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) {
-                var t = _a[_i];
-                if (isUnconstrainedTypeParameter(t)) {
-                    var index = typeParameters.indexOf(t);
-                    if (index < 0) {
-                        index = typeParameters.length;
-                        typeParameters.push(t);
+        function getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) {
+            var typeParameters = [];
+            var constraintMarker = "";
+            var sourceId = getTypeReferenceId(source, 0);
+            var targetId = getTypeReferenceId(target, 0);
+            return "" + constraintMarker + sourceId + "," + targetId + postFix;
+            function getTypeReferenceId(type, depth) {
+                if (depth === void 0) { depth = 0; }
+                var result = "" + type.target.id;
+                for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) {
+                    var t = _a[_i];
+                    if (t.flags & 262144) {
+                        if (ignoreConstraints || isUnconstrainedTypeParameter(t)) {
+                            var index = typeParameters.indexOf(t);
+                            if (index < 0) {
+                                index = typeParameters.length;
+                                typeParameters.push(t);
+                            }
+                            result += "=" + index;
+                            continue;
+                        }
+                        constraintMarker = "*";
+                    }
+                    else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
+                        result += "<" + getTypeReferenceId(t, depth + 1) + ">";
+                        continue;
                     }
-                    result += "=" + index;
-                }
-                else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
-                    result += "<" + getTypeReferenceId(t, typeParameters, depth + 1) + ">";
-                }
-                else {
                     result += "-" + t.id;
                 }
+                return result;
             }
-            return result;
         }
-        function getRelationKey(source, target, intersectionState, relation) {
+        function getRelationKey(source, target, intersectionState, relation, ignoreConstraints) {
             if (relation === identityRelation && source.id > target.id) {
                 var temp = source;
                 source = target;
                 target = temp;
             }
             var postFix = intersectionState ? ":" + intersectionState : "";
-            if (isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target)) {
-                var typeParameters = [];
-                return getTypeReferenceId(source, typeParameters) + "," + getTypeReferenceId(target, typeParameters) + postFix;
-            }
-            return source.id + "," + target.id + postFix;
+            return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ?
+                getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) :
+                source.id + "," + target.id + postFix;
         }
         function forEachProperty(prop, callback) {
             if (ts.getCheckFlags(prop) & 6) {
@@ -54349,16 +54362,21 @@ var ts;
                 !hasBaseType(checkClass, getDeclaringClass(p)) : false; }) ? undefined : checkClass;
         }
         function isDeeplyNestedType(type, stack, depth, maxDepth) {
-            if (maxDepth === void 0) { maxDepth = 5; }
+            if (maxDepth === void 0) { maxDepth = 3; }
             if (depth >= maxDepth) {
                 var identity_1 = getRecursionIdentity(type);
                 var count = 0;
+                var lastTypeId = 0;
                 for (var i = 0; i < depth; i++) {
-                    if (getRecursionIdentity(stack[i]) === identity_1) {
-                        count++;
-                        if (count >= maxDepth) {
-                            return true;
+                    var t = stack[i];
+                    if (getRecursionIdentity(t) === identity_1) {
+                        if (t.id >= lastTypeId) {
+                            count++;
+                            if (count >= maxDepth) {
+                                return true;
+                            }
                         }
+                        lastTypeId = t.id;
                     }
                 }
             }
@@ -56182,27 +56200,6 @@ var ts;
             }
             return false;
         }
-        function getPropertyAccess(expr) {
-            if (ts.isAccessExpression(expr)) {
-                return expr;
-            }
-            if (ts.isIdentifier(expr)) {
-                var symbol = getResolvedSymbol(expr);
-                if (isConstVariable(symbol)) {
-                    var declaration = symbol.valueDeclaration;
-                    if (ts.isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && ts.isAccessExpression(declaration.initializer)) {
-                        return declaration.initializer;
-                    }
-                    if (ts.isBindingElement(declaration) && !declaration.initializer) {
-                        var parent = declaration.parent.parent;
-                        if (ts.isVariableDeclaration(parent) && !parent.type && parent.initializer && (ts.isIdentifier(parent.initializer) || ts.isAccessExpression(parent.initializer))) {
-                            return declaration;
-                        }
-                    }
-                }
-            }
-            return undefined;
-        }
         function getAccessedPropertyName(access) {
             var propertyName;
             return access.kind === 205 ? access.name.escapedText :
@@ -57037,20 +57034,21 @@ var ts;
             }
             return false;
         }
-        function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer) {
+        function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer, flowNode) {
             if (initialType === void 0) { initialType = declaredType; }
+            if (flowNode === void 0) { flowNode = reference.flowNode; }
             var key;
             var isKeySet = false;
             var flowDepth = 0;
             if (flowAnalysisDisabled) {
                 return errorType;
             }
-            if (!reference.flowNode) {
+            if (!flowNode) {
                 return declaredType;
             }
             flowInvocationCount++;
             var sharedFlowStart = sharedFlowCount;
-            var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode));
+            var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));
             sharedFlowCount = sharedFlowStart;
             var resultType = ts.getObjectFlags(evolvedType) & 256 && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
             if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 229 && !(resultType.flags & 131072) && getTypeWithFacts(resultType, 2097152).flags & 131072) {
@@ -57407,13 +57405,52 @@ var ts;
                 }
                 return result;
             }
+            function getCandidateDiscriminantPropertyAccess(expr) {
+                if (ts.isBindingPattern(reference)) {
+                    if (ts.isIdentifier(expr)) {
+                        var symbol = getResolvedSymbol(expr);
+                        var declaration = symbol.valueDeclaration;
+                        if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && reference === declaration.parent) {
+                            return declaration;
+                        }
+                    }
+                }
+                else if (ts.isAccessExpression(expr)) {
+                    if (isMatchingReference(reference, expr.expression)) {
+                        return expr;
+                    }
+                }
+                else if (ts.isIdentifier(expr)) {
+                    var symbol = getResolvedSymbol(expr);
+                    if (isConstVariable(symbol)) {
+                        var declaration = symbol.valueDeclaration;
+                        if (ts.isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && ts.isAccessExpression(declaration.initializer) &&
+                            isMatchingReference(reference, declaration.initializer.expression)) {
+                            return declaration.initializer;
+                        }
+                        if (ts.isBindingElement(declaration) && !declaration.initializer) {
+                            var parent = declaration.parent.parent;
+                            if (ts.isVariableDeclaration(parent) && !parent.type && parent.initializer && (ts.isIdentifier(parent.initializer) || ts.isAccessExpression(parent.initializer)) &&
+                                isMatchingReference(reference, parent.initializer)) {
+                                return declaration;
+                            }
+                        }
+                    }
+                }
+                return undefined;
+            }
             function getDiscriminantPropertyAccess(expr, computedType) {
-                var access, name;
                 var type = declaredType.flags & 1048576 ? declaredType : computedType;
-                return type.flags & 1048576 && (access = getPropertyAccess(expr)) && (name = getAccessedPropertyName(access)) &&
-                    isMatchingReference(reference, ts.isAccessExpression(access) ? access.expression : access.parent.parent.initializer) &&
-                    isDiscriminantProperty(type, name) ?
-                    access : undefined;
+                if (type.flags & 1048576) {
+                    var access = getCandidateDiscriminantPropertyAccess(expr);
+                    if (access) {
+                        var name = getAccessedPropertyName(access);
+                        if (name && isDiscriminantProperty(type, name)) {
+                            return access;
+                        }
+                    }
+                }
+                return undefined;
             }
             function narrowTypeByDiscriminant(type, access, narrowType) {
                 var propName = getAccessedPropertyName(access);
@@ -58056,6 +58093,26 @@ var ts;
                 }
             }
         }
+        function getNarrowedTypeOfSymbol(symbol, location) {
+            var declaration = symbol.valueDeclaration;
+            if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
+                var parent = declaration.parent.parent;
+                if (parent.kind === 253 && ts.getCombinedNodeFlags(declaration) & 2 || parent.kind === 163) {
+                    var links = getNodeLinks(location);
+                    if (!(links.flags & 268435456)) {
+                        links.flags |= 268435456;
+                        var parentType = getTypeForBindingElementParent(parent);
+                        links.flags &= ~268435456;
+                        if (parentType && parentType.flags & 1048576 && !(parent.kind === 163 && isSymbolAssigned(symbol))) {
+                            var pattern = declaration.parent;
+                            var narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, undefined, location.flowNode);
+                            return getBindingElementTypeFromParentType(declaration, narrowedType);
+                        }
+                    }
+                }
+            }
+            return getTypeOfSymbol(symbol);
+        }
         function checkIdentifier(node, checkMode) {
             var symbol = getResolvedSymbol(node);
             if (symbol === unknownSymbol) {
@@ -58115,7 +58172,7 @@ var ts;
                 }
             }
             checkNestedBlockScopedBinding(node, symbol);
-            var type = getTypeOfSymbol(localOrExportSymbol);
+            var type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
             var assignmentKind = ts.getAssignmentTargetKind(node);
             if (assignmentKind) {
                 if (!(localOrExportSymbol.flags & 3) &&
@@ -58977,13 +59034,13 @@ var ts;
         function isCircularMappedProperty(symbol) {
             return !!(ts.getCheckFlags(symbol) & 262144 && !symbol.type && findResolutionCycleStartIndex(symbol, 0) >= 0);
         }
-        function getTypeOfPropertyOfContextualType(type, name) {
+        function getTypeOfPropertyOfContextualType(type, name, nameType) {
             return mapType(type, function (t) {
                 var _a;
                 if (isGenericMappedType(t)) {
                     var constraint = getConstraintTypeFromMappedType(t);
                     var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-                    var propertyNameType = getStringLiteralType(ts.unescapeLeadingUnderscores(name));
+                    var propertyNameType = nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name));
                     if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
                         return substituteIndexedMappedType(t, propertyNameType);
                     }
@@ -58999,7 +59056,7 @@ var ts;
                             return restType;
                         }
                     }
-                    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
+                    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
                 }
                 return undefined;
             }, true);
@@ -59020,7 +59077,8 @@ var ts;
             var type = getApparentTypeOfContextualType(objectLiteral, contextFlags);
             if (type) {
                 if (hasBindableName(element)) {
-                    return getTypeOfPropertyOfContextualType(type, getSymbolOfNode(element).escapedName);
+                    var symbol = getSymbolOfNode(element);
+                    return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
                 }
                 if (element.name) {
                     var nameType_2 = getLiteralTypeFromPropertyName(element.name);
@@ -65693,6 +65751,8 @@ var ts;
             if (!typeReferenceNode)
                 return undefined;
             var typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
+            if (!typeParameters)
+                return undefined;
             var constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]);
             return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReferenceNode, typeParameters)));
         }
@@ -69343,8 +69403,11 @@ var ts;
         function checkAssertClause(declaration) {
             var _a;
             if (declaration.assertClause) {
-                if (moduleKind !== ts.ModuleKind.ESNext) {
-                    return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext);
+                var mode = (moduleKind === ts.ModuleKind.NodeNext) && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier);
+                if (mode !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.ESNext) {
+                    return grammarErrorOnNode(declaration.assertClause, moduleKind === ts.ModuleKind.NodeNext
+                        ? ts.Diagnostics.Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls
+                        : ts.Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext);
                 }
                 if (ts.isImportDeclaration(declaration) ? (_a = declaration.importClause) === null || _a === void 0 ? void 0 : _a.isTypeOnly : declaration.isTypeOnly) {
                     return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Import_assertions_cannot_be_used_with_type_only_imports_or_exports);
@@ -72847,11 +72910,11 @@ var ts;
                 return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
             }
             var nodeArguments = node.arguments;
-            if (moduleKind !== ts.ModuleKind.ESNext) {
+            if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.NodeNext) {
                 checkGrammarForDisallowedTrailingComma(nodeArguments);
                 if (nodeArguments.length > 1) {
                     var assertionArgument = nodeArguments[1];
-                    return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext);
+                    return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext);
                 }
             }
             if (nodeArguments.length === 0 || nodeArguments.length > 2) {