@typescript-deploys/pr-build 4.9.0-pr-49929-7 → 4.9.0-pr-50776-2

package/lib/tsserver.js

@@ -109,7 +109,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = "".concat(ts.versionMajorMinor, ".0-insiders.20220919");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-insiders.20220922");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -298,6 +298,11 @@ var ts;
         return result;
     }
     ts.intersperse = intersperse;
+    /**
+     * Iterates through `array` by index and performs the callback on each element of array until the callback
+     * returns a falsey value, then returns false.
+     * If no such value is found, the callback is applied to each element of array and `true` is returned.
+     */
     function every(array, callback) {
         if (array) {
             for (var i = 0; i < array.length; i++) {
@@ -309,10 +314,6 @@ var ts;
         return true;
     }
     ts.every = every;
-    function isArrayOf(array, callback) {
-        return every(array, callback);
-    }
-    ts.isArrayOf = isArrayOf;
     function find(array, predicate, startIndex) {
         if (array === undefined)
             return undefined;
@@ -989,7 +990,6 @@ var ts;
     }
     ts.sum = sum;
     function append(to, value) {
-        // If to is Push<T>, return value is void, so safe to cast to T[].
         if (value === undefined)
             return to;
         if (to === undefined)
@@ -2693,7 +2693,7 @@ var ts;
             if (typeof func !== "function") {
                 return "";
             }
-            else if (func.hasOwnProperty("name")) {
+            else if (ts.hasProperty(func, "name")) {
                 return func.name;
             }
             else {
@@ -3018,7 +3018,7 @@ var ts;
             ];
             for (var _i = 0, nodeConstructors_1 = nodeConstructors; _i < nodeConstructors_1.length; _i++) {
                 var ctor = nodeConstructors_1[_i];
-                if (!ctor.prototype.hasOwnProperty("__debugKind")) {
+                if (!ts.hasProperty(ctor.prototype, "__debugKind")) {
                     Object.defineProperties(ctor.prototype, {
                         // for use with vscode-js-debug's new customDescriptionGenerator in launch.json
                         __tsDebuggerDisplay: {
@@ -3873,7 +3873,6 @@ var ts;
         var typeCatalog = []; // NB: id is index + 1
         var legendPath;
         var legend = [];
-        ;
         /** Starts tracing for the given project. */
         function startTracing(tracingMode, traceDir, configFilePath) {
             ts.Debug.assert(!ts.tracing, "Tracing already started");
@@ -8705,8 +8704,6 @@ var ts;
         The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access: diag(2357, ts.DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access_2357", "The operand of an increment or decrement operator must be a variable or a property access."),
         The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2358, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter."),
         The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: diag(2359, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_F_2359", "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type."),
-        The_left_hand_side_of_an_in_expression_must_be_a_private_identifier_or_of_type_any_string_number_or_symbol: diag(2360, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_in_expression_must_be_a_private_identifier_or_of_type_any_string_number_or__2360", "The left-hand side of an 'in' expression must be a private identifier or of type 'any', 'string', 'number', or 'symbol'."),
-        The_right_hand_side_of_an_in_expression_must_not_be_a_primitive: diag(2361, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_in_expression_must_not_be_a_primitive_2361", "The right-hand side of an 'in' expression must not be a primitive."),
         The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2362, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2362", "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."),
         The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2363, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2363", "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."),
         The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access: diag(2364, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access_2364", "The left-hand side of an assignment expression must be a variable or a property access."),
@@ -8955,6 +8952,7 @@ var ts;
         Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: diag(2635, ts.DiagnosticCategory.Error, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."),
         Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation: diag(2636, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation_2636", "Type '{0}' is not assignable to type '{1}' as implied by variance annotation."),
         Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types: diag(2637, ts.DiagnosticCategory.Error, "Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_t_2637", "Variance annotations are only supported in type aliases for object, function, constructor, and mapped types."),
+        Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator: diag(2638, ts.DiagnosticCategory.Error, "Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operato_2638", "Type '{0}' may represent a primitive value, which is not permitted as the right operand of the 'in' operator."),
         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."),
@@ -9135,6 +9133,7 @@ var ts;
         _0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: diag(2842, ts.DiagnosticCategory.Error, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"),
         We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: diag(2843, ts.DiagnosticCategory.Error, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."),
         Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2844, ts.DiagnosticCategory.Error, "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844", "Type of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
+        This_condition_will_always_return_0: diag(2845, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_2845", "This condition will always return '{0}'."),
         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}'."),
@@ -10077,6 +10076,8 @@ var ts;
         Delete_unused_param_tag_0: diag(95171, ts.DiagnosticCategory.Message, "Delete_unused_param_tag_0_95171", "Delete unused '@param' tag '{0}'"),
         Delete_all_unused_param_tags: diag(95172, ts.DiagnosticCategory.Message, "Delete_all_unused_param_tags_95172", "Delete all unused '@param' tags"),
         Rename_param_tag_name_0_to_1: diag(95173, ts.DiagnosticCategory.Message, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"),
+        Use_0: diag(95174, ts.DiagnosticCategory.Message, "Use_0_95174", "Use `{0}`."),
+        Use_Number_isNaN_in_all_conditions: diag(95175, ts.DiagnosticCategory.Message, "Use_Number_isNaN_in_all_conditions_95175", "Use `Number.isNaN` in all conditions."),
         No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
         Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
         JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -10338,7 +10339,7 @@ var ts;
     ts.stringToToken = stringToToken;
     /* @internal */
     function computeLineStarts(text) {
-        var result = new Array();
+        var result = [];
         var pos = 0;
         var lineStart = 0;
         while (pos < text.length) {
@@ -10815,7 +10816,9 @@ var ts;
     }
     ts.reduceEachTrailingCommentRange = reduceEachTrailingCommentRange;
     function appendCommentRange(pos, end, kind, hasTrailingNewLine, _state, comments) {
-        if (comments === void 0) { comments = []; }
+        if (!comments) {
+            comments = [];
+        }
         comments.push({ kind: kind, pos: pos, end: end, hasTrailingNewLine: hasTrailingNewLine });
         return comments;
     }
@@ -11897,12 +11900,36 @@ var ts;
                             pos++;
                             return token = 0 /* SyntaxKind.Unknown */;
                         }
-                        if (isIdentifierStart(codePointAt(text, pos + 1), languageVersion)) {
+                        var charAfterHash = codePointAt(text, pos + 1);
+                        if (charAfterHash === 92 /* CharacterCodes.backslash */) {
+                            pos++;
+                            var extendedCookedChar_1 = peekExtendedUnicodeEscape();
+                            if (extendedCookedChar_1 >= 0 && isIdentifierStart(extendedCookedChar_1, languageVersion)) {
+                                pos += 3;
+                                tokenFlags |= 8 /* TokenFlags.ExtendedUnicodeEscape */;
+                                tokenValue = "#" + scanExtendedUnicodeEscape() + scanIdentifierParts();
+                                return token = 80 /* SyntaxKind.PrivateIdentifier */;
+                            }
+                            var cookedChar_1 = peekUnicodeEscape();
+                            if (cookedChar_1 >= 0 && isIdentifierStart(cookedChar_1, languageVersion)) {
+                                pos += 6;
+                                tokenFlags |= 1024 /* TokenFlags.UnicodeEscape */;
+                                tokenValue = "#" + String.fromCharCode(cookedChar_1) + scanIdentifierParts();
+                                return token = 80 /* SyntaxKind.PrivateIdentifier */;
+                            }
+                            pos--;
+                        }
+                        if (isIdentifierStart(charAfterHash, languageVersion)) {
                             pos++;
-                            scanIdentifier(codePointAt(text, pos), languageVersion);
+                            // We're relying on scanIdentifier's behavior and adjusting the token kind after the fact.
+                            // Notably absent from this block is the fact that calling a function named "scanIdentifier",
+                            // but identifiers don't include '#', and that function doesn't deal with it at all.
+                            // This works because 'scanIdentifier' tries to reuse source characters and builds up substrings;
+                            // however, it starts at the 'tokenPos' which includes the '#', and will "accidentally" prepend the '#' for us.
+                            scanIdentifier(charAfterHash, languageVersion);
                         }
                         else {
-                            tokenValue = String.fromCharCode(codePointAt(text, pos));
+                            tokenValue = "#";
                             error(ts.Diagnostics.Invalid_character, pos++, charSize(ch));
                         }
                         return token = 80 /* SyntaxKind.PrivateIdentifier */;
@@ -12673,8 +12700,6 @@ var ts;
         return false;
     }
     ts.isEmptyBindingPattern = isEmptyBindingPattern;
-    // TODO(jakebailey): It is very weird that we have BindingElement and ArrayBindingElement;
-    // we should have ObjectBindingElement and ArrayBindingElement, which are both BindingElement.
     function isEmptyBindingElement(node) {
         if (ts.isOmittedExpression(node)) {
             return true;
@@ -12793,10 +12818,7 @@ var ts;
                 node = node.original;
             }
         }
-        if (!node || !nodeTest) {
-            return node;
-        }
-        return nodeTest(node) ? node : undefined;
+        return !nodeTest || nodeTest(node) ? node : undefined;
     }
     ts.getOriginalNode = getOriginalNode;
     function findAncestor(node, callback) {
@@ -13474,7 +13496,7 @@ var ts;
     // Node Arrays
     /* @internal */
     function isNodeArray(array) {
-        return array.hasOwnProperty("pos") && array.hasOwnProperty("end");
+        return ts.hasProperty(array, "pos") && ts.hasProperty(array, "end");
     }
     ts.isNodeArray = isNodeArray;
     // Literals
@@ -13822,13 +13844,6 @@ var ts;
         return false;
     }
     ts.isDeclarationBindingElement = isDeclarationBindingElement;
-    function isBindingOrAssignmentElement(node) {
-        return ts.isVariableDeclaration(node)
-            || ts.isParameter(node)
-            || isObjectBindingOrAssignmentElement(node)
-            || isArrayBindingOrAssignmentElement(node);
-    }
-    ts.isBindingOrAssignmentElement = isBindingOrAssignmentElement;
     /**
      * Determines whether a node is a BindingOrAssignmentPattern
      */
@@ -13877,22 +13892,6 @@ var ts;
     }
     ts.isArrayBindingOrAssignmentPattern = isArrayBindingOrAssignmentPattern;
     /* @internal */
-    function isArrayBindingOrAssignmentElement(node) {
-        switch (node.kind) {
-            case 205 /* SyntaxKind.BindingElement */:
-            case 229 /* SyntaxKind.OmittedExpression */: // Elision
-            case 227 /* SyntaxKind.SpreadElement */: // AssignmentRestElement
-            case 206 /* SyntaxKind.ArrayLiteralExpression */: // ArrayAssignmentPattern
-            case 207 /* SyntaxKind.ObjectLiteralExpression */: // ObjectAssignmentPattern
-            case 79 /* SyntaxKind.Identifier */: // DestructuringAssignmentTarget
-            case 208 /* SyntaxKind.PropertyAccessExpression */: // DestructuringAssignmentTarget
-            case 209 /* SyntaxKind.ElementAccessExpression */: // DestructuringAssignmentTarget
-                return true;
-        }
-        return ts.isAssignmentExpression(node, /*excludeCompoundAssignment*/ true); // AssignmentElement
-    }
-    ts.isArrayBindingOrAssignmentElement = isArrayBindingOrAssignmentElement;
-    /* @internal */
     function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) {
         var kind = node.kind;
         return kind === 208 /* SyntaxKind.PropertyAccessExpression */
@@ -14005,23 +14004,6 @@ var ts;
         }
     }
     ts.isUnaryExpressionWithWrite = isUnaryExpressionWithWrite;
-    /**
-     * See isExpression; not for use in transforms.
-     * @internal
-     */
-    function isLiteralTypeLiteral(node) {
-        node = skipPartiallyEmittedExpressions(node);
-        switch (skipPartiallyEmittedExpressions(node).kind) {
-            case 104 /* SyntaxKind.NullKeyword */:
-            case 110 /* SyntaxKind.TrueKeyword */:
-            case 95 /* SyntaxKind.FalseKeyword */:
-            case 221 /* SyntaxKind.PrefixUnaryExpression */:
-                return true;
-            default:
-                return isLiteralExpression(node);
-        }
-    }
-    ts.isLiteralTypeLiteral = isLiteralTypeLiteral;
     /* @internal */
     /**
      * Determines whether a node is an expression based only on its kind.
@@ -14986,7 +14968,6 @@ var ts;
         return emitNode && emitNode.flags || 0;
     }
     ts.getEmitFlags = getEmitFlags;
-    ;
     function getScriptTargetFeatures() {
         return {
             es2015: {
@@ -15301,7 +15282,6 @@ var ts;
     }
     ts.isBlockScope = isBlockScope;
     function isDeclarationWithTypeParameters(node) {
-        ts.Debug.type(node);
         switch (node.kind) {
             case 341 /* SyntaxKind.JSDocCallbackTag */:
             case 348 /* SyntaxKind.JSDocTypedefTag */:
@@ -15314,7 +15294,6 @@ var ts;
     }
     ts.isDeclarationWithTypeParameters = isDeclarationWithTypeParameters;
     function isDeclarationWithTypeParameterChildren(node) {
-        ts.Debug.type(node);
         switch (node.kind) {
             case 176 /* SyntaxKind.CallSignature */:
             case 177 /* SyntaxKind.ConstructSignature */:
@@ -17773,10 +17752,6 @@ var ts;
         return node.escapedText === "push" || node.escapedText === "unshift";
     }
     ts.isPushOrUnshiftIdentifier = isPushOrUnshiftIdentifier;
-    // TODO(jakebailey): this function should not be named this. While it does technically
-    // return true if the argument is a ParameterDeclaration, it also returns true for nodes
-    // that are children of ParameterDeclarations inside binding elements.
-    // Probably, this should be called `rootDeclarationIsParameter`.
     function isParameterDeclaration(node) {
         var root = getRootDeclaration(node);
         return root.kind === 166 /* SyntaxKind.Parameter */;
@@ -19718,7 +19693,7 @@ var ts;
     }
     function isWatchSet(options) {
         // Firefox has Object.prototype.watch
-        return options.watch && options.hasOwnProperty("watch");
+        return options.watch && ts.hasProperty(options, "watch");
     }
     ts.isWatchSet = isWatchSet;
     function closeFileWatcher(watcher) {
@@ -19966,7 +19941,6 @@ var ts;
             || kind === 114 /* SyntaxKind.VoidKeyword */
             || kind === 155 /* SyntaxKind.UndefinedKeyword */
             || kind === 144 /* SyntaxKind.NeverKeyword */
-            || kind === 139 /* SyntaxKind.IntrinsicKeyword */
             || kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */
             || kind === 315 /* SyntaxKind.JSDocAllType */
             || kind === 316 /* SyntaxKind.JSDocUnknownType */
@@ -22278,11 +22252,6 @@ var ts;
         }
     }
     ts.createParenthesizerRules = createParenthesizerRules;
-    function castToNodeArray(nodes) {
-        // TODO(jakebailey): Why do we need this helper? GH#49924?
-        // Also, why can't I write `isNodeArray<T>` as an expression?
-        return ts.cast(nodes, ts.isNodeArray);
-    }
     ts.nullParenthesizerRules = {
         getParenthesizeLeftSideOfBinaryForOperator: function (_) { return ts.identity; },
         getParenthesizeRightSideOfBinaryForOperator: function (_) { return ts.identity; },
@@ -22296,23 +22265,23 @@ var ts;
         parenthesizeLeftSideOfAccess: function (expression) { return ts.cast(expression, ts.isLeftHandSideExpression); },
         parenthesizeOperandOfPostfixUnary: function (operand) { return ts.cast(operand, ts.isLeftHandSideExpression); },
         parenthesizeOperandOfPrefixUnary: function (operand) { return ts.cast(operand, ts.isUnaryExpression); },
-        parenthesizeExpressionsOfCommaDelimitedList: castToNodeArray,
+        parenthesizeExpressionsOfCommaDelimitedList: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
         parenthesizeExpressionForDisallowedComma: ts.identity,
         parenthesizeExpressionOfExpressionStatement: ts.identity,
         parenthesizeConciseBodyOfArrowFunction: ts.identity,
         parenthesizeCheckTypeOfConditionalType: ts.identity,
         parenthesizeExtendsTypeOfConditionalType: ts.identity,
-        parenthesizeConstituentTypesOfUnionType: castToNodeArray,
+        parenthesizeConstituentTypesOfUnionType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
         parenthesizeConstituentTypeOfUnionType: ts.identity,
-        parenthesizeConstituentTypesOfIntersectionType: castToNodeArray,
+        parenthesizeConstituentTypesOfIntersectionType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
         parenthesizeConstituentTypeOfIntersectionType: ts.identity,
         parenthesizeOperandOfTypeOperator: ts.identity,
         parenthesizeOperandOfReadonlyTypeOperator: ts.identity,
         parenthesizeNonArrayTypeOfPostfixType: ts.identity,
-        parenthesizeElementTypesOfTupleType: castToNodeArray,
+        parenthesizeElementTypesOfTupleType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); },
         parenthesizeElementTypeOfTupleType: ts.identity,
         parenthesizeTypeOfOptionalType: ts.identity,
-        parenthesizeTypeArguments: function (nodes) { return nodes && castToNodeArray(nodes); },
+        parenthesizeTypeArguments: function (nodes) { return nodes && ts.cast(nodes, ts.isNodeArray); },
         parenthesizeLeadingTypeArgument: ts.identity,
     };
 })(ts || (ts = {}));
@@ -27009,7 +26978,7 @@ var ts;
             clone.transformFlags = node.transformFlags;
             setOriginalNode(clone, node);
             for (var key in node) {
-                if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
+                if (ts.hasProperty(clone, key) || !ts.hasProperty(node, key)) {
                     continue;
                 }
                 clone[key] = node[key];
@@ -31897,7 +31866,6 @@ var ts;
             visitNodes(cbNode, cbNodes, node.parameters) ||
             visitNode(cbNode, node.type);
     }
-    ;
     function forEachChildInUnionOrIntersectionType(node, cbNode, cbNodes) {
         return visitNodes(cbNode, cbNodes, node.types);
     }
@@ -33199,7 +33167,7 @@ var ts;
         }
         function parsePrivateIdentifier() {
             var pos = getNodePos();
-            var node = factory.createPrivateIdentifier(internPrivateIdentifier(scanner.getTokenText()));
+            var node = factory.createPrivateIdentifier(internPrivateIdentifier(scanner.getTokenValue()));
             nextToken();
             return finishNode(node, pos);
         }
@@ -39297,8 +39265,8 @@ var ts;
                 }
             }
         }
-        function moveElementEntirelyPastChangeRange(element, delta, oldText, newText, aggressiveChecks) {
-            if (ts.isArray(element)) {
+        function moveElementEntirelyPastChangeRange(element, isArray, delta, oldText, newText, aggressiveChecks) {
+            if (isArray) {
                 visitArray(element);
             }
             else {
@@ -39306,7 +39274,6 @@ var ts;
             }
             return;
             function visitNode(node) {
-                ts.Debug.type(node);
                 var text = "";
                 if (aggressiveChecks && shouldCheckNode(node)) {
                     text = oldText.substring(node.pos, node.end);
@@ -39330,7 +39297,6 @@ var ts;
                 checkNodePositions(node, aggressiveChecks);
             }
             function visitArray(array) {
-                ts.Debug.type(array);
                 array._children = undefined;
                 ts.setTextRangePosEnd(array, array.pos + delta, array.end + delta);
                 for (var _i = 0, array_9 = array; _i < array_9.length; _i++) {
@@ -39436,12 +39402,11 @@ var ts;
             visitNode(sourceFile);
             return;
             function visitNode(child) {
-                ts.Debug.type(child);
                 ts.Debug.assert(child.pos <= child.end);
                 if (child.pos > changeRangeOldEnd) {
                     // Node is entirely past the change range.  We need to move both its pos and
                     // end, forward or backward appropriately.
-                    moveElementEntirelyPastChangeRange(child, delta, oldText, newText, aggressiveChecks);
+                    moveElementEntirelyPastChangeRange(child, /*isArray*/ false, delta, oldText, newText, aggressiveChecks);
                     return;
                 }
                 // Check if the element intersects the change range.  If it does, then it is not
@@ -39467,12 +39432,11 @@ var ts;
                 ts.Debug.assert(fullEnd < changeStart);
             }
             function visitArray(array) {
-                ts.Debug.type(array);
                 ts.Debug.assert(array.pos <= array.end);
                 if (array.pos > changeRangeOldEnd) {
                     // Array is entirely after the change range.  We need to move it, and move any of
                     // its children.
-                    moveElementEntirelyPastChangeRange(array, delta, oldText, newText, aggressiveChecks);
+                    moveElementEntirelyPastChangeRange(array, /*isArray*/ true, delta, oldText, newText, aggressiveChecks);
                     return;
                 }
                 // Check if the element intersects the change range.  If it does, then it is not
@@ -43074,7 +43038,6 @@ var ts;
         }
     }
     function specToDiagnostic(spec, disallowTrailingRecursion) {
-        ts.Debug.assert(typeof spec === "string");
         if (disallowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) {
             return [ts.Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
         }
@@ -43218,7 +43181,7 @@ var ts;
     function convertCompilerOptionsForTelemetry(opts) {
         var out = {};
         for (var key in opts) {
-            if (opts.hasOwnProperty(key)) {
+            if (ts.hasProperty(opts, key)) {
                 var type = getOptionFromName(key);
                 if (type !== undefined) { // Ignore unknown options
                     out[key] = getOptionValueWithEmptyStrings(opts[key], type);
@@ -45290,6 +45253,7 @@ var ts;
         }
     }
     function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) {
+        var _a;
         var candidate = ts.normalizePath(ts.combinePaths(nodeModulesDirectory, moduleName));
         // First look for a nested package.json, as in `node_modules/foo/bar/package.json`.
         var packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state);
@@ -45304,13 +45268,7 @@ var ts;
                 return withPackageId(packageInfo, fromDirectory);
             }
         }
-        var _a = parsePackageName(moduleName), packageName = _a.packageName, rest = _a.rest;
         var loader = function (extensions, candidate, onlyRecordFailures, state) {
-            var _a;
-            // package exports are higher priority than file/directory lookups (and, if there's exports present, blocks them)
-            if (packageInfo && packageInfo.contents.packageJsonContent.exports && state.features & NodeResolutionFeatures.Exports) {
-                return (_a = loadModuleFromExports(packageInfo, extensions, ts.combinePaths(".", rest), state, cache, redirectedReference)) === null || _a === void 0 ? void 0 : _a.value;
-            }
             var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) ||
                 loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.contents.packageJsonContent, packageInfo && packageInfo.contents.versionPaths);
             if (!pathAndExtension && packageInfo
@@ -45323,19 +45281,24 @@ var ts;
             }
             return withPackageId(packageInfo, pathAndExtension);
         };
-        if (rest !== "") { // If "rest" is empty, we just did this search above.
-            var packageDirectory = ts.combinePaths(nodeModulesDirectory, packageName);
-            // Don't use a "types" or "main" from here because we're not loading the root, but a subdirectory -- just here for the packageId and path mappings.
+        var _b = parsePackageName(moduleName), packageName = _b.packageName, rest = _b.rest;
+        var packageDirectory = ts.combinePaths(nodeModulesDirectory, packageName);
+        if (rest !== "") {
+            // Previous `packageInfo` may have been from a nested package.json; ensure we have the one from the package root now.
             packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
-            if (packageInfo && packageInfo.contents.versionPaths) {
-                if (state.traceEnabled) {
-                    trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, packageInfo.contents.versionPaths.version, ts.version, rest);
-                }
-                var packageDirectoryExists = nodeModulesDirectoryExists && ts.directoryProbablyExists(packageDirectory, state.host);
-                var fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.contents.versionPaths.paths, /*pathPatterns*/ undefined, loader, !packageDirectoryExists, state);
-                if (fromPaths) {
-                    return fromPaths.value;
-                }
+        }
+        // package exports are higher priority than file/directory/typesVersions lookups and (and, if there's exports present, blocks them)
+        if (packageInfo && packageInfo.contents.packageJsonContent.exports && state.features & NodeResolutionFeatures.Exports) {
+            return (_a = loadModuleFromExports(packageInfo, extensions, ts.combinePaths(".", rest), state, cache, redirectedReference)) === null || _a === void 0 ? void 0 : _a.value;
+        }
+        if (rest !== "" && packageInfo && packageInfo.contents.versionPaths) {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, packageInfo.contents.versionPaths.version, ts.version, rest);
+            }
+            var packageDirectoryExists = nodeModulesDirectoryExists && ts.directoryProbablyExists(packageDirectory, state.host);
+            var fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.contents.versionPaths.paths, /*pathPatterns*/ undefined, loader, !packageDirectoryExists, state);
+            if (fromPaths) {
+                return fromPaths.value;
             }
         }
         return loader(extensions, candidate, !nodeModulesDirectoryExists, state);
@@ -49722,7 +49685,8 @@ var ts;
         var emptyTypeLiteralSymbol = createSymbol(2048 /* SymbolFlags.TypeLiteral */, "__type" /* InternalSymbolName.Type */);
         emptyTypeLiteralSymbol.members = ts.createSymbolTable();
         var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-        var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray)]) : unknownType;
+        var unknownEmptyObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
+        var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
         var emptyGenericType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
         emptyGenericType.instantiations = new ts.Map();
         var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
@@ -49836,6 +49800,8 @@ var ts;
         var deferredGlobalOmitSymbol;
         var deferredGlobalAwaitedSymbol;
         var deferredGlobalBigIntType;
+        var deferredGlobalNaNSymbol;
+        var deferredGlobalRecordSymbol;
         var allPotentiallyUnusedIdentifiers = new ts.Map(); // key is file name
         var flowLoopStart = 0;
         var flowLoopCount = 0;
@@ -49920,7 +49886,7 @@ var ts;
                         if (jsxFragmentPragma) {
                             var chosenPragma = ts.isArray(jsxFragmentPragma) ? jsxFragmentPragma[0] : jsxFragmentPragma;
                             file.localJsxFragmentFactory = ts.parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
-                            ts.visitNode(file.localJsxFragmentFactory, markAsSynthetic, ts.isEntityName);
+                            ts.visitNode(file.localJsxFragmentFactory, markAsSynthetic);
                             if (file.localJsxFragmentFactory) {
                                 return file.localJsxFragmentNamespace = ts.getFirstIdentifier(file.localJsxFragmentFactory).escapedText;
                             }
@@ -49965,7 +49931,7 @@ var ts;
             if (jsxPragma) {
                 var chosenPragma = ts.isArray(jsxPragma) ? jsxPragma[0] : jsxPragma;
                 file.localJsxFactory = ts.parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
-                ts.visitNode(file.localJsxFactory, markAsSynthetic, ts.isEntityName);
+                ts.visitNode(file.localJsxFactory, markAsSynthetic);
                 if (file.localJsxFactory) {
                     return file.localJsxNamespace = ts.getFirstIdentifier(file.localJsxFactory).escapedText;
                 }
@@ -51624,7 +51590,6 @@ var ts;
                 return valueSymbol;
             }
             var result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.escapedName);
-            ts.Debug.assert(valueSymbol.declarations || typeSymbol.declarations);
             result.declarations = ts.deduplicate(ts.concatenate(valueSymbol.declarations, typeSymbol.declarations), ts.equateValues);
             result.parent = valueSymbol.parent || typeSymbol.parent;
             if (valueSymbol.valueDeclaration)
@@ -53677,7 +53642,6 @@ var ts;
                 var objectFlags = ts.getObjectFlags(type);
                 if (objectFlags & 4 /* ObjectFlags.Reference */) {
                     ts.Debug.assert(!!(type.flags & 524288 /* TypeFlags.Object */));
-                    ts.Debug.type(type);
                     return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
                 }
                 if (type.flags & 262144 /* TypeFlags.TypeParameter */ || objectFlags & 3 /* ObjectFlags.ClassOrInterface */) {
@@ -55136,7 +55100,7 @@ var ts;
                 }
                 var hadError = false;
                 var file = ts.getSourceFileOfNode(existing);
-                var transformed = ts.visitNode(existing, visitExistingNodeTreeSymbols, ts.isTypeNode);
+                var transformed = ts.visitNode(existing, visitExistingNodeTreeSymbols);
                 if (hadError) {
                     return undefined;
                 }
@@ -55167,7 +55131,7 @@ var ts;
                             var typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText);
                             var overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : undefined;
                             return ts.factory.createPropertySignature(
-                            /*modifiers*/ undefined, name, t.isBracketed || t.typeExpression && ts.isJSDocOptionalType(t.typeExpression.type) ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, overrideTypeNode || (t.typeExpression && ts.visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols, ts.isTypeNode)) || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */));
+                            /*modifiers*/ undefined, name, t.isBracketed || t.typeExpression && ts.isJSDocOptionalType(t.typeExpression.type) ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, overrideTypeNode || (t.typeExpression && ts.visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols)) || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */));
                         }));
                     }
                     if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "") {
@@ -55178,18 +55142,18 @@ var ts;
                             /*modifiers*/ undefined, [ts.factory.createParameterDeclaration(
                                 /*modifiers*/ undefined, 
                                 /*dotdotdotToken*/ undefined, "x", 
-                                /*questionToken*/ undefined, ts.visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols, ts.isTypeNode))], ts.visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols))]);
+                                /*questionToken*/ undefined, ts.visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols))], ts.visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols))]);
                     }
                     if (ts.isJSDocFunctionType(node)) {
                         if (ts.isJSDocConstructSignature(node)) {
                             var newTypeNode_1;
                             return ts.factory.createConstructorTypeNode(
-                            /*modifiers*/ undefined, ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols, ts.isTypeParameterDeclaration), ts.mapDefined(node.parameters, function (p, i) { return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode_1 = p.type, undefined) : ts.factory.createParameterDeclaration(
+                            /*modifiers*/ undefined, ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.mapDefined(node.parameters, function (p, i) { return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode_1 = p.type, undefined) : ts.factory.createParameterDeclaration(
                             /*modifiers*/ undefined, getEffectiveDotDotDotForParameter(p), getNameForJSDocFunctionParameter(p, i), p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), 
                             /*initializer*/ undefined); }), ts.visitNode(newTypeNode_1 || node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */));
                         }
                         else {
-                            return ts.factory.createFunctionTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols, ts.isTypeParameterDeclaration), ts.map(node.parameters, function (p, i) { return ts.factory.createParameterDeclaration(
+                            return ts.factory.createFunctionTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.map(node.parameters, function (p, i) { return ts.factory.createParameterDeclaration(
                             /*modifiers*/ undefined, getEffectiveDotDotDotForParameter(p), getNameForJSDocFunctionParameter(p, i), p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), 
                             /*initializer*/ undefined); }), ts.visitNode(node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */));
                         }
