typescript 4.9.0-dev.20220918 → 4.9.0-dev.20220920

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-dev.20220918");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20220920");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -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, "__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."),
@@ -10338,7 +10336,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) {
@@ -13471,7 +13469,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
@@ -14943,7 +14941,6 @@ var ts;
         return emitNode && emitNode.flags || 0;
     }
     ts.getEmitFlags = getEmitFlags;
-    ;
     function getScriptTargetFeatures() {
         return {
             es2015: {
@@ -19669,7 +19666,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) {
@@ -26954,7 +26951,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];
@@ -31842,7 +31839,6 @@ var ts;
             visitNodes(cbNode, cbNodes, node.parameters) ||
             visitNode(cbNode, node.type);
     }
-    ;
     function forEachChildInUnionOrIntersectionType(node, cbNode, cbNodes) {
         return visitNodes(cbNode, cbNodes, node.types);
     }
@@ -43158,7 +43154,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);
@@ -49542,6 +49538,7 @@ var ts;
             isPropertyAccessible: isPropertyAccessible,
             getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
             getMemberOverrideModifierStatus: getMemberOverrideModifierStatus,
+            isTypeParameterPossiblyReferenced: isTypeParameterPossiblyReferenced,
         };
         function runWithInferenceBlockedFromSourceNode(node, fn) {
             var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
@@ -49661,7 +49658,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);
@@ -49775,6 +49773,7 @@ var ts;
         var deferredGlobalOmitSymbol;
         var deferredGlobalAwaitedSymbol;
         var deferredGlobalBigIntType;
+        var deferredGlobalRecordSymbol;
         var allPotentiallyUnusedIdentifiers = new ts.Map(); // key is file name
         var flowLoopStart = 0;
         var flowLoopCount = 0;
@@ -50570,12 +50569,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;
@@ -50733,7 +50733,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;
@@ -50771,7 +50773,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;
                             }
                         }
@@ -50967,7 +50971,7 @@ var ts;
                 }
                 return undefined;
             }
-            else if (checkAndReportErrorForInvalidInitializer()) {
+            else if (nameNotFoundMessage && checkAndReportErrorForInvalidInitializer()) {
                 return undefined;
             }
             // Perform extra checks only if error reporting was requested
@@ -57128,7 +57132,6 @@ var ts;
                     return container;
                 }
             }
-            ;
         }
         /** Create a synthetic property access flow node after the last statement of the file */
         function getFlowTypeFromCommonJSExport(symbol) {
@@ -61874,6 +61877,10 @@ var ts;
         function getGlobalBigIntType() {
             return (deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", /*arity*/ 0, /*reportErrors*/ false))) || emptyObjectType;
         }
+        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.
          */
@@ -64599,9 +64606,10 @@ var ts;
                 node.parent.kind === 202 /* SyntaxKind.ImportType */ && node.parent.typeArguments && node === node.parent.qualifier);
         }
         function isTypeParameterPossiblyReferenced(tp, node) {
-            // If the type parameter doesn't have exactly one declaration, if there are invening statement blocks
+            // If the type parameter doesn't have exactly one declaration, if there are intervening statement blocks
             // between the node and the type parameter declaration, if the node contains actual references to the
-            // type parameter, or if the node contains type queries, we consider the type parameter possibly referenced.
+            // type parameter, or if the node contains type queries that we can't prove couldn't contain references to the type parameter,
+            // we consider the type parameter possibly referenced.
             if (tp.symbol && tp.symbol.declarations && tp.symbol.declarations.length === 1) {
                 var container = tp.symbol.declarations[0].parent;
                 for (var n = node; n !== container; n = n.parent) {
@@ -64620,6 +64628,27 @@ var ts;
                         return !tp.isThisType && ts.isPartOfTypeNode(node) && maybeTypeParameterReference(node) &&
                             getTypeFromTypeNodeWorker(node) === tp; // use worker because we're looking for === equality
                     case 183 /* SyntaxKind.TypeQuery */:
+                        var entityName = node.exprName;
+                        var firstIdentifier = ts.getFirstIdentifier(entityName);
+                        var firstIdentifierSymbol = getResolvedSymbol(firstIdentifier);
+                        var tpDeclaration = tp.symbol.declarations[0]; // There is exactly one declaration, otherwise `containsReference` is not called
+                        var tpScope_1;
+                        if (tpDeclaration.kind === 165 /* SyntaxKind.TypeParameter */) { // Type parameter is a regular type parameter, e.g. foo<T>
+                            tpScope_1 = tpDeclaration.parent;
+                        }
+                        else if (tp.isThisType) {
+                            // Type parameter is the this type, and its declaration is the class declaration.
+                            tpScope_1 = tpDeclaration;
+                        }
+                        else {
+                            // Type parameter's declaration was unrecognized.
+                            // This could happen if the type parameter comes from e.g. a JSDoc annotation, so we default to returning true.
+                            return true;
+                        }
+                        if (firstIdentifierSymbol.declarations) {
+                            return ts.some(firstIdentifierSymbol.declarations, function (idDecl) { return ts.isNodeDescendantOf(idDecl, tpScope_1); }) ||
+                                ts.some(node.typeArguments, containsReference);
+                        }
                         return true;
                     case 171 /* SyntaxKind.MethodDeclaration */:
                     case 170 /* SyntaxKind.MethodSignature */:
@@ -72168,18 +72197,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) {
@@ -72238,15 +72275,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;
@@ -76416,7 +76452,6 @@ var ts;
                 }
                 return false;
             }
-            ;
             var suggestedMethod = ts.isAssignmentTarget(expr) ? "set" : "get";
             if (!hasProp(suggestedMethod)) {
                 return undefined;
@@ -79987,6 +80022,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;
@@ -80003,40 +80041,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) {
@@ -88478,7 +88496,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)) {
@@ -88845,6 +88863,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);
@@ -95294,9 +95331,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;
@@ -110468,7 +110506,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)));
@@ -118517,7 +118555,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.
@@ -134594,7 +134631,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);
                             }
                         }
@@ -135447,7 +135484,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)) {
@@ -138151,7 +138187,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(); }
@@ -149232,19 +149267,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 */;
@@ -162228,7 +162263,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;
@@ -162705,7 +162739,6 @@ var ts;
                 });
                 return { edits: edits, renameFilename: undefined, renameLocation: undefined };
             }
-            ;
             function isValidExpression(node) {
                 return ts.isBinaryExpression(node) || ts.isConditionalExpression(node);
             }
@@ -162753,7 +162786,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) };
@@ -165097,7 +165129,6 @@ var ts;
 (function (ts) {
     var refactor;
     (function (refactor) {
-        ;
         /**
          * Checks if some refactor info has refactor error info.
          */
@@ -165202,7 +165233,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) {
@@ -175257,7 +175287,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());
                         }
                     }
@@ -178671,7 +178701,6 @@ var ts;
             }
             return ts.deduplicate(outputs, ts.equateValues);
         }
-        ;
         function createDocumentSpanSet() {
             return ts.createSet(function (_a) {
                 var textSpan = _a.textSpan;