typescript 4.8.0-dev.20220527 → 4.8.0-dev.20220530

package/lib/typescriptServices.js

@@ -294,7 +294,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 = ts.versionMajorMinor + ".0-dev.20220527";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220530";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -5295,6 +5295,11 @@ var ts;
         // Flags that require TypeFlags.Union
         /* @internal */
         ObjectFlags[ObjectFlags["ContainsIntersections"] = 16777216] = "ContainsIntersections";
+        /* @internal */
+        ObjectFlags[ObjectFlags["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
+        /* @internal */
+        ObjectFlags[ObjectFlags["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
+        /* @internal */
         // Flags that require TypeFlags.Intersection
         /* @internal */
         ObjectFlags[ObjectFlags["IsNeverIntersectionComputed"] = 16777216] = "IsNeverIntersectionComputed";
@@ -8608,6 +8613,7 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
+        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
@@ -48741,6 +48747,7 @@ var ts;
         var emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* 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 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);
@@ -58911,7 +58918,7 @@ var ts;
                         }
                     }
                 }
-                else if (t.flags & 469892092 /* DisjointDomains */) {
+                else if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
                     hasDisjointDomainType = true;
                 }
             }
@@ -58923,7 +58930,7 @@ var ts;
                     // intersection operation to reduce the union constraints.
                     for (var _a = 0, types_6 = types; _a < types_6.length; _a++) {
                         var t = types_6[_a];
-                        if (t.flags & 469892092 /* DisjointDomains */) {
+                        if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
                             constraints = ts.append(constraints, t);
                         }
                     }
@@ -61472,7 +61479,7 @@ var ts;
             }
             return includes;
         }
-        function removeRedundantPrimitiveTypes(types, includes) {
+        function removeRedundantSupertypes(types, includes) {
             var i = types.length;
             while (i > 0) {
                 i--;
@@ -61480,7 +61487,9 @@ var ts;
                 var remove = t.flags & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ||
                     t.flags & 8 /* Number */ && includes & 256 /* NumberLiteral */ ||
                     t.flags & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ ||
-                    t.flags & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */;
+                    t.flags & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ ||
+                    t.flags & 16384 /* Void */ && includes & 32768 /* Undefined */ ||
+                    isEmptyAnonymousObjectType(t) && includes & 470302716 /* DefinitelyNonNullable */;
                 if (remove) {
                     ts.orderedRemoveItemAt(types, i);
                 }
@@ -61602,7 +61611,7 @@ var ts;
         // a type alias of the form "type List<T> = T & { next: List<T> }" cannot be reduced during its declaration.
         // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution
         // for intersections of types with signatures can be deterministic.
-        function getIntersectionType(types, aliasSymbol, aliasTypeArguments) {
+        function getIntersectionType(types, aliasSymbol, aliasTypeArguments, noSupertypeReduction) {
             var typeMembershipMap = new ts.Map();
             var includes = addTypesToIntersection(typeMembershipMap, 0, types);
             var typeSet = ts.arrayFrom(typeMembershipMap.values());
@@ -61639,11 +61648,11 @@ var ts;
             if (includes & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ||
                 includes & 8 /* Number */ && includes & 256 /* NumberLiteral */ ||
                 includes & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ ||
-                includes & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */) {
-                removeRedundantPrimitiveTypes(typeSet, includes);
-            }
-            if (includes & 16777216 /* IncludesEmptyObject */ && includes & 524288 /* Object */) {
-                ts.orderedRemoveItemAt(typeSet, ts.findIndex(typeSet, isEmptyAnonymousObjectType));
+                includes & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ ||
+                includes & 16384 /* Void */ && includes & 32768 /* Undefined */ ||
+                includes & 16777216 /* IncludesEmptyObject */ && includes & 470302716 /* DefinitelyNonNullable */) {
+                if (!noSupertypeReduction)
+                    removeRedundantSupertypes(typeSet, includes);
             }
             if (includes & 262144 /* IncludesMissingType */) {
                 typeSet[typeSet.indexOf(undefinedType)] = missingType;
@@ -61682,8 +61691,9 @@ var ts;
                         }
                         var constituents = getCrossProductIntersections(typeSet);
                         // We attach a denormalized origin type when at least one constituent of the cross-product union is an
-                        // intersection (i.e. when the intersection didn't just reduce one or more unions to smaller unions).
-                        var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* Intersection */); }) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : undefined;
+                        // intersection (i.e. when the intersection didn't just reduce one or more unions to smaller unions) and
+                        // the denormalized origin has fewer constituents than the union itself.
+                        var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* Intersection */); }) && getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : undefined;
                         result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
                     }
                 }
