typescript 4.9.0-dev.20220928 → 4.9.0-dev.20220930

package/lib/typescript.js

@@ -99,7 +99,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20220928");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20220930");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -3205,11 +3205,13 @@ var ts;
     // > alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers
     // > MUST NOT include leading zeroes.
     var prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i;
+    var prereleasePartRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)$/i;
     // https://semver.org/#spec-item-10
     // > Build metadata MAY be denoted by appending a plus sign and a series of dot separated
     // > identifiers immediately following the patch or pre-release version. Identifiers MUST
     // > comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty.
     var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i;
+    var buildPartRegExp = /^[a-z0-9-]+$/i;
     // https://semver.org/#spec-item-9
     // > Numeric identifiers MUST NOT include leading zeroes.
     var numericIdentifierRegExp = /^(0|[1-9]\d*)$/;
@@ -3229,13 +3231,15 @@ var ts;
             ts.Debug.assert(major >= 0, "Invalid argument: major");
             ts.Debug.assert(minor >= 0, "Invalid argument: minor");
             ts.Debug.assert(patch >= 0, "Invalid argument: patch");
-            ts.Debug.assert(!prerelease || prereleaseRegExp.test(prerelease), "Invalid argument: prerelease");
-            ts.Debug.assert(!build || buildRegExp.test(build), "Invalid argument: build");
+            var prereleaseArray = prerelease ? ts.isArray(prerelease) ? prerelease : prerelease.split(".") : ts.emptyArray;
+            var buildArray = build ? ts.isArray(build) ? build : build.split(".") : ts.emptyArray;
+            ts.Debug.assert(ts.every(prereleaseArray, function (s) { return prereleasePartRegExp.test(s); }), "Invalid argument: prerelease");
+            ts.Debug.assert(ts.every(buildArray, function (s) { return buildPartRegExp.test(s); }), "Invalid argument: build");
             this.major = major;
             this.minor = minor;
             this.patch = patch;
-            this.prerelease = prerelease ? prerelease.split(".") : ts.emptyArray;
-            this.build = build ? build.split(".") : ts.emptyArray;
+            this.prerelease = prereleaseArray;
+            this.build = buildArray;
         }
         Version.tryParse = function (text) {
             var result = tryParseComponents(text);
@@ -3274,6 +3278,10 @@ var ts;
                 default: return ts.Debug.assertNever(field);
             }
         };
+        Version.prototype.with = function (fields) {
+            var _a = fields.major, major = _a === void 0 ? this.major : _a, _b = fields.minor, minor = _b === void 0 ? this.minor : _b, _c = fields.patch, patch = _c === void 0 ? this.patch : _c, _d = fields.prerelease, prerelease = _d === void 0 ? this.prerelease : _d, _e = fields.build, build = _e === void 0 ? this.build : _e;
+            return new Version(major, minor, patch, prerelease, build);
+        };
         Version.prototype.toString = function () {
             var result = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch);
             if (ts.some(this.prerelease))
@@ -3282,7 +3290,7 @@ var ts;
                 result += "+".concat(this.build.join("."));
             return result;
         };
-        Version.zero = new Version(0, 0, 0);
+        Version.zero = new Version(0, 0, 0, ["0"]);
         return Version;
     }());
     ts.Version = Version;
@@ -3365,6 +3373,10 @@ var ts;
             }
             return undefined;
         };
