typescript 4.9.0-dev.20220919 → 4.9.0-dev.20220921

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20220919");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20220921");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -2673,7 +2673,7 @@ var ts;
             if (typeof func !== "function") {
                 return "";
             }
-            else if (func.hasOwnProperty("name")) {
+            else if (ts.hasProperty(func, "name")) {
                 return func.name;
             }
             else {
@@ -2998,7 +2998,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: {
@@ -3853,7 +3853,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");
@@ -8685,8 +8684,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."),
@@ -8935,6 +8932,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."),
@@ -9115,6 +9113,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}'."),
@@ -10057,6 +10056,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?"),
@@ -10318,7 +10319,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) {
@@ -11879,12 +11880,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 */;
@@ -13451,7 +13476,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
@@ -14923,7 +14948,6 @@ var ts;
         return emitNode && emitNode.flags || 0;
     }
     ts.getEmitFlags = getEmitFlags;
-    ;
     function getScriptTargetFeatures() {
         return {
             es2015: {
@@ -19649,7 +19673,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) {
@@ -26934,7 +26958,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];
@@ -31822,7 +31846,6 @@ var ts;
             visitNodes(cbNode, cbNodes, node.parameters) ||
             visitNode(cbNode, node.type);
     }
-    ;
     function forEachChildInUnionOrIntersectionType(node, cbNode, cbNodes) {
         return visitNodes(cbNode, cbNodes, node.types);
     }
@@ -33124,7 +33147,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);
         }
@@ -43138,7 +43161,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);
@@ -49642,7 +49665,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);
@@ -49756,6 +49780,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;
@@ -50551,12 +50577,13 @@ var ts;
          * the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
          * the given name can be found.
          *
+         * @param nameNotFoundMessage If defined, we will report errors found during resolve.
          * @param isUse If true, this will count towards --noUnusedLocals / --noUnusedParameters.
          */
-        function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggstions) {
+        function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions) {
             if (excludeGlobals === void 0) { excludeGlobals = false; }
-            if (getSpellingSuggstions === void 0) { getSpellingSuggstions = true; }
-            return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggstions, getSymbol);
+            if (getSpellingSuggestions === void 0) { getSpellingSuggestions = true; }
+            return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, getSymbol);
         }
         function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, lookup) {
             var _a, _b, _c;
@@ -50714,7 +50741,9 @@ var ts;
                                 // TypeScript 1.0 spec (April 2014): 3.4.1
                                 // The scope of a type parameter extends over the entire declaration with which the type
                                 // parameter list is associated, with the exception of static member declarations in classes.
-                                error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
+                                if (nameNotFoundMessage) {
+                                    error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
+                                }
                                 return undefined;
                             }
                             break loop;
@@ -50752,7 +50781,9 @@ var ts;
                         if (ts.isClassLike(grandparent) || grandparent.kind === 261 /* SyntaxKind.InterfaceDeclaration */) {
                             // A reference to this grandparent's type parameters would be an error
                             if (result = lookup(getSymbolOfNode(grandparent).members, name, meaning & 788968 /* SymbolFlags.Type */)) {
-                                error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
+                                if (nameNotFoundMessage) {
+                                    error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
+                                }
                                 return undefined;
                             }
                         }
@@ -50948,7 +50979,7 @@ var ts;
                 }
                 return undefined;
             }
-            else if (checkAndReportErrorForInvalidInitializer()) {
+            else if (nameNotFoundMessage && checkAndReportErrorForInvalidInitializer()) {
                 return undefined;
             }
             // Perform extra checks only if error reporting was requested
@@ -57109,7 +57140,6 @@ var ts;
                     return container;
                 }
             }
-            ;
         }
         /** Create a synthetic property access flow node after the last statement of the file */
         function getFlowTypeFromCommonJSExport(symbol) {
@@ -60239,7 +60269,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
@@ -60287,7 +60317,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;
@@ -60389,6 +60423,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
@@ -61103,7 +61164,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) {
@@ -61117,7 +61178,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;
             }
@@ -61134,7 +61195,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
@@ -61198,7 +61259,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);
@@ -61855,6 +61916,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.
          */
@@ -62091,7 +62159,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 */) {
@@ -62121,9 +62189,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++) {
@@ -62151,7 +62219,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);
@@ -62317,7 +62385,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); })) {
@@ -62325,7 +62393,7 @@ var ts;
                     }
                 };
                 while (i > 0) {
-                    _loop_17();
+                    _loop_18();
                 }
             }
         }
@@ -62402,14 +62470,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];
@@ -63639,7 +63707,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;
@@ -63760,10 +63828,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;
@@ -66378,7 +66446,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) {
@@ -66441,9 +66509,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;
             }
@@ -67434,11 +67502,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)
@@ -67454,8 +67522,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;
                             }
                         }