@@ -61726,11 +61736,21 @@ var ts;
             }
             return intersections;
         }
+        function getConstituentCount(type) {
+            return !(type.flags & 3145728 /* UnionOrIntersection */) || type.aliasSymbol ? 1 :
+                type.flags & 1048576 /* Union */ && type.origin ? getConstituentCount(type.origin) :
+                    getConstituentCountOfTypes(type.types);
+        }
+        function getConstituentCountOfTypes(types) {
+            return ts.reduceLeft(types, function (n, t) { return n + getConstituentCount(t); }, 0);
+        }
         function getTypeFromIntersectionTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
-                links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
+                var types = ts.map(node.types, getTypeFromTypeNode);
+                var noSupertypeReduction = types.length === 2 && !!(types[0].flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) && types[1] === emptyTypeLiteralType;
+                links.resolvedType = getIntersectionType(types, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), noSupertypeReduction);
             }
             return links.resolvedType;
         }
@@ -64516,6 +64536,17 @@ var ts;
             return !!(ts.getObjectFlags(type) & 16 /* Anonymous */ && (type.members && isEmptyResolvedType(type) ||
                 type.symbol && type.symbol.flags & 2048 /* TypeLiteral */ && getMembersOfSymbol(type.symbol).size === 0));
         }
+        function isUnknownLikeUnionType(type) {
+            if (strictNullChecks && type.flags & 1048576 /* Union */) {
+                if (!(type.objectFlags & 33554432 /* IsUnknownLikeUnionComputed */)) {
+                    var types = type.types;
+                    type.objectFlags |= 33554432 /* IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 32768 /* Undefined */ &&
+                        types[1].flags & 65536 /* Null */ && ts.some(types, isEmptyAnonymousObjectType) ? 67108864 /* IsUnknownLikeUnion */ : 0);
+                }
+                return !!(type.objectFlags & 67108864 /* IsUnknownLikeUnion */);
+            }
+            return false;
+        }
         function isStringIndexSignatureOnlyType(type) {
             return type.flags & 524288 /* Object */ && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, stringType) ||
                 type.flags & 3145728 /* UnionOrIntersection */ && ts.every(type.types, isStringIndexSignatureOnlyType) ||
@@ -64595,7 +64626,7 @@ var ts;
                 return true;
             if (s & 65536 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 65536 /* Null */))
                 return true;
-            if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */)
+            if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source)))
                 return true;
             if (relation === assignableRelation || relation === comparableRelation) {
                 if (s & 1 /* Any */)
@@ -64605,6 +64636,9 @@ var ts;
                 // bit-flag enum types sometimes look like literal enum types with numeric literal values.
                 if (s & (8 /* Number */ | 256 /* NumberLiteral */) && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || relation === assignableRelation && t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
                     return true;
+                // Anything is assignable to a union containing undefined, null, and {}
+                if (isUnknownLikeUnionType(target))
+                    return true;
             }
             return false;
         }
@@ -64647,16 +64681,27 @@ var ts;
         function getNormalizedType(type, writing) {
             while (true) {
                 var t = isFreshLiteralType(type) ? type.regularType :
-                    ts.getObjectFlags(type) & 4 /* Reference */ && type.node ? createTypeReference(type.target, getTypeArguments(type)) :
-                        type.flags & 3145728 /* UnionOrIntersection */ ? getReducedType(type) :
+                    ts.getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type :
+                        type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) :
                             type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : type.substitute :
                                 type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) :
                                     type;
-                t = getSingleBaseForNonAugmentingSubtype(t) || t;
                 if (t === type)
-                    break;
+                    return t;
                 type = t;
             }
+        }
+        function getNormalizedUnionOrIntersectionType(type, writing) {
+            var reduced = getReducedType(type);
+            if (reduced !== type) {
+                return reduced;
+            }
+            if (type.flags & 2097152 /* Intersection */) {
+                var normalizedTypes = ts.sameMap(type.types, function (t) { return getNormalizedType(t, writing); });
+                if (normalizedTypes !== type.types) {
+                    return getIntersectionType(normalizedTypes);
+                }
+            }
             return type;
         }
         /**
@@ -65103,6 +65148,7 @@ var ts;
                 return 0 /* False */;
             }
             function reportErrorResults(originalSource, originalTarget, source, target, headMessage) {
+                var _a, _b;
                 var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
                 var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
                 source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
@@ -65143,6 +65189,9 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
+                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
+                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
                 if (!ts.tracing) {
@@ -65929,13 +65978,6 @@ var ts;
                     // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
                     if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
                         var constraint = getConstraintOfType(source) || unknownType;
-                        if (!getConstraintOfType(source) || (sourceFlags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
-                            // A type variable with no constraint is not related to the non-primitive object type.
-                            if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */), 3 /* Both */)) {
-                                resetErrorInfo(saveErrorInfo);
-                                return result;
-                            }
-                        }
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
                         if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