+        /**
+         * Tests whether a version matches the range. This is equivalent to `satisfies(version, range, { includePrerelease: true })`.
+         * in `node-semver`.
+         */
         VersionRange.prototype.test = function (version) {
             if (typeof version === "string")
                 version = new Version(version);
@@ -3475,19 +3487,20 @@ var ts;
                     break;
                 case "<":
                 case ">=":
-                    comparators.push(createComparator(operator, version));
+                    comparators.push(isWildcard(minor) || isWildcard(patch) ? createComparator(operator, version.with({ prerelease: "0" })) :
+                        createComparator(operator, version));
                     break;
                 case "<=":
                 case ">":
-                    comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major")) :
-                        isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor")) :
+                    comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major").with({ prerelease: "0" })) :
+                        isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor").with({ prerelease: "0" })) :
                             createComparator(operator, version));
                     break;
                 case "=":
                 case undefined:
                     if (isWildcard(minor) || isWildcard(patch)) {
-                        comparators.push(createComparator(">=", version));
-                        comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor")));
+                        comparators.push(createComparator(">=", version.with({ prerelease: "0" })));
+                        comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor").with({ prerelease: "0" })));
                     }
                     else {
                         comparators.push(createComparator("=", version));
@@ -49475,6 +49488,12 @@ var ts;
             getOptionalType: function () { return optionalType; },
             getPromiseType: function () { return getGlobalPromiseType(/*reportErrors*/ false); },
             getPromiseLikeType: function () { return getGlobalPromiseLikeType(/*reportErrors*/ false); },
+            getAsyncIterableType: function () {
+                var type = getGlobalAsyncIterableType(/*reportErrors*/ false);
+                if (type === emptyGenericType)
+                    return undefined;
+                return type;
+            },
             isSymbolAccessible: isSymbolAccessible,
             isArrayType: isArrayType,
             isTupleType: isTupleType,
@@ -50312,9 +50331,9 @@ var ts;
                         return symbol;
                     }
                     if (symbol.flags & 2097152 /* SymbolFlags.Alias */) {
-                        var target = resolveAlias(symbol);
-                        // Unknown symbol means an error occurred in alias resolution, treat it as positive answer to avoid cascading errors
-                        if (target === unknownSymbol || target.flags & meaning) {
+                        var targetFlags = getAllSymbolFlags(symbol);
+                        // `targetFlags` will be `SymbolFlags.All` if an error occurred in alias resolution; this avoids cascading errors
+                        if (targetFlags & meaning) {
                             return symbol;
                         }
                     }
@@ -50947,8 +50966,8 @@ var ts;
                                 !checkAndReportErrorForExtendingInterface(errorLocation) &&
                                 !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
+                                !checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
-                                !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
                             var suggestion = void 0;
                             var suggestedLib = void 0;
@@ -51035,7 +51054,7 @@ var ts;
                         }
                     }
                     if (result && errorLocation && meaning & 111551 /* SymbolFlags.Value */ && result.flags & 2097152 /* SymbolFlags.Alias */ && !(result.flags & 111551 /* SymbolFlags.Value */) && !ts.isValidTypeOnlyAliasUseSite(errorLocation)) {
-                        var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result);
+                        var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result, 111551 /* SymbolFlags.Value */);
                         if (typeOnlyDeclaration) {
                             var message = typeOnlyDeclaration.kind === 278 /* SyntaxKind.ExportSpecifier */
                                 ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
@@ -51198,7 +51217,7 @@ var ts;
             return false;
         }
         function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