@@ -55515,6 +55479,7 @@ var ts;
                         && symbol.escapedName !== "export=" /* InternalSymbolName.ExportEquals */
                         && !(symbol.flags & 4194304 /* SymbolFlags.Prototype */)
                         && !(symbol.flags & 32 /* SymbolFlags.Class */)
+                        && !(symbol.flags & 8192 /* SymbolFlags.Method */)
                         && !isConstMergedWithNSPrintableAsSignatureMerge) {
                         if (propertyAsAlias) {
                             var createdExport = serializeMaybeAliasAssignment(symbol);
@@ -55644,7 +55609,7 @@ var ts;
                     }
                 }
                 function includePrivateSymbol(symbol) {
-                    if (ts.some(symbol.declarations, ts.isParameter))
+                    if (ts.some(symbol.declarations, ts.isParameterDeclaration))
                         return;
                     ts.Debug.assertIsDefined(deferredPrivatesStack[deferredPrivatesStack.length - 1]);
                     getUnusedName(ts.unescapeLeadingUnderscores(symbol.escapedName), symbol); // Call to cache unique name for symbol
@@ -56031,7 +55996,7 @@ var ts;
                         case 268 /* SyntaxKind.ImportEqualsDeclaration */:
                             // This _specifically_ only exists to handle json declarations - where we make aliases, but since
                             // we emit no declarations for the json document, must not refer to it in the declarations
-                            if (target.escapedName === "export=" /* InternalSymbolName.ExportEquals */ && ts.some(target.declarations, function (d) { return ts.isSourceFile(d) && ts.isJsonSourceFile(d); })) {
+                            if (target.escapedName === "export=" /* InternalSymbolName.ExportEquals */ && ts.some(target.declarations, ts.isJsonSourceFile)) {
                                 serializeMaybeAliasAssignment(symbol);
                                 break;
                             }
@@ -57196,7 +57161,6 @@ var ts;
                     return container;
                 }
             }
-            ;
         }
         /** Create a synthetic property access flow node after the last statement of the file */
         function getFlowTypeFromCommonJSExport(symbol) {
@@ -60326,7 +60290,7 @@ var ts;
                             var isInstantiation = (getTargetSymbol(prop) || prop) === (getTargetSymbol(singleProp) || singleProp);
                             // If the symbols are instances of one another with identical types - consider the symbols
                             // equivalent and just use the first one, which thus allows us to avoid eliding private
-                            // members when intersecting a (this-)instantiations of a class with it's raw base or another instance
+                            // members when intersecting a (this-)instantiations of a class with its raw base or another instance
                             if (isInstantiation && compareProperties(singleProp, prop, function (a, b) { return a === b ? -1 /* Ternary.True */ : 0 /* Ternary.False */; }) === -1 /* Ternary.True */) {
                                 // If we merged instantiations of a generic type, we replicate the symbol parent resetting behavior we used
                                 // to do when we recorded multiple distinct symbols so that we still get, eg, `Array<T>.length` printed
@@ -60374,7 +60338,11 @@ var ts;
                     }
                 }
             }
-            if (!singleProp || isUnion && (propSet || checkFlags & 48 /* CheckFlags.Partial */) && checkFlags & (1024 /* CheckFlags.ContainsPrivate */ | 512 /* CheckFlags.ContainsProtected */)) {
+            if (!singleProp ||
+                isUnion &&
+                    (propSet || checkFlags & 48 /* CheckFlags.Partial */) &&
+                    checkFlags & (1024 /* CheckFlags.ContainsPrivate */ | 512 /* CheckFlags.ContainsProtected */) &&
+                    !(propSet && getCommonDeclarationsOfSymbols(ts.arrayFrom(propSet.values())))) {
                 // No property was found, or, in a union, a property has a private or protected declaration in one
                 // constituent, but is missing or has a different declaration in another constituent.
                 return undefined;
@@ -60476,6 +60444,33 @@ var ts;
             }
             return property;
         }
