tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/binder.js

@@ -3,7 +3,7 @@
 //
 // Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
 // statically, but reads fields of a narrowed value dynamically.
-import { appendToList, BinaryExpression, CallExpression, ConditionalTypeNode, ElementAccessExpression, ExportAssignment, FunctionExpression, KeywordExpression, ModuleDeclaration, NodeVisitor, PatternAmbientModule, PrefixUnaryExpression, PropertyAccessExpression, ReferenceIdentifier, TypeAliasDeclaration, VariableDeclaration, getArguments, getBody, getElements, getExpression, getInitializer, getLabel, getLocals, getModifiers, getName, getParameters, getPostfixToken, getProperties, getStatements, getSymbol, getText, isDeclarationNode, isLocalsContainer, setEndFlowNode, setFlowNode, setLocalSymbol, setLocals, setNextContainer, setReturnFlowNode, setSymbol, callQuestionDotToken, callTypeArguments, } from './ast.js';
+import { appendToList, BinaryExpression, CallExpression, ConditionalTypeNode, ElementAccessExpression, ExportAssignment, FunctionExpression, KeywordExpression, ModuleDeclaration, getNodeId, NodeVisitor, PatternAmbientModule, PrefixUnaryExpression, PropertyAccessExpression, ReferenceIdentifier, TypeAliasDeclaration, VariableDeclaration, getArguments, getBody, getElements, getExpression, getInitializer, getLabel, getLocals, getModifiers, getName, getParameters, getPostfixToken, getProperties, getStatements, getSymbol, getText, isDeclarationNode, isLocalsContainer, setEndFlowNode, setFlowNode, setLocalSymbol, setLocals, setNextContainer, setReturnFlowNode, setSymbol, callQuestionDotToken, callTypeArguments, } from './ast.js';
 import { isAmbientModule, isAssignmentOperator, isFunctionLike, isGlobalScopeAugmentation, isInJSFile, isLeftHandSideExpression, isRequireCall, isStringLiteralLike, nodeIsMissing, nodeIsPresent, } from './ast-utilities.js';
 import { declarationNameToString, expressionIsAlias, getAssignmentDeclarationKind, getCombinedModifierFlags, getContainingClass, getElementOrPropertyAccessName, getErrorRangeForNode, getImmediatelyInvokedFunctionExpression, getModuleInstanceState, StatementsByName, getNameOfDeclaration, getRangeOfTokenAtPosition, getSourceTextOfNode, hasDynamicName, hasSyntacticModifier, isAssignmentTarget, isAsyncFunction, isAutoAccessorPropertyDeclaration, isBlockOrCatchScoped, isBooleanLiteral, isDeclarationStatementKind, isDestructuringAssignment, isDottedName, isEntityNameExpression, isEnumConst, isExpandoInitializer, isExpressionOfOptionalChainRoot, isExternalModule, isExternalOrCommonJSModule, isIdentifierName, isImplicitlyExportedJSDocDeclaration, isInTopLevelContext, isJsonSourceFile, isLogicalExpression, isLogicalOrCoalescingAssignmentExpression, isLogicalOrCoalescingAssignmentOperator, isLogicalOrCoalescingBinaryOperator, isModuleAugmentationExternal, isNullishCoalesce, isObjectLiteralMethod, isObjectLiteralOrClassExpressionMethodOrAccessor, isOptionalChain, isOptionalChainRoot, isOutermostOptionalChain, isParameterPropertyDeclaration, isPartOfParameterDeclaration, isPartOfTypeQuery, isPotentiallyExecutableNode, isPrologueDirective, isPropertyNameLiteral, isPushOrUnshiftIdentifier, isSignedNumericLiteral, isStatic, isStringOrNumericLiteralLike, isVariableDeclarationInitializedToRequire, moduleExportNameIsDefault, nodeText, skipParentheses, } from './binder-utilities.js';
 import { Diagnostic } from './diagnostics.js';