-            if (meaning & (111551 /* SymbolFlags.Value */ & ~1024 /* SymbolFlags.NamespaceModule */)) {
+            if (meaning & 111551 /* SymbolFlags.Value */) {
                 if (isPrimitiveTypeName(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));
@@ -51209,7 +51228,8 @@ var ts;
                     return true;
                 }
                 var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
-                if (symbol && !(symbol.flags & 1024 /* SymbolFlags.NamespaceModule */)) {
+                var allFlags = symbol && getAllSymbolFlags(symbol);
+                if (symbol && allFlags !== undefined && !(allFlags & 111551 /* SymbolFlags.Value */)) {
                     var rawName = ts.unescapeLeadingUnderscores(name);
                     if (isES2015OrLaterConstructorName(name)) {
                         error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later, rawName);
@@ -51257,16 +51277,16 @@ var ts;
             }
             return false;
         }
-        function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) {
-            if (meaning & (111551 /* SymbolFlags.Value */ & ~1024 /* SymbolFlags.NamespaceModule */ & ~788968 /* SymbolFlags.Type */)) {
-                var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* SymbolFlags.NamespaceModule */ & ~111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
+        function checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) {
+            if (meaning & (111551 /* SymbolFlags.Value */ & ~788968 /* SymbolFlags.Type */)) {
+                var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* SymbolFlags.NamespaceModule */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
                 if (symbol) {
                     error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_value, ts.unescapeLeadingUnderscores(name));
                     return true;
                 }
             }
-            else if (meaning & (788968 /* SymbolFlags.Type */ & ~1024 /* SymbolFlags.NamespaceModule */ & ~111551 /* SymbolFlags.Value */)) {
-                var symbol = resolveSymbol(resolveName(errorLocation, name, (512 /* SymbolFlags.ValueModule */ | 1024 /* SymbolFlags.NamespaceModule */) & ~788968 /* SymbolFlags.Type */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
+            else if (meaning & (788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */)) {
+                var symbol = resolveSymbol(resolveName(errorLocation, name, 1536 /* SymbolFlags.Module */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
                 if (symbol) {
                     error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_type, ts.unescapeLeadingUnderscores(name));
                     return true;
@@ -51856,6 +51876,52 @@ var ts;
             }
             return undefined;
         }
+        /**
+         * Gets combined flags of a `symbol` and all alias targets it resolves to. `resolveAlias`
+         * is typically recursive over chains of aliases, but stops mid-chain if an alias is merged
+         * with another exported symbol, e.g.
+         * ```ts
+         * // a.ts
+         * export const a = 0;
+         * // b.ts
+         * export { a } from "./a";
+         * export type a = number;
+         * // c.ts
+         * import { a } from "./b";
+         * ```
+         * Calling `resolveAlias` on the `a` in c.ts would stop at the merged symbol exported
+         * from b.ts, even though there is still more alias to resolve. Consequently, if we were
+         * trying to determine if the `a` in c.ts has a value meaning, looking at the flags on
+         * the local symbol and on the symbol returned by `resolveAlias` is not enough.
+         * @returns SymbolFlags.All if `symbol` is an alias that ultimately resolves to `unknown`;
+         * combined flags of all alias targets otherwise.
+         */
+        function getAllSymbolFlags(symbol) {
+            var flags = symbol.flags;
+            var seenSymbols;
+            while (symbol.flags & 2097152 /* SymbolFlags.Alias */) {
+                var target = resolveAlias(symbol);
+                if (target === unknownSymbol) {
+                    return 67108863 /* SymbolFlags.All */;
+                }
+                // Optimizations - try to avoid creating or adding to
+                // `seenSymbols` if possible
+                if (target === symbol || (seenSymbols === null || seenSymbols === void 0 ? void 0 : seenSymbols.has(target))) {
+                    break;
+                }
+                if (target.flags & 2097152 /* SymbolFlags.Alias */) {
+                    if (seenSymbols) {
+                        seenSymbols.add(target);
+                    }
+                    else {
+                        seenSymbols = new ts.Set([symbol, target]);
+                    }
+                }
+                flags |= target.flags;
+                symbol = target;
+            }
+            return flags;
+        }
         /**
          * Marks a symbol as type-only if its declaration is syntactically type-only.
          * If it is not itself marked type-only, but resolves to a type-only alias
@@ -51901,19 +51967,25 @@ var ts;
             return !!aliasDeclarationLinks.typeOnlyDeclaration;
         }
         /** Indicates that a symbol directly or indirectly resolves to a type-only import or export. */
-        function getTypeOnlyAliasDeclaration(symbol) {
+        function getTypeOnlyAliasDeclaration(symbol, include) {
             if (!(symbol.flags & 2097152 /* SymbolFlags.Alias */)) {
                 return undefined;
             }
             var links = getSymbolLinks(symbol);
-            return links.typeOnlyDeclaration || undefined;
+            if (include === undefined) {
+                return links.typeOnlyDeclaration || undefined;
+            }
+            if (links.typeOnlyDeclaration) {
+                return getAllSymbolFlags(resolveAlias(links.typeOnlyDeclaration.symbol)) & include ? links.typeOnlyDeclaration : undefined;
+            }
+            return undefined;
         }
         function markExportAsReferenced(node) {
             var symbol = getSymbolOfNode(node);
             var target = resolveAlias(symbol);
             if (target) {
                 var markAlias = target === unknownSymbol ||
-                    ((target.flags & 111551 /* SymbolFlags.Value */) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol));
+                    ((getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */));
                 if (markAlias) {
                     markAliasSymbolAsReferenced(symbol);
                 }
@@ -51933,8 +52005,7 @@ var ts;
                 // This way a chain of imports can be elided if ultimately the final input is only used in a type
                 // position.
                 if (ts.isInternalModuleImportEqualsDeclaration(node)) {
-                    var target = resolveSymbol(symbol);
-                    if (target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (getAllSymbolFlags(resolveSymbol(symbol)) & 111551 /* SymbolFlags.Value */) {
                         // import foo = <symbol>
                         checkExpressionCached(node.moduleReference);
                     }
@@ -52756,7 +52827,7 @@ var ts;
         }
         function symbolIsValue(symbol, includeTypeOnlyMembers) {
             return !!(symbol.flags & 111551 /* SymbolFlags.Value */ ||
-                symbol.flags & 2097152 /* SymbolFlags.Alias */ && resolveAlias(symbol).flags & 111551 /* SymbolFlags.Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
+                symbol.flags & 2097152 /* SymbolFlags.Alias */ && getAllSymbolFlags(symbol) & 111551 /* SymbolFlags.Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
         }
         function findConstructorDeclaration(node) {
             var members = node.members;
@@ -53025,8 +53096,10 @@ var ts;
                     return true;
                 }
                 // Qualify if the symbol from symbol table has same meaning as expected
-                symbolFromSymbolTable = (symbolFromSymbolTable.flags & 2097152 /* SymbolFlags.Alias */ && !ts.getDeclarationOfKind(symbolFromSymbolTable, 278 /* SyntaxKind.ExportSpecifier */)) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
-                if (symbolFromSymbolTable.flags & meaning) {
+                var shouldResolveAlias = (symbolFromSymbolTable.flags & 2097152 /* SymbolFlags.Alias */ && !ts.getDeclarationOfKind(symbolFromSymbolTable, 278 /* SyntaxKind.ExportSpecifier */));
+                symbolFromSymbolTable = shouldResolveAlias ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
+                var flags = shouldResolveAlias ? getAllSymbolFlags(symbolFromSymbolTable) : symbolFromSymbolTable.flags;
+                if (flags & meaning) {
                     qualify = true;
                     return true;
                 }
@@ -55683,7 +55756,7 @@ var ts;
                     return !symbol.exports ? [] : ts.filter(ts.arrayFrom(symbol.exports.values()), isNamespaceMember);
                 }
                 function isTypeOnlyNamespace(symbol) {
-                    return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(resolveSymbol(m).flags & 111551 /* SymbolFlags.Value */); });
+                    return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(getAllSymbolFlags(resolveSymbol(m)) & 111551 /* SymbolFlags.Value */); });
                 }
                 function serializeModule(symbol, symbolName, modifierFlags) {
                     var members = getNamespaceMembersForSerialization(symbol);
@@ -57903,7 +57976,7 @@ var ts;
                 links.type = (exportSymbol === null || exportSymbol === void 0 ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol)
                     : isDuplicatedCommonJSExport(symbol.declarations) ? autoType
                         : declaredType ? declaredType
-                            : targetSymbol.flags & 111551 /* SymbolFlags.Value */ ? getTypeOfSymbol(targetSymbol)
+                            : getAllSymbolFlags(targetSymbol) & 111551 /* SymbolFlags.Value */ ? getTypeOfSymbol(targetSymbol)
                                 : errorType;
             }
             return links.type;
@@ -60256,7 +60329,7 @@ var ts;
             var indexTypes;
             var isUnion = containingType.flags & 1048576 /* TypeFlags.Union */;
             // Flags we want to propagate to the result if they exist in all source symbols
-            var optionalFlag = isUnion ? 0 /* SymbolFlags.None */ : 16777216 /* SymbolFlags.Optional */;
+            var optionalFlag;
             var syntheticFlag = 4 /* CheckFlags.SyntheticMethod */;
             var checkFlags = isUnion ? 0 : 8 /* CheckFlags.Readonly */;
             var mergedInstantiations = false;
@@ -60267,11 +60340,14 @@ var ts;
                     var prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment);
                     var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0;
                     if (prop) {
-                        if (isUnion) {
-                            optionalFlag |= (prop.flags & 16777216 /* SymbolFlags.Optional */);
-                        }
-                        else {
-                            optionalFlag &= prop.flags;
+                        if (prop.flags & 106500 /* SymbolFlags.ClassMember */) {
+                            optionalFlag !== null && optionalFlag !== void 0 ? optionalFlag : (optionalFlag = isUnion ? 0 /* SymbolFlags.None */ : 16777216 /* SymbolFlags.Optional */);
+                            if (isUnion) {
+                                optionalFlag |= (prop.flags & 16777216 /* SymbolFlags.Optional */);
+                            }
+                            else {
+                                optionalFlag &= prop.flags;
+                            }
                         }
                         if (!singleProp) {
                             singleProp = prop;
@@ -60390,7 +60466,7 @@ var ts;
                 propTypes.push(type);
             }
             ts.addRange(propTypes, indexTypes);
-            var result = createSymbol(4 /* SymbolFlags.Property */ | optionalFlag, name, syntheticFlag | checkFlags);
+            var result = createSymbol(4 /* SymbolFlags.Property */ | (optionalFlag !== null && optionalFlag !== void 0 ? optionalFlag : 0), name, syntheticFlag | checkFlags);
             result.containingType = containingType;
             if (!hasNonUniformValueDeclaration && firstValueDeclaration) {
                 result.valueDeclaration = firstValueDeclaration;
@@ -67001,7 +67077,7 @@ var ts;
                         // with another type parameter unless one extends the other. (Remember: comparability is mostly bidirectional!)
                         var constraint = getConstraintOfTypeParameter(source);
                         if (constraint && hasNonCircularBaseConstraint(source)) {
-                            while (constraint && constraint.flags & 262144 /* TypeFlags.TypeParameter */) {
+                            while (constraint && someType(constraint, function (c) { return !!(c.flags & 262144 /* TypeFlags.TypeParameter */); })) {
                                 if (result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false)) {
                                     return result;
                                 }
@@ -67657,7 +67733,7 @@ var ts;
                     return 0 /* Ternary.False */;
                 }
                 // When checking for comparability, be more lenient with optional properties.
-                if (!skipOptional && sourceProp.flags & 16777216 /* SymbolFlags.Optional */ && !(targetProp.flags & 16777216 /* SymbolFlags.Optional */)) {
+                if (!skipOptional && sourceProp.flags & 16777216 /* SymbolFlags.Optional */ && targetProp.flags & 106500 /* SymbolFlags.ClassMember */ && !(targetProp.flags & 16777216 /* SymbolFlags.Optional */)) {
                     // TypeScript 1.0 spec (April 2014): 3.8.3
                     // S is a subtype of a type T, and T is a supertype of S if ...
                     // S' and T are object types and, for each member M in T..
@@ -72929,9 +73005,9 @@ var ts;
             });
         }
         function markAliasReferenced(symbol, location) {
-            if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) {
+            if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)) {
                 var target = resolveAlias(symbol);
-                if (target.flags & 111551 /* SymbolFlags.Value */) {
+                if (getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) {
                     // An alias resolving to a const enum cannot be elided if (1) 'isolatedModules' is enabled
                     // (because the const enum value will not be inlined), or if (2) the alias is an export
                     // of a const enum declaration that will be preserved.
@@ -78823,7 +78899,7 @@ var ts;
                     if (symbol && symbol.flags & 2097152 /* SymbolFlags.Alias */) {
                         symbol = resolveAlias(symbol);
                     }
-                    return !!(symbol && (symbol.flags & 384 /* SymbolFlags.Enum */) && getEnumKind(symbol) === 1 /* EnumKind.Literal */);
+                    return !!(symbol && (getAllSymbolFlags(symbol) & 384 /* SymbolFlags.Enum */) && getEnumKind(symbol) === 1 /* EnumKind.Literal */);
             }
             return false;
         }
@@ -84998,7 +85074,16 @@ var ts;
             var message = allowAsyncIterables
                 ? ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator
                 : ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
-            return errorAndMaybeSuggestAwait(errorNode, !!getAwaitedTypeOfPromise(type), message, typeToString(type));
+            var suggestAwait = 
+            // for (const x of Promise<...>) or [...Promise<...>]
+            !!getAwaitedTypeOfPromise(type)
+                // for (const x of AsyncIterable<...>)
+                || (!allowAsyncIterables &&
+                    ts.isForOfStatement(errorNode.parent) &&
+                    errorNode.parent.expression === errorNode &&
+                    getGlobalAsyncIterableType(/** reportErrors */ false) !== emptyGenericType &&
+                    isTypeAssignableTo(type, getGlobalAsyncIterableType(/** reportErrors */ false)));
+            return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type));
         }
         /**
          * Gets the *yield*, *return*, and *next* types from an `Iterator`-like or `AsyncIterator`-like type.
@@ -86849,10 +86934,11 @@ var ts;
                     }
                     return;
                 }
+                var targetFlags = getAllSymbolFlags(target);
                 var excludedMeanings = (symbol.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */) ? 111551 /* SymbolFlags.Value */ : 0) |
                     (symbol.flags & 788968 /* SymbolFlags.Type */ ? 788968 /* SymbolFlags.Type */ : 0) |
                     (symbol.flags & 1920 /* SymbolFlags.Namespace */ ? 1920 /* SymbolFlags.Namespace */ : 0);
-                if (target.flags & excludedMeanings) {
+                if (targetFlags & excludedMeanings) {
                     var message = node.kind === 278 /* SyntaxKind.ExportSpecifier */ ?
                         ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 :
                         ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
@@ -86862,7 +86948,7 @@ var ts;
                     && !ts.isTypeOnlyImportOrExportDeclaration(node)
                     && !(node.flags & 16777216 /* NodeFlags.Ambient */)) {
                     var typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol);
-                    var isType = !(target.flags & 111551 /* SymbolFlags.Value */);
+                    var isType = !(targetFlags & 111551 /* SymbolFlags.Value */);
                     if (isType || typeOnlyAlias) {
                         switch (node.kind) {
                             case 270 /* SyntaxKind.ImportClause */:
@@ -87022,14 +87108,15 @@ var ts;
                 if (node.moduleReference.kind !== 280 /* SyntaxKind.ExternalModuleReference */) {
                     var target = resolveAlias(getSymbolOfNode(node));
                     if (target !== unknownSymbol) {
-                        if (target.flags & 111551 /* SymbolFlags.Value */) {
+                        var targetFlags = getAllSymbolFlags(target);
+                        if (targetFlags & 111551 /* SymbolFlags.Value */) {
                             // Target is a value symbol, check that it is not hidden by a local declaration with the same name
                             var moduleName = ts.getFirstIdentifier(node.moduleReference);
                             if (!(resolveEntityName(moduleName, 111551 /* SymbolFlags.Value */ | 1920 /* SymbolFlags.Namespace */).flags & 1920 /* SymbolFlags.Namespace */)) {
                                 error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName));
                             }
                         }
-                        if (target.flags & 788968 /* SymbolFlags.Type */) {
+                        if (targetFlags & 788968 /* SymbolFlags.Type */) {
                             checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0);
                         }
                     }
@@ -87168,7 +87255,7 @@ var ts;
                         markExportAsReferenced(node);
                     }
                     var target = symbol && (symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol);
-                    if (!target || target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (!target || getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) {
                         checkExpressionCached(node.propertyName || node.name);
                     }
                 }
@@ -87215,7 +87302,7 @@ var ts;
                     markAliasReferenced(sym, id);
                     // If not a value, we're interpreting the identifier as a type export, along the lines of (`export { Id as default }`)
                     var target = sym.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(sym) : sym;
-                    if (target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) {
                         // However if it is a value, we need to check it's being used correctly
                         checkExpressionCached(node.expression);
                     }
@@ -88537,7 +88624,7 @@ var ts;
             return symbolLinks.exportsSomeValue;
             function isValue(s) {
                 s = resolveSymbol(s);
-                return s && !!(s.flags & 111551 /* SymbolFlags.Value */);
+                return s && !!(getAllSymbolFlags(s) & 111551 /* SymbolFlags.Value */);
             }
         }
         function isNameOfModuleOrEnumDeclaration(node) {
@@ -88590,7 +88677,7 @@ var ts;
                 var symbol = getReferencedValueOrAliasSymbol(node);
                 // We should only get the declaration of an alias if there isn't a local value
                 // declaration for the symbol
-                if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !getTypeOnlyAliasDeclaration(symbol)) {
+                if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)) {
                     return getDeclarationOfAliasSymbol(symbol);
                 }
             }
@@ -88678,7 +88765,7 @@ var ts;
                 case 273 /* SyntaxKind.ImportSpecifier */:
                 case 278 /* SyntaxKind.ExportSpecifier */:
                     var symbol = getSymbolOfNode(node);
-                    return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol);
+                    return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */);
                 case 275 /* SyntaxKind.ExportDeclaration */:
                     var exportClause = node.exportClause;
                     return !!exportClause && (ts.isNamespaceExport(exportClause) ||
@@ -88700,6 +88787,7 @@ var ts;
             return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference);
         }
         function isAliasResolvedToValue(symbol) {
+            var _a;
             if (!symbol) {
                 return false;
             }
@@ -88709,7 +88797,7 @@ var ts;
             }
             // const enums and modules that contain only const enums are not considered values from the emit perspective
             // unless 'preserveConstEnums' option is set to true