+        function getCommonDeclarationsOfSymbols(symbols) {
+            var commonDeclarations;
+            var _loop_14 = function (symbol) {
+                if (!symbol.declarations) {
+                    return { value: undefined };
+                }
+                if (!commonDeclarations) {
+                    commonDeclarations = new ts.Set(symbol.declarations);
+                    return "continue";
+                }
+                commonDeclarations.forEach(function (declaration) {
+                    if (!ts.contains(symbol.declarations, declaration)) {
+                        commonDeclarations.delete(declaration);
+                    }
+                });
+                if (commonDeclarations.size === 0) {
+                    return { value: undefined };
+                }
+            };
+            for (var _i = 0, symbols_3 = symbols; _i < symbols_3.length; _i++) {
+                var symbol = symbols_3[_i];
+                var state_4 = _loop_14(symbol);
+                if (typeof state_4 === "object")
+                    return state_4.value;
+            }
+            return commonDeclarations;
+        }
         function getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment) {
             var property = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
             // We need to filter out partial properties in union types
@@ -61190,7 +61185,7 @@ var ts;
         function getIndexInfosOfIndexSymbol(indexSymbol) {
             if (indexSymbol.declarations) {
                 var indexInfos_4 = [];
-                var _loop_14 = function (declaration) {
+                var _loop_15 = function (declaration) {
                     if (declaration.parameters.length === 1) {
                         var parameter = declaration.parameters[0];
                         if (parameter.type) {
@@ -61204,7 +61199,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_14(declaration);
+                    _loop_15(declaration);
                 }
                 return indexInfos_4;
             }
@@ -61221,7 +61216,7 @@ var ts;
             var _a;
             var inferences;
             if ((_a = typeParameter.symbol) === null || _a === void 0 ? void 0 : _a.declarations) {
-                var _loop_15 = function (declaration) {
+                var _loop_16 = function (declaration) {
                     if (declaration.parent.kind === 192 /* SyntaxKind.InferType */) {
                         // When an 'infer T' declaration is immediately contained in a type reference node
                         // (such as 'Foo<infer T>'), T's constraint is inferred from the constraint of the
@@ -61285,7 +61280,7 @@ var ts;
                 };
                 for (var _i = 0, _b = typeParameter.symbol.declarations; _i < _b.length; _i++) {
                     var declaration = _b[_i];
-                    _loop_15(declaration);
+                    _loop_16(declaration);
                 }
             }
             return inferences && getIntersectionType(inferences);
@@ -61942,6 +61937,13 @@ var ts;
         function getGlobalBigIntType() {
             return (deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", /*arity*/ 0, /*reportErrors*/ false))) || emptyObjectType;
         }
+        function getGlobalNaNSymbol() {
+            return (deferredGlobalNaNSymbol || (deferredGlobalNaNSymbol = getGlobalValueSymbol("NaN", /*reportErrors*/ false)));
+        }
+        function getGlobalRecordSymbol() {
+            deferredGlobalRecordSymbol || (deferredGlobalRecordSymbol = getGlobalTypeAliasSymbol("Record", /*arity*/ 2, /*reportErrors*/ true) || unknownSymbol);
+            return deferredGlobalRecordSymbol === unknownSymbol ? undefined : deferredGlobalRecordSymbol;
+        }
         /**
          * Instantiates a global type that is generic with some element type, and returns that instantiation.
          */
@@ -62178,7 +62180,7 @@ var ts;
             var lastRequiredIndex = -1;
             var firstRestIndex = -1;
             var lastOptionalOrRestIndex = -1;
-            var _loop_16 = function (i) {
+            var _loop_17 = function (i) {
                 var type = elementTypes[i];
                 var flags = target.elementFlags[i];
                 if (flags & 8 /* ElementFlags.Variadic */) {
@@ -62208,9 +62210,9 @@ var ts;
                 }
             };
             for (var i = 0; i < elementTypes.length; i++) {
-                var state_4 = _loop_16(i);
-                if (typeof state_4 === "object")
-                    return state_4.value;
+                var state_5 = _loop_17(i);
+                if (typeof state_5 === "object")
+                    return state_5.value;
             }
             // Turn optional elements preceding the last required element into required elements
             for (var i = 0; i < lastRequiredIndex; i++) {
@@ -62238,7 +62240,7 @@ var ts;
                 if (flags & (2 /* ElementFlags.Optional */ | 4 /* ElementFlags.Rest */)) {
                     lastOptionalOrRestIndex = expandedFlags.length;
                 }
-                expandedTypes.push(type);
+                expandedTypes.push(flags & 2 /* ElementFlags.Optional */ ? addOptionality(type, /*isProperty*/ true) : type);
                 expandedFlags.push(flags);
                 if (expandedDeclarations && declaration) {
                     expandedDeclarations.push(declaration);
@@ -62404,7 +62406,7 @@ var ts;
             var templates = ts.filter(types, isPatternLiteralType);
             if (templates.length) {
                 var i = types.length;
-                var _loop_17 = function () {
+                var _loop_18 = function () {
                     i--;
                     var t = types[i];
                     if (t.flags & 128 /* TypeFlags.StringLiteral */ && ts.some(templates, function (template) { return isTypeMatchedByTemplateLiteralType(t, template); })) {
@@ -62412,7 +62414,7 @@ var ts;
                     }
                 };
                 while (i > 0) {
-                    _loop_17();
+                    _loop_18();
                 }
             }
         }
@@ -62489,14 +62491,14 @@ var ts;
                 var namedUnions = [];
                 addNamedUnions(namedUnions, types);
                 var reducedTypes = [];
-                var _loop_18 = function (t) {
+                var _loop_19 = function (t) {
                     if (!ts.some(namedUnions, function (union) { return containsType(union.types, t); })) {
                         reducedTypes.push(t);
                     }
                 };
                 for (var _i = 0, typeSet_1 = typeSet; _i < typeSet_1.length; _i++) {
                     var t = typeSet_1[_i];
-                    _loop_18(t);
+                    _loop_19(t);
                 }
                 if (!aliasSymbol && namedUnions.length === 1 && reducedTypes.length === 0) {
                     return namedUnions[0];
@@ -63726,7 +63728,7 @@ var ts;
             var result;
             var extraTypes;
             var tailCount = 0;
-            var _loop_19 = function () {
+            var _loop_20 = function () {
                 if (tailCount === 1000) {
                     error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
                     result = errorType;
@@ -63847,10 +63849,10 @@ var ts;
             // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive
             // cases we increment the tail recursion counter and stop after 1000 iterations.
             while (true) {
-                var state_5 = _loop_19();
-                if (typeof state_5 === "object")
-                    return state_5.value;
-                if (state_5 === "break")
+                var state_6 = _loop_20();
+                if (typeof state_6 === "object")
+                    return state_6.value;
+                if (state_6 === "break")
                     break;
             }
             return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result;
@@ -66465,7 +66467,7 @@ var ts;
                     reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target);
                     checkTypes = reducedTarget.flags & 1048576 /* TypeFlags.Union */ ? reducedTarget.types : [reducedTarget];
                 }
-                var _loop_20 = function (prop) {
+                var _loop_21 = function (prop) {
                     if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) {
                         if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
                             if (reportErrors) {
@@ -66528,9 +66530,9 @@ var ts;
                 };
                 for (var _i = 0, _b = getPropertiesOfType(source); _i < _b.length; _i++) {
                     var prop = _b[_i];
-                    var state_6 = _loop_20(prop);
-                    if (typeof state_6 === "object")
-                        return state_6.value;
+                    var state_7 = _loop_21(prop);
+                    if (typeof state_7 === "object")
+                        return state_7.value;
                 }
                 return false;
             }
@@ -67521,11 +67523,11 @@ var ts;
                 // constituents of 'target'. If any combination does not have a match then 'source' is not relatable.
                 var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes);
                 var matchingTypes = [];
-                var _loop_21 = function (combination) {
+                var _loop_22 = function (combination) {
                     var hasMatch = false;
                     outer: for (var _c = 0, _d = target.types; _c < _d.length; _c++) {
                         var type = _d[_c];
-                        var _loop_22 = function (i) {
+                        var _loop_23 = function (i) {
                             var sourceProperty = sourcePropertiesFiltered[i];
                             var targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
                             if (!targetProperty)
@@ -67541,8 +67543,8 @@ var ts;
                             }
                         };
                         for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
-                            var state_8 = _loop_22(i);
-                            switch (state_8) {
+                            var state_9 = _loop_23(i);
+                            switch (state_9) {
                                 case "continue-outer": continue outer;
                             }
                         }
@@ -67555,9 +67557,9 @@ var ts;
                 };
                 for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) {
                     var combination = discriminantCombinations_1[_a];
-                    var state_7 = _loop_21(combination);
-                    if (typeof state_7 === "object")
-                        return state_7.value;
+                    var state_8 = _loop_22(combination);
+                    if (typeof state_8 === "object")
+                        return state_8.value;
                 }
                 // Compare the remaining non-discriminant properties of each match.
                 var result = -1 /* Ternary.True */;
@@ -68262,7 +68264,7 @@ var ts;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* tracing.Phase.CheckTypes */, "getVariancesWorker", { arity: typeParameters.length, id: getTypeId(getDeclaredTypeOfSymbol(symbol)) });
                 links.variances = ts.emptyArray;
                 var variances = [];
-                var _loop_23 = function (tp) {
+                var _loop_24 = function (tp) {
                     var modifiers = getVarianceModifiers(tp);
                     var variance = modifiers & 65536 /* ModifierFlags.Out */ ?
                         modifiers & 32768 /* ModifierFlags.In */ ? 0 /* VarianceFlags.Invariant */ : 1 /* VarianceFlags.Covariant */ :
@@ -68300,7 +68302,7 @@ var ts;
                 };
                 for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) {
                     var tp = typeParameters_2[_i];
-                    _loop_23(tp);
+                    _loop_24(tp);
                 }
                 links.variances = variances;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop({ variances: variances.map(ts.Debug.formatVariance) });
@@ -68892,7 +68894,8 @@ var ts;
         function getOptionalType(type, isProperty) {
             if (isProperty === void 0) { isProperty = false; }
             ts.Debug.assert(strictNullChecks);
-            return type.flags & 32768 /* TypeFlags.Undefined */ ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
+            var missingOrUndefined = isProperty ? missingType : undefinedType;
+            return type.flags & 32768 /* TypeFlags.Undefined */ || type.flags & 1048576 /* TypeFlags.Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
         }
         function getGlobalNonNullableTypeInstantiation(type) {
             if (!deferredGlobalNonNullableTypeAlias) {
@@ -70257,7 +70260,7 @@ var ts;
                 // upon instantiation, would collapse all the placeholders to just 'string', and an assignment check might
                 // succeed. That would be a pointless and confusing outcome.
                 if (matches || ts.every(target.texts, function (s) { return s.length === 0; })) {
-                    var _loop_24 = function (i) {
+                    var _loop_25 = function (i) {
                         var source_1 = matches ? matches[i] : neverType;
                         var target_3 = types[i];
                         // If we are inferring from a string literal type to a type variable whose constraint includes one of the
@@ -70307,7 +70310,7 @@ var ts;
                         inferFromTypes(source_1, target_3);
                     };
                     for (var i = 0; i < types.length; i++) {
-                        _loop_24(i);
+                        _loop_25(i);
                     }
                 }
             }
@@ -70771,7 +70774,7 @@ var ts;
                         return name;
                     }
                 }
-                if (ts.hasOnlyExpressionInitializer(declaration)) {
+                if (ts.hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node.argumentExpression)) {
                     var initializer = ts.getEffectiveInitializer(declaration);
                     return initializer && tryGetNameFromType(getTypeOfExpression(initializer));
                 }
@@ -70831,7 +70834,7 @@ var ts;
         function mapTypesByKeyProperty(types, name) {
             var map = new ts.Map();
             var count = 0;
-            var _loop_25 = function (type) {
+            var _loop_26 = function (type) {
                 if (type.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */)) {
                     var discriminant = getTypeOfPropertyOfType(type, name);
                     if (discriminant) {
@@ -70857,9 +70860,9 @@ var ts;
             };
             for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
                 var type = types_15[_i];
-                var state_9 = _loop_25(type);
-                if (typeof state_9 === "object")
-                    return state_9.value;
+                var state_10 = _loop_26(type);
+                if (typeof state_10 === "object")
+                    return state_10.value;
             }
             return count >= 10 && count * 2 >= types.length ? map : undefined;
         }
@@ -72258,18 +72261,26 @@ var ts;
             }
             function isTypePresencePossible(type, propName, assumeTrue) {
                 var prop = getPropertyOfType(type, propName);
-                if (prop) {
-                    return prop.flags & 16777216 /* SymbolFlags.Optional */ ? true : assumeTrue;
-                }
-                return getApplicableIndexInfoForName(type, propName) ? true : !assumeTrue;
-            }
-            function narrowByInKeyword(type, name, assumeTrue) {
-                if (type.flags & 1048576 /* TypeFlags.Union */
-                    || type.flags & 524288 /* TypeFlags.Object */ && declaredType !== type && !(declaredType === unknownType && isEmptyAnonymousObjectType(type))
-                    || ts.isThisTypeParameter(type)
-                    || type.flags & 2097152 /* TypeFlags.Intersection */ && ts.every(type.types, function (t) { return t.symbol !== globalThisSymbol; })) {
+                return prop ?
+                    !!(prop.flags & 16777216 /* SymbolFlags.Optional */) || assumeTrue :
+                    !!getApplicableIndexInfoForName(type, propName) || !assumeTrue;
+            }
+            function narrowByInKeyword(type, nameType, assumeTrue) {
+                var name = getPropertyNameFromType(nameType);
+                var isKnownProperty = someType(type, function (t) { return isTypePresencePossible(t, name, /*assumeTrue*/ true); });
+                if (isKnownProperty) {
+                    // If the check is for a known property (i.e. a property declared in some constituent of
+                    // the target type), we filter the target type by presence of absence of the property.
                     return filterType(type, function (t) { return isTypePresencePossible(t, name, assumeTrue); });
                 }
+                if (assumeTrue) {
+                    // If the check is for an unknown property, we intersect the target type with `Record<X, unknown>`,
+                    // where X is the name of the property.
+                    var recordSymbol = getGlobalRecordSymbol();
+                    if (recordSymbol) {
+                        return getIntersectionType([type, getTypeAliasInstantiation(recordSymbol, [nameType, unknownType])]);
+                    }
+                }
                 return type;
             }
             function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
@@ -72328,15 +72339,14 @@ var ts;
                             return narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue);
                         }
                         var target = getReferenceCandidate(expr.right);
-                        var leftType = getTypeOfNode(expr.left);
-                        if (leftType.flags & 128 /* TypeFlags.StringLiteral */) {
-                            var name = ts.escapeLeadingUnderscores(leftType.value);
+                        var leftType = getTypeOfExpression(expr.left);
+                        if (leftType.flags & 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */) {
                             if (containsMissingType(type) && ts.isAccessExpression(reference) && isMatchingReference(reference.expression, target) &&
-                                getAccessedPropertyName(reference) === name) {
+                                getAccessedPropertyName(reference) === getPropertyNameFromType(leftType)) {
                                 return getTypeWithFacts(type, assumeTrue ? 524288 /* TypeFacts.NEUndefined */ : 65536 /* TypeFacts.EQUndefined */);
                             }
                             if (isMatchingReference(reference, target)) {
-                                return narrowByInKeyword(type, name, assumeTrue);
+                                return narrowByInKeyword(type, leftType, assumeTrue);
                             }
                         }
                         break;
@@ -74598,7 +74608,7 @@ var ts;
                     return left === right || !left ? left
                         : compareTypeParametersIdentical(left.typeParameters, right.typeParameters) ? combineSignaturesOfIntersectionMembers(left, right)
                             : undefined;
-                }) // TODO(jakebailey): This is suspect. Can't pass initialValue as reduceLeft checks argument length.
+                })
                 : undefined;
         }
         function combineIntersectionThisParam(left, right, mapper) {
@@ -76506,7 +76516,6 @@ var ts;
                 }
                 return false;
             }
-            ;
             var suggestedMethod = ts.isAssignmentTarget(expr) ? "set" : "get";
             if (!hasProp(suggestedMethod)) {
                 return undefined;
@@ -77308,7 +77317,7 @@ var ts;
             if (spreadIndex >= 0) {
                 // Create synthetic arguments from spreads of tuple types.
                 var effectiveArgs_1 = args.slice(0, spreadIndex);
-                var _loop_26 = function (i) {
+                var _loop_27 = function (i) {
                     var arg = args[i];
                     // We can call checkExpressionCached because spread expressions never have a contextual type.
                     var spreadType = arg.kind === 227 /* SyntaxKind.SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
@@ -77325,7 +77334,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_26(i);
+                    _loop_27(i);
                 }
                 return effectiveArgs_1;
             }
@@ -77654,7 +77663,7 @@ var ts;
                         var min_3 = Number.MAX_VALUE;
                         var minIndex = 0;
                         var i_1 = 0;
-                        var _loop_27 = function (c) {
+                        var _loop_28 = function (c) {
                             var chain_2 = function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); };
                             var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* CheckMode.Normal */, /*reportErrors*/ true, chain_2);
                             if (diags_2) {
@@ -77672,7 +77681,7 @@ var ts;
                         };
                         for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
                             var c = candidatesForArgumentError_1[_a];
-                            _loop_27(c);
+                            _loop_28(c);
                         }
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
@@ -77830,7 +77839,7 @@ var ts;
             }
             var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
             var parameters = [];
-            var _loop_28 = function (i) {
+            var _loop_29 = function (i) {
                 var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ?
                     i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) :
                     i < s.parameters.length ? s.parameters[i] : undefined; });
@@ -77838,7 +77847,7 @@ var ts;
                 parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
             };
             for (var i = 0; i < maxNonRestParam; i++) {
-                _loop_28(i);
+                _loop_29(i);
             }
             var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
             var flags = 0 /* SignatureFlags.None */;
@@ -80077,6 +80086,9 @@ var ts;
             }
             return booleanType;
         }
+        function hasEmptyObjectIntersection(type) {
+            return someType(type, function (t) { return t === unknownEmptyObjectType || !!(t.flags & 2097152 /* TypeFlags.Intersection */) && ts.some(t.types, isEmptyAnonymousObjectType); });
+        }
         function checkInExpression(left, right, leftType, rightType) {
             if (leftType === silentNeverType || rightType === silentNeverType) {
                 return silentNeverType;
@@ -80093,40 +80105,20 @@ var ts;
                 }
             }
             else {
-                leftType = checkNonNullType(leftType, left);
-                // TypeScript 1.0 spec (April 2014): 4.15.5
-                // Require the left operand to be of type Any, the String primitive type, or the Number primitive type.
-                if (!(allTypesAssignableToKind(leftType, 402653316 /* TypeFlags.StringLike */ | 296 /* TypeFlags.NumberLike */ | 12288 /* TypeFlags.ESSymbolLike */) ||
-                    isTypeAssignableToKind(leftType, 4194304 /* TypeFlags.Index */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */ | 262144 /* TypeFlags.TypeParameter */))) {
-                    error(left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_a_private_identifier_or_of_type_any_string_number_or_symbol);
+                // The type of the lef operand must be assignable to string, number, or symbol.
+                checkTypeAssignableTo(checkNonNullType(leftType, left), stringNumberSymbolType, left);
+            }
+            // The type of the right operand must be assignable to 'object'.
+            if (checkTypeAssignableTo(checkNonNullType(rightType, right), nonPrimitiveType, right)) {
+                // The {} type is assignable to the object type, yet {} might represent a primitive type. Here we
+                // detect and error on {} that results from narrowing the unknown type, as well as intersections
+                // that include {} (we know that the other types in such intersections are assignable to object
+                // since we already checked for that).
+                if (hasEmptyObjectIntersection(rightType)) {
+                    error(right, ts.Diagnostics.Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator, typeToString(rightType));
                 }
             }
-            rightType = checkNonNullType(rightType, right);
-            // TypeScript 1.0 spec (April 2014): 4.15.5
-            // The in operator requires the right operand to be
-            //
-            //   1. assignable to the non-primitive type,
-            //   2. an unconstrained type parameter,
-            //   3. a union or intersection including one or more type parameters, whose constituents are all assignable to the
-            //      the non-primitive type, or are unconstrainted type parameters, or have constraints assignable to the
-            //      non-primitive type, or
-            //   4. a type parameter whose constraint is
-            //      i. an object type,
-            //     ii. the non-primitive type, or
-            //    iii. a union or intersection with at least one constituent assignable to an object or non-primitive type.
-            //
-            // The divergent behavior for type parameters and unions containing type parameters is a workaround for type
-            // parameters not being narrowable. If the right operand is a concrete type, we can error if there is any chance
-            // it is a primitive. But if the operand is a type parameter, it cannot be narrowed, so we don't issue an error
-            // unless *all* instantiations would result in an error.
-            //
             // The result is always of the Boolean primitive type.
-            var rightTypeConstraint = getConstraintOfType(rightType);
-            if (!allTypesAssignableToKind(rightType, 67108864 /* TypeFlags.NonPrimitive */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */) ||
-                rightTypeConstraint && (isTypeAssignableToKind(rightType, 3145728 /* TypeFlags.UnionOrIntersection */) && !allTypesAssignableToKind(rightTypeConstraint, 67108864 /* TypeFlags.NonPrimitive */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */) ||
-                    !maybeTypeOfKind(rightTypeConstraint, 67108864 /* TypeFlags.NonPrimitive */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */ | 524288 /* TypeFlags.Object */))) {
-                error(right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_not_be_a_primitive);
-            }
             return booleanType;
         }
         function checkObjectLiteralAssignment(node, sourceType, rightIsThis) {
@@ -80637,6 +80629,7 @@ var ts;
                         var eqType = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */;
                         error(errorNode, ts.Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
                     }
+                    checkNaNEquality(errorNode, operator, left, right);
                     reportOperatorErrorUnless(function (left, right) { return isTypeEqualityComparableTo(left, right) || isTypeEqualityComparableTo(right, left); });
                     return booleanType;
                 case 102 /* SyntaxKind.InstanceOfKeyword */:
@@ -80842,6 +80835,26 @@ var ts;
                         return undefined;
                 }
             }
+            function checkNaNEquality(errorNode, operator, left, right) {
+                var isLeftNaN = isGlobalNaN(ts.skipParentheses(left));
+                var isRightNaN = isGlobalNaN(ts.skipParentheses(right));
+                if (isLeftNaN || isRightNaN) {
+                    var err = error(errorNode, ts.Diagnostics.This_condition_will_always_return_0, ts.tokenToString(operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */ || operator === 34 /* SyntaxKind.EqualsEqualsToken */ ? 95 /* SyntaxKind.FalseKeyword */ : 110 /* SyntaxKind.TrueKeyword */));
+                    if (isLeftNaN && isRightNaN)
+                        return;
+                    var operatorString = operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */ ? ts.tokenToString(53 /* SyntaxKind.ExclamationToken */) : "";
+                    var location = isLeftNaN ? right : left;
+                    var expression = ts.skipParentheses(location);
+                    ts.addRelatedInfo(err, ts.createDiagnosticForNode(location, ts.Diagnostics.Did_you_mean_0, "".concat(operatorString, "Number.isNaN(").concat(ts.isEntityNameExpression(expression) ? ts.entityNameToString(expression) : "...", ")")));
+                }
+            }
+            function isGlobalNaN(expr) {
+                if (ts.isIdentifier(expr) && expr.escapedText === "NaN") {
+                    var globalNaNSymbol = getGlobalNaNSymbol();
+                    return !!globalNaNSymbol && globalNaNSymbol === getResolvedSymbol(expr);
+                }
+                return false;
+            }
         }
         function getBaseTypesIfUnrelated(leftType, rightType, isRelated) {
             var effectiveLeft = leftType;
@@ -81879,7 +81892,7 @@ var ts;
             var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
             if (indexSymbol === null || indexSymbol === void 0 ? void 0 : indexSymbol.declarations) {
                 var indexSignatureMap_1 = new ts.Map();
-                var _loop_29 = function (declaration) {
+                var _loop_30 = function (declaration) {
                     if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
                         forEachType(getTypeFromTypeNode(declaration.parameters[0].type), function (type) {
                             var entry = indexSignatureMap_1.get(getTypeId(type));
@@ -81894,7 +81907,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_29(declaration);
+                    _loop_30(declaration);
                 }
                 indexSignatureMap_1.forEach(function (entry) {
                     if (entry.declarations.length > 1) {
@@ -85494,7 +85507,7 @@ var ts;
             var propDeclaration = declaration && declaration.kind === 223 /* SyntaxKind.BinaryExpression */ ||
                 name && name.kind === 164 /* SyntaxKind.ComputedPropertyName */ ? declaration : undefined;
             var localPropDeclaration = getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
-            var _loop_30 = function (info) {
+            var _loop_31 = function (info) {
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
                 // We check only when (a) the property is declared in the containing type, or (b) the applicable index signature is declared
                 // in the containing type, or (c) the containing type is an interface and no base interface contains both the property and
@@ -85511,7 +85524,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
                 var info = indexInfos_9[_i];
-                _loop_30(info);
+                _loop_31(info);
             }
         }
         function checkIndexConstraintForIndexSignature(type, checkInfo) {
@@ -85519,7 +85532,7 @@ var ts;
             var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* ObjectFlags.Interface */ ? ts.getDeclarationOfKind(type.symbol, 261 /* SyntaxKind.InterfaceDeclaration */) : undefined;
             var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined;
-            var _loop_31 = function (info) {
+            var _loop_32 = function (info) {
                 if (info === checkInfo)
                     return "continue";
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
@@ -85534,7 +85547,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
                 var info = indexInfos_10[_i];
-                _loop_31(info);
+                _loop_32(info);
             }
         }
         function checkTypeNameIsReserved(name, message) {
@@ -85854,7 +85867,7 @@ var ts;
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
             var baseStaticType = getBaseConstructorTypeOfClass(type);
-            var _loop_32 = function (member) {
+            var _loop_33 = function (member) {
                 if (ts.hasAmbientModifier(member)) {
                     return "continue";
                 }
@@ -85871,7 +85884,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_32(member);
+                _loop_33(member);
             }
         }
         /**
@@ -85959,7 +85972,7 @@ var ts;
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
             var issuedMemberError = false;
-            var _loop_33 = function (member) {
+            var _loop_34 = function (member) {
                 if (ts.isStatic(member)) {
                     return "continue";
                 }
@@ -85978,7 +85991,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_33(member);
+                _loop_34(member);
             }
             if (!issuedMemberError) {
                 // check again with diagnostics to generate a less-specific error
@@ -86049,7 +86062,7 @@ var ts;
             var _a, _b, _c, _d;
             // NOTE: assignability is checked in checkClassDeclaration
             var baseProperties = getPropertiesOfType(baseType);
-            var _loop_34 = function (baseProperty) {
+            var _loop_35 = function (baseProperty) {
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 4194304 /* SymbolFlags.Prototype */) {
                     return "continue";
@@ -86159,8 +86172,8 @@ var ts;
             };
             basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
                 var baseProperty = baseProperties_1[_i];
-                var state_10 = _loop_34(baseProperty);
-                switch (state_10) {
+                var state_11 = _loop_35(baseProperty);
+                switch (state_11) {
                     case "continue-basePropertyCheck": continue basePropertyCheck;
                 }
             }
@@ -91136,27 +91149,17 @@ var ts;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
-    // TODO(jakebailey): include type guard and non-type guard variants on visitNode and visitNodes
     var _a;
-    /**
-     * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
-     *
-     * @param node The Node to visit.
-     * @param visitor The callback used to visit the Node.
-     * @param test A callback to execute to verify the Node is valid.
-     * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
-     */
     function visitNode(node, visitor, test, lift) {
-        if (node === undefined) {
-            // If the input type is undefined, then the output type can be undefined.
+        if (node === undefined || visitor === undefined) {
+            return node;
+        }
+        var visited = visitor(node);
+        if (visited === node) {
             return node;
         }
-        var visited = visitor ? visitor(node) : node;
         var visitedNode;
         if (visited === undefined) {
-            // If the visited node is undefined, then the visitor must have returned undefined,
-            // so the visitor must have been declared as able to return undefined, so TOut must be
-            // potentially undefined.
             return undefined;
         }
         else if (ts.isArray(visited)) {
@@ -91169,7 +91172,6 @@ var ts;
         return visitedNode;
     }
     ts.visitNode = visitNode;
-    (function (_) { })(visitNode); // Check that visitNode is a NodeVisitor.
     /**
      * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
      *
@@ -91180,8 +91182,7 @@ var ts;
      * @param count An optional value indicating the maximum number of nodes to visit.
      */
     function visitNodes(nodes, visitor, test, start, count) {
-        if (nodes === undefined) {
-            // If the input type is undefined, then the output type can be undefined.
+        if (nodes === undefined || visitor === undefined) {
             return nodes;
         }
         // Ensure start and count have valid values
@@ -91212,17 +91213,11 @@ var ts;
             ts.setTextRangePosEnd(updatedArray, pos, end);
             return updatedArray;
         }
-        // If we are here, updated === nodes. This means that it's still a NodeArray,
-        // and also that its contents passed the tests in visitArrayWorker, so has contents
-        // of type TOut.
         return nodes;
     }
     ts.visitNodes = visitNodes;
-    (function (_) { })(visitNodes); // Check that visitNode is a NodeVisitor.
-    /* @internal */
     function visitArray(nodes, visitor, test, start, count) {
         if (nodes === undefined) {
-            // If the input type is undefined, then the output type can be undefined.
             return nodes;
         }
         // Ensure start and count have valid values
@@ -91247,7 +91242,7 @@ var ts;
         // Visit each original node.
         for (var i = 0; i < count; i++) {
             var node = nodes[i + start];
-            var visited = node !== undefined ? (visitor ? visitor(node) : node) : undefined;
+            var visited = node !== undefined ? visitor(node) : undefined;
             if (updated !== undefined || visited === undefined || visited !== node) {
                 if (updated === undefined) {
                     // Ensure we have a copy of `nodes`, up to the current index.
@@ -91257,20 +91252,18 @@ var ts;
                     if (ts.isArray(visited)) {
                         for (var _i = 0, visited_1 = visited; _i < visited_1.length; _i++) {
                             var visitedNode = visited_1[_i];
-                            // void Debug.assertNode(visitedNode, test);
+                            void ts.Debug.assertNode(visitedNode, test);
                             updated.push(visitedNode);
                         }
                     }
                     else {
-                        // void Debug.assertNode(visited, test);
+                        void ts.Debug.assertNode(visited, test);
                         updated.push(visited);
                     }
                 }
             }
         }
-        var result = updated !== null && updated !== void 0 ? updated : nodes;
-        ts.Debug.assertEachNode(result, test);
-        return result;
+        return updated !== null && updated !== void 0 ? updated : nodes;
     }
     /**
      * Starts a new lexical environment and visits a statement list, ending the lexical environment
@@ -91291,7 +91284,7 @@ var ts;
         context.startLexicalEnvironment();
         if (nodes) {
             context.setLexicalEnvironmentFlags(1 /* LexicalEnvironmentFlags.InParameters */, true);
-            updated = nodesVisitor(nodes, visitor, ts.isParameter);
+            updated = nodesVisitor(nodes, visitor, ts.isParameterDeclaration);
             // As of ES2015, any runtime execution of that occurs in for a parameter (such as evaluating an
             // initializer or a binding pattern), occurs in its own lexical scope. As a result, any expression
             // that we might transform that introduces a temporary variable would fail as the temporary variable
@@ -91374,7 +91367,6 @@ var ts;
         if (nodeVisitor === void 0) { nodeVisitor = visitNode; }
         context.startBlockScope();
         var updated = nodeVisitor(body, visitor, ts.isStatement, context.factory.liftToBlock);
-        ts.Debug.assert(updated);
         var declarations = context.endBlockScope();
         if (ts.some(declarations)) {
             if (ts.isBlock(updated)) {
@@ -91414,23 +91406,23 @@ var ts;
             return context.factory.updateTypeParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.constraint, visitor, ts.isTypeNode), nodeVisitor(node.default, visitor, ts.isTypeNode));
         },
         _a[166 /* SyntaxKind.Parameter */] = function visitEachChildOfParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
-            return context.factory.updateParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), ts.Debug.checkDefined(nodeVisitor(node.name, visitor, ts.isBindingName)), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
+            return context.factory.updateParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
         },
         _a[167 /* SyntaxKind.Decorator */] = function visitEachChildOfDecorator(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
             return context.factory.updateDecorator(node, nodeVisitor(node.expression, visitor, ts.isExpression));
         },
         // Type elements
         _a[168 /* SyntaxKind.PropertySignature */] = function visitEachChildOfPropertySignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
-            return context.factory.updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
+            return context.factory.updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
         },
         _a[169 /* SyntaxKind.PropertyDeclaration */] = function visitEachChildOfPropertyDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
             var _a;
-            return context.factory.updatePropertyDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), ts.Debug.checkDefined(nodeVisitor(node.name, visitor, ts.isPropertyName)), 
+            return context.factory.updatePropertyDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), 
             // QuestionToken and ExclamationToken are mutually exclusive in PropertyDeclaration
             nodeVisitor((_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, tokenVisitor, ts.isQuestionOrExclamationToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
         },
         _a[170 /* SyntaxKind.MethodSignature */] = function visitEachChildOfMethodSignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
-            return context.factory.updateMethodSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameter), nodeVisitor(node.type, visitor, ts.isTypeNode));
+            return context.factory.updateMethodSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
         },
         _a[171 /* SyntaxKind.MethodDeclaration */] = function visitEachChildOfMethodDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
             return context.factory.updateMethodDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
@@ -91450,13 +91442,13 @@ var ts;
             return context.factory.updateClassStaticBlockDeclaration(node, visitFunctionBody(node.body, visitor, context, nodeVisitor));
         },
         _a[176 /* SyntaxKind.CallSignature */] = function visitEachChildOfCallSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
-            return context.factory.updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameter), nodeVisitor(node.type, visitor, ts.isTypeNode));
+            return context.factory.updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
         },
         _a[177 /* SyntaxKind.ConstructSignature */] = function visitEachChildOfConstructSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