@@ -67409,9 +67451,11 @@ var ts;
                 return getSupertypeOrUnion(types);
             }
             var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
-            return primaryTypes.length ?
-                getNullableType(getSupertypeOrUnion(primaryTypes), getFalsyFlagsOfTypes(types) & 98304 /* Nullable */) :
-                getUnionType(types, 2 /* Subtype */);
+            if (primaryTypes.length) {
+                var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
+                return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
+            }
+            return getUnionType(types, 2 /* Subtype */);
         }
         // Return the leftmost type for which no type to the right is a subtype.
         function getCommonSubtype(types) {
@@ -67610,12 +67654,13 @@ var ts;
         // flags for the string, number, boolean, "", 0, false, void, undefined, or null types respectively. Returns
         // no flags for all other types (including non-falsy literal types).
         function getFalsyFlags(type) {
-            return type.flags & 1048576 /* Union */ ? getFalsyFlagsOfTypes(type.types) :
-                type.flags & 128 /* StringLiteral */ ? type.value === "" ? 128 /* StringLiteral */ : 0 :
-                    type.flags & 256 /* NumberLiteral */ ? type.value === 0 ? 256 /* NumberLiteral */ : 0 :
-                        type.flags & 2048 /* BigIntLiteral */ ? isZeroBigInt(type) ? 2048 /* BigIntLiteral */ : 0 :
-                            type.flags & 512 /* BooleanLiteral */ ? (type === falseType || type === regularFalseType) ? 512 /* BooleanLiteral */ : 0 :
-                                type.flags & 117724 /* PossiblyFalsy */;
+            var t = type.flags & 2097152 /* Intersection */ ? getBaseConstraintOrType(type) : type;
+            return t.flags & 1048576 /* Union */ ? getFalsyFlagsOfTypes(t.types) :
+                t.flags & 128 /* StringLiteral */ ? t.value === "" ? 128 /* StringLiteral */ : 0 :
+                    t.flags & 256 /* NumberLiteral */ ? t.value === 0 ? 256 /* NumberLiteral */ : 0 :
+                        t.flags & 2048 /* BigIntLiteral */ ? isZeroBigInt(t) ? 2048 /* BigIntLiteral */ : 0 :
+                            t.flags & 512 /* BooleanLiteral */ ? (t === falseType || t === regularFalseType) ? 512 /* BooleanLiteral */ : 0 :
+                                t.flags & 117724 /* PossiblyFalsy */;
         }
         function removeDefinitelyFalsyTypes(type) {
             return getFalsyFlags(type) & 117632 /* DefinitelyFalsy */ ?
@@ -67655,20 +67700,22 @@ var ts;
             return type.flags & 32768 /* Undefined */ ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
         }
         function getGlobalNonNullableTypeInstantiation(type) {
-            // First reduce away any constituents that are assignable to 'undefined' or 'null'. This not only eliminates
-            // 'undefined' and 'null', but also higher-order types such as a type parameter 'U extends undefined | null'
-            // that isn't eliminated by a NonNullable<T> instantiation.
-            var reducedType = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
             if (!deferredGlobalNonNullableTypeAlias) {
                 deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288 /* TypeAlias */, /*diagnostic*/ undefined) || unknownSymbol;
             }
-            // If the NonNullable<T> type is available, return an instantiation. Otherwise just return the reduced type.
             return deferredGlobalNonNullableTypeAlias !== unknownSymbol ?
-                getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [reducedType]) :
-                reducedType;
+                getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]) :
+                getIntersectionType([type, emptyObjectType]);
         }
         function getNonNullableType(type) {
-            return strictNullChecks ? getGlobalNonNullableTypeInstantiation(type) : type;
+            if (strictNullChecks) {
+                // First reduce away any constituents that are assignable to 'undefined' or 'null'. This not only eliminates
+                // 'undefined' and 'null', but also higher-order types such as a type parameter 'U extends undefined | null'
+                // that isn't eliminated by a NonNullable<T> instantiation.
+                var reducedType = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                return maybeTypeOfKind(reducedType, 465829888 /* Instantiable */) ? getGlobalNonNullableTypeInstantiation(reducedType) : reducedType;
+            }
+            return type;
         }
         function addOptionalTypeMarker(type) {
             return strictNullChecks ? getUnionType([type, optionalType]) : type;
@@ -68349,13 +68396,40 @@ var ts;
             return sourceStart.slice(0, startLen) !== targetStart.slice(0, startLen) ||
                 sourceEnd.slice(sourceEnd.length - endLen) !== targetEnd.slice(targetEnd.length - endLen);
         }