-            return !!(target.flags & 111551 /* SymbolFlags.Value */) &&
+            return !!(((_a = getAllSymbolFlags(target)) !== null && _a !== void 0 ? _a : -1) & 111551 /* SymbolFlags.Value */) &&
                 (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target));
         }
         function isConstEnumOrConstEnumOnlyModule(s) {
@@ -88724,7 +88812,7 @@ var ts;
                 }
                 var target = getSymbolLinks(symbol).aliasTarget; // TODO: GH#18217
                 if (target && ts.getEffectiveModifierFlags(node) & 1 /* ModifierFlags.Export */ &&
-                    target.flags & 111551 /* SymbolFlags.Value */ &&
+                    getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */ &&
                     (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
                     // An `export import ... =` of a value symbol is always considered referenced
                     return true;
@@ -129180,6 +129268,12 @@ var ts;
         SemanticClassificationFormat["Original"] = "original";
         SemanticClassificationFormat["TwentyTwenty"] = "2020";
     })(SemanticClassificationFormat = ts.SemanticClassificationFormat || (ts.SemanticClassificationFormat = {}));
+    var OrganizeImportsMode;
+    (function (OrganizeImportsMode) {
+        OrganizeImportsMode["All"] = "All";
+        OrganizeImportsMode["SortAndCombine"] = "SortAndCombine";
+        OrganizeImportsMode["RemoveUnused"] = "RemoveUnused";
+    })(OrganizeImportsMode = ts.OrganizeImportsMode || (ts.OrganizeImportsMode = {}));
     var CompletionTriggerKind;
     (function (CompletionTriggerKind) {
         /** Completion was triggered by typing an identifier, manual invocation (e.g Ctrl+Space) or via API. */
@@ -144935,23 +145029,39 @@ var ts;
          *   2) Coalescing imports from the same module
          *   3) Sorting imports
          */