-            return context.factory.updateConstructSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameter), nodeVisitor(node.type, visitor, ts.isTypeNode));
+            return context.factory.updateConstructSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
         },
         _a[178 /* SyntaxKind.IndexSignature */] = function visitEachChildOfIndexSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
-            return context.factory.updateIndexSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.parameters, visitor, ts.isParameter), nodeVisitor(node.type, visitor, ts.isTypeNode));
+            return context.factory.updateIndexSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
         },
         // Types
         _a[179 /* SyntaxKind.TypePredicate */] = function visitEachChildOfTypePredicateNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
@@ -91466,10 +91458,10 @@ var ts;
             return context.factory.updateTypeReferenceNode(node, nodeVisitor(node.typeName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
         },
         _a[181 /* SyntaxKind.FunctionType */] = function visitEachChildOfFunctionTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
-            return context.factory.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameter), nodeVisitor(node.type, visitor, ts.isTypeNode));
+            return context.factory.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
         },
         _a[182 /* SyntaxKind.ConstructorType */] = function visitEachChildOfConstructorTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
-            return context.factory.updateConstructorTypeNode(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameter), nodeVisitor(node.type, visitor, ts.isTypeNode));
+            return context.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));
         },
         _a[183 /* SyntaxKind.TypeQuery */] = function visitEachChildOfTypeQueryNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
             return context.factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
@@ -91523,7 +91515,7 @@ var ts;
             return context.factory.updateMappedTypeNode(node, nodeVisitor(node.readonlyToken, tokenVisitor, ts.isReadonlyKeywordOrPlusOrMinusToken), nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.nameType, visitor, ts.isTypeNode), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionOrPlusOrMinusToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodesVisitor(node.members, visitor, ts.isTypeElement));
         },
         _a[198 /* SyntaxKind.LiteralType */] = function visitEachChildOfLiteralTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
-            return context.factory.updateLiteralTypeNode(node, nodeVisitor(node.literal, visitor, ts.isLiteralTypeLiteral));
+            return context.factory.updateLiteralTypeNode(node, nodeVisitor(node.literal, visitor, ts.isExpression));
         },
         _a[200 /* SyntaxKind.TemplateLiteralType */] = function visitEachChildOfTemplateLiteralType(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
             return context.factory.updateTemplateLiteralType(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateLiteralTypeSpan));
@@ -93013,7 +93005,6 @@ var ts;
         };
         if (value) {
             value = ts.visitNode(value, visitor, ts.isExpression);
-            ts.Debug.assert(value);
             if (ts.isIdentifier(value) && bindingOrAssignmentElementAssignsToName(node, value.escapedText) ||
                 bindingOrAssignmentElementContainsNonLiteralComputedName(node)) {
                 // If the right-hand value of the assignment is also an assignment target then
@@ -93240,7 +93231,7 @@ var ts;
                     && !(element.transformFlags & (32768 /* TransformFlags.ContainsRestOrSpread */ | 65536 /* TransformFlags.ContainsObjectRestOrSpread */))
                     && !(ts.getTargetOfBindingOrAssignmentElement(element).transformFlags & (32768 /* TransformFlags.ContainsRestOrSpread */ | 65536 /* TransformFlags.ContainsObjectRestOrSpread */))
                     && !ts.isComputedPropertyName(propertyName)) {
-                    bindingElements = ts.append(bindingElements, ts.visitNode(element, flattenContext.visitor, ts.isBindingOrAssignmentElement));
+                    bindingElements = ts.append(bindingElements, ts.visitNode(element, flattenContext.visitor));
                 }
                 else {
                     if (bindingElements) {
@@ -93421,7 +93412,6 @@ var ts;
         return factory.createArrayBindingPattern(elements);
     }
     function makeArrayAssignmentPattern(factory, elements) {
-        ts.Debug.assertEachNode(elements, ts.isArrayBindingOrAssignmentElement);
         return factory.createArrayLiteralExpression(ts.map(elements, factory.converters.convertToArrayAssignmentElement));
     }
     function makeObjectBindingPattern(factory, elements) {
@@ -93429,7 +93419,6 @@ var ts;
         return factory.createObjectBindingPattern(elements);
     }
     function makeObjectAssignmentPattern(factory, elements) {
-        ts.Debug.assertEachNode(elements, ts.isObjectBindingOrAssignmentElement);
         return factory.createObjectLiteralExpression(ts.map(elements, factory.converters.convertToObjectAssignmentElement));
     }
     function makeBindingElement(factory, name) {
@@ -93450,7 +93439,6 @@ var ts;
     function processTaggedTemplateExpression(context, node, visitor, currentSourceFile, recordTaggedTemplateString, level) {
         // Visit the tag expression
         var tag = ts.visitNode(node.tag, visitor, ts.isExpression);
-        ts.Debug.assert(tag);
         // Build up the template arguments and the raw and cooked strings for the template.
         // We start out with 'undefined' for the first argument and revisit later
         // to avoid walking over the template string twice and shifting all our arguments over after the fact.
@@ -94016,7 +94004,7 @@ var ts;
             return factory.updateSourceFile(node, ts.visitLexicalEnvironment(node.statements, sourceElementVisitor, context, /*start*/ 0, alwaysStrict));
         }
         function visitObjectLiteralExpression(node) {
-            return factory.updateObjectLiteralExpression(node, ts.visitNodes(node.properties, getObjectLiteralElementVisitor(node), ts.isObjectLiteralElementLike));
+            return factory.updateObjectLiteralExpression(node, ts.visitNodes(node.properties, getObjectLiteralElementVisitor(node), ts.isObjectLiteralElement));
         }
         function getClassFacts(node, staticProperties) {
             var facts = 0 /* ClassFacts.None */;
@@ -94202,7 +94190,6 @@ var ts;
                 for (var _i = 0, parameterDecorators_1 = parameterDecorators; _i < parameterDecorators_1.length; _i++) {
                     var parameterDecorator = parameterDecorators_1[_i];
                     var expression = ts.visitNode(parameterDecorator.expression, visitor, ts.isExpression);
-                    ts.Debug.assert(expression);
                     var helper = emitHelpers().createParamHelper(expression, parameterOffset);
                     ts.setTextRange(helper, parameterDecorator.expression);
                     ts.setEmitFlags(helper, 1536 /* EmitFlags.NoComments */);
@@ -94345,7 +94332,6 @@ var ts;
             //   - the property has a decorator.
             if (ts.isComputedPropertyName(name) && ((!ts.hasStaticModifier(member) && currentClassHasParameterProperties) || ts.hasDecorators(member))) {
                 var expression = ts.visitNode(name.expression, visitor, ts.isExpression);
-                ts.Debug.assert(expression);
                 var innerExpression = ts.skipPartiallyEmittedExpressions(expression);
                 if (!ts.isSimpleInlineableExpression(innerExpression)) {
                     var generatedName = factory.getGeneratedNameForNode(name);
@@ -94380,7 +94366,7 @@ var ts;
          * @param node The ExpressionWithTypeArguments to transform.
          */
         function visitExpressionWithTypeArguments(node) {
-            return factory.updateExpressionWithTypeArguments(node, ts.Debug.checkDefined(ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression)), 
+            return factory.updateExpressionWithTypeArguments(node, ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression), 
             /*typeArguments*/ undefined);
         }
         /**
@@ -94401,7 +94387,7 @@ var ts;
             var decorators = transformAllDecoratorsOfDeclaration(node, parent, allDecorators);
             // Preserve a `declare x` property with decorators to be handled by the decorators transform
             if (isAmbient) {
-                return factory.updatePropertyDeclaration(node, ts.concatenate(decorators, factory.createModifiersFromModifierFlags(2 /* ModifierFlags.Ambient */)), ts.Debug.checkDefined(ts.visitNode(node.name, visitor, ts.isPropertyName)), 
+                return factory.updatePropertyDeclaration(node, ts.concatenate(decorators, factory.createModifiersFromModifierFlags(2 /* ModifierFlags.Ambient */)), ts.visitNode(node.name, visitor, ts.isPropertyName), 
                 /*questionOrExclamationToken*/ undefined, 
                 /*type*/ undefined, 
                 /*initializer*/ undefined);
@@ -94562,7 +94548,7 @@ var ts;
                 return undefined;
             }
             var updated = factory.updateParameterDeclaration(node, ts.elideNodes(factory, node.modifiers), // preserve positions, if available
-            node.dotDotDotToken, ts.Debug.checkDefined(ts.visitNode(node.name, visitor, ts.isBindingName)), 
+            node.dotDotDotToken, ts.visitNode(node.name, visitor, ts.isBindingName), 
             /*questionToken*/ undefined, 
             /*type*/ undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
             if (updated !== node) {
@@ -94614,7 +94600,6 @@ var ts;
                 // Make sure we consider all nested cast expressions, e.g.:
                 // (<any><number><any>-A).x;
                 var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
-                ts.Debug.assert(expression);
                 // We have an expression of the form: (<Type>SubExpr). Emitting this as (SubExpr)
                 // is really not desirable. We would like to emit the subexpression as-is. Omitting
                 // the parentheses, however, could cause change in the semantics of the generated
@@ -94638,17 +94623,14 @@ var ts;
         }
         function visitAssertionExpression(node) {
             var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
-            ts.Debug.assert(expression);
             return factory.createPartiallyEmittedExpression(expression, node);
         }
         function visitNonNullExpression(node) {
             var expression = ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression);
-            ts.Debug.assert(expression);
             return factory.createPartiallyEmittedExpression(expression, node);
         }
         function visitSatisfiesExpression(node) {
             var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
-            ts.Debug.assert(expression);
             return factory.createPartiallyEmittedExpression(expression, node);
         }
         function visitCallExpression(node) {
@@ -94661,7 +94643,7 @@ var ts;
         }
         function visitTaggedTemplateExpression(node) {
             return factory.updateTaggedTemplateExpression(node, ts.visitNode(node.tag, visitor, ts.isExpression), 
-            /*typeArguments*/ undefined, ts.visitNode(node.template, visitor, ts.isTemplateLiteral));
+            /*typeArguments*/ undefined, ts.visitNode(node.template, visitor, ts.isExpression));
         }
         function visitJsxSelfClosingElement(node) {
             return factory.updateJsxSelfClosingElement(node, ts.visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), 
@@ -95691,7 +95673,6 @@ var ts;
             var info = accessPrivateIdentifier(node.left);
             if (info) {
                 var receiver = ts.visitNode(node.right, visitor, ts.isExpression);
-                ts.Debug.assert(receiver);
                 return ts.setOriginalNode(context.getEmitHelperFactory().createClassPrivateFieldInHelper(info.brandCheckIdentifier, receiver), node);
             }
             // Private name has not been declared. Subsequent transformers will handle this error
@@ -95708,7 +95689,6 @@ var ts;
         }
         function visitComputedPropertyName(node) {
             var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
-            ts.Debug.assert(expression);
             if (ts.some(pendingExpressions)) {
                 if (ts.isParenthesizedExpression(expression)) {
                     expression = factory.updateParenthesizedExpression(expression, factory.inlineExpressions(__spreadArray(__spreadArray([], pendingExpressions, true), [expression.expression], false)));
@@ -95788,7 +95768,6 @@ var ts;
                 var temp = factory.createTempVariable(hoistVariableDeclaration);
                 ts.setSourceMapRange(temp, name.expression);
                 var expression = ts.visitNode(name.expression, visitor, ts.isExpression);
-                ts.Debug.assert(expression);
                 var assignment = factory.createAssignment(temp, expression);
                 ts.setSourceMapRange(assignment, name.expression);
                 getterName = factory.updateComputedPropertyName(name, factory.inlineExpressions([assignment, temp]));
@@ -95939,7 +95918,6 @@ var ts;
                     var info = void 0;
                     if (info = accessPrivateIdentifier(operand.name)) {
                         var receiver = ts.visitNode(operand.expression, visitor, ts.isExpression);
-                        ts.Debug.assert(receiver);
                         var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression;
                         var expression = createPrivateIdentifierAccess(info, readExpression);
                         var temp = ts.isPrefixUnaryExpression(node) || valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration);
@@ -96143,17 +96121,14 @@ var ts;
                                 var superPropertyGet = factory.createReflectGetCall(superClassReference, getterName, classConstructor);
                                 ts.setOriginalNode(superPropertyGet, node.left);
                                 ts.setTextRange(superPropertyGet, node.left);
-                                ts.Debug.assert(expression);
                                 expression = factory.createBinaryExpression(superPropertyGet, ts.getNonAssignmentOperatorForCompoundAssignment(node.operatorToken.kind), expression);
                                 ts.setTextRange(expression, node);
                             }
                             var temp = valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration);
                             if (temp) {
-                                ts.Debug.assert(expression);
                                 expression = factory.createAssignment(temp, expression);
                                 ts.setTextRange(temp, node);
                             }
-                            ts.Debug.assert(expression);
                             expression = factory.createReflectSetCall(superClassReference, setterName, expression, classConstructor);
                             ts.setOriginalNode(expression, node);
                             ts.setTextRange(expression, node);
@@ -96913,7 +96888,6 @@ var ts;
         function getPropertyNameExpressionIfNeeded(name, shouldHoist) {
             if (ts.isComputedPropertyName(name)) {
                 var expression = ts.visitNode(name.expression, visitor, ts.isExpression);
-                ts.Debug.assert(expression);
                 var innerExpression = ts.skipPartiallyEmittedExpressions(expression);
                 var inlinable = ts.isSimpleInlineableExpression(innerExpression);
                 var alreadyTransformed = ts.isAssignmentExpression(innerExpression) && ts.isGeneratedIdentifier(innerExpression.left);
@@ -97237,8 +97211,7 @@ var ts;
                 //
                 // Transformation:
                 // [ { set value(x) { this.#myProp = x; } }.value ] = [ "hello" ];
-                return factory.updateArrayLiteralExpression(node, ts.visitNodes(node.elements, visitArrayAssignmentTarget, ts.isExpression) // TODO(jakebailey): the elements property's type looks to be wrong.
-                );
+                return factory.updateArrayLiteralExpression(node, ts.visitNodes(node.elements, visitArrayAssignmentTarget, ts.isExpression));
             }
             else {
                 // Transforms private names in destructuring assignment object bindings.
@@ -97958,7 +97931,7 @@ var ts;
             /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), ts.visitNodes(node.members, visitor, ts.isClassElement));
         }
         function visitConstructorDeclaration(node) {
-            return factory.updateConstructorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNodes(node.parameters, visitor, ts.isParameter), ts.visitNode(node.body, visitor, ts.isBlock));
+            return factory.updateConstructorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), ts.visitNode(node.body, visitor, ts.isBlock));
         }
         function finishClassElement(updated, original) {
             if (updated !== original) {
@@ -97972,26 +97945,26 @@ var ts;
         function visitMethodDeclaration(node) {
             return finishClassElement(factory.updateMethodDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), 
             /*questionToken*/ undefined, 
-            /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor, ts.isParameter), 
+            /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), 
             /*type*/ undefined, ts.visitNode(node.body, visitor, ts.isBlock)), node);
         }
         function visitGetAccessorDeclaration(node) {
-            return finishClassElement(factory.updateGetAccessorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNodes(node.parameters, visitor, ts.isParameter), 
+            return finishClassElement(factory.updateGetAccessorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), 
             /*type*/ undefined, ts.visitNode(node.body, visitor, ts.isBlock)), node);
         }
         function visitSetAccessorDeclaration(node) {
-            return finishClassElement(factory.updateSetAccessorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNodes(node.parameters, visitor, ts.isParameter), ts.visitNode(node.body, visitor, ts.isBlock)), node);
+            return finishClassElement(factory.updateSetAccessorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), ts.visitNode(node.body, visitor, ts.isBlock)), node);
         }
         function visitPropertyDeclaration(node) {
             if (node.flags & 16777216 /* NodeFlags.Ambient */ || ts.hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */)) {
                 return undefined;
             }