@@ -67468,9 +67536,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 */;
@@ -68175,7 +68243,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 */ :
@@ -68213,7 +68281,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) });
@@ -68805,7 +68873,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) {
@@ -70170,7 +70239,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
@@ -70220,7 +70289,7 @@ var ts;
                         inferFromTypes(source_1, target_3);
                     };
                     for (var i = 0; i < types.length; i++) {
-                        _loop_24(i);
+                        _loop_25(i);
                     }
                 }
             }
@@ -70684,7 +70753,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));
                 }
@@ -70744,7 +70813,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) {
@@ -70770,9 +70839,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;
         }
@@ -72171,18 +72240,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) {
@@ -72241,15 +72318,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;
@@ -76419,7 +76495,6 @@ var ts;
                 }
                 return false;
             }
-            ;
             var suggestedMethod = ts.isAssignmentTarget(expr) ? "set" : "get";
             if (!hasProp(suggestedMethod)) {
                 return undefined;
@@ -77221,7 +77296,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));
@@ -77238,7 +77313,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_26(i);
+                    _loop_27(i);
                 }
                 return effectiveArgs_1;
             }
@@ -77567,7 +77642,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) {
@@ -77585,7 +77660,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");
@@ -77743,7 +77818,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; });
@@ -77751,7 +77826,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 */;
@@ -79990,6 +80065,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;
@@ -80006,40 +80084,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) {
@@ -80550,6 +80608,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 */:
@@ -80755,6 +80814,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;
@@ -81792,7 +81871,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));
@@ -81807,7 +81886,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) {
@@ -85407,7 +85486,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
@@ -85424,7 +85503,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) {
@@ -85432,7 +85511,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;
@@ -85447,7 +85526,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) {
@@ -85767,7 +85846,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";
                 }
@@ -85784,7 +85863,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_32(member);
+                _loop_33(member);
             }
         }
         /**
@@ -85872,7 +85951,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";
                 }
@@ -85891,7 +85970,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
@@ -85962,7 +86041,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";
@@ -86072,8 +86151,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;
                 }
             }
@@ -88481,7 +88560,7 @@ var ts;
             }
             var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier);
             if (node) {
-                var symbol = getReferencedValueSymbol(node);
+                var symbol = getReferencedValueOrAliasSymbol(node);
                 // We should only get the declaration of an alias if there isn't a local value
                 // declaration for the symbol
                 if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !getTypeOnlyAliasDeclaration(symbol)) {
@@ -88848,6 +88927,25 @@ var ts;
             }
             return resolveName(location, reference.escapedText, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */ | 2097152 /* SymbolFlags.Alias */, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ true);
         }
+        /**
+         * Get either a value-meaning symbol or an alias symbol.
+         * Unlike `getReferencedValueSymbol`, if the cached resolved symbol is the unknown symbol,
+         * we call `resolveName` to find a symbol.
+         * This is because when caching the resolved symbol, we only consider value symbols, but here
+         * we want to also get an alias symbol if one exists.
+         */
+        function getReferencedValueOrAliasSymbol(reference) {
+            var resolvedSymbol = getNodeLinks(reference).resolvedSymbol;
+            if (resolvedSymbol && resolvedSymbol !== unknownSymbol) {
+                return resolvedSymbol;
+            }
+            return resolveName(reference, reference.escapedText, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */ | 2097152 /* SymbolFlags.Alias */, 
+            /*nodeNotFoundMessage*/ undefined, 
+            /*nameArg*/ undefined, 
+            /*isUse*/ true, 
+            /*excludeGlobals*/ undefined, 
+            /*getSpellingSuggestions*/ undefined);
+        }
         function getReferencedValueDeclaration(referenceIn) {
             if (!ts.isGeneratedIdentifier(referenceIn)) {
                 var reference = ts.getParseTreeNode(referenceIn, ts.isIdentifier);
@@ -95297,9 +95395,10 @@ var ts;
             return ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node) ? resolver.getConstantValue(node) : undefined;
         }
         function shouldEmitAliasDeclaration(node) {
-            return compilerOptions.preserveValueImports
-                ? resolver.isValueAliasDeclaration(node)
-                : resolver.isReferencedAliasDeclaration(node);
+            return ts.isInJSFile(node) ||
+                (compilerOptions.preserveValueImports
+                    ? resolver.isValueAliasDeclaration(node)
+                    : resolver.isReferencedAliasDeclaration(node));
         }
     }
     ts.transformTypeScript = transformTypeScript;
@@ -110471,7 +110570,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)));
@@ -118520,7 +118619,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.
@@ -124897,7 +124995,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) {
@@ -124921,9 +125019,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) {
@@ -124992,7 +125090,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,
@@ -125059,9 +125157,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) {