-        function organizeImports(sourceFile, formatContext, host, program, preferences, skipDestructiveCodeActions) {
+        function organizeImports(sourceFile, formatContext, host, program, preferences, mode) {
             var changeTracker = ts.textChanges.ChangeTracker.fromContext({ host: host, formatContext: formatContext, preferences: preferences });
-            var coalesceAndOrganizeImports = function (importGroup) { return ts.stableSort(coalesceImports(removeUnusedImports(importGroup, sourceFile, program, skipDestructiveCodeActions)), function (s1, s2) { return compareImportsOrRequireStatements(s1, s2); }); };
+            var shouldSort = mode === "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ || mode === "All" /* OrganizeImportsMode.All */;
+            var shouldCombine = shouldSort; // These are currently inseparable, but I draw a distinction for clarity and in case we add modes in the future.
+            var shouldRemove = mode === "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */ || mode === "All" /* OrganizeImportsMode.All */;
+            var maybeRemove = shouldRemove ? removeUnusedImports : ts.identity;
+            var maybeCoalesce = shouldCombine ? coalesceImports : ts.identity;
+            var processImportsOfSameModuleSpecifier = function (importGroup) {
+                var processedDeclarations = maybeCoalesce(maybeRemove(importGroup, sourceFile, program));
+                return shouldSort
+                    ? ts.stableSort(processedDeclarations, function (s1, s2) { return compareImportsOrRequireStatements(s1, s2); })
+                    : processedDeclarations;
+            };
             // All of the old ImportDeclarations in the file, in syntactic order.
             var topLevelImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, sourceFile.statements.filter(ts.isImportDeclaration));
-            topLevelImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports); });
-            // All of the old ExportDeclarations in the file, in syntactic order.
-            var topLevelExportDecls = sourceFile.statements.filter(ts.isExportDeclaration);
-            organizeImportsWorker(topLevelExportDecls, coalesceExports);
+            topLevelImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier); });
+            // Exports are always used
+            if (mode !== "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */) {
+                // All of the old ExportDeclarations in the file, in syntactic order.
+                var topLevelExportDecls = sourceFile.statements.filter(ts.isExportDeclaration);
+                organizeImportsWorker(topLevelExportDecls, coalesceExports);
+            }
             for (var _i = 0, _a = sourceFile.statements.filter(ts.isAmbientModule); _i < _a.length; _i++) {
                 var ambientModule = _a[_i];
                 if (!ambientModule.body)
                     continue;
                 var ambientModuleImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, ambientModule.body.statements.filter(ts.isImportDeclaration));