-            return finishClassElement(factory.updatePropertyDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.Debug.checkDefined(ts.visitNode(node.name, visitor, ts.isPropertyName)), 
+            return finishClassElement(factory.updatePropertyDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNode(node.name, visitor, ts.isPropertyName), 
             /*questionOrExclamationToken*/ undefined, 
             /*type*/ undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)), node);
         }
         function visitParameterDeclaration(node) {
-            var updated = factory.updateParameterDeclaration(node, ts.elideNodes(factory, node.modifiers), node.dotDotDotToken, ts.Debug.checkDefined(ts.visitNode(node.name, visitor, ts.isBindingName)), 
+            var updated = factory.updateParameterDeclaration(node, ts.elideNodes(factory, node.modifiers), node.dotDotDotToken, ts.visitNode(node.name, visitor, ts.isBindingName), 
             /*questionToken*/ undefined, 
             /*type*/ undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
             if (updated !== node) {
@@ -98165,7 +98138,7 @@ var ts;
          * @param decorator The decorator node.
          */
         function transformDecorator(decorator) {
-            return ts.Debug.checkDefined(ts.visitNode(decorator.expression, visitor, ts.isExpression));
+            return ts.visitNode(decorator.expression, visitor, ts.isExpression);
         }
         /**
          * Transforms the decorators of a parameter.
@@ -98476,7 +98449,7 @@ var ts;
                 : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitIterationBody(node.statement, asyncBodyVisitor, context));
         }
         function visitForOfStatementInAsyncBody(node) {
-            return factory.updateForOfStatement(node, ts.visitNode(node.awaitModifier, visitor, ts.isAwaitKeyword), isVariableDeclarationListWithCollidingName(node.initializer)
+            return factory.updateForOfStatement(node, ts.visitNode(node.awaitModifier, visitor, ts.isToken), isVariableDeclarationListWithCollidingName(node.initializer)
                 ? visitVariableDeclarationListWithCollidingNames(node.initializer, /*hasReceiver*/ true)
                 : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitIterationBody(node.statement, asyncBodyVisitor, context));
         }
@@ -98541,7 +98514,7 @@ var ts;
          * @param node The node to visit.
          */
         function visitFunctionExpression(node) {
-            return factory.updateFunctionExpression(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, node.name, 
+            return factory.updateFunctionExpression(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.asteriskToken, node.name, 
             /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
             /*type*/ undefined, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */
                 ? transformAsyncFunctionBody(node)
@@ -98556,7 +98529,7 @@ var ts;
          * @param node The node to visit.
          */
         function visitArrowFunction(node) {
-            return factory.updateArrowFunction(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), 
+            return factory.updateArrowFunction(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), 
             /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
             /*type*/ undefined, node.equalsGreaterThanToken, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */
                 ? transformAsyncFunctionBody(node)
@@ -98612,7 +98585,7 @@ var ts;
         }
         function transformInitializedVariable(node) {
             var converted = ts.setSourceMapRange(factory.createAssignment(factory.converters.convertToAssignmentElementTarget(node.name), node.initializer), node);
-            return ts.Debug.checkDefined(ts.visitNode(converted, visitor, ts.isExpression));
+            return ts.visitNode(converted, visitor, ts.isExpression);
         }
         function collidesWithParameterName(_a) {
             var name = _a.name;
@@ -99476,7 +99449,7 @@ var ts;
                 ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifierLike)
                 : node.modifiers, enclosingFunctionFlags & 2 /* FunctionFlags.Async */
                 ? undefined
-                : node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNode(/*questionToken*/ undefined, visitor, ts.isQuestionToken), 
+                : node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNode(/*questionToken*/ undefined, visitor, ts.isToken), 
             /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), 
             /*type*/ undefined, enclosingFunctionFlags & 2 /* FunctionFlags.Async */ && enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
                 ? transformAsyncGeneratorFunctionBody(node)
@@ -100365,7 +100338,7 @@ var ts;
             return ts.singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions);
         }
         function transformJsxSpreadAttributeToExpression(node) {
-            return ts.Debug.checkDefined(ts.visitNode(node.expression, visitor, ts.isExpression));
+            return ts.visitNode(node.expression, visitor, ts.isExpression);
         }
         function transformJsxAttributeToObjectLiteralElement(node) {
             var name = getAttributeName(node);
@@ -102033,7 +102006,6 @@ var ts;
             var sourceMapRange = ts.getSourceMapRange(member);
             var memberFunction = transformFunctionLikeToExpression(member, /*location*/ member, /*name*/ undefined, container);
             var propertyName = ts.visitNode(member.name, visitor, ts.isPropertyName);
-            ts.Debug.assert(propertyName);
             var e;
             if (!ts.isPrivateIdentifier(propertyName) && ts.getUseDefineForClassFields(context.getCompilerOptions())) {
                 var name = ts.isComputedPropertyName(propertyName) ? propertyName.expression
@@ -102086,7 +102058,6 @@ var ts;
             ts.setEmitFlags(target, 1536 /* EmitFlags.NoComments */ | 32 /* EmitFlags.NoTrailingSourceMap */);
             ts.setSourceMapRange(target, firstAccessor.name);
             var visitedAccessorName = ts.visitNode(firstAccessor.name, visitor, ts.isPropertyName);
-            ts.Debug.assert(visitedAccessorName);
             if (ts.isPrivateIdentifier(visitedAccessorName)) {
                 return ts.Debug.failBadSyntaxKind(visitedAccessorName, "Encountered unhandled private identifier while transforming ES2015.");
             }
@@ -102361,7 +102332,6 @@ var ts;
                 var visited = ts.visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, ts.isExpression);
                 if (result || visited !== element) {
                     result || (result = node.elements.slice(0, i));
-                    ts.Debug.assert(visited);
                     result.push(visited);
                 }
             }
@@ -102421,7 +102391,6 @@ var ts;
                 var declarations = ts.flatMap(node.declarations, node.flags & 1 /* NodeFlags.Let */
                     ? visitVariableDeclarationInLetDeclarationList
                     : visitVariableDeclaration);
-                ts.Debug.assertEachNode(declarations, ts.isVariableDeclaration); // TODO(jakebailey): side effect of VisitResult.
                 var declarationList = factory.createVariableDeclarationList(declarations);
                 ts.setOriginalNode(declarationList, node);
                 ts.setTextRange(declarationList, node);
@@ -102641,7 +102610,6 @@ var ts;
             }
             else {
                 var statement = ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock);
-                ts.Debug.assert(statement);
                 if (ts.isBlock(statement)) {
                     return factory.updateBlock(statement, ts.setTextRange(factory.createNodeArray(ts.concatenate(statements, statement.statements)), statement.statements));
                 }
@@ -102677,7 +102645,6 @@ var ts;
             // Note also that because an extra statement is needed to assign to the LHS,
             // for-of bodies are always emitted as blocks.
             var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
-            ts.Debug.assert(expression);
             // In the case where the user wrote an identifier as the RHS, like this:
             //
             //     for (let v of arr) { }
@@ -102703,7 +102670,6 @@ var ts;
         }
         function convertForOfStatementForIterable(node, outermostLabeledStatement, convertedLoopBodyStatements, ancestorFacts) {
             var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
-            ts.Debug.assert(expression);
             var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
             var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined);
             var errorRecord = factory.createUniqueName("e");
@@ -103132,7 +103098,6 @@ var ts;
                     statements.push(factory.createIfStatement(factory.createPrefixUnaryExpression(53 /* SyntaxKind.ExclamationToken */, ts.visitNode(node.condition, visitor, ts.isExpression)), ts.visitNode(factory.createBreakStatement(), visitor, ts.isStatement)));
                 }
             }
-            ts.Debug.assert(statement);
             if (ts.isBlock(statement)) {
                 ts.addRange(statements, statement.statements);
             }
@@ -103773,9 +103738,7 @@ var ts;
             return ts.map(chunk, visitExpressionOfSpread);
         }
         function visitExpressionOfSpread(node) {
-            ts.Debug.assertNode(node, ts.isSpreadElement);
             var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
-            ts.Debug.assert(expression);
             // We don't need to pack already packed array literals, or existing calls to the `__read` helper.
             var isCallToReadHelper = ts.isCallToHelper(expression, "___read");
             var kind = isCallToReadHelper || ts.isPackedArrayLiteral(expression) ? 2 /* SpreadSegmentKind.PackedSpread */ : 1 /* SpreadSegmentKind.UnpackedSpread */;
@@ -103843,7 +103806,7 @@ var ts;
             var expression = factory.createStringLiteral(node.head.text);
             for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) {
                 var span = _a[_i];
-                var args = [ts.Debug.checkDefined(ts.visitNode(span.expression, visitor, ts.isExpression))];
+                var args = [ts.visitNode(span.expression, visitor, ts.isExpression)];
                 if (span.literal.text.length > 0) {
                     args.push(factory.createStringLiteral(span.literal.text));
                 }
@@ -104744,7 +104707,7 @@ var ts;
                         //  .yield resumeLabel
                         //  .mark resumeLabel
                         //      _a.b = %sent%;
-                        target = factory.updatePropertyAccessExpression(left, cacheExpression(ts.Debug.checkDefined(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression))), left.name);
+                        target = factory.updatePropertyAccessExpression(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), left.name);
                         break;
                     case 209 /* SyntaxKind.ElementAccessExpression */:
                         // [source]
@@ -104757,7 +104720,7 @@ var ts;
                         //  .yield resumeLabel
                         //  .mark resumeLabel
                         //      _a[_b] = %sent%;
-                        target = factory.updateElementAccessExpression(left, cacheExpression(ts.Debug.checkDefined(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression))), cacheExpression(ts.Debug.checkDefined(ts.visitNode(left.argumentExpression, visitor, ts.isExpression))));
+                        target = factory.updateElementAccessExpression(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), cacheExpression(ts.visitNode(left.argumentExpression, visitor, ts.isExpression)));
                         break;
                     default:
                         target = ts.visitNode(left, visitor, ts.isExpression);
@@ -105075,7 +105038,7 @@ var ts;
                 //  .yield resumeLabel
                 //  .mark resumeLabel
                 //      a = _a[%sent%]
-                return factory.updateElementAccessExpression(node, cacheExpression(ts.Debug.checkDefined(ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression))), ts.visitNode(node.argumentExpression, visitor, ts.isExpression));
+                return factory.updateElementAccessExpression(node, cacheExpression(ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression)), ts.visitNode(node.argumentExpression, visitor, ts.isExpression));
             }
             return ts.visitEachChild(node, visitor, context);
         }
@@ -105092,7 +105055,7 @@ var ts;
                 //  .mark resumeLabel
                 //      _b.apply(_a, _c.concat([%sent%, 2]));
                 var _a = factory.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, /*cacheIdentifiers*/ true), target = _a.target, thisArg = _a.thisArg;
-                return ts.setOriginalNode(ts.setTextRange(factory.createFunctionApplyCall(cacheExpression(ts.Debug.checkDefined(ts.visitNode(target, visitor, ts.isLeftHandSideExpression))), thisArg, visitElements(node.arguments)), node), node);
+                return ts.setOriginalNode(ts.setTextRange(factory.createFunctionApplyCall(cacheExpression(ts.visitNode(target, visitor, ts.isLeftHandSideExpression)), thisArg, visitElements(node.arguments)), node), node);
             }
             return ts.visitEachChild(node, visitor, context);
         }
@@ -107077,7 +107040,7 @@ var ts;
          */
         function addExportEqualsIfNeeded(statements, emitAsReturn) {
             if (currentModuleInfo.exportEquals) {
-                var expressionResult = ts.visitNode(currentModuleInfo.exportEquals.expression, visitor, ts.isExpression);
+                var expressionResult = ts.visitNode(currentModuleInfo.exportEquals.expression, visitor);
                 if (expressionResult) {
                     if (emitAsReturn) {
                         var statement = factory.createReturnStatement(expressionResult);
@@ -107277,7 +107240,7 @@ var ts;
         }
         function visitImportCallExpression(node) {
             var externalModuleName = ts.getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions);
-            var firstArgument = ts.visitNode(ts.firstOrUndefined(node.arguments), visitor, ts.isExpression);
+            var firstArgument = ts.visitNode(ts.firstOrUndefined(node.arguments), visitor);
             // Only use the external module name if it differs from the first argument. This allows us to preserve the quote style of the argument on output.
             var argument = externalModuleName && (!firstArgument || !ts.isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
             var containsLexicalThis = !!(node.transformFlags & 16384 /* TransformFlags.ContainsLexicalThis */);
@@ -107625,7 +107588,7 @@ var ts;
             var statements;
             if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) {
                 statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createFunctionDeclaration(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, factory.getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true), 
-                /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor, ts.isParameter), 
+                /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor), 
                 /*type*/ undefined, ts.visitEachChild(node.body, visitor, context)), 
                 /*location*/ node), 
                 /*original*/ node));
@@ -107652,7 +107615,7 @@ var ts;
             var statements;
             if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) {
                 statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createClassDeclaration(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike), factory.getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true), 
-                /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), ts.visitNodes(node.members, visitor, ts.isClassElement)), node), node));
+                /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor), ts.visitNodes(node.members, visitor)), node), node));
             }
             else {
                 statements = ts.append(statements, ts.visitEachChild(node, visitor, context));
@@ -107692,7 +107655,7 @@ var ts;
                         if (!ts.isBindingPattern(variable.name) && (ts.isArrowFunction(variable.initializer) || ts.isFunctionExpression(variable.initializer) || ts.isClassExpression(variable.initializer))) {
                             var expression = factory.createAssignment(ts.setTextRange(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), variable.name), 
                             /*location*/ variable.name), factory.createIdentifier(ts.getTextOfIdentifierOrLiteral(variable.name)));
-                            var updatedVariable = factory.createVariableDeclaration(variable.name, variable.exclamationToken, variable.type, ts.visitNode(variable.initializer, visitor, ts.isExpression));
+                            var updatedVariable = factory.createVariableDeclaration(variable.name, variable.exclamationToken, variable.type, ts.visitNode(variable.initializer, visitor));
                             variables = ts.append(variables, updatedVariable);
                             expressions = ts.append(expressions, expression);
                             removeCommentsOnExpressions = true;
@@ -108720,7 +108683,7 @@ var ts;
         function visitFunctionDeclaration(node) {
             if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) {
                 hoistedStatements = ts.append(hoistedStatements, factory.updateFunctionDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike), node.asteriskToken, factory.getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true), 
-                /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor, ts.isParameter), 
+                /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), 
                 /*type*/ undefined, ts.visitNode(node.body, visitor, ts.isBlock)));
             }
             else {
@@ -109236,7 +109199,7 @@ var ts;
                 return expressions ? factory.inlineExpressions(expressions) : factory.createOmittedExpression();
             }
             else {
-                return ts.visitNode(node, discardedValueVisitor, ts.isForInitializer);
+                return ts.visitNode(node, discardedValueVisitor, ts.isExpression);
             }
         }
         /**
@@ -109408,7 +109371,7 @@ var ts;
             //     };
             // });
             var externalModuleName = ts.getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions);
-            var firstArgument = ts.visitNode(ts.firstOrUndefined(node.arguments), visitor, ts.isExpression);
+            var firstArgument = ts.visitNode(ts.firstOrUndefined(node.arguments), visitor);
             // Only use the external module name if it differs from the first argument. This allows us to preserve the quote style of the argument on output.
             var argument = externalModuleName && (!firstArgument || !ts.isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
             return factory.createCallExpression(factory.createPropertyAccessExpression(contextObject, factory.createIdentifier("import")), 
@@ -110628,7 +110591,7 @@ var ts;
             var _a;
             var primaryDeclaration = (_a = parentSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return ts.getSourceFileOfNode(d) === containingFile; });
             var augmentingDeclarations = ts.filter(symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) !== containingFile; });
-            if (augmentingDeclarations) {
+            if (primaryDeclaration && augmentingDeclarations) {
                 for (var _i = 0, augmentingDeclarations_1 = augmentingDeclarations; _i < augmentingDeclarations_1.length; _i++) {
                     var augmentations = augmentingDeclarations_1[_i];
                     context.addDiagnostic(ts.addRelatedInfo(ts.createDiagnosticForNode(augmentations, ts.Diagnostics.Declaration_augments_declaration_in_another_file_This_cannot_be_serialized), ts.createDiagnosticForNode(primaryDeclaration, ts.Diagnostics.This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file)));
@@ -110683,12 +110646,12 @@ var ts;
                     if (ts.isExternalOrCommonJsModule(sourceFile) || ts.isJsonSourceFile(sourceFile)) {
                         resultHasExternalModuleIndicator = false; // unused in external module bundle emit (all external modules are within module blocks, therefore are known to be modules)
                         needsDeclare = false;
-                        var statements = ts.isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile, /*bundled*/ true)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements, ts.isStatement);
+                        var statements = ts.isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile, /*bundled*/ true)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements);
                         var newFile = factory.updateSourceFile(sourceFile, [factory.createModuleDeclaration([factory.createModifier(136 /* SyntaxKind.DeclareKeyword */)], factory.createStringLiteral(ts.getResolvedExternalModuleName(context.getEmitHost(), sourceFile)), factory.createModuleBlock(ts.setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements)))], /*isDeclarationFile*/ true, /*referencedFiles*/ [], /*typeReferences*/ [], /*hasNoDefaultLib*/ false, /*libReferences*/ []);
                         return newFile;
                     }
                     needsDeclare = true;
-                    var updated = ts.isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements, ts.isStatement);
+                    var updated = ts.isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements);
                     return factory.updateSourceFile(sourceFile, transformAndReplaceLatePaintedStatements(updated), /*isDeclarationFile*/ true, /*referencedFiles*/ [], /*typeReferences*/ [], /*hasNoDefaultLib*/ false, /*libReferences*/ []);
                 }), ts.mapDefined(node.prepends, function (prepend) {
                     if (prepend.kind === 311 /* SyntaxKind.InputFiles */) {
@@ -110735,7 +110698,7 @@ var ts;
                 emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax);
             }
             else {
-                var statements = ts.visitNodes(node.statements, visitDeclarationStatements, ts.isStatement);
+                var statements = ts.visitNodes(node.statements, visitDeclarationStatements);
                 combinedStatements = ts.setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements);
                 refs.forEach(referenceVisitor);
                 emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax);
@@ -110833,10 +110796,10 @@ var ts;
             }
             else {
                 if (name.kind === 204 /* SyntaxKind.ArrayBindingPattern */) {
-                    return factory.updateArrayBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement, ts.isArrayBindingElement));
+                    return factory.updateArrayBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement));
                 }
                 else {
-                    return factory.updateObjectBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement, ts.isBindingElement));
+                    return factory.updateObjectBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement));
                 }
             }
             function visitBindingElement(elem) {
@@ -110886,10 +110849,10 @@ var ts;
                 (resolver.isRequiredInitializedParameter(node) ||
                     resolver.isOptionalUninitializedParameterProperty(node));
             if (type && !shouldUseResolverType) {
-                return ts.visitNode(type, visitDeclarationSubtree, ts.isTypeNode);
+                return ts.visitNode(type, visitDeclarationSubtree);
             }
             if (!ts.getParseTreeNode(node)) {
-                return type ? ts.visitNode(type, visitDeclarationSubtree, ts.isTypeNode) : factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */);
+                return type ? ts.visitNode(type, visitDeclarationSubtree) : factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */);
             }
             if (node.kind === 175 /* SyntaxKind.SetAccessor */) {
                 // Set accessors with no associated type node (from it's param or get accessor return) are `any` since they are never contextually typed right now
@@ -111002,7 +110965,7 @@ var ts;
             return factory.createNodeArray(newParams || ts.emptyArray);
         }
         function ensureTypeParams(node, params) {
-            return ts.hasEffectiveModifier(node, 8 /* ModifierFlags.Private */) ? undefined : ts.visitNodes(params, visitDeclarationSubtree, ts.isTypeParameterDeclaration);
+            return ts.hasEffectiveModifier(node, 8 /* ModifierFlags.Private */) ? undefined : ts.visitNodes(params, visitDeclarationSubtree);
         }
         function isEnclosingDeclaration(node) {
             return ts.isSourceFile(node)
@@ -111134,7 +111097,6 @@ var ts;
                     var key = ts.getOriginalNodeId(statement);
                     if (lateStatementReplacementMap.has(key)) {
                         var result = lateStatementReplacementMap.get(key);
-                        ts.Debug.type(result);
                         lateStatementReplacementMap.delete(key);
                         if (result) {
                             if (ts.isArray(result) ? ts.some(result, ts.needsScopeMarker) : ts.needsScopeMarker(result)) {
@@ -111282,17 +111244,13 @@ var ts;
                     case 191 /* SyntaxKind.ConditionalType */: {
                         // We have to process conditional types in a special way because for visibility purposes we need to push a new enclosingDeclaration
                         // just for the `infer` types in the true branch. It's an implicit declaration scope that only applies to _part_ of the type.
-                        var checkType = ts.visitNode(input.checkType, visitDeclarationSubtree, ts.isTypeNode);
-                        var extendsType = ts.visitNode(input.extendsType, visitDeclarationSubtree, ts.isTypeNode);
+                        var checkType = ts.visitNode(input.checkType, visitDeclarationSubtree);
+                        var extendsType = ts.visitNode(input.extendsType, visitDeclarationSubtree);
                         var oldEnclosingDecl = enclosingDeclaration;
                         enclosingDeclaration = input.trueType;
-                        var trueType = ts.visitNode(input.trueType, visitDeclarationSubtree, ts.isTypeNode);
+                        var trueType = ts.visitNode(input.trueType, visitDeclarationSubtree);
                         enclosingDeclaration = oldEnclosingDecl;
-                        var falseType = ts.visitNode(input.falseType, visitDeclarationSubtree, ts.isTypeNode);
-                        ts.Debug.assert(checkType);
-                        ts.Debug.assert(extendsType);
-                        ts.Debug.assert(trueType);
-                        ts.Debug.assert(falseType);
+                        var falseType = ts.visitNode(input.falseType, visitDeclarationSubtree);
                         return cleanup(factory.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
                     }
                     case 181 /* SyntaxKind.FunctionType */: {
@@ -111430,7 +111388,7 @@ var ts;
                     return clean;
                 }
                 case 261 /* SyntaxKind.InterfaceDeclaration */: {
-                    return cleanup(factory.updateInterfaceDeclaration(input, ensureModifiers(input), input.name, ensureTypeParams(input, input.typeParameters), transformHeritageClauses(input.heritageClauses), ts.visitNodes(input.members, visitDeclarationSubtree, ts.isTypeElement)));
+                    return cleanup(factory.updateInterfaceDeclaration(input, ensureModifiers(input), input.name, ensureTypeParams(input, input.typeParameters), transformHeritageClauses(input.heritageClauses), ts.visitNodes(input.members, visitDeclarationSubtree)));
                 }
                 case 259 /* SyntaxKind.FunctionDeclaration */: {
                     // Generators lose their generator-ness, excepting their return type
@@ -111502,7 +111460,7 @@ var ts;
                         var oldHasScopeFix = resultHasScopeMarker;
                         resultHasScopeMarker = false;
                         needsScopeFixMarker = false;
-                        var statements = ts.visitNodes(inner.statements, visitDeclarationStatements, ts.isStatement);
+                        var statements = ts.visitNodes(inner.statements, visitDeclarationStatements);
                         var lateStatements = transformAndReplaceLatePaintedStatements(statements);
                         if (input.flags & 16777216 /* NodeFlags.Ambient */) {
                             needsScopeFixMarker = false; // If it was `declare`'d everything is implicitly exported already, ignore late printed "privates"
@@ -111587,7 +111545,7 @@ var ts;
                         /*type*/ undefined, 
                         /*initializer*/ undefined)
                     ] : undefined;
-                    var memberNodes = ts.concatenate(ts.concatenate(privateIdentifier, parameterProperties), ts.visitNodes(input.members, visitDeclarationSubtree, ts.isClassElement));
+                    var memberNodes = ts.concatenate(ts.concatenate(privateIdentifier, parameterProperties), ts.visitNodes(input.members, visitDeclarationSubtree));
                     var members = factory.createNodeArray(memberNodes);
                     var extendsClause_1 = ts.getEffectiveBaseTypeNode(input);
                     if (extendsClause_1 && !ts.isEntityNameExpression(extendsClause_1.expression) && extendsClause_1.expression.kind !== 104 /* SyntaxKind.NullKeyword */) {
@@ -111605,11 +111563,11 @@ var ts;
                             if (clause.token === 94 /* SyntaxKind.ExtendsKeyword */) {
                                 var oldDiag_2 = getSymbolAccessibilityDiagnostic;
                                 getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(clause.types[0]);
-                                var newClause = factory.updateHeritageClause(clause, ts.map(clause.types, function (t) { return factory.updateExpressionWithTypeArguments(t, newId_1, ts.visitNodes(t.typeArguments, visitDeclarationSubtree, ts.isTypeNode)); }));
+                                var newClause = factory.updateHeritageClause(clause, ts.map(clause.types, function (t) { return factory.updateExpressionWithTypeArguments(t, newId_1, ts.visitNodes(t.typeArguments, visitDeclarationSubtree)); }));
                                 getSymbolAccessibilityDiagnostic = oldDiag_2;
                                 return newClause;
                             }
-                            return factory.updateHeritageClause(clause, ts.visitNodes(factory.createNodeArray(ts.filter(clause.types, function (t) { return ts.isEntityNameExpression(t.expression) || t.expression.kind === 104 /* SyntaxKind.NullKeyword */; })), visitDeclarationSubtree, ts.isExpressionWithTypeArguments));
+                            return factory.updateHeritageClause(clause, ts.visitNodes(factory.createNodeArray(ts.filter(clause.types, function (t) { return ts.isEntityNameExpression(t.expression) || t.expression.kind === 104 /* SyntaxKind.NullKeyword */; })), visitDeclarationSubtree));
                         }));
                         return [statement, cleanup(factory.updateClassDeclaration(input, modifiers, input.name, typeParameters, heritageClauses, members))]; // TODO: GH#18217
                     }
@@ -111654,7 +111612,7 @@ var ts;
         function transformVariableStatement(input) {
             if (!ts.forEach(input.declarationList.declarations, getBindingNameVisible))
                 return;
-            var nodes = ts.visitNodes(input.declarationList.declarations, visitDeclarationSubtree, ts.isVariableDeclaration);
+            var nodes = ts.visitNodes(input.declarationList.declarations, visitDeclarationSubtree);
             if (!ts.length(nodes))
                 return;
             return factory.updateVariableStatement(input, factory.createNodeArray(ensureModifiers(input)), factory.updateVariableDeclarationList(input.declarationList, nodes));
@@ -111737,7 +111695,7 @@ var ts;
         function transformHeritageClauses(nodes) {
             return factory.createNodeArray(ts.filter(ts.map(nodes, function (clause) { return factory.updateHeritageClause(clause, ts.visitNodes(factory.createNodeArray(ts.filter(clause.types, function (t) {
                 return ts.isEntityNameExpression(t.expression) || (clause.token === 94 /* SyntaxKind.ExtendsKeyword */ && t.expression.kind === 104 /* SyntaxKind.NullKeyword */);
-            })), visitDeclarationSubtree, ts.isExpressionWithTypeArguments)); }), function (clause) { return clause.types && !!clause.types.length; }));
+            })), visitDeclarationSubtree)); }), function (clause) { return clause.types && !!clause.types.length; }));
         }
     }
     ts.transformDeclarations = transformDeclarations;
