typescript 4.8.0-dev.20220529 → 4.8.0-dev.20220601

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220529";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220601";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8894,6 +8894,7 @@ var ts;
         Import_assertion_values_must_be_string_literal_expressions: diag(2837, ts.DiagnosticCategory.Error, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."),
         All_declarations_of_0_must_have_identical_constraints: diag(2838, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."),
         This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."),
+        An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes: diag(2840, ts.DiagnosticCategory.Error, "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840", "An interface cannot extend a primitive type like '{0}'; an interface can only extend named types and classes"),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -44163,8 +44164,8 @@ var ts;
             var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) ||
                 loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.packageJsonContent, packageInfo && packageInfo.versionPaths);
             if (!pathAndExtension && packageInfo
-                && packageInfo.packageJsonContent.exports === undefined
-                && packageInfo.packageJsonContent.main === undefined
+                // eslint-disable-next-line no-null/no-null
+                && (packageInfo.packageJsonContent.exports === undefined || packageInfo.packageJsonContent.exports === null)
                 && state.features & NodeResolutionFeatures.EsmMode) {
                 // EsmMode disables index lookup in `loadNodeModuleFromDirectoryWorker` generally, however non-relative package resolutions still assume
                 // a default `index.js` entrypoint if no `main` or `exports` are present
@@ -47829,7 +47830,10 @@ var ts;
         TypeFacts[TypeFacts["NEUndefinedOrNull"] = 2097152] = "NEUndefinedOrNull";
         TypeFacts[TypeFacts["Truthy"] = 4194304] = "Truthy";
         TypeFacts[TypeFacts["Falsy"] = 8388608] = "Falsy";
-        TypeFacts[TypeFacts["All"] = 16777215] = "All";
+        TypeFacts[TypeFacts["IsUndefined"] = 16777216] = "IsUndefined";
+        TypeFacts[TypeFacts["IsNull"] = 33554432] = "IsNull";
+        TypeFacts[TypeFacts["IsUndefinedOrNull"] = 50331648] = "IsUndefinedOrNull";
+        TypeFacts[TypeFacts["All"] = 134217727] = "All";
         // The following members encode facts about particular kinds of types for use in the getTypeFacts function.
         // The presence of a particular fact means that the given test is true for some (and possibly all) values
         // of that kind of type.
@@ -47871,14 +47875,16 @@ var ts;
         TypeFacts[TypeFacts["ObjectFacts"] = 16736160] = "ObjectFacts";
         TypeFacts[TypeFacts["FunctionStrictFacts"] = 7880640] = "FunctionStrictFacts";
         TypeFacts[TypeFacts["FunctionFacts"] = 16728000] = "FunctionFacts";
-        TypeFacts[TypeFacts["UndefinedFacts"] = 9830144] = "UndefinedFacts";
-        TypeFacts[TypeFacts["NullFacts"] = 9363232] = "NullFacts";
-        TypeFacts[TypeFacts["EmptyObjectStrictFacts"] = 16318463] = "EmptyObjectStrictFacts";
+        TypeFacts[TypeFacts["VoidFacts"] = 9830144] = "VoidFacts";
+        TypeFacts[TypeFacts["UndefinedFacts"] = 26607360] = "UndefinedFacts";
+        TypeFacts[TypeFacts["NullFacts"] = 42917664] = "NullFacts";
+        TypeFacts[TypeFacts["EmptyObjectStrictFacts"] = 83427327] = "EmptyObjectStrictFacts";
+        TypeFacts[TypeFacts["EmptyObjectFacts"] = 83886079] = "EmptyObjectFacts";
+        TypeFacts[TypeFacts["UnknownFacts"] = 83886079] = "UnknownFacts";
         TypeFacts[TypeFacts["AllTypeofNE"] = 556800] = "AllTypeofNE";
-        TypeFacts[TypeFacts["EmptyObjectFacts"] = 16777215] = "EmptyObjectFacts";
         // Masks
         TypeFacts[TypeFacts["OrFactsMask"] = 8256] = "OrFactsMask";
-        TypeFacts[TypeFacts["AndFactsMask"] = 16768959] = "AndFactsMask";
+        TypeFacts[TypeFacts["AndFactsMask"] = 134209471] = "AndFactsMask";
     })(TypeFacts || (TypeFacts = {}));
     var typeofEQFacts = new ts.Map(ts.getEntries({
         string: 1 /* TypeofEQString */,
@@ -50042,7 +50048,12 @@ var ts;
         function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
             if (meaning & (111551 /* Value */ & ~1024 /* NamespaceModule */)) {
                 if (isPrimitiveTypeName(name)) {
-                    error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, ts.unescapeLeadingUnderscores(name));
+                    if (isExtendedByInterface(errorLocation)) {
+                        error(errorLocation, ts.Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes, ts.unescapeLeadingUnderscores(name));
+                    }
+                    else {
+                        error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, ts.unescapeLeadingUnderscores(name));
+                    }
                     return true;
                 }
                 var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* Type */ & ~111551 /* Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
@@ -50062,6 +50073,16 @@ var ts;
             }
             return false;
         }
+        function isExtendedByInterface(node) {
+            var grandparent = node.parent.parent;
+            var parentOfGrandparent = grandparent.parent;
+            if (grandparent && parentOfGrandparent) {
+                var isExtending = ts.isHeritageClause(grandparent) && grandparent.token === 94 /* ExtendsKeyword */;
+                var isInterface = ts.isInterfaceDeclaration(parentOfGrandparent);
+                return isExtending && isInterface;
+            }
+            return false;
+        }
         function maybeMappedType(node, symbol) {
             var container = ts.findAncestor(node.parent, function (n) {
                 return ts.isComputedPropertyName(n) || ts.isPropertySignature(n) ? false : ts.isTypeLiteralNode(n) || "quit";
@@ -52902,7 +52923,7 @@ var ts;
                     anyType : getNonMissingTypeOfSymbol(propertySymbol);
                 var saveEnclosingDeclaration = context.enclosingDeclaration;
                 context.enclosingDeclaration = undefined;
-                if (context.tracker.trackSymbol && ts.getCheckFlags(propertySymbol) & 4096 /* Late */ && isLateBoundName(propertySymbol.escapedName)) {
+                if (context.tracker.trackSymbol && isLateBoundName(propertySymbol.escapedName)) {
                     if (propertySymbol.declarations) {
                         var decl = ts.first(propertySymbol.declarations);
                         if (hasLateBindableName(decl)) {
@@ -54586,7 +54607,7 @@ var ts;
                         ? getBaseConstructorTypeOfClass(staticType)
                         : anyType;
                     var heritageClauses = __spreadArray(__spreadArray([], !ts.length(baseTypes) ? [] : [ts.factory.createHeritageClause(94 /* ExtendsKeyword */, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))], true), !ts.length(implementsExpressions) ? [] : [ts.factory.createHeritageClause(117 /* ImplementsKeyword */, implementsExpressions)], true);
-                    var symbolProps = getNonInterhitedProperties(classType, baseTypes, getPropertiesOfType(classType));
+                    var symbolProps = getNonInheritedProperties(classType, baseTypes, getPropertiesOfType(classType));
                     var publicSymbolProps = ts.filter(symbolProps, function (s) {
                         // `valueDeclaration` could be undefined if inherited from
                         // a union/intersection base type, but inherited properties
@@ -55724,7 +55745,7 @@ var ts;
             if (ts.getEffectiveTypeAnnotationNode(ts.walkUpBindingElementsAndPatterns(declaration))) {
                 // In strict null checking mode, if a default value of a non-undefined type is specified, remove
                 // undefined from the final type.
-                return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 32768 /* Undefined */) ? getNonUndefinedType(type) : type;
+                return strictNullChecks && !(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
             }
             return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
         }
@@ -64219,7 +64240,7 @@ var ts;
                     var sourceSig = checkMode & 3 /* Callback */ ? undefined : getSingleCallSignature(getNonNullableType(sourceType));
                     var targetSig = checkMode & 3 /* Callback */ ? undefined : getSingleCallSignature(getNonNullableType(targetType));
                     var callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) &&
-                        (getFalsyFlags(sourceType) & 98304 /* Nullable */) === (getFalsyFlags(targetType) & 98304 /* Nullable */);
+                        (getTypeFacts(sourceType) & 50331648 /* IsUndefinedOrNull */) === (getTypeFacts(targetType) & 50331648 /* IsUndefinedOrNull */);
                     var related = callbacks ?
                         compareSignaturesRelated(targetSig, sourceSig, (checkMode & 8 /* StrictArity */) | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) :
                         !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors);
@@ -67437,30 +67458,8 @@ var ts;
             var value = _a.value;
             return value.base10Value === "0";
         }
-        function getFalsyFlagsOfTypes(types) {
-            var result = 0;
-            for (var _i = 0, types_14 = types; _i < types_14.length; _i++) {
-                var t = types_14[_i];
-                result |= getFalsyFlags(t);
-            }
-            return result;
-        }
-        // Returns the String, Number, Boolean, StringLiteral, NumberLiteral, BooleanLiteral, Void, Undefined, or Null
-        // 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) {
-            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 */ ?
-                filterType(type, function (t) { return !(getFalsyFlags(t) & 117632 /* DefinitelyFalsy */); }) :
-                type;
+            return filterType(type, function (t) { return !!(getTypeFacts(t) & 4194304 /* Truthy */); });
         }
         function extractDefinitelyFalsyTypes(type) {
             return mapType(type, getDefinitelyFalsyPartOfType);
@@ -67503,14 +67502,7 @@ var ts;
                 getIntersectionType([type, emptyObjectType]);
         }
         function getNonNullableType(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;
+            return strictNullChecks ? getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
         }
         function addOptionalTypeMarker(type) {
             return strictNullChecks ? getUnionType([type, optionalType]) : type;
@@ -68654,8 +68646,8 @@ var ts;
             }
             function getSingleTypeVariableFromIntersectionTypes(types) {
                 var typeVariable;
-                for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
-                    var type = types_15[_i];
+                for (var _i = 0, types_14 = types; _i < types_14.length; _i++) {
+                    var type = types_14[_i];
                     var t = type.flags & 2097152 /* Intersection */ && ts.find(type.types, function (t) { return !!getInferenceInfoForType(t); });
                     if (!t || typeVariable && t !== typeVariable) {
                         return undefined;
@@ -69408,8 +69400,8 @@ var ts;
                     }
                 }
             };
-            for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
-                var type = types_16[_i];
+            for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
+                var type = types_15[_i];
                 var state_9 = _loop_24(type);
                 if (typeof state_9 === "object")
                     return state_9.value;
@@ -69524,14 +69516,16 @@ var ts;
             return !!(resolved.callSignatures.length || resolved.constructSignatures.length ||
                 resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
         }
-        function getTypeFacts(type, ignoreObjects) {
-            if (ignoreObjects === void 0) { ignoreObjects = false; }
+        function getTypeFacts(type) {
+            if (type.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */)) {
+                type = getBaseConstraintOfType(type) || unknownType;
+            }
             var flags = type.flags;
-            if (flags & 4 /* String */) {
+            if (flags & (4 /* String */ | 268435456 /* StringMapping */)) {
                 return strictNullChecks ? 16317953 /* StringStrictFacts */ : 16776705 /* StringFacts */;
             }
-            if (flags & 128 /* StringLiteral */) {
-                var isEmpty = type.value === "";
+            if (flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */)) {
+                var isEmpty = flags & 128 /* StringLiteral */ && type.value === "";
                 return strictNullChecks ?
                     isEmpty ? 12123649 /* EmptyStringStrictFacts */ : 7929345 /* NonEmptyStringStrictFacts */ :
                     isEmpty ? 12582401 /* EmptyStringFacts */ : 16776705 /* NonEmptyStringFacts */;
@@ -69563,20 +69557,20 @@ var ts;
                     (type === falseType || type === regularFalseType) ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
             }
             if (flags & 524288 /* Object */) {
-                if (ignoreObjects) {
-                    return 16768959 /* AndFactsMask */; // This is the identity element for computing type facts of intersection.
-                }
                 return ts.getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ?
-                    strictNullChecks ? 16318463 /* EmptyObjectStrictFacts */ : 16777215 /* EmptyObjectFacts */ :
+                    strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ :
                     isFunctionObjectType(type) ?
                         strictNullChecks ? 7880640 /* FunctionStrictFacts */ : 16728000 /* FunctionFacts */ :
                         strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
             }
-            if (flags & (16384 /* Void */ | 32768 /* Undefined */)) {
-                return 9830144 /* UndefinedFacts */;
+            if (flags & 16384 /* Void */) {
+                return 9830144 /* VoidFacts */;
+            }
+            if (flags & 32768 /* Undefined */) {
+                return 26607360 /* UndefinedFacts */;
             }
             if (flags & 65536 /* Null */) {
-                return 9363232 /* NullFacts */;
+                return 42917664 /* NullFacts */;
             }
             if (flags & 12288 /* ESSymbolLike */) {
                 return strictNullChecks ? 7925520 /* SymbolStrictFacts */ : 16772880 /* SymbolFacts */;
@@ -69587,38 +69581,39 @@ var ts;
             if (flags & 131072 /* Never */) {
                 return 0 /* None */;
             }
-            if (flags & 465829888 /* Instantiable */) {
-                return !isPatternLiteralType(type) ? getTypeFacts(getBaseConstraintOfType(type) || unknownType, ignoreObjects) :
-                    strictNullChecks ? 7929345 /* NonEmptyStringStrictFacts */ : 16776705 /* NonEmptyStringFacts */;
-            }
             if (flags & 1048576 /* Union */) {
-                return ts.reduceLeft(type.types, function (facts, t) { return facts | getTypeFacts(t, ignoreObjects); }, 0 /* None */);
+                return ts.reduceLeft(type.types, function (facts, t) { return facts | getTypeFacts(t); }, 0 /* None */);
             }
             if (flags & 2097152 /* Intersection */) {
-                // When an intersection contains a primitive type we ignore object type constituents as they are
-                // presumably type tags. For example, in string & { __kind__: "name" } we ignore the object type.
-                ignoreObjects || (ignoreObjects = maybeTypeOfKind(type, 131068 /* Primitive */));
-                return getIntersectionTypeFacts(type, ignoreObjects);
+                return getIntersectionTypeFacts(type);
             }
-            return 16777215 /* All */;
+            return 83886079 /* UnknownFacts */;
         }
-        function getIntersectionTypeFacts(type, ignoreObjects) {
+        function getIntersectionTypeFacts(type) {
+            // When an intersection contains a primitive type we ignore object type constituents as they are
+            // presumably type tags. For example, in string & { __kind__: "name" } we ignore the object type.
+            var ignoreObjects = maybeTypeOfKind(type, 131068 /* Primitive */);
             // When computing the type facts of an intersection type, certain type facts are computed as `and`
             // and others are computed as `or`.
             var oredFacts = 0 /* None */;
-            var andedFacts = 16777215 /* All */;
+            var andedFacts = 134217727 /* All */;
             for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
                 var t = _a[_i];
-                var f = getTypeFacts(t, ignoreObjects);
-                oredFacts |= f;
-                andedFacts &= f;
+                if (!(ignoreObjects && t.flags & 524288 /* Object */)) {
+                    var f = getTypeFacts(t);
+                    oredFacts |= f;
+                    andedFacts &= f;
+                }
             }
-            return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 16768959 /* AndFactsMask */;
+            return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 134209471 /* AndFactsMask */;
         }
         function getTypeWithFacts(type, include) {
             return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; });
         }
-        function getIntersectionWithFacts(type, facts) {
+        // This function is similar to getTypeWithFacts, except that in strictNullChecks mode it replaces type
+        // unknown with the union {} | null | undefined (and reduces that accordingly), and it intersects remaining
+        // instantiable types with {}, {} | null, or {} | undefined in order to remove null and/or undefined.
+        function getAdjustedTypeWithFacts(type, facts) {
             var reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* Unknown */ ? unknownUnionType : type, facts));
             if (strictNullChecks) {
                 switch (facts) {
@@ -69884,8 +69879,8 @@ var ts;
             var types = origin && origin.flags & 1048576 /* Union */ ? origin.types : type.types;
             var mappedTypes;
             var changed = false;
-            for (var _i = 0, types_17 = types; _i < types_17.length; _i++) {
-                var t = types_17[_i];
+            for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
+                var t = types_16[_i];
                 var mapped = t.flags & 1048576 /* Union */ ? mapType(t, mapper, noReductions) : mapper(t);
                 changed || (changed = t !== mapped);
                 if (mapped) {
@@ -69971,8 +69966,8 @@ var ts;
         }
         function isEvolvingArrayTypeList(types) {
             var hasEvolvingArrayType = false;
-            for (var _i = 0, types_18 = types; _i < types_18.length; _i++) {
-                var t = types_18[_i];
+            for (var _i = 0, types_17 = types; _i < types_17.length; _i++) {
+                var t = types_17[_i];
                 if (!(t.flags & 131072 /* Never */)) {
                     if (!(ts.getObjectFlags(t) & 256 /* EvolvingArray */)) {
                         return false;
@@ -70795,10 +70790,10 @@ var ts;
             }
             function narrowTypeByTruthiness(type, expr, assumeTrue) {
                 if (isMatchingReference(reference, expr)) {
-                    return getIntersectionWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
+                    return getAdjustedTypeWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
                 }
                 if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) {
-                    type = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                    type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
                 }
                 var access = getDiscriminantPropertyAccess(expr, type);
                 if (access) {
@@ -70938,7 +70933,7 @@ var ts;
                 // Note that we include any and unknown in the exclusion test because their domain includes null and undefined.
                 var removeNullable = equalsOperator !== assumeTrue && everyType(valueType, function (t) { return !!(t.flags & nullableFlags); }) ||
                     equalsOperator === assumeTrue && everyType(valueType, function (t) { return !(t.flags & (3 /* AnyOrUnknown */ | nullableFlags)); });
-                return removeNullable ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
+                return removeNullable ? getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
             }
             function narrowTypeByEquality(type, operator, value, assumeTrue) {
                 if (type.flags & 1 /* Any */) {
@@ -70967,7 +70962,7 @@ var ts;
                         valueType.flags & 65536 /* Null */ ?
                             assumeTrue ? 131072 /* EQNull */ : 1048576 /* NENull */ :
                             assumeTrue ? 65536 /* EQUndefined */ : 524288 /* NEUndefined */;
-                    return getIntersectionWithFacts(type, facts);
+                    return getAdjustedTypeWithFacts(type, facts);
                 }
                 if (assumeTrue) {
                     var filterFn = operator === 34 /* EqualsEqualsToken */ ?
@@ -70988,7 +70983,7 @@ var ts;
                 var target = getReferenceCandidate(typeOfExpr.expression);
                 if (!isMatchingReference(reference, target)) {
                     if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
-                        return getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                        return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
                     }
                     return type;
                 }
@@ -71192,7 +71187,7 @@ var ts;
                 var left = getReferenceCandidate(expr.left);
                 if (!isMatchingReference(reference, left)) {
                     if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) {
-                        return getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                        return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
                     }
                     return type;
                 }
@@ -71280,7 +71275,7 @@ var ts;
                         }
                         if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) &&
                             !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
-                            type = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                            type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
                         }
                         var access = getDiscriminantPropertyAccess(predicateArgument, type);
                         if (access) {
@@ -71337,7 +71332,7 @@ var ts;
             }
             function narrowTypeByOptionality(type, expr, assumePresent) {
                 if (isMatchingReference(reference, expr)) {
-                    return getTypeWithFacts(type, assumePresent ? 2097152 /* NEUndefinedOrNull */ : 262144 /* EQUndefinedOrNull */);
+                    return getAdjustedTypeWithFacts(type, assumePresent ? 2097152 /* NEUndefinedOrNull */ : 262144 /* EQUndefinedOrNull */);
                 }
                 var access = getDiscriminantPropertyAccess(expr, type);
                 if (access) {
@@ -71423,8 +71418,8 @@ var ts;
                 var annotationIncludesUndefined = strictNullChecks &&
                     declaration.kind === 164 /* Parameter */ &&
                     declaration.initializer &&
-                    getFalsyFlags(declaredType) & 32768 /* Undefined */ &&
-                    !(getFalsyFlags(checkExpression(declaration.initializer)) & 32768 /* Undefined */);
+                    getTypeFacts(declaredType) & 16777216 /* IsUndefined */ &&
+                    !(getTypeFacts(checkExpression(declaration.initializer)) & 16777216 /* IsUndefined */);
                 popTypeResolution();
                 return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
             }
@@ -71752,7 +71747,7 @@ var ts;
                     return convertAutoToAny(flowType);
                 }
             }
-            else if (!assumeInitialized && !(getFalsyFlags(type) & 32768 /* Undefined */) && getFalsyFlags(flowType) & 32768 /* Undefined */) {
+            else if (!assumeInitialized && !(getTypeFacts(type) & 16777216 /* IsUndefined */) && getTypeFacts(flowType) & 16777216 /* IsUndefined */) {
                 error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
                 // Return the declared type to reduce follow-on errors
                 return type;
@@ -73281,8 +73276,8 @@ var ts;
             }
             var signatureList;
             var types = type.types;
-            for (var _i = 0, types_19 = types; _i < types_19.length; _i++) {
-                var current = types_19[_i];
+            for (var _i = 0, types_18 = types; _i < types_18.length; _i++) {
+                var current = types_18[_i];
                 var signature = getContextualCallSignature(current, node);
                 if (signature) {
                     if (!signatureList) {
@@ -74444,19 +74439,19 @@ var ts;
             return checkNonNullType(checkExpression(node), node);
         }
         function isNullableType(type) {
-            return !!((strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304 /* Nullable */);
+            return !!(getTypeFacts(type) & 50331648 /* IsUndefinedOrNull */);
         }
         function getNonNullableTypeIfNeeded(type) {
             return isNullableType(type) ? getNonNullableType(type) : type;
         }
-        function reportObjectPossiblyNullOrUndefinedError(node, flags) {
-            error(node, flags & 32768 /* Undefined */ ? flags & 65536 /* Null */ ?
+        function reportObjectPossiblyNullOrUndefinedError(node, facts) {
+            error(node, facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ?
                 ts.Diagnostics.Object_is_possibly_null_or_undefined :
                 ts.Diagnostics.Object_is_possibly_undefined :
                 ts.Diagnostics.Object_is_possibly_null);
         }
-        function reportCannotInvokePossiblyNullOrUndefinedError(node, flags) {
-            error(node, flags & 32768 /* Undefined */ ? flags & 65536 /* Null */ ?
+        function reportCannotInvokePossiblyNullOrUndefinedError(node, facts) {
+            error(node, facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ?
                 ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined :
                 ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined :
                 ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null);
@@ -74466,9 +74461,9 @@ var ts;
                 error(node, ts.Diagnostics.Object_is_of_type_unknown);
                 return errorType;
             }
-            var kind = (strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304 /* Nullable */;
-            if (kind) {
-                reportError(node, kind);
+            var facts = getTypeFacts(type);
+            if (facts & 50331648 /* IsUndefinedOrNull */) {
+                reportError(node, facts);
                 var t = getNonNullableType(type);
                 return t.flags & (98304 /* Nullable */ | 131072 /* Never */) ? errorType : t;
             }
@@ -74763,7 +74758,7 @@ var ts;
                 assumeUninitialized = true;
             }
             var flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType);
-            if (assumeUninitialized && !(getFalsyFlags(propType) & 32768 /* Undefined */) && getFalsyFlags(flowType) & 32768 /* Undefined */) {
+            if (assumeUninitialized && !(getTypeFacts(propType) & 16777216 /* IsUndefined */) && getTypeFacts(flowType) & 16777216 /* IsUndefined */) {
                 error(errorNode, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop)); // TODO: GH#18217
                 // Return the declared type to reduce follow-on errors
                 return propType;
@@ -76679,8 +76674,8 @@ var ts;
             if (apparentType.flags & 1048576 /* Union */) {
                 var types = apparentType.types;
                 var hasSignatures = false;
-                for (var _i = 0, types_20 = types; _i < types_20.length; _i++) {
-                    var constituent = types_20[_i];
+                for (var _i = 0, types_19 = types; _i < types_19.length; _i++) {
+                    var constituent = types_19[_i];
                     var signatures = getSignaturesOfType(constituent, kind);
                     if (signatures.length !== 0) {
                         hasSignatures = true;
@@ -78371,7 +78366,7 @@ var ts;
             var type = getTypeOfSymbol(symbol);
             if (strictNullChecks &&
                 !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) &&
-                !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getFalsyFlags(type) & 32768 /* Undefined */)) {
+                !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getTypeFacts(type) & 16777216 /* IsUndefined */)) {
                 error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_must_be_optional);
             }
         }
@@ -78539,8 +78534,8 @@ var ts;
             }
             if (type.flags & 3145728 /* UnionOrIntersection */) {
                 var types = type.types;
-                for (var _i = 0, types_21 = types; _i < types_21.length; _i++) {
-                    var t = types_21[_i];
+                for (var _i = 0, types_20 = types; _i < types_20.length; _i++) {
+                    var t = types_20[_i];
                     if (maybeTypeOfKind(t, kind)) {
                         return true;
                     }
@@ -78767,7 +78762,7 @@ var ts;
                     // In strict null checking mode, if a default value of a non-undefined type is specified, remove
                     // undefined from the final type.
                     if (strictNullChecks &&
-                        !(getFalsyFlags(checkExpression(prop.objectAssignmentInitializer)) & 32768 /* Undefined */)) {
+                        !(getTypeFacts(checkExpression(prop.objectAssignmentInitializer)) & 16777216 /* IsUndefined */)) {
                         sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
                     }
                     checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
@@ -79167,7 +79162,7 @@ var ts;
                 case 56 /* BarBarToken */:
                 case 75 /* BarBarEqualsToken */: {
                     var resultType_3 = getTypeFacts(leftType) & 8388608 /* Falsy */ ?
-                        getUnionType([removeDefinitelyFalsyTypes(leftType), rightType], 2 /* Subtype */) :
+                        getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) :
                         leftType;
                     if (operator === 75 /* BarBarEqualsToken */) {
                         checkAssignmentOperator(rightType);
@@ -81708,8 +81703,8 @@ var ts;
         }
         function getEntityNameForDecoratorMetadataFromTypeList(types) {
             var commonEntityName;
-            for (var _i = 0, types_22 = types; _i < types_22.length; _i++) {
-                var typeNode = types_22[_i];
+            for (var _i = 0, types_21 = types; _i < types_21.length; _i++) {
+                var typeNode = types_21[_i];
                 while (typeNode.kind === 191 /* ParenthesizedType */ || typeNode.kind === 197 /* NamedTupleMember */) {
                     typeNode = typeNode.type; // Skip parens if need be
                 }
@@ -82575,7 +82570,7 @@ var ts;
             // For a binding pattern, validate the initializer and exit
             if (ts.isBindingPattern(node.name)) {
                 var needCheckInitializer = node.initializer && node.parent.parent.kind !== 243 /* ForInStatement */;
-                var needCheckWidenedType = node.name.elements.length === 0;
+                var needCheckWidenedType = !ts.some(node.name.elements, ts.not(ts.isOmittedExpression));
                 if (needCheckInitializer || needCheckWidenedType) {
                     // Don't validate for-in initializer as it is already an error
                     var widenedType = getWidenedTypeForVariableLikeDeclaration(node);
@@ -82728,7 +82723,7 @@ var ts;
                     return;
                 var type = checkTruthinessExpression(location);
                 var isPropertyExpressionCast = ts.isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
-                if (getFalsyFlags(type) || isPropertyExpressionCast)
+                if (!(getTypeFacts(type) & 4194304 /* Truthy */) || isPropertyExpressionCast)
                     return;
                 // While it technically should be invalid for any known-truthy value
                 // to be tested, we de-scope to functions and Promises unreferenced in
@@ -84414,18 +84409,17 @@ var ts;
             // but not by other kinds of members.
             // Base class instance member variables and accessors can be overridden by
             // derived class instance member variables and accessors, but not by other kinds of members.
-            var _a, _b;
+            var _a, _b, _c, _d;
             // NOTE: assignability is checked in checkClassDeclaration
             var baseProperties = getPropertiesOfType(baseType);
-            basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
-                var baseProperty = baseProperties_1[_i];
+            var _loop_33 = function (baseProperty) {
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 4194304 /* Prototype */) {
-                    continue;
+                    return "continue";
                 }
                 var baseSymbol = getPropertyOfObjectType(type, base.escapedName);
                 if (!baseSymbol) {
-                    continue;
+                    return "continue";
                 }
                 var derived = getTargetSymbol(baseSymbol);
                 var baseDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(base);
@@ -84443,14 +84437,14 @@ var ts;
                         // Searches other base types for a declaration that would satisfy the inherited abstract member.
                         // (The class may have more than one base type via declaration merging with an interface with the
                         // same name.)
-                        for (var _c = 0, _d = getBaseTypes(type); _c < _d.length; _c++) {
-                            var otherBaseType = _d[_c];
+                        for (var _e = 0, _f = getBaseTypes(type); _e < _f.length; _e++) {
+                            var otherBaseType = _f[_e];
                             if (otherBaseType === baseType)
                                 continue;
                             var baseSymbol_1 = getPropertyOfObjectType(otherBaseType, base.escapedName);
                             var derivedElsewhere = baseSymbol_1 && getTargetSymbol(baseSymbol_1);
                             if (derivedElsewhere && derivedElsewhere !== base) {
-                                continue basePropertyCheck;
+                                return "continue-basePropertyCheck";
                             }
                         }
                         if (derivedClassDecl.kind === 226 /* ClassExpression */) {
@@ -84465,20 +84459,19 @@ var ts;
                     // derived overrides base.
                     var derivedDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(derived);
                     if (baseDeclarationFlags & 8 /* Private */ || derivedDeclarationFlags & 8 /* Private */) {
-                        // either base or derived property is private - not override, skip it
-                        continue;
+                        return "continue";
                     }
                     var errorMessage = void 0;
                     var basePropertyFlags = base.flags & 98308 /* PropertyOrAccessor */;
                     var derivedPropertyFlags = derived.flags & 98308 /* PropertyOrAccessor */;
                     if (basePropertyFlags && derivedPropertyFlags) {
                         // property/accessor is overridden with property/accessor
-                        if (baseDeclarationFlags & 128 /* Abstract */ && !(base.valueDeclaration && ts.isPropertyDeclaration(base.valueDeclaration) && base.valueDeclaration.initializer)
-                            || base.valueDeclaration && base.valueDeclaration.parent.kind === 258 /* InterfaceDeclaration */
+                        if ((ts.getCheckFlags(base) & 6 /* Synthetic */
+                            ? (_a = base.declarations) === null || _a === void 0 ? void 0 : _a.some(function (d) { return isPropertyAbstractOrInterface(d, baseDeclarationFlags); })
+                            : (_b = base.declarations) === null || _b === void 0 ? void 0 : _b.every(function (d) { return isPropertyAbstractOrInterface(d, baseDeclarationFlags); }))
+                            || ts.getCheckFlags(base) & 262144 /* Mapped */
                             || derived.valueDeclaration && ts.isBinaryExpression(derived.valueDeclaration)) {
-                            // when the base property is abstract or from an interface, base/derived flags don't need to match
-                            // same when the derived property is from an assignment
-                            continue;
+                            return "continue";
                         }
                         var overriddenInstanceProperty = basePropertyFlags !== 4 /* Property */ && derivedPropertyFlags === 4 /* Property */;
                         var overriddenInstanceAccessor = basePropertyFlags === 4 /* Property */ && derivedPropertyFlags !== 4 /* Property */;
@@ -84489,12 +84482,12 @@ var ts;
                             error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_1, symbolToString(base), typeToString(baseType), typeToString(type));
                         }
                         else if (useDefineForClassFields) {
-                            var uninitialized = (_a = derived.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return d.kind === 167 /* PropertyDeclaration */ && !d.initializer; });
+                            var uninitialized = (_c = derived.declarations) === null || _c === void 0 ? void 0 : _c.find(function (d) { return d.kind === 167 /* PropertyDeclaration */ && !d.initializer; });
                             if (uninitialized
                                 && !(derived.flags & 33554432 /* Transient */)
                                 && !(baseDeclarationFlags & 128 /* Abstract */)
                                 && !(derivedDeclarationFlags & 128 /* Abstract */)
-                                && !((_b = derived.declarations) === null || _b === void 0 ? void 0 : _b.some(function (d) { return !!(d.flags & 16777216 /* Ambient */); }))) {
+                                && !((_d = derived.declarations) === null || _d === void 0 ? void 0 : _d.some(function (d) { return !!(d.flags & 16777216 /* Ambient */); }))) {
                                 var constructor = findConstructorDeclaration(ts.getClassLikeDeclarationOfSymbol(type.symbol));
                                 var propName = uninitialized.name;
                                 if (uninitialized.exclamationToken
@@ -84507,13 +84500,11 @@ var ts;
                                 }
                             }
                         }
-                        // correct case
-                        continue;
+                        return "continue";
                     }
                     else if (isPrototypeProperty(base)) {
                         if (isPrototypeProperty(derived) || derived.flags & 4 /* Property */) {
-                            // method is overridden with method or property -- correct case
-                            continue;
+                            return "continue";
                         }
                         else {
                             ts.Debug.assert(!!(derived.flags & 98304 /* Accessor */));
@@ -84528,9 +84519,20 @@ var ts;
                     }
                     error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type));
                 }
+            };
+            basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
+                var baseProperty = baseProperties_1[_i];
+                var state_10 = _loop_33(baseProperty);
+                switch (state_10) {
+                    case "continue-basePropertyCheck": continue basePropertyCheck;
+                }
             }
         }
-        function getNonInterhitedProperties(type, baseTypes, properties) {
+        function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) {
+            return baseDeclarationFlags & 128 /* Abstract */ && (!ts.isPropertyDeclaration(declaration) || !declaration.initializer)
+                || ts.isInterfaceDeclaration(declaration.parent);
+        }
+        function getNonInheritedProperties(type, baseTypes, properties) {
             if (!ts.length(baseTypes)) {
                 return properties;
             }
@@ -84599,7 +84601,7 @@ var ts;
                     var propName = member.name;
                     if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName) || ts.isComputedPropertyName(propName)) {
                         var type = getTypeOfSymbol(getSymbolOfNode(member));
-                        if (!(type.flags & 3 /* AnyOrUnknown */ || getFalsyFlags(type) & 32768 /* Undefined */)) {
+                        if (!(type.flags & 3 /* AnyOrUnknown */ || getTypeFacts(type) & 16777216 /* IsUndefined */)) {
                             if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) {
                                 error(member.name, ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, ts.declarationNameToString(propName));
                             }
@@ -84624,7 +84626,7 @@ var ts;
                     ts.setParent(reference, staticBlock);
                     reference.flowNode = staticBlock.returnFlowNode;
                     var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
-                    if (!(getFalsyFlags(flowType) & 32768 /* Undefined */)) {
+                    if (!(getTypeFacts(flowType) & 16777216 /* IsUndefined */)) {
                         return true;
                     }
                 }
@@ -84639,7 +84641,7 @@ var ts;
             ts.setParent(reference, constructor);
             reference.flowNode = constructor.returnFlowNode;
             var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
-            return !(getFalsyFlags(flowType) & 32768 /* Undefined */);
+            return !(getTypeFacts(flowType) & 16777216 /* IsUndefined */);
         }
         function checkInterfaceDeclaration(node) {
             // Grammar checking
@@ -92929,8 +92931,8 @@ var ts;
             // Note when updating logic here also update getEntityNameForDecoratorMetadata
             // so that aliases can be marked as referenced
             var serializedUnion;
-            for (var _i = 0, types_23 = types; _i < types_23.length; _i++) {
-                var typeNode = types_23[_i];
+            for (var _i = 0, types_22 = types; _i < types_22.length; _i++) {
+                var typeNode = types_22[_i];
                 while (typeNode.kind === 191 /* ParenthesizedType */) {
                     typeNode = typeNode.type; // Skip parens if need be
                 }
@@ -113545,8 +113547,8 @@ var ts;
                     bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "reference" /* Reference */, data: directive.fileName });
                 writeLine();
             }
-            for (var _d = 0, types_24 = types; _d < types_24.length; _d++) {
-                var directive = types_24[_d];
+            for (var _d = 0, types_23 = types; _d < types_23.length; _d++) {
+                var directive = types_23[_d];
                 var pos = writer.getTextPos();
                 var resolutionMode = directive.resolutionMode && directive.resolutionMode !== (currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.impliedNodeFormat)
                     ? "resolution-mode=\"" + (directive.resolutionMode === ts.ModuleKind.ESNext ? "import" : "require") + "\""
@@ -122314,7 +122316,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_33 = function (directory) {
+            var _loop_34 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -122338,9 +122340,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_10 = _loop_33(directory);
+                var state_11 = _loop_34(directory);
                 directory = out_directory_1;
-                if (state_10 === "break")
+                if (state_11 === "break")
                     break;
             }
             if (allFileNames.size) {