@@ -13,26 +13,26 @@ import { getIdentifierToken, tokenToString } from './scanner.js';
 import { addDeclaration, copyDeclarations, declarationCount, getDeclarations, getExports, getMembers, getSymbolId, internalSymbolNamePrefix, Symbol, } from './symbol.js';
 export function getContainerFlags(node) {
     switch (node.kind) {
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 188 /* SyntaxKind.TypeLiteral */:
-        case 293 /* SyntaxKind.JsxAttributes */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 189 /* SyntaxKind.TypeLiteral */:
+        case 294 /* SyntaxKind.JsxAttributes */:
             return 1 /* ContainerFlags.IsContainer */;
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
             return 1 /* ContainerFlags.IsContainer */ | 64 /* ContainerFlags.IsInterface */;
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 201 /* SyntaxKind.MappedType */:
-        case 182 /* SyntaxKind.IndexSignature */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 202 /* SyntaxKind.MappedType */:
+        case 183 /* SyntaxKind.IndexSignature */:
             return 1 /* ContainerFlags.IsContainer */ | 32 /* ContainerFlags.HasLocals */;
-        case 307 /* SyntaxKind.SourceFile */:
+        case 308 /* SyntaxKind.SourceFile */:
             return 1 /* ContainerFlags.IsContainer */ | 4 /* ContainerFlags.IsControlFlowContainer */ | 32 /* ContainerFlags.HasLocals */;
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             if (isObjectLiteralOrClassExpressionMethodOrAccessor(node))
                 return (1 /* ContainerFlags.IsContainer */ |
                     4 /* ContainerFlags.IsControlFlowContainer */ |
@@ -41,49 +41,49 @@ export function getContainerFlags(node) {
                     128 /* ContainerFlags.IsObjectLiteralOrClassExpressionMethodOrAccessor */ |
                     256 /* ContainerFlags.IsThisContainer */);
             return functionContainerFlags;
-        case 177 /* SyntaxKind.Constructor */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
             return functionContainerFlags;
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 185 /* SyntaxKind.FunctionType */:
-        case 181 /* SyntaxKind.ConstructSignature */:
-        case 186 /* SyntaxKind.ConstructorType */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 187 /* SyntaxKind.ConstructorType */:
             return (1 /* ContainerFlags.IsContainer */ |
                 4 /* ContainerFlags.IsControlFlowContainer */ |
                 32 /* ContainerFlags.HasLocals */ |
                 8 /* ContainerFlags.IsFunctionLike */ |
                 512 /* ContainerFlags.PropagatesThisKeyword */);
-        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.FunctionExpression */:
             return (1 /* ContainerFlags.IsContainer */ |
                 4 /* ContainerFlags.IsControlFlowContainer */ |
                 32 /* ContainerFlags.HasLocals */ |
                 8 /* ContainerFlags.IsFunctionLike */ |
                 16 /* ContainerFlags.IsFunctionExpression */ |
                 256 /* ContainerFlags.IsThisContainer */);
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return (1 /* ContainerFlags.IsContainer */ |
                 4 /* ContainerFlags.IsControlFlowContainer */ |
                 32 /* ContainerFlags.HasLocals */ |
                 8 /* ContainerFlags.IsFunctionLike */ |
                 16 /* ContainerFlags.IsFunctionExpression */ |
                 512 /* ContainerFlags.PropagatesThisKeyword */);
-        case 269 /* SyntaxKind.ModuleBlock */:
+        case 270 /* SyntaxKind.ModuleBlock */:
             return 4 /* ContainerFlags.IsControlFlowContainer */;
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             return getInitializer(node) !== undefined
                 ? 4 /* ContainerFlags.IsControlFlowContainer */ | 256 /* ContainerFlags.IsThisContainer */
                 : 0 /* ContainerFlags.None */;
-        case 300 /* SyntaxKind.CatchClause */:
-        case 249 /* SyntaxKind.ForStatement */:
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
-        case 270 /* SyntaxKind.CaseBlock */:
+        case 301 /* SyntaxKind.CatchClause */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
+        case 271 /* SyntaxKind.CaseBlock */:
             return 2 /* ContainerFlags.IsBlockScopedContainer */ | 32 /* ContainerFlags.HasLocals */;
-        case 242 /* SyntaxKind.Block */: {
+        case 243 /* SyntaxKind.Block */: {
             const parent = node.parent;
-            return isFunctionLike(parent) || parent.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */
+            return isFunctionLike(parent) || parent.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */
                 ? 0 /* ContainerFlags.None */
                 : 2 /* ContainerFlags.IsBlockScopedContainer */ | 32 /* ContainerFlags.HasLocals */;
         }
@@ -148,17 +148,17 @@ export function setValueDeclaration(symbol, node) {
 }
 function isAssignmentDeclaration(declaration) {
     switch (declaration.kind) {
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
         case 79 /* SyntaxKind.Identifier */:
-        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             return true;
     }
     return false;
 }
 function isEffectiveModuleDeclaration(node) {
-    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ || node.kind === 79 /* SyntaxKind.Identifier */;
+    return node.kind === 269 /* SyntaxKind.ModuleDeclaration */ || node.kind === 79 /* SyntaxKind.Identifier */;
 }
 class Binder extends NodeVisitor {
     file;
@@ -251,7 +251,7 @@ class Binder extends NodeVisitor {
     }
     declareSymbolEx(symbolTable, parent, node, includes, excludes, isReplaceableByMethod, isComputedName) {
         const isDefaultExport = hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */) ||
-            (node.kind === 282 /* SyntaxKind.ExportSpecifier */ && moduleExportNameIsDefault(getName(node)));
+            (node.kind === 283 /* SyntaxKind.ExportSpecifier */ && moduleExportNameIsDefault(getName(node)));
         // The exported symbol of `export default function/class` is always named "default".
         const name = isComputedName
             ? "\uFFFEcomputed" /* InternalSymbolName.Computed */
@@ -298,18 +298,18 @@ class Binder extends NodeVisitor {
     }
     reportDuplicate(symbol, node, includes, isDefaultExport) {
         let message = (symbol.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0
-            ? 619 /* Diagnostics.Cannot_redeclare_block_scoped_variable_0 */
-            : 478 /* Diagnostics.Duplicate_identifier_0 */;
+            ? 626 /* Diagnostics.Cannot_redeclare_block_scoped_variable_0 */
+            : 485 /* Diagnostics.Duplicate_identifier_0 */;
         let messageNeedsName = true;
         if ((symbol.flags & 384 /* SymbolFlags.Enum */) !== 0 || (includes & 384 /* SymbolFlags.Enum */) !== 0) {
-            message = 721 /* Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations */;
+            message = 728 /* Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations */;
             messageNeedsName = false;
         }
         let multipleDefaultExports = false;
         if (declarationCount(symbol) !== 0) {
             // A default export (by modifier, or `export default` assignment) after another one.
             if (isDefaultExport || (node instanceof ExportAssignment && !node.isExportEquals)) {
-                message = 686 /* Diagnostics.A_module_cannot_have_multiple_default_exports */;
+                message = 693 /* Diagnostics.A_module_cannot_have_multiple_default_exports */;
                 messageNeedsName = false;
                 multipleDefaultExports = true;
             }
@@ -331,10 +331,10 @@ class Binder extends NodeVisitor {
             const decl = getNameOfDeclaration(declaration) ?? declaration;
             const d = this.createDiagnosticForNode(decl, message, messageNeedsName ? [this.getDisplayName(declaration)] : noArgs);
             if (multipleDefaultExports)
-                d.addRelatedInfo(this.createDiagnosticForNode(declarationName, index === 0 ? 885 /* Diagnostics.Another_export_default_is_here */ : 1357 /* Diagnostics.X_and_here */, noArgs));
+                d.addRelatedInfo(this.createDiagnosticForNode(declarationName, index === 0 ? 892 /* Diagnostics.Another_export_default_is_here */ : 1368 /* Diagnostics.X_and_here */, noArgs));
             this.addDiagnostic(d);
             if (multipleDefaultExports)
-                diagnostic.addRelatedInfo(this.createDiagnosticForNode(decl, 884 /* Diagnostics.The_first_export_default_is_here */, noArgs));
+                diagnostic.addRelatedInfo(this.createDiagnosticForNode(decl, 891 /* Diagnostics.The_first_export_default_is_here */, noArgs));
         }
         this.addDiagnostic(diagnostic);
         // An accessor conflicting with a non-accessor or the other accessor kind makes the symbol a
@@ -352,7 +352,14 @@ class Binder extends NodeVisitor {
             if (isAmbientModule(node)) {
                 if (isGlobalScopeAugmentation(node))
                     return "\uFFFEglobal" /* InternalSymbolName.Global */;
-                return '"' + nodeText(name) + '"';
+                const moduleName = nodeText(name);
+                // A pattern module with import attributes has its own symbol, named after the attributes node's id: it merges
+                // only with pattern modules of the same pattern and identical attributes, which the checker decides. The id
+                // is written at a fixed width so that names sort in declaration order.
+                const attributes = node.attributes;
+                if (attributes !== undefined && hasSingleStar(moduleName))
+                    return (internalSymbolNamePrefix + '"' + moduleName + '"pattern@' + String(getNodeId(attributes)).padStart(10, '0'));
+                return '"' + moduleName + '"';
             }
             if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
                 // Private names are only allowed in classes; elsewhere there is already a parse error.
@@ -361,9 +368,9 @@ class Binder extends NodeVisitor {
                     return "\uFFFEmissing" /* InternalSymbolName.Missing */;
                 return getSymbolNameForPrivateIdentifier(getSymbol(containingClass), getText(name));
             }
-            if (isPropertyNameLiteral(name) || name.kind === 296 /* SyntaxKind.JsxNamespacedName */)
+            if (isPropertyNameLiteral(name) || name.kind === 297 /* SyntaxKind.JsxNamespacedName */)
                 return nodeText(name);
-            if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */) {
+            if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */) {
                 const expression = getExpression(name);
                 // A literal computed name is just the literal.
                 if (isStringOrNumericLiteralLike(expression))
@@ -377,20 +384,20 @@ class Binder extends NodeVisitor {
             return "\uFFFEmissing" /* InternalSymbolName.Missing */;
         }
         switch (node.kind) {
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 return "\uFFFEconstructor" /* InternalSymbolName.Constructor */;
-            case 185 /* SyntaxKind.FunctionType */:
-            case 180 /* SyntaxKind.CallSignature */:
+            case 186 /* SyntaxKind.FunctionType */:
+            case 181 /* SyntaxKind.CallSignature */:
                 return "\uFFFEcall" /* InternalSymbolName.Call */;
-            case 186 /* SyntaxKind.ConstructorType */:
-            case 181 /* SyntaxKind.ConstructSignature */:
+            case 187 /* SyntaxKind.ConstructorType */:
+            case 182 /* SyntaxKind.ConstructSignature */:
                 return "\uFFFEnew" /* InternalSymbolName.New */;
-            case 182 /* SyntaxKind.IndexSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
                 return "\uFFFEindex" /* InternalSymbolName.Index */;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 return "\uFFFEexport" /* InternalSymbolName.ExportStar */;
-            case 307 /* SyntaxKind.SourceFile */:
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 308 /* SyntaxKind.SourceFile */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 return "export=" /* InternalSymbolName.ExportEquals */;
         }
         return "\uFFFEmissing" /* InternalSymbolName.Missing */;
@@ -411,8 +418,8 @@ class Binder extends NodeVisitor {
         const container = this.container;
         const hasExportModifier = (getCombinedModifierFlags(node) & 32 /* ModifierFlags.Export */) !== 0 || isImplicitlyExportedJSDocDeclaration(node);
         if ((symbolFlags & 2097152 /* SymbolFlags.Alias */) !== 0) {
-            if (node.kind === 282 /* SyntaxKind.ExportSpecifier */ ||
-                (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ && hasExportModifier)) {
+            if (node.kind === 283 /* SyntaxKind.ExportSpecifier */ ||
+                (node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ && hasExportModifier)) {
                 const containerSymbol = getSymbol(container);
                 return this.declareSymbol(getExports(containerSymbol), containerSymbol, node, symbolFlags, symbolExcludes);
             }
@@ -447,41 +454,41 @@ class Binder extends NodeVisitor {
     declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
         const container = this.container;
         switch (container.kind) {
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 return this.declareModuleMember(node, symbolFlags, symbolExcludes);
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 return this.declareSourceFileMember(node, symbolFlags, symbolExcludes);
-            case 232 /* SyntaxKind.ClassExpression */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 return this.declareClassMember(node, symbolFlags, symbolExcludes);
-            case 267 /* SyntaxKind.EnumDeclaration */: {
+            case 268 /* SyntaxKind.EnumDeclaration */: {
                 const enumSymbol = getSymbol(container);
                 return this.declareSymbol(getExports(enumSymbol), enumSymbol, node, symbolFlags, symbolExcludes);
             }
-            case 188 /* SyntaxKind.TypeLiteral */:
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 293 /* SyntaxKind.JsxAttributes */: {
+            case 189 /* SyntaxKind.TypeLiteral */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 294 /* SyntaxKind.JsxAttributes */: {
                 const containerSymbol = getSymbol(container);
                 return this.declareSymbol(getMembers(containerSymbol), containerSymbol, node, symbolFlags, symbolExcludes);
             }
-            case 185 /* SyntaxKind.FunctionType */:
-            case 186 /* SyntaxKind.ConstructorType */:
-            case 180 /* SyntaxKind.CallSignature */:
-            case 181 /* SyntaxKind.ConstructSignature */:
-            case 182 /* SyntaxKind.IndexSignature */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 174 /* SyntaxKind.MethodSignature */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-            case 201 /* SyntaxKind.MappedType */:
+            case 186 /* SyntaxKind.FunctionType */:
+            case 187 /* SyntaxKind.ConstructorType */:
+            case 181 /* SyntaxKind.CallSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 175 /* SyntaxKind.MethodSignature */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 202 /* SyntaxKind.MappedType */:
                 return this.declareSymbol(this.localsOf(container), undefined, node, symbolFlags, symbolExcludes);
         }
         throw new Error('Unhandled case in declareSymbolAndAddToSymbolTable');
@@ -519,9 +526,9 @@ class Binder extends NodeVisitor {
     bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) {
         const blockScopeContainer = this.blockScopeContainer;
         switch (blockScopeContainer.kind) {
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 return this.declareModuleMember(node, symbolFlags, symbolExcludes);
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (isExternalOrCommonJSModule(this.file))
                     return this.declareModuleMember(node, symbolFlags, symbolExcludes);
                 break;
@@ -564,22 +571,22 @@ class Binder extends NodeVisitor {
                 if (node instanceof KeywordExpression)
                     node.flowNode = this.currentFlowValue();
                 break;
-            case 167 /* SyntaxKind.QualifiedName */:
+            case 168 /* SyntaxKind.QualifiedName */:
                 if (isPartOfTypeQuery(node))
                     node.flowNode = this.currentFlowValue();
                 break;
-            case 237 /* SyntaxKind.MetaProperty */:
+            case 238 /* SyntaxKind.MetaProperty */:
                 node.flowNode = this.currentFlowValue();
                 break;
             case 80 /* SyntaxKind.PrivateIdentifier */:
                 this.checkPrivateIdentifier(node);
                 break;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 if (isNarrowableReference(node))
                     setFlowNode(node, this.currentFlowValue());
                 break;
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 switch (getAssignmentDeclarationKind(node)) {
                     case 1 /* JSDeclarationKind.ModuleExports */:
                         this.bindModuleExportsAssignment(node);
@@ -596,103 +603,103 @@ class Binder extends NodeVisitor {
                 }
                 this.checkStrictModeBinaryExpression(node);
                 break;
-            case 300 /* SyntaxKind.CatchClause */:
+            case 301 /* SyntaxKind.CatchClause */:
                 this.checkStrictModeCatchClause(node);
                 break;
-            case 221 /* SyntaxKind.DeleteExpression */:
+            case 222 /* SyntaxKind.DeleteExpression */:
                 this.checkStrictModeDeleteExpression(node);
                 break;
-            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+            case 227 /* SyntaxKind.PostfixUnaryExpression */:
                 this.checkStrictModeEvalOrArguments(node, node.operand);
                 break;
-            case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            case 226 /* SyntaxKind.PrefixUnaryExpression */: {
                 const operator = node.operator;
                 if (operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */)
                     this.checkStrictModeEvalOrArguments(node, node.operand);
                 break;
             }
-            case 255 /* SyntaxKind.WithStatement */:
+            case 256 /* SyntaxKind.WithStatement */:
                 this.errorOnFirstToken(node, 70 /* Diagnostics.X_with_statements_are_not_allowed_in_strict_mode */, noArgs);
                 break;
-            case 257 /* SyntaxKind.LabeledStatement */: {
+            case 258 /* SyntaxKind.LabeledStatement */: {
                 const statement = node.statement;
-                if (isDeclarationStatementKind(statement.kind) || statement.kind === 244 /* SyntaxKind.VariableStatement */)
+                if (isDeclarationStatementKind(statement.kind) || statement.kind === 245 /* SyntaxKind.VariableStatement */)
                     this.errorOnFirstToken(node.label, 278 /* Diagnostics.A_label_is_not_allowed_here */, noArgs);
                 break;
             }
-            case 198 /* SyntaxKind.ThisType */:
+            case 199 /* SyntaxKind.ThisType */:
                 this.seenThisKeyword = true;
                 break;
-            case 169 /* SyntaxKind.TypeParameter */:
+            case 170 /* SyntaxKind.TypeParameter */:
                 this.bindTypeParameter(node);
                 break;
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 this.bindParameter(node);
                 break;
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 this.bindVariableDeclarationOrBindingElement(node);
                 break;
-            case 209 /* SyntaxKind.BindingElement */:
+            case 210 /* SyntaxKind.BindingElement */:
                 node.flowNode = this.currentFlowValue();
                 this.bindVariableDeclarationOrBindingElement(node);
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 172 /* SyntaxKind.PropertySignature */: {
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 173 /* SyntaxKind.PropertySignature */: {
                 const isAutoAccessor = isAutoAccessorPropertyDeclaration(node);
                 this.bindPropertyOrMethodOrAccessor(node, (isAutoAccessor ? 98304 /* SymbolFlags.Accessor */ : 4 /* SymbolFlags.Property */) | optionalSymbolFlag(node), isAutoAccessor ? 111547 /* SymbolFlags.AccessorExcludes */ : 13243 /* SymbolFlags.PropertyExcludes */);
                 break;
             }
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
                 this.bindPropertyOrMethodOrAccessor(node, 4 /* SymbolFlags.Property */, 13243 /* SymbolFlags.PropertyExcludes */);
                 break;
-            case 306 /* SyntaxKind.EnumMember */:
+            case 307 /* SyntaxKind.EnumMember */:
                 this.bindPropertyOrMethodOrAccessor(node, 8 /* SymbolFlags.EnumMember */, 900095 /* SymbolFlags.EnumMemberExcludes */);
                 break;
-            case 180 /* SyntaxKind.CallSignature */:
-            case 181 /* SyntaxKind.ConstructSignature */:
-            case 182 /* SyntaxKind.IndexSignature */:
+            case 181 /* SyntaxKind.CallSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
                 this.declareSymbolAndAddToSymbolTable(node, 131072 /* SymbolFlags.Signature */, 0 /* SymbolFlags.None */);
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 174 /* SyntaxKind.MethodSignature */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 175 /* SyntaxKind.MethodSignature */:
                 this.bindPropertyOrMethodOrAccessor(node, 8192 /* SymbolFlags.Method */ | optionalSymbolFlag(node), isObjectLiteralMethod(node) ? 111551 /* SymbolFlags.Value */ : 103359 /* SymbolFlags.MethodExcludes */);
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
                 this.bindFunctionDeclaration(node);
                 break;
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 this.declareSymbolAndAddToSymbolTable(node, 16384 /* SymbolFlags.Constructor */, 0 /* SymbolFlags.None */);
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 this.bindPropertyOrMethodOrAccessor(node, 32768 /* SymbolFlags.GetAccessor */, 46011 /* SymbolFlags.GetAccessorExcludes */);
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 this.bindPropertyOrMethodOrAccessor(node, 65536 /* SymbolFlags.SetAccessor */, 78779 /* SymbolFlags.SetAccessorExcludes */);
                 break;
-            case 185 /* SyntaxKind.FunctionType */:
-            case 186 /* SyntaxKind.ConstructorType */:
+            case 186 /* SyntaxKind.FunctionType */:
+            case 187 /* SyntaxKind.ConstructorType */:
                 this.bindFunctionOrConstructorType(node);
                 break;
-            case 188 /* SyntaxKind.TypeLiteral */:
-            case 201 /* SyntaxKind.MappedType */:
+            case 189 /* SyntaxKind.TypeLiteral */:
+            case 202 /* SyntaxKind.MappedType */:
                 this.bindAnonymousDeclaration(node, 2048 /* SymbolFlags.TypeLiteral */, "\uFFFEtype" /* InternalSymbolName.Type */);
                 break;
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
                 this.bindAnonymousDeclaration(node, 4096 /* SymbolFlags.ObjectLiteral */, "\uFFFEobject" /* InternalSymbolName.Object */);
                 break;
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 this.bindFunctionExpression(node);
                 break;
-            case 232 /* SyntaxKind.ClassExpression */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 this.bindClassLikeDeclaration(node);
                 break;
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
                 this.bindBlockScopedDeclaration(node, 64 /* SymbolFlags.Interface */, 788872 /* SymbolFlags.InterfaceExcludes */);
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 switch (getAssignmentDeclarationKind(node)) {
                     case 5 /* JSDeclarationKind.ObjectDefinePropertyValue */:
                         this.bindExpandoPropertyAssignment(node);
@@ -705,55 +712,55 @@ class Binder extends NodeVisitor {
                 if (isInJSFile(node) && this.file.commonJSModuleIndicator === undefined && isRequireCall(node, false))
                     this.setCommonJSModuleIndicator(node);
                 break;
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
                 this.bindBlockScopedDeclaration(node, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */);
                 break;
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
                 // Top-level ones are bound by bindContainer, after CommonJS module indicators.
-                if (this.blockScopeContainer.kind !== 307 /* SyntaxKind.SourceFile */)
+                if (this.blockScopeContainer.kind !== 308 /* SyntaxKind.SourceFile */)
                     this.bindBlockScopedDeclaration(node, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */);
                 break;
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 if (isEnumConst(node))
                     this.bindBlockScopedDeclaration(node, 128 /* SymbolFlags.ConstEnum */, 899967 /* SymbolFlags.ConstEnumExcludes */);
                 else
                     this.bindBlockScopedDeclaration(node, 256 /* SymbolFlags.RegularEnum */, 899327 /* SymbolFlags.RegularEnumExcludes */);
                 break;
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 this.bindModuleDeclaration(node);
                 break;
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-            case 275 /* SyntaxKind.NamespaceImport */:
-            case 277 /* SyntaxKind.ImportSpecifier */:
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 276 /* SyntaxKind.NamespaceImport */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 this.declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
                 break;
-            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+            case 272 /* SyntaxKind.NamespaceExportDeclaration */:
                 this.bindNamespaceExportDeclaration(node);
                 break;
-            case 274 /* SyntaxKind.ImportClause */:
+            case 275 /* SyntaxKind.ImportClause */:
                 if (node.name !== undefined)
                     this.declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 this.bindExportDeclaration(node);
                 break;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 this.bindExportAssignment(node);
                 break;
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 this.bindSourceFileIfExternalModule(node);
                 break;
-            case 293 /* SyntaxKind.JsxAttributes */:
+            case 294 /* SyntaxKind.JsxAttributes */:
                 this.bindAnonymousDeclaration(node, 4096 /* SymbolFlags.ObjectLiteral */, "\uFFFEjsxAttributes" /* InternalSymbolName.JSXAttributes */);
                 break;
-            case 292 /* SyntaxKind.JsxAttribute */:
+            case 293 /* SyntaxKind.JsxAttribute */:
                 this.declareSymbolAndAddToSymbolTable(node, 4 /* SymbolFlags.Property */, 13243 /* SymbolFlags.PropertyExcludes */);
                 break;
         }
         // Then bind the children, tracking the current container. Tokens have no children.
         let thisNodeOrAnySubnodesHasError = (node.flags & 32768 /* NodeFlags.ThisNodeHasError */) !== 0;
-        if (node.kind > 166 /* SyntaxKind.LastToken */) {
+        if (node.kind > 167 /* SyntaxKind.LastToken */) {
             const saveSeenParseError = this.seenParseError;
             this.seenParseError = false;
             const containerFlags = getContainerFlags(node);
@@ -806,7 +813,7 @@ class Binder extends NodeVisitor {
         }
         else
             this.bindChildren(node);
-        if (node.kind === 307 /* SyntaxKind.SourceFile */)
+        if (node.kind === 308 /* SyntaxKind.SourceFile */)
             this.finishSourceFile(node);
         else if (isAmbientModule(node))
             this.bindCommonJSTypeExports(getSymbol(node));
@@ -829,7 +836,7 @@ class Binder extends NodeVisitor {
             !hasSyntacticModifier(node, 1024 /* ModifierFlags.Async */) &&
             !isGeneratorFunctionExpression(node) &&
             getImmediatelyInvokedFunctionExpression(node) !== undefined) ||
-            node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */;
+            node.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */;
         if (!isImmediatelyInvoked) {
             const flowStart = new FlowNode(2 /* FlowFlags.Start */, undefined, undefined);
             this.currentFlow = flowStart;
@@ -840,7 +847,7 @@ class Binder extends NodeVisitor {
         }
         // IIFEs and constructors get a return graph; constructors use it to check property initialization.
         this.currentReturnTarget =
-            isImmediatelyInvoked || node.kind === 177 /* SyntaxKind.Constructor */ ? this.createBranchLabel() : undefined;
+            isImmediatelyInvoked || node.kind === 178 /* SyntaxKind.Constructor */ ? this.createBranchLabel() : undefined;
         this.currentExceptionTarget = undefined;
         this.currentBreakTarget = undefined;
         this.currentContinueTarget = undefined;
@@ -851,7 +858,7 @@ class Binder extends NodeVisitor {
         node.flags &= ~(262912 /* NodeFlags.ReachabilityAndEmitFlags */ | 128 /* NodeFlags.ContainsThis */);
         if ((this.currentFlow.flags & 1 /* FlowFlags.Unreachable */) === 0 &&
             (containerFlags & 8 /* ContainerFlags.IsFunctionLike */) !== 0 &&
-            node.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */ &&
+            node.kind !== 177 /* SyntaxKind.ClassStaticBlockDeclaration */ &&
             nodeIsPresent(getBody(node))) {
             node.flags |= 256 /* NodeFlags.HasImplicitReturn */;
             if (this.hasExplicitReturn)
@@ -860,15 +867,14 @@ class Binder extends NodeVisitor {
         }
         if (this.seenThisKeyword)
             node.flags |= 128 /* NodeFlags.ContainsThis */;
-        if (node.kind === 307 /* SyntaxKind.SourceFile */) {
+        if (node.kind === 308 /* SyntaxKind.SourceFile */) {
             node.flags |= this.emitFlags;
-            node.endFlowNode = this.currentFlow;
         }
         const returnTarget = this.currentReturnTarget;
         if (returnTarget !== undefined) {
             this.addAntecedent(returnTarget, this.currentFlow);
             this.currentFlow = this.finishFlowLabel(returnTarget);
-            if (node.kind === 177 /* SyntaxKind.Constructor */ || node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+            if (node.kind === 178 /* SyntaxKind.Constructor */ || node.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
                 setReturnFlowNode(node, this.currentFlow);
         }
         if (!isImmediatelyInvoked)
@@ -888,7 +894,7 @@ class Binder extends NodeVisitor {
         if (isInJSFile(file)) {
             // Top-level @typedef aliases wait until CommonJS module indicators are known.
             for (const statement of file.statements.nodes)
-                if (statement.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+                if (statement.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */)
                     this.bindBlockScopedDeclaration(statement, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */);
             if (file.commonJSModuleIndicator !== undefined) {
                 this.declareCommonJSVariable('module');
@@ -932,26 +938,26 @@ class Binder extends NodeVisitor {
             this.inAssignmentPattern = saveInAssignmentPattern;
             return;
         }
-        if (node.kind >= 244 /* SyntaxKind.FirstStatement */ && node.kind <= 260 /* SyntaxKind.LastStatement */)
+        if (node.kind >= 245 /* SyntaxKind.FirstStatement */ && node.kind <= 261 /* SyntaxKind.LastStatement */)
             setFlowNode(node, this.currentFlowValue());
         switch (node.kind) {
-            case 248 /* SyntaxKind.WhileStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
                 this.bindWhileStatement(node);
                 break;
-            case 247 /* SyntaxKind.DoStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
                 this.bindDoStatement(node);
                 break;
-            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
                 this.bindForStatement(node);
                 break;
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
                 this.bindForInOrForOfStatement(node);
                 break;
-            case 246 /* SyntaxKind.IfStatement */:
+            case 247 /* SyntaxKind.IfStatement */:
                 this.bindIfStatement(node);
                 break;
-            case 254 /* SyntaxKind.ReturnStatement */:
+            case 255 /* SyntaxKind.ReturnStatement */:
                 this.bindOptional(getExpression(node));
                 if (this.currentReturnTarget !== undefined)
                     this.addAntecedent(this.currentReturnTarget, this.currentFlow);
@@ -959,50 +965,50 @@ class Binder extends NodeVisitor {
                 this.hasExplicitReturn = true;
                 this.hasFlowEffects = true;
                 break;
-            case 258 /* SyntaxKind.ThrowStatement */:
+            case 259 /* SyntaxKind.ThrowStatement */:
                 this.bindOptional(getExpression(node));
                 this.currentFlow = this.unreachableFlow;
                 this.hasFlowEffects = true;
                 break;
-            case 253 /* SyntaxKind.BreakStatement */:
+            case 254 /* SyntaxKind.BreakStatement */:
                 this.bindBreakOrContinueStatement(getLabel(node), true);
                 break;
-            case 252 /* SyntaxKind.ContinueStatement */:
+            case 253 /* SyntaxKind.ContinueStatement */:
                 this.bindBreakOrContinueStatement(getLabel(node), false);
                 break;
-            case 259 /* SyntaxKind.TryStatement */:
+            case 260 /* SyntaxKind.TryStatement */:
                 this.bindTryStatement(node);
                 break;
-            case 256 /* SyntaxKind.SwitchStatement */:
+            case 257 /* SyntaxKind.SwitchStatement */:
                 this.bindSwitchStatement(node);
                 break;
-            case 270 /* SyntaxKind.CaseBlock */:
+            case 271 /* SyntaxKind.CaseBlock */:
                 this.bindCaseBlock(node);
                 break;
-            case 297 /* SyntaxKind.CaseClause */:
-            case 298 /* SyntaxKind.DefaultClause */:
+            case 298 /* SyntaxKind.CaseClause */:
+            case 299 /* SyntaxKind.DefaultClause */:
                 this.bindCaseOrDefaultClause(node);
                 break;
-            case 245 /* SyntaxKind.ExpressionStatement */: {
+            case 246 /* SyntaxKind.ExpressionStatement */: {
                 const expression = node.expression;
                 this.bind(expression);
                 this.maybeBindExpressionFlowIfCall(expression);
                 break;
             }
-            case 257 /* SyntaxKind.LabeledStatement */:
+            case 258 /* SyntaxKind.LabeledStatement */:
                 this.bindLabeledStatement(node);
                 break;
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
                 this.bindPrefixUnaryExpressionFlow(node);
                 break;
-            case 226 /* SyntaxKind.PostfixUnaryExpression */: {
+            case 227 /* SyntaxKind.PostfixUnaryExpression */: {
                 node.forEachChild(this);
                 const operator = node.operator;
                 if (operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */)
                     this.bindAssignmentTargetFlow(node.operand);
                 break;
             }
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 if (isDestructuringAssignment(node)) {
                     // Carry the assignment pattern state into initializers of the pattern.
                     this.inAssignmentPattern = saveInAssignmentPattern;
@@ -1011,40 +1017,40 @@ class Binder extends NodeVisitor {
                 }
                 this.bindBinaryExpressionFlow(node);
                 break;
-            case 221 /* SyntaxKind.DeleteExpression */:
+            case 222 /* SyntaxKind.DeleteExpression */:
                 node.forEachChild(this);
-                if (node.expression.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+                if (node.expression.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
                     this.bindAssignmentTargetFlow(node.expression);
                 break;
-            case 228 /* SyntaxKind.ConditionalExpression */:
+            case 229 /* SyntaxKind.ConditionalExpression */:
                 this.bindConditionalExpressionFlow(node);
                 break;
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 node.forEachChild(this);
                 if (node.initializer !== undefined ||
                     isForInOrOfStatementKind(node.parent.parent.kind))
                     this.bindInitializedVariableFlow(node);
                 break;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
-            case 236 /* SyntaxKind.NonNullExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
+            case 237 /* SyntaxKind.NonNullExpression */:
                 if (isOptionalChain(node))
                     this.bindOptionalChainFlow(node);
                 else
                     node.forEachChild(this);
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 this.bindCallExpressionFlow(node);
                 break;
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 this.bindEachStatementFunctionsFirst(node.statements);
                 this.bind(node.endOfFileToken);
                 break;
-            case 242 /* SyntaxKind.Block */:
-            case 269 /* SyntaxKind.ModuleBlock */:
+            case 243 /* SyntaxKind.Block */:
+            case 270 /* SyntaxKind.ModuleBlock */:
                 this.bindEachStatementFunctionsFirst(getStatements(node));
                 break;
-            case 209 /* SyntaxKind.BindingElement */: {
+            case 210 /* SyntaxKind.BindingElement */: {
                 // The initializer runs before the binding pattern.
                 const element = node;
                 this.bindOptional(element.dotDotDotToken);
@@ -1053,7 +1059,7 @@ class Binder extends NodeVisitor {
                 this.bindOptional(element.name);
                 break;
             }
-            case 170 /* SyntaxKind.Parameter */: {
+            case 171 /* SyntaxKind.Parameter */: {
                 const parameter = node;
                 this.bindNodes(parameter.modifiers);
                 this.bindOptional(parameter.dotDotDotToken);
@@ -1063,10 +1069,10 @@ class Binder extends NodeVisitor {
                 this.bind(parameter.name);
                 break;
             }
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 231 /* SyntaxKind.SpreadElement */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
+            case 232 /* SyntaxKind.SpreadElement */:
                 this.inAssignmentPattern = saveInAssignmentPattern;
                 node.forEachChild(this);
                 break;
@@ -1085,10 +1091,10 @@ class Binder extends NodeVisitor {
     bindEachStatementFunctionsFirst(statements) {
         const nodes = statements.nodes;
         for (let i = 0; i < nodes.length; i++)
-            if (nodes[i].kind === 263 /* SyntaxKind.FunctionDeclaration */)
+            if (nodes[i].kind === 264 /* SyntaxKind.FunctionDeclaration */)
                 this.bind(nodes[i]);
         for (let i = 0; i < nodes.length; i++)
-            if (nodes[i].kind !== 263 /* SyntaxKind.FunctionDeclaration */)
+            if (nodes[i].kind !== 264 /* SyntaxKind.FunctionDeclaration */)
                 this.bind(nodes[i]);
     }
     // Flow graph
@@ -1156,7 +1162,7 @@ class Binder extends NodeVisitor {
     setContinueTarget(node, target) {
         let label = this.activeLabelList;
         let current = node;
-        while (label !== undefined && current.parent.kind === 257 /* SyntaxKind.LabeledStatement */) {
+        while (label !== undefined && current.parent.kind === 258 /* SyntaxKind.LabeledStatement */) {
             label.continueTarget = target;
             label = label.next;
             current = current.parent;
@@ -1194,24 +1200,24 @@ class Binder extends NodeVisitor {
     }
     bindAssignmentTargetFlow(node) {
         switch (node.kind) {
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
                 for (const element of getElements(node).nodes) {
-                    if (element.kind === 231 /* SyntaxKind.SpreadElement */)
+                    if (element.kind === 232 /* SyntaxKind.SpreadElement */)
                         this.bindAssignmentTargetFlow(getExpression(element));
                     else
                         this.bindDestructuringTargetFlow(element);
                 }
                 break;
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
                 for (const property of getProperties(node).nodes) {
                     switch (property.kind) {
-                        case 303 /* SyntaxKind.PropertyAssignment */:
+                        case 304 /* SyntaxKind.PropertyAssignment */:
                             this.bindDestructuringTargetFlow(getInitializer(property));
                             break;
-                        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+                        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
                             this.bindAssignmentTargetFlow(getName(property));
                             break;
-                        case 305 /* SyntaxKind.SpreadAssignment */:
+                        case 306 /* SyntaxKind.SpreadAssignment */:
                             this.bindAssignmentTargetFlow(getExpression(property));
                             break;
                     }
@@ -1253,11 +1259,19 @@ class Binder extends NodeVisitor {
         this.currentFlow = this.finishFlowLabel(postDoLabel);
     }
     bindForStatement(node) {
+        this.bindOptional(node.initializer);
+        if (this.currentFlow === this.unreachableFlow) {
+            // An initializer that ends the flow (a throwing IIFE) would leave the loop label only the
+            // incrementor's back edge: a cycle with no entry. Bind the rest as unreachable.
+            this.bindOptional(node.condition);
+            this.bind(node.statement);
+            this.bindOptional(node.incrementor);
+            return;
+        }
         const preLoopLabel = this.setContinueTarget(node, this.createLoopLabel());
         const preBodyLabel = this.createBranchLabel();
         const preIncrementorLabel = this.createBranchLabel();
         const postLoopLabel = this.createBranchLabel();
-        this.bindOptional(node.initializer);
         this.addAntecedent(preLoopLabel, this.currentFlow);
         this.currentFlow = preLoopLabel;
         this.bindCondition(node.condition, preBodyLabel, postLoopLabel);
@@ -1270,16 +1284,22 @@ class Binder extends NodeVisitor {
         this.currentFlow = this.finishFlowLabel(postLoopLabel);
     }
     bindForInOrForOfStatement(node) {
+        this.bind(node.expression);
+        if (this.currentFlow === this.unreachableFlow) {
+            // As for a `for` initializer: an expression that ends the flow leaves the loop unreachable.
+            this.bind(node.initializer);
+            this.bind(node.statement);
+            return;
+        }
         const preLoopLabel = this.setContinueTarget(node, this.createLoopLabel());
         const postLoopLabel = this.createBranchLabel();
-        this.bind(node.expression);
         this.addAntecedent(preLoopLabel, this.currentFlow);
         this.currentFlow = preLoopLabel;
-        if (node.kind === 251 /* SyntaxKind.ForOfStatement */)
+        if (node.kind === 252 /* SyntaxKind.ForOfStatement */)
             this.bindOptional(node.awaitModifier);
         this.addAntecedent(postLoopLabel, this.currentFlow);
         this.bind(node.initializer);
-        if (node.initializer.kind !== 262 /* SyntaxKind.VariableDeclarationList */)
+        if (node.initializer.kind !== 263 /* SyntaxKind.VariableDeclarationList */)
             this.bindAssignmentTargetFlow(node.initializer);
         this.bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
         this.addAntecedent(preLoopLabel, this.currentFlow);
@@ -1388,7 +1408,7 @@ class Binder extends NodeVisitor {
         this.addAntecedent(postSwitchLabel, this.currentFlow);
         let hasDefault = false;
         for (const clause of node.caseBlock.clauses.nodes)
-            if (clause.kind === 298 /* SyntaxKind.DefaultClause */)
+            if (clause.kind === 299 /* SyntaxKind.DefaultClause */)
                 hasDefault = true;
         if (!hasDefault)
             this.addAntecedent(postSwitchLabel, this.createFlowSwitchClause(this.preSwitchCaseFlow, node, 0, 0));
@@ -1562,7 +1582,7 @@ class Binder extends NodeVisitor {
     bindInitializedVariableFlow(node) {
         const name = getName(node);
         if (name !== undefined &&
-            (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)) {
+            (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)) {
             for (const element of getElements(name).nodes)
                 this.bindInitializedVariableFlow(element);
         }
@@ -1630,7 +1650,7 @@ class Binder extends NodeVisitor {
         else {
             // An IIFE's flow node includes the evaluation of its arguments.
             const callee = skipParentheses(node.expression);
-            if (callee.kind === 219 /* SyntaxKind.FunctionExpression */ || callee.kind === 220 /* SyntaxKind.ArrowFunction */) {
+            if (callee.kind === 220 /* SyntaxKind.FunctionExpression */ || callee.kind === 221 /* SyntaxKind.ArrowFunction */) {
                 this.bindNodes(callTypeArguments(node));
                 this.bindNodes(node.arguments);
                 this.bind(node.expression);
@@ -1684,7 +1704,7 @@ class Binder extends NodeVisitor {
         this.setExportContextFlag(node);
         if (isAmbientModule(node)) {
             if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
-                this.errorOnFirstToken(node, 802 /* Diagnostics.X_export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible */, noArgs);
+                this.errorOnFirstToken(node, 809 /* Diagnostics.X_export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible */, noArgs);
             if (isModuleAugmentationExternal(node)) {
                 this.declareModuleSymbol(node);
                 return;
@@ -1695,9 +1715,11 @@ class Binder extends NodeVisitor {
                 const text = getText(name);
                 const starIndex = text.indexOf('*');
                 if (starIndex >= 0 && text.indexOf('*', starIndex + 1) >= 0)
-                    this.errorOnFirstToken(name, 1136 /* Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character */, [text]);
+                    this.errorOnFirstToken(name, 1143 /* Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character */, [text]);
                 else if (starIndex >= 0)
                     this.file.patternAmbientModules = appendToList(this.file.patternAmbientModules, new PatternAmbientModule(text, starIndex, symbol));
+                else if (node.attributes !== undefined)
+                    this.errorOnNode(name, 463 /* Diagnostics.An_ambient_module_declaration_with_import_attributes_must_use_a_pattern_name_with_an_Asterisk_character */, noArgs);
             }
             return;
         }
@@ -1726,7 +1748,7 @@ class Binder extends NodeVisitor {
         const parent = node.parent;
         if (getModifiers(node) !== undefined)
             this.errorOnNode(node, 140 /* Diagnostics.Modifiers_cannot_appear_here */, noArgs);
-        if (parent.kind !== 307 /* SyntaxKind.SourceFile */)
+        if (parent.kind !== 308 /* SyntaxKind.SourceFile */)
             this.errorOnNode(node, 252 /* Diagnostics.Global_module_exports_may_only_appear_at_top_level */, noArgs);
         else if (!isExternalModule(parent))
             this.errorOnNode(node, 250 /* Diagnostics.Global_module_exports_may_only_appear_in_module_files */, noArgs);
@@ -1750,7 +1772,7 @@ class Binder extends NodeVisitor {
         else if (node.exportClause === undefined)
             // All `export *` declarations go in one symbol.
             this.declareSymbol(getExports(containerSymbol), containerSymbol, node, 8388608 /* SymbolFlags.ExportStar */, 0 /* SymbolFlags.None */);
-        else if (node.exportClause.kind === 281 /* SyntaxKind.NamespaceExport */)
+        else if (node.exportClause.kind === 282 /* SyntaxKind.NamespaceExport */)
             this.declareSymbol(getExports(containerSymbol), containerSymbol, node.exportClause, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
     }
     bindExportAssignment(node) {
@@ -1794,7 +1816,7 @@ class Binder extends NodeVisitor {
         this.bindAnonymousDeclaration(node, 16 /* SymbolFlags.Function */, bindingName);
     }
     bindClassLikeDeclaration(node) {
-        if (node.kind === 264 /* SyntaxKind.ClassDeclaration */)
+        if (node.kind === 265 /* SyntaxKind.ClassDeclaration */)
             this.bindBlockScopedDeclaration(node, 32 /* SymbolFlags.Class */, 899503 /* SymbolFlags.ClassExcludes */);
         else {
             const name = getName(node);
@@ -1807,7 +1829,7 @@ class Binder extends NodeVisitor {
         const exports = getExports(symbol);
         const existing = exports.get('prototype');
         if (existing !== undefined)
-            this.errorOnNode(existing.declaration, 478 /* Diagnostics.Duplicate_identifier_0 */, ['prototype']);
+            this.errorOnNode(existing.declaration, 485 /* Diagnostics.Duplicate_identifier_0 */, ['prototype']);
         exports.set('prototype', prototypeSymbol);
         prototypeSymbol.parent = symbol;
     }
@@ -1833,8 +1855,8 @@ class Binder extends NodeVisitor {
         const name = getName(node);
         this.checkStrictModeEvalOrArguments(node, name);
         if (name === undefined ||
-            name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ ||
-            name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+            name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ ||
+            name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
             return;
         if (isVariableDeclarationInitializedToRequire(node))
             this.declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
@@ -1851,7 +1873,7 @@ class Binder extends NodeVisitor {
         if ((node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
             this.checkStrictModeEvalOrArguments(node, node.name);
         const name = node.name;
-        if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */) {
+        if (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */) {
             const index = getParameters(node.parent).nodes.indexOf(node);
             this.bindAnonymousDeclaration(node, 1 /* SymbolFlags.FunctionScopedVariable */, '__' + index);
         }
@@ -1866,7 +1888,7 @@ class Binder extends NodeVisitor {
     }
     bindTypeParameter(node) {
         const parent = node.parent;
-        if (parent.kind !== 196 /* SyntaxKind.InferType */) {
+        if (parent.kind !== 197 /* SyntaxKind.InferType */) {
             this.declareSymbolAndAddToSymbolTable(node, 262144 /* SymbolFlags.TypeParameter */, 526824 /* SymbolFlags.TypeParameterExcludes */);
             return;
         }
@@ -1874,7 +1896,7 @@ class Binder extends NodeVisitor {
         let container;
         for (let current = parent; current !== undefined; current = current.parent) {
             const p = current.parent;
-            if (p !== undefined && p.kind === 195 /* SyntaxKind.ConditionalType */ && getExtendsType(p) === current) {
+            if (p !== undefined && p.kind === 196 /* SyntaxKind.ConditionalType */ && getExtendsType(p) === current) {
                 container = p;
                 break;
             }
@@ -1990,8 +2012,8 @@ class Binder extends NodeVisitor {
             else
                 this.declareSymbolEx(symbolTable, classSymbol, node, 4 /* SymbolFlags.Property */ | 67108864 /* SymbolFlags.Assignment */, 0 /* SymbolFlags.None */, true, false);
         }
-        else if (thisContainer.kind !== 263 /* SyntaxKind.FunctionDeclaration */ &&
-            thisContainer.kind !== 219 /* SyntaxKind.FunctionExpression */)
+        else if (thisContainer.kind !== 264 /* SyntaxKind.FunctionDeclaration */ &&
+            thisContainer.kind !== 220 /* SyntaxKind.FunctionExpression */)
             throw new Error('Unhandled case in bindThisPropertyAssignment');
     }
     /** For `this.x` in a class member, the class's members, or exports if the member is static. */
@@ -2000,12 +2022,12 @@ class Binder extends NodeVisitor {
         if (thisContainer === undefined)
             return undefined;
         switch (thisContainer.kind) {
-            case 177 /* SyntaxKind.Constructor */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */: {
+            case 178 /* SyntaxKind.Constructor */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */: {
                 const classSymbol = getSymbol(thisContainer.parent);
                 return isStatic(thisContainer) ? getExports(classSymbol) : getMembers(classSymbol);
             }
@@ -2066,7 +2088,7 @@ class Binder extends NodeVisitor {
     }
     checkPrivateIdentifier(node) {
         if (getText(node) === '#constructor' && this.file.diagnostics.length === 0)
-            this.errorOnNode(node, 1834 /* Diagnostics.X_constructor_is_a_reserved_word */, [declarationNameToString(this.file, node)]);
+            this.errorOnNode(node, 1854 /* Diagnostics.X_constructor_is_a_reserved_word */, [declarationNameToString(this.file, node)]);
     }
     getStrictModeIdentifierMessage(node) {
         if (getContainingClass(node) !== undefined)
@@ -2125,21 +2147,21 @@ function isGeneratorFunctionExpression(node) {
     return node instanceof FunctionExpression && node.asteriskToken !== undefined;
 }
 function isForInOrOfStatementKind(kind) {
-    return kind === 250 /* SyntaxKind.ForInStatement */ || kind === 251 /* SyntaxKind.ForOfStatement */;
+    return kind === 251 /* SyntaxKind.ForInStatement */ || kind === 252 /* SyntaxKind.ForOfStatement */;
 }
 function hasExportDeclarations(node) {
     let statements;
-    if (node.kind === 307 /* SyntaxKind.SourceFile */)
+    if (node.kind === 308 /* SyntaxKind.SourceFile */)
         statements = node.statements;
     else if (node instanceof ModuleDeclaration) {
         const body = node.body;
-        if (body !== undefined && body.kind === 269 /* SyntaxKind.ModuleBlock */)
+        if (body !== undefined && body.kind === 270 /* SyntaxKind.ModuleBlock */)
             statements = getStatements(body);
     }
     if (statements === undefined)
         return false;
     for (const statement of statements.nodes)
-        if (statement.kind === 279 /* SyntaxKind.ExportDeclaration */ || statement.kind === 278 /* SyntaxKind.ExportAssignment */)
+        if (statement.kind === 280 /* SyntaxKind.ExportDeclaration */ || statement.kind === 279 /* SyntaxKind.ExportAssignment */)
             return true;
     return false;
 }
@@ -2168,8 +2190,8 @@ function getInitializerSymbol(symbol) {
     const declaration = symbol.valueDeclaration;
     if (declaration === undefined)
         return undefined;
-    if (declaration.kind === 263 /* SyntaxKind.FunctionDeclaration */ ||
-        (isInJSFile(declaration) && declaration.kind === 264 /* SyntaxKind.ClassDeclaration */))
+    if (declaration.kind === 264 /* SyntaxKind.FunctionDeclaration */ ||
+        (isInJSFile(declaration) && declaration.kind === 265 /* SyntaxKind.ClassDeclaration */))
         return symbol;
     if (declaration instanceof VariableDeclaration) {
         if ((declaration.parent.flags & 2 /* NodeFlags.Const */) !== 0 || isInJSFile(declaration)) {
@@ -2198,13 +2220,13 @@ function combineFlowLists(head, tail) {
 function isStatementCondition(node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 246 /* SyntaxKind.IfStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
+        case 247 /* SyntaxKind.IfStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
             return getExpression(parent) === node;
-        case 249 /* SyntaxKind.ForStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
             return parent.condition === node;
-        case 228 /* SyntaxKind.ConditionalExpression */:
+        case 229 /* SyntaxKind.ConditionalExpression */:
             return parent.condition === node;
     }
     return false;
@@ -2213,7 +2235,7 @@ function isTopLevelLogicalExpression(node) {
     let current = node;
     for (;;) {
         const parent = current.parent;
-        if (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */ ||
+        if (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */ ||
             (parent instanceof PrefixUnaryExpression &&
                 parent.operator === 53 /* SyntaxKind.ExclamationToken */))
             current = parent;
@@ -2231,18 +2253,18 @@ function isNarrowingExpression(expression) {
         case 79 /* SyntaxKind.Identifier */:
         case 109 /* SyntaxKind.ThisKeyword */:
             return true;
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
             return containsNarrowableReference(expression);
-        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             return hasNarrowableArgument(expression);
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 222 /* SyntaxKind.TypeOfExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 223 /* SyntaxKind.TypeOfExpression */:
             return isNarrowingExpression(getExpression(expression));
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return isNarrowingBinaryExpression(expression);
-        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+        case 226 /* SyntaxKind.PrefixUnaryExpression */: {
             const unary = expression;
             return unary.operator === 53 /* SyntaxKind.ExclamationToken */ && isNarrowingExpression(unary.operand);
         }
@@ -2254,10 +2276,10 @@ function containsNarrowableReference(expression) {
         return true;
     if ((expression.flags & 32 /* NodeFlags.OptionalChain */) !== 0) {
         switch (expression.kind) {
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
-            case 214 /* SyntaxKind.CallExpression */:
-            case 236 /* SyntaxKind.NonNullExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
+            case 237 /* SyntaxKind.NonNullExpression */:
                 return containsNarrowableReference(getExpression(expression));
         }
     }
@@ -2269,20 +2291,20 @@ export function isNarrowableReference(node) {
         case 79 /* SyntaxKind.Identifier */:
         case 109 /* SyntaxKind.ThisKeyword */:
         case 107 /* SyntaxKind.SuperKeyword */:
-        case 237 /* SyntaxKind.MetaProperty */:
+        case 238 /* SyntaxKind.MetaProperty */:
             return true;
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return isNarrowableReference(node.expression);
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return isNarrowableReference(node.expression);
-        case 236 /* SyntaxKind.NonNullExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
             return isNarrowableReference(node.expression);
-        case 213 /* SyntaxKind.ElementAccessExpression */: {
+        case 214 /* SyntaxKind.ElementAccessExpression */: {
             const access = node;
             return (isStringOrNumericLiteralLike(access.argumentExpression) ||
                 (isEntityNameExpression(access.argumentExpression, false) && isNarrowableReference(access.expression)));
         }
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             const binary = node;
             const operator = binary.operatorToken.kind;
             return ((operator === 27 /* SyntaxKind.CommaToken */ && isNarrowableReference(binary.right)) ||
@@ -2328,7 +2350,7 @@ function isNarrowingBinaryExpression(expression) {
     return false;
 }
 function isNarrowableOperand(expression) {
-    if (expression.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    if (expression.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         return isNarrowableOperand(getExpression(expression));
     if (expression instanceof BinaryExpression) {
         const binary = expression;
@@ -2341,7 +2363,7 @@ function isNarrowableOperand(expression) {
     return containsNarrowableReference(expression);
 }
 function isNarrowingTypeOfOperands(expression1, expression2) {
-    return (expression1.kind === 222 /* SyntaxKind.TypeOfExpression */ &&
+    return (expression1.kind === 223 /* SyntaxKind.TypeOfExpression */ &&
         isNarrowableOperand(getExpression(expression1)) &&
         isStringLiteralLike(expression2));
 }
@@ -2357,3 +2379,8 @@ export function findUseStrictPrologue(file, statements) {
     }
     return undefined;
 }
+/** Whether a module name is a pattern with exactly one `*`. */
+function hasSingleStar(text) {
+    const star = text.indexOf('*');
+    return star >= 0 && text.indexOf('*', star + 1) < 0;
+}