@@ -115456,6 +115414,7 @@ var ts;
             writeTrailingSemicolon();
         }
         function emitExportDeclaration(node) {
+            emitModifiers(node, node.modifiers);
             var nextPos = emitTokenWithComment(93 /* SyntaxKind.ExportKeyword */, node.pos, writeKeyword, node);
             writeSpace();
             if (node.isTypeOnly) {
@@ -118682,7 +118641,6 @@ var ts;
         return resolutions;
     }
     ts.loadWithTypeDirectiveCache = loadWithTypeDirectiveCache;
-    ;
     /**
      * Calculates the resulting resolution mode for some reference in some file - this is generally the explicitly
      * provided resolution mode in the reference, unless one is not present, in which case it is the mode of the containing file.
@@ -123940,17 +123898,13 @@ var ts;
             var value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path);
             return !!value && !!value.length;
         }
-        function createHasInvalidatedResolution(forceAllFilesAsInvalidated) {
+        function createHasInvalidatedResolution(userProvidedHasInvalidatedResolution) {
             // Ensure pending resolutions are applied
             invalidateResolutionsOfFailedLookupLocations();
-            if (forceAllFilesAsInvalidated) {
-                // Any file asked would have invalidated resolution
-                filesWithInvalidatedResolutions = undefined;
-                return ts.returnTrue;
-            }
             var collected = filesWithInvalidatedResolutions;
             filesWithInvalidatedResolutions = undefined;
-            return function (path) { return (!!collected && collected.has(path)) ||
+            return function (path) { return (userProvidedHasInvalidatedResolution === null || userProvidedHasInvalidatedResolution === void 0 ? void 0 : userProvidedHasInvalidatedResolution(path)) ||
+                !!(collected === null || collected === void 0 ? void 0 : collected.has(path)) ||
                 isFileWithInvalidatedNonRelativeUnresolvedImports(path); };
         }
         function startCachingPerDirectoryResolution() {
@@ -125059,7 +125013,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_35 = function (directory) {
+            var _loop_36 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -125083,9 +125037,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_11 = _loop_35(directory);
+                var state_12 = _loop_36(directory);
                 directory = out_directory_1;
-                if (state_11 === "break")
+                if (state_12 === "break")
                     break;
             }
             if (allFileNames.size) {
@@ -125154,7 +125108,7 @@ var ts;
         }
         function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) {
             for (var key in paths) {
-                var _loop_36 = function (patternText_1) {
+                var _loop_37 = function (patternText_1) {
                     var pattern = ts.normalizePath(patternText_1);
                     var indexOfStar = pattern.indexOf("*");
                     // In module resolution, if `pattern` itself has an extension, a file with that extension is looked up directly,
@@ -125221,9 +125175,9 @@ var ts;
                 };
                 for (var _i = 0, _a = paths[key]; _i < _a.length; _i++) {
                     var patternText_1 = _a[_i];
-                    var state_12 = _loop_36(patternText_1);
-                    if (typeof state_12 === "object")
-                        return state_12.value;
+                    var state_13 = _loop_37(patternText_1);
+                    if (typeof state_13 === "object")
+                        return state_13.value;
                 }
             }
             function validateEnding(_a) {
@@ -125628,9 +125582,6 @@ var ts;
             return "".concat(errorDiagnostic.file.fileName);
         });
         return filesInError.map(function (fileName) {
-            if (fileName === undefined) {
-                return undefined;
-            }
             var diagnosticForFileName = ts.find(diagnostics, function (diagnostic) {
                 return diagnostic.file !== undefined && diagnostic.file.fileName === fileName;
             });
@@ -126267,8 +126218,6 @@ var ts;
             parseConfigFile();
             newLine = updateNewLine();
         }
-        ts.Debug.assert(compilerOptions);
-        ts.Debug.assert(rootFileNames);
         var _b = ts.createWatchFactory(host, compilerOptions), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory, writeLog = _b.writeLog;
         var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
         writeLog("Current directory: ".concat(currentDirectory, " CaseSensitiveFileNames: ").concat(useCaseSensitiveFileNames));
@@ -126335,6 +126284,7 @@ var ts;
             ts.maybeBind(host, host.getModuleResolutionCache) :
             (function () { return resolutionCache.getModuleResolutionCache(); });
         var userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
+        var userProvidedHasInvalidatedResolution = ts.maybeBind(host, host.hasInvalidatedResolution) || ts.returnTrue;
         builderProgram = readBuilderProgram(compilerOptions, compilerHost);
         synchronizeProgram();
         // Update the wild card directory watch
@@ -126392,8 +126342,6 @@ var ts;
         }
         function synchronizeProgram() {
             writeLog("Synchronizing program");
-            ts.Debug.assert(compilerOptions);
-            ts.Debug.assert(rootFileNames);
             clearInvalidateResolutionsOfFailedLookupLocations();
             var program = getCurrentBuilderProgram();
             if (hasChangedCompilerOptions) {
@@ -126403,7 +126351,7 @@ var ts;
                 }
             }
             // All resolutions are invalid if user provided resolutions
-            var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution);
+            var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution ? userProvidedHasInvalidatedResolution : undefined);
             var _a = ts.changeCompilerHostLikeToUseCache(compilerHost, toPath), originalReadFile = _a.originalReadFile, originalFileExists = _a.originalFileExists, originalDirectoryExists = _a.originalDirectoryExists, originalCreateDirectory = _a.originalCreateDirectory, originalWriteFile = _a.originalWriteFile;
             if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
                 if (hasChangedConfigFileParsingErrors) {
@@ -126642,8 +126590,6 @@ var ts;
         }
         function reloadFileNamesFromConfigFile() {
             writeLog("Reloading new file names and options");
-            ts.Debug.assert(compilerOptions);
-            ts.Debug.assert(configFileName);
             reloadLevel = ts.ConfigFileProgramReloadLevel.None;
             rootFileNames = ts.getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions);
             if (ts.updateErrorForNoInputFiles(rootFileNames, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) {
@@ -126653,7 +126599,6 @@ var ts;
             synchronizeProgram();
         }
         function reloadConfigFile() {
-            ts.Debug.assert(configFileName);
             writeLog("Reloading config file: ".concat(configFileName));
             reloadLevel = ts.ConfigFileProgramReloadLevel.None;
             if (cachedDirectoryStructureHost) {
@@ -126668,7 +126613,6 @@ var ts;
             updateExtendedConfigFilesWatches(toPath(configFileName), compilerOptions, watchOptions, ts.WatchType.ExtendedConfigFile);
         }
         function parseConfigFile() {
-            ts.Debug.assert(configFileName);
             setConfigFileParsingResult(ts.getParsedCommandLineOfConfigFile(configFileName, optionsToExtendForConfigFile, parseConfigFileHost, extendedConfigCache || (extendedConfigCache = new ts.Map()), watchOptionsToExtend, extraFileExtensions)); // TODO: GH#18217
         }
         function setConfigFileParsingResult(configFileParseResult) {
@@ -126690,7 +126634,6 @@ var ts;
                 // With host implementing getParsedCommandLine we cant just update file names
                 if (config.parsedCommandLine && config.reloadLevel === ts.ConfigFileProgramReloadLevel.Partial && !host.getParsedCommandLine) {
                     writeLog("Reloading new file names and options");
-                    ts.Debug.assert(compilerOptions);
                     var fileNames = ts.getFileNamesFromConfigSpecs(config.parsedCommandLine.options.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost);
                     config.parsedCommandLine = __assign(__assign({}, config.parsedCommandLine), { fileNames: fileNames });
                     config.reloadLevel = undefined;
@@ -126777,8 +126720,7 @@ var ts;
         }
         function watchWildcardDirectory(directory, flags) {
             return watchDirectory(directory, function (fileOrDirectory) {
-                ts.Debug.assert(configFileName);
-                ts.Debug.assert(compilerOptions);
+                ts.Debug.assert(!!configFileName);
                 var fileOrDirectoryPath = toPath(fileOrDirectory);
                 // Since the file existence changed, update the sourceFiles cache
                 if (cachedDirectoryStructureHost) {
@@ -126808,7 +126750,6 @@ var ts;
             }, flags, watchOptions, ts.WatchType.WildcardDirectory);
         }
         function updateExtendedConfigFilesWatches(forProjectPath, options, watchOptions, watchType) {
-            ts.Debug.assert(configFileName);
             ts.updateSharedExtendedConfigFileWatcher(forProjectPath, options, sharedExtendedConfigFileWatchers || (sharedExtendedConfigFileWatchers = new ts.Map()), function (extendedConfigFileName, extendedConfigFilePath) { return watchFile(extendedConfigFileName, function (_fileName, eventKind) {
                 var _a;
                 updateCachedSystemWithFile(extendedConfigFileName, extendedConfigFilePath, eventKind);
@@ -131532,6 +131473,12 @@ var ts;
     }
     ts.getSynthesizedDeepCloneWithReplacements = getSynthesizedDeepCloneWithReplacements;
     function getSynthesizedDeepCloneWorker(node, replaceNode) {
+        var nodeClone = replaceNode
+            ? function (n) { return getSynthesizedDeepCloneWithReplacements(n, /*includeTrivia*/ true, replaceNode); }
+            : getSynthesizedDeepClone;
+        var nodesClone = replaceNode
+            ? function (ns) { return ns && getSynthesizedDeepClonesWithReplacements(ns, /*includeTrivia*/ true, replaceNode); }
+            : function (ns) { return ns && getSynthesizedDeepClones(ns); };
         var visited = ts.visitEachChild(node, nodeClone, ts.nullTransformationContext, nodesClone, nodeClone);
         if (visited === node) {
             // This only happens for leaf nodes - internal nodes always see their children change.
@@ -131545,16 +131492,6 @@ var ts;
         // would have made.
         visited.parent = undefined;
         return visited;
-        function nodeClone(node) {
-            return replaceNode
-                ? getSynthesizedDeepCloneWithReplacements(node, /*includeTrivia*/ true, replaceNode)
-                : getSynthesizedDeepClone(node);
-        }
-        function nodesClone(nodes) {
-            return replaceNode
-                ? nodes && getSynthesizedDeepClonesWithReplacements(nodes, /*includeTrivia*/ true, replaceNode)
-                : nodes && getSynthesizedDeepClones(nodes);
-        }
     }
     function getSynthesizedDeepClones(nodes, includeTrivia) {
         if (includeTrivia === void 0) { includeTrivia = true; }
@@ -132294,7 +132231,7 @@ var ts;
             return false;
         }
         // If the file is a module written in TypeScript, it still might be in a `declare global` augmentation
-        return ts.isInJSFile(declaration) || !ts.findAncestor(declaration, function (d) { return ts.isModuleDeclaration(d) && ts.isGlobalScopeAugmentation(d); });
+        return ts.isInJSFile(declaration) || !ts.findAncestor(declaration, ts.isGlobalScopeAugmentation);
     }
     ts.isNonGlobalDeclaration = isNonGlobalDeclaration;
     function isDeprecatedDeclaration(decl) {
@@ -134777,7 +134714,7 @@ var ts;
                         if (!dependencies)
                             continue;
                         for (var dep in dependencies) {
-                            if (dependencies.hasOwnProperty(dep) && !ts.startsWith(dep, "@types/")) {
+                            if (ts.hasProperty(dependencies, dep) && !ts.startsWith(dep, "@types/")) {
                                 result.push(dep);
                             }
                         }
@@ -135161,7 +135098,7 @@ var ts;
             return (location === null || location === void 0 ? void 0 : location.kind) === 79 /* SyntaxKind.Identifier */ ? ts.createTextSpanFromNode(location) : undefined;
         }
         function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext, position) {
-            var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, isRightOfOpenTag = completionData.isRightOfOpenTag, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextMap = completionData.symbolToSortTextMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
+            var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, isRightOfOpenTag = completionData.isRightOfOpenTag, importStatementCompletion = completionData.importStatementCompletion, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextMap = completionData.symbolToSortTextMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
             // Verify if the file is JSX language variant
             if (ts.getLanguageVariant(sourceFile.scriptKind) === 1 /* LanguageVariant.JSX */) {
                 var completionInfo = getJsxClosingTagCompletion(location, sourceFile);
@@ -135175,7 +135112,7 @@ var ts;
                 return undefined;
             }
             var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, 
-            /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag);
+            /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importStatementCompletion, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag);
             if (keywordFilters !== 0 /* KeywordCompletionFilters.None */) {
                 for (var _i = 0, _a = getKeywordCompletions(keywordFilters, !insideJsDocTagTypeExpression && ts.isSourceFileJS(sourceFile)); _i < _a.length; _i++) {
                     var keywordEntry = _a[_i];
@@ -135293,7 +135230,7 @@ var ts;
         function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
             return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* ScriptElementKind.string */, kindModifiers: "" /* ScriptElementKindModifier.none */, sortText: Completions.SortText.LocationPriority };
         }
-        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences, completionKind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag) {
+        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importStatementCompletion, useSemicolons, options, preferences, completionKind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a, _b;
             var insertText;
             var replacementSpan = ts.getReplacementSpanForContextToken(replacementToken);
@@ -135349,8 +135286,8 @@ var ts;
             }
             if (originIsResolvedExport(origin)) {
                 sourceDisplay = [ts.textPart(origin.moduleSpecifier)];
-                if (importCompletionNode) {
-                    (_a = getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, contextToken, origin, useSemicolons, options, preferences), insertText = _a.insertText, replacementSpan = _a.replacementSpan);
+                if (importStatementCompletion) {
+                    (_a = getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, options, preferences), insertText = _a.insertText, replacementSpan = _a.replacementSpan);
                     isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined;
                 }
             }
@@ -135405,7 +135342,7 @@ var ts;
             }
             if (originIsExport(origin) || originIsResolvedExport(origin)) {
                 data = originToCompletionEntryData(origin);
-                hasAction = !importCompletionNode;
+                hasAction = !importStatementCompletion;
             }
             // TODO(drosen): Right now we just permit *all* semantic meanings when calling
             // 'getSymbolKind' which is permissible given that it is backwards compatible; but
@@ -135428,7 +135365,7 @@ var ts;
                 labelDetails: labelDetails,
                 isSnippet: isSnippet,
                 isPackageJsonImport: originIsPackageJsonImport(origin) || undefined,
-                isImportStatementCompletion: !!importCompletionNode || undefined,
+                isImportStatementCompletion: !!importStatementCompletion || undefined,
                 data: data,
             };
         }
@@ -135630,7 +135567,6 @@ var ts;
             var labelDetails = { detail: signaturePrinter.printNode(4 /* EmitHint.Unspecified */, methodSignature, sourceFile) };
             return { isSnippet: isSnippet, insertText: insertText, labelDetails: labelDetails };
         }
-        ;
         function createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences) {
             var declarations = symbol.getDeclarations();
             if (!(declarations && declarations.length)) {
@@ -135801,19 +135737,16 @@ var ts;
             };
             return unresolvedOrigin;
         }
-        function getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, contextToken, origin, useSemicolons, options, preferences) {
-            var _a, _b, _c;
-            var sourceFile = importCompletionNode.getSourceFile();
-            var replacementSpan = ts.createTextSpanFromNode(ts.findAncestor(importCompletionNode, ts.or(ts.isImportDeclaration, ts.isImportEqualsDeclaration)) || importCompletionNode, sourceFile);
+        function getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, options, preferences) {
+            var replacementSpan = importStatementCompletion.replacementSpan;
             var quotedModuleSpecifier = ts.quote(sourceFile, preferences, origin.moduleSpecifier);
             var exportKind = origin.isDefaultExport ? 1 /* ExportKind.Default */ :
                 origin.exportName === "export=" /* InternalSymbolName.ExportEquals */ ? 2 /* ExportKind.ExportEquals */ :
                     0 /* ExportKind.Named */;
             var tabStop = preferences.includeCompletionsWithSnippetText ? "$1" : "";
             var importKind = ts.codefix.getImportKind(sourceFile, exportKind, options, /*forceImportKeyword*/ true);
-            var isTopLevelTypeOnly = ((_b = (_a = ts.tryCast(importCompletionNode, ts.isImportDeclaration)) === null || _a === void 0 ? void 0 : _a.importClause) === null || _b === void 0 ? void 0 : _b.isTypeOnly) || ((_c = ts.tryCast(importCompletionNode, ts.isImportEqualsDeclaration)) === null || _c === void 0 ? void 0 : _c.isTypeOnly);
-            var isImportSpecifierTypeOnly = couldBeTypeOnlyImportSpecifier(importCompletionNode, contextToken);
-            var topLevelTypeOnlyText = isTopLevelTypeOnly ? " ".concat(ts.tokenToString(154 /* SyntaxKind.TypeKeyword */), " ") : " ";
+            var isImportSpecifierTypeOnly = importStatementCompletion.couldBeTypeOnlyImportSpecifier;
+            var topLevelTypeOnlyText = importStatementCompletion.isTopLevelTypeOnly ? " ".concat(ts.tokenToString(154 /* SyntaxKind.TypeKeyword */), " ") : " ";
             var importSpecifierTypeOnlyText = isImportSpecifierTypeOnly ? "".concat(ts.tokenToString(154 /* SyntaxKind.TypeKeyword */), " ") : "";
             var suffix = useSemicolons ? ";" : "";
             switch (importKind) {
@@ -135847,7 +135780,7 @@ var ts;
                 return CompletionSource.TypeOnlyAlias;
             }
         }
-        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag) {
+        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importStatementCompletion, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a;
             var start = ts.timestamp();
             var variableDeclaration = getVariableDeclaration(location);
@@ -135868,7 +135801,7 @@ var ts;
                 var name = info.name, needsConvertPropertyAccess = info.needsConvertPropertyAccess;
                 var originalSortText = (_a = symbolToSortTextMap === null || symbolToSortTextMap === void 0 ? void 0 : symbolToSortTextMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : Completions.SortText.LocationPriority;
                 var sortText = (isDeprecated(symbol, typeChecker) ? Completions.SortText.Deprecated(originalSortText) : originalSortText);
-                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences, kind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag);
+                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importStatementCompletion, useSemicolons, compilerOptions, preferences, kind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag);
                 if (!entry) {
                     continue;
                 }