-                ambientModuleImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports); });
-                var ambientModuleExportDecls = ambientModule.body.statements.filter(ts.isExportDeclaration);
-                organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
+                ambientModuleImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier); });
+                // Exports are always used
+                if (mode !== "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */) {
+                    var ambientModuleExportDecls = ambientModule.body.statements.filter(ts.isExportDeclaration);
+                    organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
+                }
             }
             return changeTracker.getChanges();
             function organizeImportsWorker(oldImportDecls, coalesce) {
@@ -144964,8 +145074,12 @@ var ts;
                 // Consider: we could do a more careful check that this trivia is actually a header,
                 // but the consequences of being wrong are very minor.
                 ts.suppressLeadingTrivia(oldImportDecls[0]);
-                var oldImportGroups = ts.group(oldImportDecls, function (importDecl) { return getExternalModuleName(importDecl.moduleSpecifier); });
-                var sortedImportGroups = ts.stableSort(oldImportGroups, function (group1, group2) { return compareModuleSpecifiers(group1[0].moduleSpecifier, group2[0].moduleSpecifier); });
+                var oldImportGroups = shouldCombine
+                    ? ts.group(oldImportDecls, function (importDecl) { return getExternalModuleName(importDecl.moduleSpecifier); })
+                    : [oldImportDecls];
+                var sortedImportGroups = shouldSort
+                    ? ts.stableSort(oldImportGroups, function (group1, group2) { return compareModuleSpecifiers(group1[0].moduleSpecifier, group2[0].moduleSpecifier); })
+                    : oldImportGroups;
                 var newImportDecls = ts.flatMap(sortedImportGroups, function (importGroup) {
                     return getExternalModuleName(importGroup[0].moduleSpecifier)
                         ? coalesce(importGroup)
@@ -145029,11 +145143,7 @@ var ts;
             }
             return false;
         }
-        function removeUnusedImports(oldImports, sourceFile, program, skipDestructiveCodeActions) {
-            // As a precaution, consider unused import detection to be destructive (GH #43051)
-            if (skipDestructiveCodeActions) {
-                return oldImports;
-            }
+        function removeUnusedImports(oldImports, sourceFile, program) {
             var typeChecker = program.getTypeChecker();
             var compilerOptions = program.getCompilerOptions();
             var jsxNamespace = typeChecker.getJsxNamespace(sourceFile);
@@ -154066,6 +154176,15 @@ var ts;
             });
         }
         function makeChange(changeTracker, errorCode, sourceFile, checker, insertionSite, fixedDeclarations) {
+            if (ts.isForOfStatement(insertionSite.parent) && !insertionSite.parent.awaitModifier) {
+                var exprType = checker.getTypeAtLocation(insertionSite);
+                var asyncIter = checker.getAsyncIterableType();
+                if (asyncIter && checker.isTypeAssignableTo(exprType, asyncIter)) {
+                    var forOf = insertionSite.parent;
+                    changeTracker.replaceNode(sourceFile, forOf, ts.factory.updateForOfStatement(forOf, ts.factory.createToken(133 /* SyntaxKind.AwaitKeyword */), forOf.initializer, forOf.expression, forOf.statement));
+                    return;
+                }
+            }
             if (ts.isBinaryExpression(insertionSite)) {
                 for (var _i = 0, _a = [insertionSite.left, insertionSite.right]; _i < _a.length; _i++) {
                     var side = _a[_i];
@@ -169421,12 +169540,14 @@ var ts;
             return ts.codefix.getAllFixes({ fixId: fixId, sourceFile: sourceFile, program: program, host: host, cancellationToken: cancellationToken, formatContext: formatContext, preferences: preferences });
         }
         function organizeImports(args, formatOptions, preferences) {
+            var _a;
             if (preferences === void 0) { preferences = ts.emptyOptions; }
             synchronizeHostData();
             ts.Debug.assert(args.type === "file");
             var sourceFile = getValidSourceFile(args.fileName);
             var formatContext = ts.formatting.getFormatContext(formatOptions, host);
-            return ts.OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences, args.skipDestructiveCodeActions);
+            var mode = (_a = args.mode) !== null && _a !== void 0 ? _a : (args.skipDestructiveCodeActions ? "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ : "All" /* OrganizeImportsMode.All */);
+            return ts.OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences, mode);
         }
         function getEditsForFileRename(oldFilePath, newFilePath, formatOptions, preferences) {
             if (preferences === void 0) { preferences = ts.emptyOptions; }