-        function isValidBigIntString(s) {
+        /**
+         * Tests whether the provided string can be parsed as a number.
+         * @param s The string to test.
+         * @param roundTripOnly Indicates the resulting number matches the input when converted back to a string.
+         */
+        function isValidNumberString(s, roundTripOnly) {
+            if (s === "")
+                return false;
+            var n = +s;
+            return isFinite(n) && (!roundTripOnly || "" + n === s);
+        }
+        /**
+         * @param text a valid bigint string excluding a trailing `n`, but including a possible prefix `-`. Use `isValidBigIntString(text, roundTripOnly)` before calling this function.
+         */
+        function parseBigIntLiteralType(text) {
+            var negative = text.startsWith("-");
+            var base10Value = ts.parsePseudoBigInt((negative ? text.slice(1) : text) + "n");
+            return getBigIntLiteralType({ negative: negative, base10Value: base10Value });
+        }
+        /**
+         * Tests whether the provided string can be parsed as a bigint.
+         * @param s The string to test.
+         * @param roundTripOnly Indicates the resulting bigint matches the input when converted back to a string.
+         */
+        function isValidBigIntString(s, roundTripOnly) {
+            if (s === "")
+                return false;
             var scanner = ts.createScanner(99 /* ESNext */, /*skipTrivia*/ false);
             var success = true;
             scanner.setOnError(function () { return success = false; });
             scanner.setText(s + "n");
             var result = scanner.scan();
-            if (result === 40 /* MinusToken */) {
+            var negative = result === 40 /* MinusToken */;
+            if (negative) {
                 result = scanner.scan();
             }
             var flags = scanner.getTokenFlags();
@@ -68364,7 +68438,8 @@ var ts;
             // * a bigint can be scanned, and that when it is scanned, it is
             // * the full length of the input string (so the scanner is one character beyond the augmented input length)
             // * it does not contain a numeric seperator (the `BigInt` constructor does not accept a numeric seperator in its input)
-            return success && result === 9 /* BigIntLiteral */ && scanner.getTextPos() === (s.length + 1) && !(flags & 512 /* ContainsSeparator */);
+            return success && result === 9 /* BigIntLiteral */ && scanner.getTextPos() === (s.length + 1) && !(flags & 512 /* ContainsSeparator */)
+                && (!roundTripOnly || s === ts.pseudoBigIntToString({ negative: negative, base10Value: ts.parsePseudoBigInt(scanner.getTokenValue()) }));
         }
         function isValidTypeForTemplateLiteralPlaceholder(source, target) {
             if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
@@ -68372,8 +68447,8 @@ var ts;
             }
             if (source.flags & 128 /* StringLiteral */) {
                 var value = source.value;
-                return !!(target.flags & 8 /* Number */ && value !== "" && isFinite(+value) ||
-                    target.flags & 64 /* BigInt */ && value !== "" && isValidBigIntString(value) ||
+                return !!(target.flags & 8 /* Number */ && isValidNumberString(value, /*roundTripOnly*/ false) ||
+                    target.flags & 64 /* BigInt */ && isValidBigIntString(value, /*roundTripOnly*/ false) ||
                     target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName);
             }
             if (source.flags & 134217728 /* TemplateLiteral */) {
@@ -68946,8 +69021,57 @@ 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_23 = 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
+                        // allowed template literal placeholder types, infer from a literal type corresponding to the constraint.
+                        if (source_1.flags & 128 /* StringLiteral */ && target_3.flags & 8650752 /* TypeVariable */) {
+                            var inferenceContext = getInferenceInfoForType(target_3);
+                            var constraint = inferenceContext ? getBaseConstraintOfType(inferenceContext.typeParameter) : undefined;
+                            if (constraint && !isTypeAny(constraint)) {
+                                var constraintTypes = constraint.flags & 1048576 /* Union */ ? constraint.types : [constraint];
+                                var allTypeFlags_1 = ts.reduceLeft(constraintTypes, function (flags, t) { return flags | t.flags; }, 0);
+                                // If the constraint contains `string`, we don't need to look for a more preferred type
+                                if (!(allTypeFlags_1 & 4 /* String */)) {
+                                    var str_1 = source_1.value;
+                                    // If the type contains `number` or a number literal and the string isn't a valid number, exclude numbers
+                                    if (allTypeFlags_1 & 296 /* NumberLike */ && !isValidNumberString(str_1, /*roundTripOnly*/ true)) {
+                                        allTypeFlags_1 &= ~296 /* NumberLike */;
+                                    }
+                                    // If the type contains `bigint` or a bigint literal and the string isn't a valid bigint, exclude bigints
+                                    if (allTypeFlags_1 & 2112 /* BigIntLike */ && !isValidBigIntString(str_1, /*roundTripOnly*/ true)) {
+                                        allTypeFlags_1 &= ~2112 /* BigIntLike */;
+                                    }
+                                    // for each type in the constraint, find the highest priority matching type
+                                    var matchingType = ts.reduceLeft(constraintTypes, function (left, right) {
+                                        return !(right.flags & allTypeFlags_1) ? left :
+                                            left.flags & 4 /* String */ ? left : right.flags & 4 /* String */ ? source_1 :
+                                                left.flags & 134217728 /* TemplateLiteral */ ? left : right.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source_1, right) ? source_1 :
+                                                    left.flags & 268435456 /* StringMapping */ ? left : right.flags & 268435456 /* StringMapping */ && str_1 === applyStringMapping(right.symbol, str_1) ? source_1 :
+                                                        left.flags & 128 /* StringLiteral */ ? left : right.flags & 128 /* StringLiteral */ && right.value === str_1 ? right :
+                                                            left.flags & 8 /* Number */ ? left : right.flags & 8 /* Number */ ? getNumberLiteralType(+str_1) :
+                                                                left.flags & 32 /* Enum */ ? left : right.flags & 32 /* Enum */ ? getNumberLiteralType(+str_1) :
+                                                                    left.flags & 256 /* NumberLiteral */ ? left : right.flags & 256 /* NumberLiteral */ && right.value === +str_1 ? right :
+                                                                        left.flags & 64 /* BigInt */ ? left : right.flags & 64 /* BigInt */ ? parseBigIntLiteralType(str_1) :
+                                                                            left.flags & 2048 /* BigIntLiteral */ ? left : right.flags & 2048 /* BigIntLiteral */ && ts.pseudoBigIntToString(right.value) === str_1 ? right :
+                                                                                left.flags & 16 /* Boolean */ ? left : right.flags & 16 /* Boolean */ ? str_1 === "true" ? trueType : str_1 === "false" ? falseType : booleanType :
+                                                                                    left.flags & 512 /* BooleanLiteral */ ? left : right.flags & 512 /* BooleanLiteral */ && right.intrinsicName === str_1 ? right :
+                                                                                        left.flags & 32768 /* Undefined */ ? left : right.flags & 32768 /* Undefined */ && right.intrinsicName === str_1 ? right :
+                                                                                            left.flags & 65536 /* Null */ ? left : right.flags & 65536 /* Null */ && right.intrinsicName === str_1 ? right :
+                                                                                                left;
+                                    }, neverType);
+                                    if (!(matchingType.flags & 131072 /* Never */)) {
+                                        inferFromTypes(matchingType, target_3);
+                                        return "continue";
+                                    }
+                                }
+                            }
+                        }
+                        inferFromTypes(source_1, target_3);
+                    };
                     for (var i = 0; i < types.length; i++) {
-                        inferFromTypes(matches ? matches[i] : neverType, types[i]);
+                        _loop_23(i);
                     }
                 }
             }