@@ -136059,7 +135992,7 @@ var ts;
         Completions.createCompletionDetails = createCompletionDetails;
         function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source, cancellationToken) {
             if (data === null || data === void 0 ? void 0 : data.moduleSpecifier) {
-                if (previousToken && getImportStatementCompletionInfo(contextToken || previousToken).replacementNode) {
+                if (previousToken && getImportStatementCompletionInfo(contextToken || previousToken).replacementSpan) {
                     // Import statement completion: 'import c|'
                     return { codeActions: undefined, sourceDisplay: [ts.textPart(data.moduleSpecifier)] };
                 }
@@ -136260,34 +136193,34 @@ var ts;
             var isStartingCloseTag = false;
             var isJsxInitializer = false;
             var isJsxIdentifierExpected = false;
-            var importCompletionNode;
+            var importStatementCompletion;
             var location = ts.getTouchingPropertyName(sourceFile, position);
             var keywordFilters = 0 /* KeywordCompletionFilters.None */;
             var isNewIdentifierLocation = false;
             var flags = 0 /* CompletionInfoFlags.None */;
             if (contextToken) {
-                var importStatementCompletion = getImportStatementCompletionInfo(contextToken);
-                isNewIdentifierLocation = importStatementCompletion.isNewIdentifierLocation;
-                if (importStatementCompletion.keywordCompletion) {
-                    if (importStatementCompletion.isKeywordOnlyCompletion) {
+                var importStatementCompletionInfo = getImportStatementCompletionInfo(contextToken);
+                if (importStatementCompletionInfo.keywordCompletion) {
+                    if (importStatementCompletionInfo.isKeywordOnlyCompletion) {
                         return {
                             kind: 4 /* CompletionDataKind.Keywords */,
-                            keywordCompletions: [keywordToCompletionEntry(importStatementCompletion.keywordCompletion)],
-                            isNewIdentifierLocation: isNewIdentifierLocation,
+                            keywordCompletions: [keywordToCompletionEntry(importStatementCompletionInfo.keywordCompletion)],
+                            isNewIdentifierLocation: importStatementCompletionInfo.isNewIdentifierLocation,
                         };
                     }
-                    keywordFilters = keywordFiltersFromSyntaxKind(importStatementCompletion.keywordCompletion);
+                    keywordFilters = keywordFiltersFromSyntaxKind(importStatementCompletionInfo.keywordCompletion);
                 }
-                if (importStatementCompletion.replacementNode && preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) {
+                if (importStatementCompletionInfo.replacementSpan && preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) {
                     // Import statement completions use `insertText`, and also require the `data` property of `CompletionEntryIdentifier`
                     // added in TypeScript 4.3 to be sent back from the client during `getCompletionEntryDetails`. Since this feature
                     // is not backward compatible with older clients, the language service defaults to disabling it, allowing newer clients
                     // to opt in with the `includeCompletionsForImportStatements` user preference.
-                    importCompletionNode = importStatementCompletion.replacementNode;
                     flags |= 2 /* CompletionInfoFlags.IsImportStatementCompletion */;
+                    importStatementCompletion = importStatementCompletionInfo;
+                    isNewIdentifierLocation = importStatementCompletionInfo.isNewIdentifierLocation;
                 }
                 // Bail out if this is a known invalid completion location
-                if (!importCompletionNode && isCompletionListBlocker(contextToken)) {
+                if (!importStatementCompletionInfo.replacementSpan && isCompletionListBlocker(contextToken)) {
                     log("Returning an empty list because completion was requested in an invalid position.");
                     return keywordFilters
                         ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierDefinitionLocation())
@@ -136333,7 +136266,7 @@ var ts;
                             return undefined;
                     }
                 }
-                else if (!importCompletionNode && sourceFile.languageVariant === 1 /* LanguageVariant.JSX */) {
+                else if (!importStatementCompletion) {
                     // <UI.Test /* completion position */ />
                     // If the tagname is a property access expression, we will then walk up to the top most of property access expression.
                     // Then, try to get a JSX container and its associated attributes type.
@@ -136476,7 +136409,7 @@ var ts;
                 isTypeOnlyLocation: isTypeOnlyLocation,
                 isJsxIdentifierExpected: isJsxIdentifierExpected,
                 isRightOfOpenTag: isRightOfOpenTag,
-                importCompletionNode: importCompletionNode,
+                importStatementCompletion: importStatementCompletion,
                 hasUnresolvedAutoImports: hasUnresolvedAutoImports,
                 flags: flags,
             };
@@ -136730,7 +136663,7 @@ var ts;
                 return 1 /* GlobalsSearch.Success */;
             }
             function tryGetImportCompletionSymbols() {
-                if (!importCompletionNode)
+                if (!importStatementCompletion)
                     return 0 /* GlobalsSearch.Continue */;
                 isNewIdentifierLocation = true;
                 collectAutoImports();
@@ -136813,7 +136746,7 @@ var ts;
             }
             function shouldOfferImportCompletions() {
                 // If already typing an import statement, provide completions for it.
-                if (importCompletionNode)
+                if (importStatementCompletion)
                     return true;
                 // If current completion is for non-contextual Object literal shortahands, ignore auto-import symbols
                 if (isNonContextualObjectLiteral)
@@ -136843,7 +136776,7 @@ var ts;
             }
             function isTypeOnlyCompletion() {
                 return insideJsDocTagTypeExpression
-                    || !!importCompletionNode && ts.isTypeOnlyImportOrExportDeclaration(location.parent)
+                    || !!importStatementCompletion && ts.isTypeOnlyImportOrExportDeclaration(location.parent)
                     || !isContextTokenValueLocation(contextToken) &&
                         (ts.isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker)
                             || ts.isPartOfTypeNode(location)
@@ -136893,8 +136826,7 @@ var ts;
                 flags |= 1 /* CompletionInfoFlags.MayIncludeAutoImports */;
                 // import { type | -> token text should be blank
                 var isAfterTypeOnlyImportSpecifierModifier = previousToken === contextToken
-                    && importCompletionNode
-                    && couldBeTypeOnlyImportSpecifier(importCompletionNode, contextToken);
+                    && importStatementCompletion;
                 var lowerCaseTokenText = isAfterTypeOnlyImportSpecifierModifier ? "" :
                     previousToken && ts.isIdentifier(previousToken) ? previousToken.text.toLowerCase() :
                         "";
@@ -136902,14 +136834,14 @@ var ts;
                 var exportInfo = ts.getExportInfoMap(sourceFile, host, program, preferences, cancellationToken);
                 var packageJsonAutoImportProvider = (_b = host.getPackageJsonAutoImportProvider) === null || _b === void 0 ? void 0 : _b.call(host);
                 var packageJsonFilter = detailsEntryId ? undefined : ts.createPackageJsonImportFilter(sourceFile, preferences, host);
-                resolvingModuleSpecifiers("collectAutoImports", host, importSpecifierResolver || (importSpecifierResolver = ts.codefix.createImportSpecifierResolver(sourceFile, program, host, preferences)), program, position, preferences, !!importCompletionNode, ts.isValidTypeOnlyAliasUseSite(location), function (context) {
+                resolvingModuleSpecifiers("collectAutoImports", host, importSpecifierResolver || (importSpecifierResolver = ts.codefix.createImportSpecifierResolver(sourceFile, program, host, preferences)), program, position, preferences, !!importStatementCompletion, ts.isValidTypeOnlyAliasUseSite(location), function (context) {
                     exportInfo.search(sourceFile.path, 
                     /*preferCapitalized*/ isRightOfOpenTag, function (symbolName, targetFlags) {
                         if (!ts.isIdentifierText(symbolName, ts.getEmitScriptTarget(host.getCompilationSettings())))
                             return false;
                         if (!detailsEntryId && ts.isStringANonContextualKeyword(symbolName))
                             return false;
-                        if (!isTypeOnlyLocation && !importCompletionNode && !(targetFlags & 111551 /* SymbolFlags.Value */))
+                        if (!isTypeOnlyLocation && !importStatementCompletion && !(targetFlags & 111551 /* SymbolFlags.Value */))
                             return false;
                         if (isTypeOnlyLocation && !(targetFlags & (1536 /* SymbolFlags.Module */ | 788968 /* SymbolFlags.Type */)))
                             return false;
@@ -136990,7 +136922,7 @@ var ts;
                     return;
                 }
                 symbolToOriginInfoMap[symbols.length] = origin;
-                symbolToSortTextMap[symbolId] = importCompletionNode ? Completions.SortText.LocationPriority : Completions.SortText.AutoImportSuggestions;
+                symbolToSortTextMap[symbolId] = importStatementCompletion ? Completions.SortText.LocationPriority : Completions.SortText.AutoImportSuggestions;
                 symbols.push(symbol);
             }
             /* Mutates `symbols` and `symbolToOriginInfoMap`. */
@@ -138257,6 +138189,7 @@ var ts;
             return undefined;
         }
         function getImportStatementCompletionInfo(contextToken) {
+            var _a, _b, _c;
             var keywordCompletion;
             var isKeywordOnlyCompletion = false;
             var candidate = getCandidate();
@@ -138264,9 +138197,9 @@ var ts;
                 isKeywordOnlyCompletion: isKeywordOnlyCompletion,
                 keywordCompletion: keywordCompletion,
                 isNewIdentifierLocation: !!(candidate || keywordCompletion === 154 /* SyntaxKind.TypeKeyword */),
-                replacementNode: candidate && ts.rangeIsOnSingleLine(candidate, candidate.getSourceFile())
-                    ? candidate
-                    : undefined
+                isTopLevelTypeOnly: !!((_b = (_a = ts.tryCast(candidate, ts.isImportDeclaration)) === null || _a === void 0 ? void 0 : _a.importClause) === null || _b === void 0 ? void 0 : _b.isTypeOnly) || !!((_c = ts.tryCast(candidate, ts.isImportEqualsDeclaration)) === null || _c === void 0 ? void 0 : _c.isTypeOnly),
+                couldBeTypeOnlyImportSpecifier: !!candidate && couldBeTypeOnlyImportSpecifier(candidate, contextToken),
+                replacementSpan: getSingleLineReplacementSpanForImportCompletionNode(candidate),
             };
             function getCandidate() {
                 var parent = contextToken.parent;
@@ -138308,14 +138241,71 @@ var ts;
                 return undefined;
             }
         }
+        function getSingleLineReplacementSpanForImportCompletionNode(node) {
+            var _a, _b, _c;
+            if (!node)
+                return undefined;
+            var top = (_a = ts.findAncestor(node, ts.or(ts.isImportDeclaration, ts.isImportEqualsDeclaration))) !== null && _a !== void 0 ? _a : node;
+            var sourceFile = top.getSourceFile();
+            if (ts.rangeIsOnSingleLine(top, sourceFile)) {
+                return ts.createTextSpanFromNode(top, sourceFile);
+            }
+            // ImportKeyword was necessarily on one line; ImportSpecifier was necessarily parented in an ImportDeclaration
+            ts.Debug.assert(top.kind !== 100 /* SyntaxKind.ImportKeyword */ && top.kind !== 273 /* SyntaxKind.ImportSpecifier */);
+            // Guess which point in the import might actually be a later statement parsed as part of the import
+            // during parser recovery - either in the middle of named imports, or the module specifier.
+            var potentialSplitPoint = top.kind === 269 /* SyntaxKind.ImportDeclaration */
+                ? (_c = getPotentiallyInvalidImportSpecifier((_b = top.importClause) === null || _b === void 0 ? void 0 : _b.namedBindings)) !== null && _c !== void 0 ? _c : top.moduleSpecifier
+                : top.moduleReference;
+            var withoutModuleSpecifier = {
+                pos: top.getFirstToken().getStart(),
+                end: potentialSplitPoint.pos,
+            };
+            // The module specifier/reference was previously found to be missing, empty, or
+            // not a string literal - in this last case, it's likely that statement on a following
+            // line was parsed as the module specifier of a partially-typed import, e.g.
+            //   import Foo|
+            //   interface Blah {}
+            // This appears to be a multiline-import, and editors can't replace multiple lines.
+            // But if everything but the "module specifier" is on one line, by this point we can
+            // assume that the "module specifier" is actually just another statement, and return
+            // the single-line range of the import excluding that probable statement.
+            if (ts.rangeIsOnSingleLine(withoutModuleSpecifier, sourceFile)) {
+                return ts.createTextSpanFromRange(withoutModuleSpecifier);
+            }
+        }
+        // Tries to identify the first named import that is not really a named import, but rather
+        // just parser recovery for a situation like:
+        //   import { Foo|
+        //   interface Bar {}
+        // in which `Foo`, `interface`, and `Bar` are all parsed as import specifiers. The caller
+        // will also check if this token is on a separate line from the rest of the import.
+        function getPotentiallyInvalidImportSpecifier(namedBindings) {
+            var _a;
+            return ts.find((_a = ts.tryCast(namedBindings, ts.isNamedImports)) === null || _a === void 0 ? void 0 : _a.elements, function (e) {
+                var _a;
+                return !e.propertyName &&
+                    ts.isStringANonContextualKeyword(e.name.text) &&
+                    ((_a = ts.findPrecedingToken(e.name.pos, namedBindings.getSourceFile(), namedBindings)) === null || _a === void 0 ? void 0 : _a.kind) !== 27 /* SyntaxKind.CommaToken */;
+            });
+        }
         function couldBeTypeOnlyImportSpecifier(importSpecifier, contextToken) {
             return ts.isImportSpecifier(importSpecifier)
                 && (importSpecifier.isTypeOnly || contextToken === importSpecifier.name && ts.isTypeKeywordTokenOrIdentifier(contextToken));
         }
         function canCompleteFromNamedBindings(namedBindings) {
-            return isModuleSpecifierMissingOrEmpty(namedBindings.parent.parent.moduleSpecifier)
-                && (ts.isNamespaceImport(namedBindings) || namedBindings.elements.length < 2)
-                && !namedBindings.parent.name;
+            if (!isModuleSpecifierMissingOrEmpty(namedBindings.parent.parent.moduleSpecifier) || namedBindings.parent.name) {
+                return false;
+            }
+            if (ts.isNamedImports(namedBindings)) {
+                // We can only complete on named imports if there are no other named imports already,
+                // but parser recovery sometimes puts later statements in the named imports list, so
+                // we try to only consider the probably-valid ones.
+                var invalidNamedImport = getPotentiallyInvalidImportSpecifier(namedBindings);
+                var validImports = invalidNamedImport ? namedBindings.elements.indexOf(invalidNamedImport) : namedBindings.elements.length;
+                return validImports < 2;
+            }
+            return true;
         }
         function isModuleSpecifierMissingOrEmpty(specifier) {
             var _a;
@@ -138334,7 +138324,6 @@ var ts;
         function isArrowFunctionBody(node) {
             return node.parent && ts.isArrowFunction(node.parent) && node.parent.body === node;
         }
-        ;
         /** True if symbol is a type or a module containing at least one type. */
         function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules) {
             if (seenModules === void 0) { seenModules = new ts.Map(); }
@@ -138618,7 +138607,7 @@ var ts;
                     // If we're an accessibility modifier, we're in an instance member and should search
                     // the constructor's parameter list for instance members as well.
                     if (modifierFlag & (28 /* ModifierFlags.AccessibilityModifier */ | 64 /* ModifierFlags.Readonly */)) {
-                        var constructor = ts.find(container.members, ts.isConstructorDeclaration); // TODO(jakebailey): GH#49924 ???
+                        var constructor = ts.find(container.members, ts.isConstructorDeclaration);
                         if (constructor) {
                             return __spreadArray(__spreadArray([], nodes, true), constructor.parameters, true);
                         }
@@ -146351,6 +146340,10 @@ var ts;
                         pushSelectionCommentRange(comment.pos, comment.end);
                     }
                     if (positionShouldSnapToNode(sourceFile, pos, node)) {
+                        if (ts.isFunctionBody(node)
+                            && ts.isFunctionLikeDeclaration(parentNode) && !ts.positionsAreOnSameLine(node.getStart(sourceFile), node.getEnd(), sourceFile)) {
+                            pushSelectionRange(node.getStart(sourceFile), node.getEnd());
+                        }
                         // 1. Blocks are effectively redundant with SyntaxLists.
                         // 2. TemplateSpans, along with the SyntaxLists containing them, are a somewhat unintuitive grouping
                         //    of things that should be considered independently.
@@ -147502,7 +147495,7 @@ var ts;
                 return name === "undefined";
             }
             function isHintableDeclaration(node) {
-                if ((ts.isParameter(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) && node.initializer) {
+                if ((ts.isParameterDeclaration(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) && node.initializer) {
                     var initializer = ts.skipParentheses(node.initializer);
                     return !(isHintableLiteral(initializer) || ts.isNewExpression(initializer) || ts.isObjectLiteralExpression(initializer) || ts.isAssertionExpression(initializer));
                 }
@@ -149415,19 +149408,19 @@ var ts;
             return function (context) { return context.options && context.options[optionName] === optionValue; };
         }
         function isOptionEnabled(optionName) {
-            return function (context) { return context.options && context.options.hasOwnProperty(optionName) && !!context.options[optionName]; };
+            return function (context) { return context.options && ts.hasProperty(context.options, optionName) && !!context.options[optionName]; };
         }
         function isOptionDisabled(optionName) {
-            return function (context) { return context.options && context.options.hasOwnProperty(optionName) && !context.options[optionName]; };
+            return function (context) { return context.options && ts.hasProperty(context.options, optionName) && !context.options[optionName]; };
         }
         function isOptionDisabledOrUndefined(optionName) {
-            return function (context) { return !context.options || !context.options.hasOwnProperty(optionName) || !context.options[optionName]; };
+            return function (context) { return !context.options || !ts.hasProperty(context.options, optionName) || !context.options[optionName]; };
         }
         function isOptionDisabledOrUndefinedOrTokensOnSameLine(optionName) {
-            return function (context) { return !context.options || !context.options.hasOwnProperty(optionName) || !context.options[optionName] || context.TokensAreOnSameLine(); };
+            return function (context) { return !context.options || !ts.hasProperty(context.options, optionName) || !context.options[optionName] || context.TokensAreOnSameLine(); };
         }
         function isOptionEnabledOrUndefined(optionName) {
-            return function (context) { return !context.options || !context.options.hasOwnProperty(optionName) || !!context.options[optionName]; };
+            return function (context) { return !context.options || !ts.hasProperty(context.options, optionName) || !!context.options[optionName]; };
         }
         function isForContext(context) {
             return context.contextNode.kind === 245 /* SyntaxKind.ForStatement */;
@@ -152743,7 +152736,6 @@ var ts;
             if (!visited) {
                 return visited;
             }
-            ts.Debug.assert(nodes);
             // clone nodearray if necessary
             var nodeArray = visited === nodes ? ts.factory.createNodeArray(visited.slice(0)) : visited;
             ts.setTextRangePosEnd(nodeArray, getPos(nodes), getEnd(nodes));
@@ -154032,31 +154024,22 @@ var ts;
                     var param = _a[_i];
                     if (!param.type) {
                         var paramType = ts.getJSDocType(param);
-                        if (paramType) {
-                            var transformedType = transformJSDocType(paramType);
-                            ts.Debug.assertNode(transformedType, ts.isTypeNode);
-                            changes.tryInsertTypeAnnotation(sourceFile, param, transformedType);
-                        }
+                        if (paramType)
+                            changes.tryInsertTypeAnnotation(sourceFile, param, transformJSDocType(paramType));
                     }
                 }
                 if (needParens)
                     changes.insertNodeAfter(sourceFile, ts.last(decl.parameters), ts.factory.createToken(21 /* SyntaxKind.CloseParenToken */));
                 if (!decl.type) {
                     var returnType = ts.getJSDocReturnType(decl);
-                    if (returnType) {
-                        var transformedType = transformJSDocType(returnType);
-                        ts.Debug.assertNode(transformedType, ts.isTypeNode);
-                        changes.tryInsertTypeAnnotation(sourceFile, decl, transformedType);
-                    }
-                    ;
+                    if (returnType)
+                        changes.tryInsertTypeAnnotation(sourceFile, decl, transformJSDocType(returnType));
                 }
             }
             else {
                 var jsdocType = ts.Debug.checkDefined(ts.getJSDocType(decl), "A JSDocType for this declaration should exist"); // If not defined, shouldn't have been an error to fix
                 ts.Debug.assert(!decl.type, "The JSDocType decl should have a type"); // If defined, shouldn't have been an error to fix.
-                var transformedType = transformJSDocType(jsdocType);
-                ts.Debug.assertNode(transformedType, ts.isTypeNode);
-                changes.tryInsertTypeAnnotation(sourceFile, decl, transformedType);
+                changes.tryInsertTypeAnnotation(sourceFile, decl, transformJSDocType(jsdocType));
             }
         }
         function isDeclarationWithType(node) {
@@ -157059,7 +157042,7 @@ var ts;
             var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
             if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
                 return;
-            var declaration = findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            var declaration = codefix.findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
             if (declaration === undefined)
                 return;
             if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) {
@@ -157093,14 +157076,6 @@ var ts;
                 }
             }
         }
-        function findAncestorMatchingSpan(sourceFile, span) {
-            var end = ts.textSpanEnd(span);
-            var token = ts.getTokenAtPosition(sourceFile, span.start);
-            while (token.end < end) {
-                token = token.parent;
-            }
-            return token;
-        }
         function tryGetConstraintFromDiagnosticMessage(messageText) {
             var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1];
             return constraint;
@@ -157981,7 +157956,7 @@ var ts;
                 return { kind: InfoKind.TypeLikeDeclaration, token: token, call: call, modifierFlags: modifierFlags, parentDeclaration: declaration, declSourceFile: declSourceFile, isJSFile: isJSFile };
             }
             var enumDeclaration = ts.find(symbol.declarations, ts.isEnumDeclaration);
-            if (enumDeclaration && !ts.isPrivateIdentifier(token) && !isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) {
+            if (enumDeclaration && !(leftExpressionType.flags & 1056 /* TypeFlags.EnumLike */) && !ts.isPrivateIdentifier(token) && !isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) {
                 return { kind: InfoKind.Enum, token: token, parentDeclaration: enumDeclaration };
             }
             return undefined;
@@ -158646,6 +158621,63 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var fixId = "fixNaNEquality";
+        var errorCodes = [
+            ts.Diagnostics.This_condition_will_always_return_0.code,
+        ];
+        codefix.registerCodeFix({
+            errorCodes: errorCodes,
+            getCodeActions: function (context) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program;
+                var info = getInfo(program, sourceFile, span);
+                if (info === undefined)
+                    return;
+                var suggestion = info.suggestion, expression = info.expression, arg = info.arg;
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, arg, expression); });
+                return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Use_0, suggestion], fixId, ts.Diagnostics.Use_Number_isNaN_in_all_conditions)];
+            },
+            fixIds: [fixId],
+            getAllCodeActions: function (context) {
+                return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
+                    var info = getInfo(context.program, diag.file, ts.createTextSpan(diag.start, diag.length));
+                    if (info) {
+                        doChange(changes, diag.file, info.arg, info.expression);
+                    }
+                });
+            }
+        });
+        function getInfo(program, sourceFile, span) {
+            var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
+            if (diag === undefined || diag.relatedInformation === undefined)
+                return;
+            var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.Did_you_mean_0.code; });
+            if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
+                return;
+            var token = codefix.findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            if (token === undefined)
+                return;
+            if (ts.isExpression(token) && ts.isBinaryExpression(token.parent)) {
+                return { suggestion: getSuggestion(related.messageText), expression: token.parent, arg: token };
+            }
+            return undefined;
+        }
+        function doChange(changes, sourceFile, arg, expression) {
+            var callExpression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("Number"), ts.factory.createIdentifier("isNaN")), /*typeArguments*/ undefined, [arg]);
+            var operator = expression.operatorToken.kind;
+            changes.replaceNode(sourceFile, expression, operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */
+                ? ts.factory.createPrefixUnaryExpression(53 /* SyntaxKind.ExclamationToken */, callExpression) : callExpression);
+        }
+        function getSuggestion(messageText) {
+            var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/\'(.*)\'/) || [], _ = _a[0], suggestion = _a[1];
+            return suggestion;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {
@@ -161332,11 +161364,12 @@ var ts;
          */
         function tryGetAutoImportableReferenceFromTypeNode(importTypeNode, scriptTarget) {
             var symbols;
-            var typeNode = ts.visitNode(importTypeNode, visit, ts.isTypeNode);
+            var typeNode = ts.visitNode(importTypeNode, visit);
             if (symbols && typeNode) {
                 return { typeNode: typeNode, symbols: symbols };
             }
             function visit(node) {
+                var _a;
                 if (ts.isLiteralImportTypeNode(node) && node.qualifier) {
                     // Symbol for the left-most thing after the dot
                     var firstIdentifier = ts.getFirstIdentifier(node.qualifier);
@@ -161345,7 +161378,7 @@ var ts;
                         ? replaceFirstIdentifierOfEntityName(node.qualifier, ts.factory.createIdentifier(name))
                         : node.qualifier;
                     symbols = ts.append(symbols, firstIdentifier.symbol);
-                    var typeArguments = ts.visitNodes(node.typeArguments, visit, ts.isTypeNode);
+                    var typeArguments = (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a.map(visit);
                     return ts.factory.createTypeReferenceNode(qualifier, typeArguments);
                 }
                 return ts.visitEachChild(node, visit, ts.nullTransformationContext);
@@ -161362,6 +161395,15 @@ var ts;
             symbols.forEach(function (s) { return importAdder.addImportFromExportedSymbol(s, /*isValidTypeOnlyUseSite*/ true); });
         }
         codefix.importSymbols = importSymbols;
+        function findAncestorMatchingSpan(sourceFile, span) {
+            var end = ts.textSpanEnd(span);
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
+            while (token.end < end) {
+                token = token.parent;
+            }
+            return token;
+        }
+        codefix.findAncestorMatchingSpan = findAncestorMatchingSpan;
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */
@@ -162420,7 +162462,6 @@ var ts;
                 return { edits: edits, renameFilename: undefined, renameLocation: undefined };
             },
         });
-        ;
         function getInfo(context, considerPartialSpans) {
             if (considerPartialSpans === void 0) { considerPartialSpans = true; }
             var file = context.file, program = context.program;
@@ -162897,7 +162938,6 @@ var ts;
                 });
                 return { edits: edits, renameFilename: undefined, renameLocation: undefined };
             }
-            ;
             function isValidExpression(node) {
                 return ts.isBinaryExpression(node) || ts.isConditionalExpression(node);
             }
@@ -162945,7 +162985,6 @@ var ts;
                 if (expression.operatorToken.kind !== 55 /* SyntaxKind.AmpersandAmpersandToken */) {
                     return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Can_only_convert_logical_AND_access_chains) };
                 }
-                ;
                 var finalExpression = getFinalExpressionInChain(expression.right);
                 if (!finalExpression)
                     return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_convertible_access_expression) };
@@ -164462,7 +164501,7 @@ var ts;
                 var statements = ts.factory.createNodeArray(ts.isBlock(body) ? body.statements.slice(0) : [ts.isStatement(body) ? body : ts.factory.createReturnStatement(ts.skipParentheses(body))]);
                 // rewrite body if either there are writes that should be propagated back via return statements or there are substitutions
                 if (hasWritesOrVariableDeclarations || substitutions.size) {
-                    var rewrittenStatements = ts.visitNodes(statements, visitor, ts.isStatement).slice();
+                    var rewrittenStatements = ts.visitNodes(statements, visitor).slice();
                     if (hasWritesOrVariableDeclarations && !hasReturn && ts.isStatement(body)) {
                         // add return at the end to propagate writes back in case if control flow falls out of the function body
                         // it is ok to know that range has at least one return since it we only allow unconditional returns
@@ -165289,7 +165328,6 @@ var ts;
 (function (ts) {
     var refactor;
     (function (refactor) {
-        ;
         /**
          * Checks if some refactor info has refactor error info.
          */
@@ -165394,7 +165432,6 @@ var ts;
             // Imports will be copied to the new file anyway, and may still be needed in the old file.
             // Prologue directives will be copied to the new file and should be left in the old file.
             return !isPureImport(statement) && !ts.isPrologueDirective(statement);
-            ;
         }
         function isPureImport(node) {
             switch (node.kind) {
@@ -175449,7 +175486,7 @@ var ts;
                     // raw is now fixed and ready
                     this.safelist = raw.typesMap;
                     for (var key in raw.simpleMap) {
-                        if (raw.simpleMap.hasOwnProperty(key)) {
+                        if (ts.hasProperty(raw.simpleMap, key)) {
                             this.legacySafelist.set(key, raw.simpleMap[key].toLowerCase());
                         }
                     }
@@ -178863,7 +178900,6 @@ var ts;
             }
             return ts.deduplicate(outputs, ts.equateValues);
         }
-        ;
         function createDocumentSpanSet() {
             return ts.createSet(function (_a) {
                 var textSpan = _a.textSpan;
@@ -183983,7 +184019,7 @@ var ts;
                     (name === undefined || typeof name === "string" || ts.isPropertyName(name)) &&
                     (questionToken === undefined || typeof questionToken === "object" && ts.isQuestionToken(questionToken)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (parameters === undefined || ts.isArrayOf(parameters, ts.isParameter)) &&
+                    (parameters === undefined || !ts.some(parameters, ts.isTypeParameterDeclaration)) &&
                     (type === undefined || !ts.isArray(type)) &&
                     (body === undefined || ts.isBlock(body));
             },
@@ -183993,7 +184029,7 @@ var ts;
                     (asteriskToken === undefined || typeof asteriskToken === "object" && ts.isAsteriskToken(asteriskToken)) &&
                     (name === undefined || typeof name === "string" || ts.isPropertyName(name)) &&
                     (questionToken === undefined || !ts.isArray(questionToken)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (typeParameters === undefined || !ts.some(typeParameters, ts.isParameter)) &&
                     (parameters === undefined || ts.isArray(parameters)) &&
                     (type === undefined || ts.isTypeNode(type)) &&
                     (body === undefined || ts.isBlock(body));
@@ -184020,7 +184056,7 @@ var ts;
                     (name === undefined || typeof name === "string" || ts.isPropertyName(name)) &&
                     (questionToken === undefined || typeof questionToken === "object" && ts.isQuestionToken(questionToken)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (parameters === undefined || ts.isArrayOf(parameters, ts.isParameter)) &&
+                    (parameters === undefined || !ts.some(parameters, ts.isTypeParameterDeclaration)) &&
                     (type === undefined || !ts.isArray(type)) &&
                     (body === undefined || ts.isBlock(body));
             },
@@ -184030,7 +184066,7 @@ var ts;
                     (asteriskToken === undefined || typeof asteriskToken === "object" && ts.isAsteriskToken(asteriskToken)) &&
                     (name === undefined || typeof name === "string" || ts.isPropertyName(name)) &&
                     (questionToken === undefined || !ts.isArray(questionToken)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (typeParameters === undefined || !ts.some(typeParameters, ts.isParameter)) &&
                     (parameters === undefined || ts.isArray(parameters)) &&
                     (type === undefined || ts.isTypeNode(type)) &&
                     (body === undefined || ts.isBlock(body));
@@ -184053,14 +184089,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], parameters = _a[1], body = _a[2], other = _a[3];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
-                    (parameters === undefined || ts.isArrayOf(parameters, ts.isParameter)) &&
+                    (modifiers === undefined || !ts.some(modifiers, ts.isDecorator)) &&
+                    (parameters === undefined || !ts.some(parameters, ts.isModifier)) &&
                     (body === undefined || !ts.isArray(body));
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], parameters = _a[2], body = _a[3];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                return (decorators === undefined || !ts.some(decorators, ts.isModifier)) &&
+                    (modifiers === undefined || !ts.some(modifiers, ts.isParameter)) &&
                     (parameters === undefined || ts.isArray(parameters)) &&
                     (body === undefined || ts.isBlock(body));
             },
@@ -184082,14 +184118,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], parameters = _a[2], body = _a[3], other = _a[4];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
-                    (parameters === undefined || ts.isArrayOf(parameters, ts.isParameter)) &&
+                    (modifiers === undefined || !ts.some(modifiers, ts.isDecorator)) &&
+                    (parameters === undefined || !ts.some(parameters, ts.isModifier)) &&
                     (body === undefined || !ts.isArray(body));
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], parameters = _a[3], body = _a[4];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                return (decorators === undefined || !ts.some(decorators, ts.isModifier)) &&
+                    (modifiers === undefined || !ts.some(modifiers, ts.isParameter)) &&
                     (parameters === undefined || ts.isArray(parameters)) &&
                     (body === undefined || ts.isBlock(body));
             },
@@ -184231,14 +184267,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], parameters = _a[1], type = _a[2], other = _a[3];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
-                    (parameters === undefined || ts.isArrayOf(parameters, ts.isParameter)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
+                    (parameters === undefined || ts.every(parameters, ts.isParameter)) &&
                     (type === undefined || !ts.isArray(type));
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], parameters = _a[2], type = _a[3];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (parameters === undefined || ts.isArray(parameters)) &&
                     (type === undefined || ts.isTypeNode(type));
             },
@@ -184260,14 +184296,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], parameters = _a[2], type = _a[3], other = _a[4];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
-                    (parameters === undefined || ts.isArrayOf(parameters, ts.isParameter)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
+                    (parameters === undefined || ts.every(parameters, ts.isParameter)) &&
                     (type === undefined || !ts.isArray(type));
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], parameters = _a[3], type = _a[4];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (parameters === undefined || ts.isArray(parameters)) &&
                     (type === undefined || ts.isTypeNode(type));
             },
@@ -184345,15 +184381,15 @@ var ts;
                 return (other === undefined) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
-                    (members === undefined || ts.isArrayOf(members, ts.isClassElement));
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
+                    (members === undefined || ts.every(members, ts.isClassElement));
             },
             1: function (_a) {
                 var modifiers = _a[1], name = _a[2], typeParameters = _a[3], heritageClauses = _a[4], members = _a[5];
                 return (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
+                    (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
                     (members === undefined || ts.isArray(members));
             },
         })
@@ -184376,15 +184412,15 @@ var ts;
                 return (other === undefined) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
-                    (members === undefined || ts.isArrayOf(members, ts.isClassElement));
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
+                    (members === undefined || ts.every(members, ts.isClassElement));
             },
             1: function (_a) {
                 var modifiers = _a[2], name = _a[3], typeParameters = _a[4], heritageClauses = _a[5], members = _a[6];
                 return (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
+                    (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
                     (members === undefined || ts.isArray(members));
             },
         })
@@ -184408,7 +184444,7 @@ var ts;
                     (asteriskToken === undefined || !ts.isArray(asteriskToken)) &&
                     (name === undefined || typeof name === "string" || ts.isIdentifier(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (parameters === undefined || ts.isArrayOf(parameters, ts.isParameter)) &&
+                    (parameters === undefined || ts.every(parameters, ts.isParameter)) &&
                     (type === undefined || !ts.isArray(type)) &&
                     (body === undefined || ts.isBlock(body));
             },
@@ -184417,7 +184453,7 @@ var ts;
                 return (modifiers === undefined || ts.isArray(modifiers)) &&
                     (asteriskToken === undefined || typeof asteriskToken !== "string" && ts.isAsteriskToken(asteriskToken)) &&
                     (name === undefined || !ts.isArray(name)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) &&
                     (parameters === undefined || ts.isArray(parameters)) &&
                     (type === undefined || ts.isTypeNode(type)) &&
                     (body === undefined || ts.isBlock(body));
@@ -184443,7 +184479,7 @@ var ts;
                     (asteriskToken === undefined || !ts.isArray(asteriskToken)) &&
                     (name === undefined || ts.isIdentifier(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (parameters === undefined || ts.isArrayOf(parameters, ts.isParameter)) &&
+                    (parameters === undefined || ts.every(parameters, ts.isParameter)) &&
                     (type === undefined || !ts.isArray(type)) &&
                     (body === undefined || ts.isBlock(body));
             },
@@ -184452,7 +184488,7 @@ var ts;
                 return (modifiers === undefined || ts.isArray(modifiers)) &&
                     (asteriskToken === undefined || typeof asteriskToken !== "string" && ts.isAsteriskToken(asteriskToken)) &&
                     (name === undefined || !ts.isArray(name)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) &&
                     (parameters === undefined || ts.isArray(parameters)) &&
                     (type === undefined || ts.isTypeNode(type)) &&
                     (body === undefined || ts.isBlock(body));
@@ -184477,8 +184513,8 @@ var ts;
                 return (other === undefined) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
-                    (members === undefined || ts.isArrayOf(members, ts.isClassElement));
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
+                    (members === undefined || ts.every(members, ts.isClassElement));
             },
             1: function () { return true; },
         })
@@ -184501,15 +184537,15 @@ var ts;
                 return (other === undefined) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
-                    (members === undefined || ts.isArrayOf(members, ts.isClassElement));
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
+                    (members === undefined || ts.every(members, ts.isClassElement));
             },
             1: function (_a) {
                 var modifiers = _a[2], name = _a[3], typeParameters = _a[4], heritageClauses = _a[5], members = _a[6];
                 return (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
+                    (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
                     (members === undefined || ts.isArray(members));
             },
         })
@@ -184530,19 +184566,19 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], name = _a[1], typeParameters = _a[2], heritageClauses = _a[3], members = _a[4], other = _a[5];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
-                    (members === undefined || ts.isArrayOf(members, ts.isTypeElement));
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
+                    (members === undefined || ts.every(members, ts.isTypeElement));
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], name = _a[2], typeParameters = _a[3], heritageClauses = _a[4], members = _a[5];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
+                    (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
                     (members === undefined || ts.every(members, ts.isTypeElement));
             },
         })
@@ -184563,19 +184599,19 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], name = _a[2], typeParameters = _a[3], heritageClauses = _a[4], members = _a[5], other = _a[6];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
-                    (members === undefined || ts.isArrayOf(members, ts.isTypeElement));
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
+                    (members === undefined || ts.every(members, ts.isTypeElement));
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], name = _a[3], typeParameters = _a[4], heritageClauses = _a[5], members = _a[6];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
-                    (typeParameters === undefined || ts.isArrayOf(typeParameters, ts.isTypeParameterDeclaration)) &&
-                    (heritageClauses === undefined || ts.isArrayOf(heritageClauses, ts.isHeritageClause)) &&
+                    (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) &&
+                    (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) &&
                     (members === undefined || ts.every(members, ts.isTypeElement));
             },
         })
@@ -184596,14 +184632,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], name = _a[1], typeParameters = _a[2], type = _a[3], other = _a[4];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
                     (type === undefined || !ts.isArray(type));
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], name = _a[2], typeParameters = _a[3], type = _a[4];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
@@ -184627,14 +184663,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], name = _a[2], typeParameters = _a[3], type = _a[4], other = _a[5];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
                     (type === undefined || !ts.isArray(type));
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], name = _a[3], typeParameters = _a[4], type = _a[5];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (typeParameters === undefined || ts.isArray(typeParameters)) &&
@@ -184658,13 +184694,13 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], name = _a[1], members = _a[2], other = _a[3];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (members === undefined || ts.isArray(members));
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], name = _a[2], members = _a[3];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (members === undefined || ts.isArray(members));
@@ -184687,13 +184723,13 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], name = _a[2], members = _a[3], other = _a[4];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (members === undefined || ts.isArray(members));
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], name = _a[3], members = _a[4];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (members === undefined || ts.isArray(members));
@@ -184716,14 +184752,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], name = _a[1], body = _a[2], flags = _a[3], other = _a[4];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (name !== undefined && !ts.isArray(name)) &&
                     (body === undefined || ts.isModuleBody(body)) &&
                     (flags === undefined || typeof flags === "number");
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], name = _a[2], body = _a[3], flags = _a[4];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name !== undefined && ts.isModuleName(name)) &&
                     (body === undefined || typeof body === "object") &&
@@ -184747,13 +184783,13 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], name = _a[2], body = _a[3], other = _a[4];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (name === undefined || !ts.isArray(name)) &&
                     (body === undefined || ts.isModuleBody(body));
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], name = _a[3], body = _a[4];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (name !== undefined && ts.isModuleName(name)) &&
                     (body === undefined || ts.isModuleBody(body));
@@ -184776,14 +184812,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], isTypeOnly = _a[1], name = _a[2], moduleReference = _a[3], other = _a[4];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (isTypeOnly === undefined || typeof isTypeOnly === "boolean") &&
                     (typeof name !== "boolean") &&
                     (typeof moduleReference !== "string");
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], isTypeOnly = _a[2], name = _a[3], moduleReference = _a[4];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (isTypeOnly === undefined || typeof isTypeOnly === "boolean") &&
                     (typeof name === "string" || ts.isIdentifier(name)) &&
@@ -184807,14 +184843,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], isTypeOnly = _a[2], name = _a[3], moduleReference = _a[4], other = _a[5];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (isTypeOnly === undefined || typeof isTypeOnly === "boolean") &&
                     (typeof name !== "boolean") &&
                     (typeof moduleReference !== "string");
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], isTypeOnly = _a[3], name = _a[4], moduleReference = _a[5];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (isTypeOnly === undefined || typeof isTypeOnly === "boolean") &&
                     (typeof name === "string" || ts.isIdentifier(name)) &&
@@ -184838,14 +184874,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], importClause = _a[1], moduleSpecifier = _a[2], assertClause = _a[3], other = _a[4];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (importClause === undefined || !ts.isArray(importClause)) &&
                     (moduleSpecifier !== undefined && ts.isExpression(moduleSpecifier)) &&
                     (assertClause === undefined || ts.isAssertClause(assertClause));
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], importClause = _a[2], moduleSpecifier = _a[3], assertClause = _a[4];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (importClause === undefined || ts.isImportClause(importClause)) &&
                     (moduleSpecifier !== undefined && ts.isExpression(moduleSpecifier)) &&
@@ -184869,14 +184905,14 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], importClause = _a[2], moduleSpecifier = _a[3], assertClause = _a[4], other = _a[5];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (importClause === undefined || !ts.isArray(importClause)) &&
                     (moduleSpecifier === undefined || ts.isExpression(moduleSpecifier)) &&
                     (assertClause === undefined || ts.isAssertClause(assertClause));
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], importClause = _a[3], moduleSpecifier = _a[4], assertClause = _a[5];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (importClause === undefined || ts.isImportClause(importClause)) &&
                     (moduleSpecifier !== undefined && ts.isExpression(moduleSpecifier)) &&
@@ -184900,13 +184936,13 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], isExportEquals = _a[1], expression = _a[2], other = _a[3];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (isExportEquals === undefined || typeof isExportEquals === "boolean") &&
                     (typeof expression === "object");
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], isExportEquals = _a[2], expression = _a[3];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (isExportEquals === undefined || typeof isExportEquals === "boolean") &&
                     (expression !== undefined && ts.isExpression(expression));
@@ -184929,12 +184965,12 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], expression = _a[2], other = _a[3];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (expression !== undefined && !ts.isArray(expression));
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], expression = _a[3];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (expression !== undefined && ts.isExpression(expression));
             },
@@ -184956,7 +184992,7 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[0], isTypeOnly = _a[1], exportClause = _a[2], moduleSpecifier = _a[3], assertClause = _a[4], other = _a[5];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (typeof isTypeOnly === "boolean") &&
                     (typeof exportClause !== "boolean") &&
                     (moduleSpecifier === undefined || ts.isExpression(moduleSpecifier)) &&
@@ -184964,7 +185000,7 @@ var ts;
             },
             1: function (_a) {
                 var decorators = _a[0], modifiers = _a[1], isTypeOnly = _a[2], exportClause = _a[3], moduleSpecifier = _a[4], assertClause = _a[5];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (typeof isTypeOnly === "boolean") &&
                     (exportClause === undefined || ts.isNamedExportBindings(exportClause)) &&
@@ -184989,7 +185025,7 @@ var ts;
             0: function (_a) {
                 var modifiers = _a[1], isTypeOnly = _a[2], exportClause = _a[3], moduleSpecifier = _a[4], assertClause = _a[5], other = _a[6];
                 return (other === undefined) &&
-                    (modifiers === undefined || ts.isArrayOf(modifiers, ts.isModifier)) &&
+                    (modifiers === undefined || ts.every(modifiers, ts.isModifier)) &&
                     (typeof isTypeOnly === "boolean") &&
                     (typeof exportClause !== "boolean") &&
                     (moduleSpecifier === undefined || ts.isExpression(moduleSpecifier)) &&
@@ -184997,7 +185033,7 @@ var ts;
             },
             1: function (_a) {
                 var decorators = _a[1], modifiers = _a[2], isTypeOnly = _a[3], exportClause = _a[4], moduleSpecifier = _a[5], assertClause = _a[6];
-                return (decorators === undefined || ts.isArrayOf(decorators, ts.isDecorator)) &&
+                return (decorators === undefined || ts.every(decorators, ts.isDecorator)) &&
                     (modifiers === undefined || ts.isArray(modifiers)) &&
                     (typeof isTypeOnly === "boolean") &&
                     (exportClause === undefined || ts.isNamedExportBindings(exportClause)) &&