@@ -69465,7 +69589,7 @@ var ts;
         function mapTypesByKeyProperty(types, name) {
             var map = new ts.Map();
             var count = 0;
-            var _loop_23 = function (type) {
+            var _loop_24 = function (type) {
                 if (type.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
                     var discriminant = getTypeOfPropertyOfType(type, name);
                     if (discriminant) {
@@ -69491,7 +69615,7 @@ var ts;
             };
             for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
                 var type = types_16[_i];
-                var state_9 = _loop_23(type);
+                var state_9 = _loop_24(type);
                 if (typeof state_9 === "object")
                     return state_9.value;
             }
@@ -69699,6 +69823,24 @@ var ts;
         function getTypeWithFacts(type, include) {
             return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; });
         }
+        function getIntersectionWithFacts(type, facts) {
+            var reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* Unknown */ ? unknownUnionType : type, facts));
+            if (strictNullChecks) {
+                switch (facts) {
+                    case 524288 /* NEUndefined */:
+                        return mapType(reduced, function (t) { return getTypeFacts(t) & 65536 /* EQUndefined */ ? getIntersectionType([t, getTypeFacts(t) & 131072 /* EQNull */ && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t; });
+                    case 1048576 /* NENull */:
+                        return mapType(reduced, function (t) { return getTypeFacts(t) & 131072 /* EQNull */ ? getIntersectionType([t, getTypeFacts(t) & 65536 /* EQUndefined */ && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t; });
+                    case 2097152 /* NEUndefinedOrNull */:
+                    case 4194304 /* Truthy */:
+                        return mapType(reduced, function (t) { return getTypeFacts(t) & 262144 /* EQUndefinedOrNull */ ? getGlobalNonNullableTypeInstantiation(t) : t; });
+                }
+            }
+            return reduced;
+        }
+        function recombineUnknownType(type) {
+            return type === unknownUnionType ? unknownType : type;
+        }
         function getTypeWithDefault(type, defaultExpression) {
             return defaultExpression ?
                 getUnionType([getNonUndefinedType(type), getTypeOfExpression(defaultExpression)]) :
@@ -70756,7 +70898,7 @@ var ts;
                 if (isEvolvingArrayTypeList(types)) {
                     return getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType)));
                 }
-                var result = getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction);
+                var result = recombineUnknownType(getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction));
                 if (result !== declaredType && result.flags & declaredType.flags & 1048576 /* Union */ && ts.arraysEqual(result.types, declaredType.types)) {
                     return declaredType;
                 }
@@ -70858,8 +71000,7 @@ var ts;
             }
             function narrowTypeByTruthiness(type, expr, assumeTrue) {
                 if (isMatchingReference(reference, expr)) {
-                    return type.flags & 2 /* Unknown */ && assumeTrue ? nonNullUnknownType :
-                        getTypeWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
+                    return getIntersectionWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
                 }
                 if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) {
                     type = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
@@ -71012,9 +71153,6 @@ var ts;
                     assumeTrue = !assumeTrue;
                 }
                 var valueType = getTypeOfExpression(value);
-                if (assumeTrue && (type.flags & 2 /* Unknown */) && (operator === 34 /* EqualsEqualsToken */ || operator === 35 /* ExclamationEqualsToken */) && (valueType.flags & 65536 /* Null */)) {
-                    return getUnionType([nullType, undefinedType]);
-                }
                 if ((type.flags & 2 /* Unknown */) && assumeTrue && (operator === 36 /* EqualsEqualsEqualsToken */ || operator === 37 /* ExclamationEqualsEqualsToken */)) {
                     if (valueType.flags & (131068 /* Primitive */ | 67108864 /* NonPrimitive */)) {
                         return valueType;
@@ -71034,7 +71172,7 @@ var ts;
                         valueType.flags & 65536 /* Null */ ?
                             assumeTrue ? 131072 /* EQNull */ : 1048576 /* NENull */ :
                             assumeTrue ? 65536 /* EQUndefined */ : 524288 /* NEUndefined */;
-                    return type.flags & 2 /* Unknown */ && facts & (1048576 /* NENull */ | 2097152 /* NEUndefinedOrNull */) ? nonNullUnknownType : getTypeWithFacts(type, facts);
+                    return getIntersectionWithFacts(type, facts);
                 }
                 if (assumeTrue) {
                     var filterFn = operator === 34 /* EqualsEqualsToken */ ?
@@ -71062,17 +71200,11 @@ var ts;
                 if (type.flags & 1 /* Any */ && literal.text === "function") {
                     return type;
                 }
-                if (assumeTrue && type.flags & 2 /* Unknown */ && literal.text === "object") {
-                    // The non-null unknown type is used to track whether a previous narrowing operation has removed the null type
-                    // from the unknown type. For example, the expression `x && typeof x === 'object'` first narrows x to the non-null
-                    // unknown type, and then narrows that to the non-primitive type.
-                    return type === nonNullUnknownType ? nonPrimitiveType : getUnionType([nonPrimitiveType, nullType]);
-                }
                 var facts = assumeTrue ?
                     typeofEQFacts.get(literal.text) || 128 /* TypeofEQHostObject */ :
                     typeofNEFacts.get(literal.text) || 32768 /* TypeofNEHostObject */;
                 var impliedType = getImpliedTypeFromTypeofGuard(type, literal.text);
-                return getTypeWithFacts(assumeTrue && impliedType ? mapType(type, narrowUnionMemberByTypeof(impliedType)) : type, facts);
+                return getTypeWithFacts(assumeTrue && impliedType ? narrowTypeByImpliedType(type, impliedType) : type, facts);
             }
             function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
                 var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
@@ -71121,10 +71253,10 @@ var ts;
             }
             function getImpliedTypeFromTypeofGuard(type, text) {
                 switch (text) {
+                    case "object":
+                        return type.flags & 1 /* Any */ ? type : getUnionType([nullType, nonPrimitiveType]);
                     case "function":
                         return type.flags & 1 /* Any */ ? type : globalFunctionType;
-                    case "object":
-                        return type.flags & 2 /* Unknown */ ? getUnionType([nonPrimitiveType, nullType]) : type;
                     default:
                         return typeofTypesByName.get(text);
                 }
@@ -71135,22 +71267,27 @@ var ts;
             // the guard. For example: narrowing `{} | undefined` by `"boolean"` should produce the type `boolean`, not
             // the filtered type `{}`. For this reason we narrow constituents of the union individually, in addition to
             // filtering by type-facts.
-            function narrowUnionMemberByTypeof(candidate) {
-                return function (type) {
-                    if (isTypeSubtypeOf(type, candidate)) {
-                        return type;
-                    }
-                    if (isTypeSubtypeOf(candidate, type)) {
-                        return candidate;
+            function narrowTypeByImpliedType(type, candidate) {
+                if (type.flags & 3 /* AnyOrUnknown */) {
+                    return candidate;
+                }
+                return mapType(type, function (t) {
+                    if (isTypeRelatedTo(t, candidate, strictSubtypeRelation)) {
+                        return t;
                     }
-                    if (type.flags & 465829888 /* Instantiable */) {
-                        var constraint = getBaseConstraintOfType(type) || anyType;
-                        if (isTypeSubtypeOf(candidate, constraint)) {
-                            return getIntersectionType([type, candidate]);
+                    return mapType(candidate, function (c) {
+                        if (!areTypesComparable(t, c)) {
+                            return neverType;
                         }
-                    }
-                    return type;
-                };
+                        if (c.flags & 131068 /* Primitive */ && t.flags & 524288 /* Object */ && !isEmptyAnonymousObjectType(t)) {
+                            return isTypeSubtypeOf(c, t) ? c : neverType;
+                        }
+                        if (c === globalFunctionType && isTypeSubtypeOf(c, t)) {
+                            return c;
+                        }
+                        return getIntersectionType([t, c]);
+                    });
+                });
             }
             function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
                 var switchWitnesses = getSwitchClauseTypeOfWitnesses(switchStatement, /*retainDefault*/ true);
@@ -71209,7 +71346,7 @@ var ts;
                   because it is caught in the first clause.
                 */
                 var impliedType = getTypeWithFacts(getUnionType(clauseWitnesses.map(function (text) { return getImpliedTypeFromTypeofGuard(type, text) || type; })), switchFacts);
-                return getTypeWithFacts(mapType(type, narrowUnionMemberByTypeof(impliedType)), switchFacts);
+                return getTypeWithFacts(narrowTypeByImpliedType(type, impliedType), switchFacts);
             }
             function isMatchingConstructorReference(expr) {
                 return (ts.isPropertyAccessExpression(expr) && ts.idText(expr.name) === "constructor" ||
@@ -71513,7 +71650,9 @@ var ts;
                     !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression)));
         }
         function isGenericTypeWithUnionConstraint(type) {
-            return !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
+            return type.flags & 2097152 /* Intersection */ ?
+                ts.some(type.types, isGenericTypeWithUnionConstraint) :
+                !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
         }
         function isGenericTypeWithoutNullableConstraint(type) {
             return !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
@@ -71541,7 +71680,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {
@@ -75879,7 +76018,7 @@ var ts;
             if (spreadIndex >= 0) {
                 // Create synthetic arguments from spreads of tuple types.
                 var effectiveArgs_1 = args.slice(0, spreadIndex);
-                var _loop_24 = function (i) {
+                var _loop_25 = function (i) {
                     var arg = args[i];
                     // We can call checkExpressionCached because spread expressions never have a contextual type.
                     var spreadType = arg.kind === 225 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
@@ -75896,7 +76035,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_24(i);
+                    _loop_25(i);
                 }
                 return effectiveArgs_1;
             }
@@ -76216,7 +76355,7 @@ var ts;
                         var min_3 = Number.MAX_VALUE;
                         var minIndex = 0;
                         var i_1 = 0;
-                        var _loop_25 = function (c) {
+                        var _loop_26 = 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 /* Normal */, /*reportErrors*/ true, chain_2);
                             if (diags_2) {
@@ -76234,7 +76373,7 @@ var ts;
                         };
                         for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
                             var c = candidatesForArgumentError_1[_a];
-                            _loop_25(c);
+                            _loop_26(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");
@@ -76392,7 +76531,7 @@ var ts;
             }
             var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
             var parameters = [];
-            var _loop_26 = function (i) {
+            var _loop_27 = 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; });
@@ -76400,7 +76539,7 @@ var ts;
                 parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
             };
             for (var i = 0; i < maxNonRestParam; i++) {
-                _loop_26(i);
+                _loop_27(i);
             }
             var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
             var flags = 0 /* None */;
@@ -80457,7 +80596,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_27 = function (declaration) {
+                var _loop_28 = 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));
@@ -80472,7 +80611,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_27(declaration);
+                    _loop_28(declaration);
                 }
                 indexSignatureMap_1.forEach(function (entry) {
                     if (entry.declarations.length > 1) {
@@ -83933,7 +84072,7 @@ var ts;
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 258 /* InterfaceDeclaration */) : undefined;
             var localPropDeclaration = declaration && declaration.kind === 221 /* BinaryExpression */ ||
                 name && name.kind === 162 /* ComputedPropertyName */ || getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
-            var _loop_28 = function (info) {
+            var _loop_29 = 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
@@ -83946,7 +84085,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
                 var info = indexInfos_9[_i];
-                _loop_28(info);
+                _loop_29(info);
             }
         }
         function checkIndexConstraintForIndexSignature(type, checkInfo) {
@@ -83954,7 +84093,7 @@ var ts;
             var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 258 /* InterfaceDeclaration */) : undefined;
             var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined;
-            var _loop_29 = function (info) {
+            var _loop_30 = function (info) {
                 if (info === checkInfo)
                     return "continue";
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
@@ -83969,7 +84108,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
                 var info = indexInfos_10[_i];
-                _loop_29(info);
+                _loop_30(info);
             }
         }
         function checkTypeNameIsReserved(name, message) {
@@ -84288,7 +84427,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_30 = function (member) {
+            var _loop_31 = function (member) {
                 if (ts.hasAmbientModifier(member)) {
                     return "continue";
                 }
@@ -84305,7 +84444,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_30(member);
+                _loop_31(member);
             }
         }
         /**
@@ -84393,7 +84532,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_31 = function (member) {
+            var _loop_32 = function (member) {
                 if (ts.isStatic(member)) {
                     return "continue";
                 }
@@ -84412,7 +84551,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_31(member);
+                _loop_32(member);
             }
             if (!issuedMemberError) {
                 // check again with diagnostics to generate a less-specific error
@@ -122380,7 +122519,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_32 = function (directory) {
+            var _loop_33 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -122404,7 +122543,7 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_10 = _loop_32(directory);
+                var state_10 = _loop_33(directory);
                 directory = out_directory_1;
                 if (state_10 === "break")
                     break;
@@ -147791,11 +147930,9 @@ var ts;
                     if (listEndToken !== 0 /* Unknown */ && formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) {
                         var tokenInfo = formattingScanner.readTokenInfo(parent);
                         if (tokenInfo.token.kind === 27 /* CommaToken */ && ts.isCallLikeExpression(parent)) {
-                            var commaTokenLine = sourceFile.getLineAndCharacterOfPosition(tokenInfo.token.pos).line;
-                            if (startLine !== commaTokenLine) {
-                                formattingScanner.advance();
-                                tokenInfo = formattingScanner.isOnToken() ? formattingScanner.readTokenInfo(parent) : undefined;
-                            }
+                            // consume the comma
+                            consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent);
+                            tokenInfo = formattingScanner.isOnToken() ? formattingScanner.readTokenInfo(parent) : undefined;
                         }
                         // consume the list end token only if it is still belong to the parent
                         // there might be the case when current token matches end token but does not considered as one