tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/checker-grammar.js

@@ -4,7 +4,7 @@
 // of each node in the order tsgo's checker runs them. Checks that need types read the checker's
 // caches. Errors reported with `grammarError*` are dropped when the file has parse errors.
 import { ElementAccessExpression, Identifier, NodeVisitor, StringLiteral, getAsteriskToken, getBody, getElements, getExpression, getHeritageClauses, getInitializer, getLabel, getIsTypeOnly, getLocals, getMembers, getModifiers, getName, getNodeId, getParameters, getPostfixToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, isDeclarationNode, callQuestionDotToken, callTypeArguments, } from './ast.js';
-import { canHaveDecorators, canHaveIllegalDecorators, getExternalModuleName, getTextOfNodeFromSourceText, isAmbientModule, isFunctionLike, isFunctionLikeDeclarationKind, isModifierKind, isStringLiteralLike, modifierToFlag, nodeIsPresent, isInJSFile, } from './ast-utilities.js';
+import { canHaveDecorators, canHaveIllegalDecorators, getExternalModuleName, getTextOfNodeFromSourceText, isAmbientModule, isFunctionLike, isFunctionLikeDeclarationKind, isImportDeferMetaProperty, isImportPhaseMetaProperty, isImportSourceMetaProperty, isModifierKind, isSourcePhaseImportCall, isStringLiteralLike, modifierToFlag, nodeIsPresent, isInJSFile, } from './ast-utilities.js';
 import { getCombinedModifierFlags, getCombinedNodeFlags, getContainingClass, getRangeOfTokenAtPosition, getSourceFileOfNode, hasSyntacticModifier, isAutoAccessorPropertyDeclaration, isClassLike, isDynamicName, isEntityNameExpression, isExternalModule, isInTopLevelContext, isModuleAugmentationExternal, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, } from './binder-utilities.js';
 import { findUseStrictPrologue } from './binder.js';
 import { createDiagnosticForNode } from './checker.js';
@@ -17,12 +17,12 @@ import { isGenericType } from './checker-type-operators.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName, isValidIndexKeyType } from './checker-utilities.js';
 import { getSymbolOfDeclaration, resolveAlias } from './checker-symbols.js';
 import { Diagnostic, messageCategory } from './diagnostics.js';
-import { ModuleKind, ScriptTarget, getEmitModuleKind } from './options.js';
+import { ModuleKind, ScriptTarget, getEmitModuleKind, supportsDeferredImports, supportsSourcePhaseImports, } from './options.js';
+import { getEmitSyntaxForModuleSpecifierExpression } from './checker-modules.js';
 import { fileExtensionIsOneOf, isExternalModuleNameRelative } from './path.js';
-import { SourceFileMetadata, getEmitModuleFormatOfFile, getImpliedNodeFormatForEmit } from './program-utilities.js';
+import { SourceFileMetadata, getEmitModuleFormatOfFile, getImpliedNodeFormatForEmit, resolutionModeAttribute, } from './program-utilities.js';
 import { Scanner, ScannerErrorReporter, skipTrivia, tokenToString } from './scanner.js';
 import { typeToString } from './type-printer.js';
-import { findMismatchedAugmentsTag } from './checker-jsdoc.js';
 import { getDeclarations } from './symbol.js';
 /** Runs the grammar checks of every node of `file`. */
 export function checkGrammarSourceFile(c, file) {
@@ -52,7 +52,7 @@ export function checkGrammarRestTrailingComma(c, node, list) {
 /** Checks the grammar of a function expression or arrow function each time it is checked. */
 export function checkGrammarFunctionExpression(c, node) {
     const g = grammarCheckerOf(c, node);
-    if (!checkGrammarFunctionLikeDeclaration(g, node) && node.kind === 219 /* SyntaxKind.FunctionExpression */)
+    if (!checkGrammarFunctionLikeDeclaration(g, node) && node.kind === 220 /* SyntaxKind.FunctionExpression */)
         checkGrammarForGenerator(g, node);
 }
 /** Checks the grammar of an `await` expression each time it is checked. */
@@ -135,42 +135,42 @@ function addRelated(diagnostic, node, message) {
 function checkGrammarNode(g, node) {
     switch (node.kind) {
         // Declarations and members
-        case 169 /* SyntaxKind.TypeParameter */: {
+        case 170 /* SyntaxKind.TypeParameter */: {
             checkGrammarModifiers(g, node);
             const expression = node.expression;
             if (expression !== undefined)
                 grammarErrorOnFirstToken(g, expression, 79 /* Diagnostics.Type_expected */);
             return true;
         }
-        case 170 /* SyntaxKind.Parameter */:
+        case 171 /* SyntaxKind.Parameter */:
             checkGrammarModifiers(g, node);
             checkGrammarDecorators(g, node);
             return true;
-        case 172 /* SyntaxKind.PropertySignature */:
+        case 173 /* SyntaxKind.PropertySignature */:
             checkGrammarPropertyDeclaration(g, node);
             return true;
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             checkGrammarPropertyDeclaration(g, node);
             checkGrammarDecorators(g, node);
             return true;
-        case 186 /* SyntaxKind.ConstructorType */:
-        case 185 /* SyntaxKind.FunctionType */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 181 /* SyntaxKind.ConstructSignature */:
+        case 187 /* SyntaxKind.ConstructorType */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */:
             checkGrammarFunctionLikeDeclaration(g, node);
             return true;
-        case 182 /* SyntaxKind.IndexSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
             if (!checkGrammarModifiers(g, node))
                 checkGrammarIndexSignatureParameters(g, node);
             return true;
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
             checkGrammarMethodDeclaration(g, node);
             return true;
-        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
             checkGrammarModifiers(g, node);
             return true;
-        case 177 /* SyntaxKind.Constructor */:
+        case 178 /* SyntaxKind.Constructor */:
             checkGrammarFunctionLikeDeclaration(g, node);
             if (!checkGrammarConstructorTypeParameters(g, node)) {
                 const type = node.type;
@@ -178,100 +178,100 @@ function checkGrammarNode(g, node) {
                     grammarErrorOnNode(g, type, 62 /* Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration */);
             }
             return true;
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             checkGrammarAccessorDeclaration(g, node);
             return true;
-        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
             checkGrammarDecorators(g, node);
             checkGrammarFunctionLikeDeclaration(g, node);
             checkGrammarForGenerator(g, node);
             return true;
-        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
             checkGrammarClassDeclaration(g, node);
             return true;
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
             checkGrammarClassLikeDeclaration(g, node);
             return true;
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
             checkGrammarInterfaceDeclaration(g, node);
             return true;
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
             checkGrammarModifiers(g, node);
             if (!containerAllowsBlockScopedVariable(node.parent))
                 grammarErrorOnNode(g, node, 116 /* Diagnostics.X_0_declarations_can_only_be_declared_inside_a_block */, 'type');
             return true;
-        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
             checkGrammarModifiers(g, node);
             return true;
-        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
             return checkGrammarModuleDeclaration(g, node);
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
             checkGrammarImportDeclaration(g, node);
             return false;
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             checkGrammarImportEqualsDeclaration(g, node);
             return false;
-        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
             checkGrammarExportDeclaration(g, node);
             return false;
-        case 278 /* SyntaxKind.ExportAssignment */:
+        case 279 /* SyntaxKind.ExportAssignment */:
             return checkGrammarExportAssignment(g, node);
-        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
             // Catch clause variables are checked with the clause.
-            if (node.parent.kind !== 300 /* SyntaxKind.CatchClause */)
+            if (node.parent.kind !== 301 /* SyntaxKind.CatchClause */)
                 checkGrammarVariableDeclaration(g, node);
             return true;
-        case 209 /* SyntaxKind.BindingElement */:
+        case 210 /* SyntaxKind.BindingElement */:
             checkGrammarBindingElement(g, node);
             return true;
         // Statements
-        case 242 /* SyntaxKind.Block */:
-        case 243 /* SyntaxKind.EmptyStatement */:
-        case 260 /* SyntaxKind.DebuggerStatement */:
-        case 245 /* SyntaxKind.ExpressionStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
-        case 259 /* SyntaxKind.TryStatement */:
+        case 243 /* SyntaxKind.Block */:
+        case 244 /* SyntaxKind.EmptyStatement */:
+        case 261 /* SyntaxKind.DebuggerStatement */:
+        case 246 /* SyntaxKind.ExpressionStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
+        case 260 /* SyntaxKind.TryStatement */:
             checkGrammarStatementInAmbientContext(g, node);
             return true;
-        case 246 /* SyntaxKind.IfStatement */: {
+        case 247 /* SyntaxKind.IfStatement */: {
             checkGrammarStatementInAmbientContext(g, node);
             return true;
         }
-        case 244 /* SyntaxKind.VariableStatement */:
+        case 245 /* SyntaxKind.VariableStatement */:
             checkGrammarVariableStatement(g, node);
             return true;
-        case 249 /* SyntaxKind.ForStatement */: {
+        case 250 /* SyntaxKind.ForStatement */: {
             const initializer = node.initializer;
             if (!checkGrammarStatementInAmbientContext(g, node) &&
                 initializer !== undefined &&
-                initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+                initializer.kind === 263 /* SyntaxKind.VariableDeclarationList */)
                 checkGrammarVariableDeclarationList(g, initializer);
             return true;
         }
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             checkGrammarForInOrForOfStatement(g, node);
             return true;
-        case 253 /* SyntaxKind.BreakStatement */:
-        case 252 /* SyntaxKind.ContinueStatement */:
+        case 254 /* SyntaxKind.BreakStatement */:
+        case 253 /* SyntaxKind.ContinueStatement */:
             if (!checkGrammarStatementInAmbientContext(g, node))
                 checkGrammarBreakOrContinueStatement(g, node);
             return true;
-        case 254 /* SyntaxKind.ReturnStatement */:
+        case 255 /* SyntaxKind.ReturnStatement */:
             return checkGrammarReturnStatement(g, node);
-        case 255 /* SyntaxKind.WithStatement */:
+        case 256 /* SyntaxKind.WithStatement */:
             checkGrammarWithStatement(g, node);
             return false;
-        case 256 /* SyntaxKind.SwitchStatement */:
+        case 257 /* SyntaxKind.SwitchStatement */:
             checkGrammarSwitchStatement(g, node);
             return true;
-        case 257 /* SyntaxKind.LabeledStatement */:
+        case 258 /* SyntaxKind.LabeledStatement */:
             checkGrammarLabeledStatement(g, node);
             return true;
-        case 258 /* SyntaxKind.ThrowStatement */: {
+        case 259 /* SyntaxKind.ThrowStatement */: {
             const expression = node.expression;
             if (!checkGrammarStatementInAmbientContext(g, node) &&
                 expression instanceof Identifier &&
@@ -279,75 +279,76 @@ function checkGrammarNode(g, node) {
                 grammarErrorAtPos(g, expression.pos, 0, 108 /* Diagnostics.Line_break_not_permitted_here */);
             return true;
         }
-        case 300 /* SyntaxKind.CatchClause */:
+        case 301 /* SyntaxKind.CatchClause */:
             checkGrammarCatchClause(g, node);
             return true;
         // Type nodes
-        case 184 /* SyntaxKind.TypeReference */:
+        case 185 /* SyntaxKind.TypeReference */:
             checkGrammarTypeReference(g, node);
             return true;
-        case 187 /* SyntaxKind.TypeQuery */:
+        case 188 /* SyntaxKind.TypeQuery */:
             checkGrammarTypeArguments(g, getTypeArguments(node));
             return true;
-        case 199 /* SyntaxKind.TypeOperator */:
+        case 200 /* SyntaxKind.TypeOperator */:
             checkGrammarTypeOperatorNode(g, node);
             return true;
-        case 196 /* SyntaxKind.InferType */:
+        case 197 /* SyntaxKind.InferType */:
             checkGrammarInferType(g, node);
             return true;
-        case 206 /* SyntaxKind.ImportType */: {
+        case 207 /* SyntaxKind.ImportType */: {
             const attributes = node.attributes;
             if (attributes !== undefined)
-                getResolutionModeOverride(g, attributes, true);
+                checkGrammarImportAttributeValues(g, attributes);
+            checkGrammarImportAttributes(g, node);
             return true;
         }
-        case 190 /* SyntaxKind.TupleType */:
+        case 191 /* SyntaxKind.TupleType */:
             checkGrammarTupleType(g, node);
             return true;
-        case 203 /* SyntaxKind.NamedTupleMember */:
+        case 204 /* SyntaxKind.NamedTupleMember */:
             checkGrammarNamedTupleMember(g, node);
             return true;
-        case 312 /* SyntaxKind.JSDocNonNullableType */:
-        case 311 /* SyntaxKind.JSDocNullableType */:
-        case 310 /* SyntaxKind.JSDocAllType */:
-        case 317 /* SyntaxKind.JSDocTypeLiteral */:
+        case 313 /* SyntaxKind.JSDocNonNullableType */:
+        case 312 /* SyntaxKind.JSDocNullableType */:
+        case 311 /* SyntaxKind.JSDocAllType */:
+        case 318 /* SyntaxKind.JSDocTypeLiteral */:
             checkGrammarJSDocTypeInTypeScript(g, node);
             return true;
-        case 201 /* SyntaxKind.MappedType */: {
+        case 202 /* SyntaxKind.MappedType */: {
             const members = node.members;
             if (members !== undefined && members.nodes.length > 0)
-                grammarErrorOnNode(g, members.nodes[0], 1732 /* Diagnostics.A_mapped_type_may_not_declare_properties_or_methods */);
+                grammarErrorOnNode(g, members.nodes[0], 1751 /* Diagnostics.A_mapped_type_may_not_declare_properties_or_methods */);
             return true;
         }
         // Expressions
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             // Heritage clause elements are checked with their class or interface.
-            if (node.parent.kind !== 299 /* SyntaxKind.HeritageClause */)
+            if (node.parent.kind !== 300 /* SyntaxKind.HeritageClause */)
                 checkGrammarExpressionWithTypeArguments(g, node);
             return true;
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             // Checked by the checker each time the function is checked.
             return true;
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
             // Checked by the checker each time the literal is checked.
             return true;
-        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             checkGrammarCallExpression(g, node);
             return true;
-        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
             checkGrammarTypeArguments(g, getTypeArguments(node));
             return true;
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
             if (!checkGrammarTaggedTemplateChain(g, node))
                 checkGrammarTypeArguments(g, getTypeArguments(node));
             return true;
-        case 237 /* SyntaxKind.MetaProperty */:
+        case 238 /* SyntaxKind.MetaProperty */:
             checkGrammarMetaProperty(g, node);
             return true;
-        case 224 /* SyntaxKind.AwaitExpression */:
-        case 230 /* SyntaxKind.YieldExpression */:
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
+        case 231 /* SyntaxKind.YieldExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             // Checked by the checker each time the expression is checked.
             return true;
         case 80 /* SyntaxKind.PrivateIdentifier */:
@@ -359,7 +360,7 @@ function checkGrammarNode(g, node) {
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
             checkGrammarRegularExpressionLiteral(g, node);
             return false;
-        case 171 /* SyntaxKind.Decorator */: {
+        case 172 /* SyntaxKind.Decorator */: {
             // Decorators are only checked on valid targets.
             const target = node.parent;
             return (canHaveDecorators(target) &&
@@ -377,7 +378,7 @@ function checkGrammarModifiers(g, node) {
         return true;
     if (isThisParameter(node))
         return grammarErrorOnFirstToken(g, node, 359 /* Diagnostics.Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters */);
-    const blockScopeKind = node.kind === 244 /* SyntaxKind.VariableStatement */
+    const blockScopeKind = node.kind === 245 /* SyntaxKind.VariableStatement */
         ? node.declarationList.flags & 7 /* NodeFlags.BlockScoped */
         : 0 /* NodeFlags.None */;
     const parent = node.parent;
@@ -392,13 +393,13 @@ function checkGrammarModifiers(g, node) {
     // trailing decorators and trailing modifiers. Leading and trailing decorators can't both appear.
     let hasLeadingDecorators = false;
     for (const modifier of modifiers.nodes) {
-        if (modifier.kind === 171 /* SyntaxKind.Decorator */) {
+        if (modifier.kind === 172 /* SyntaxKind.Decorator */) {
             if (!nodeCanBeDecorated(g.legacyDecorators, node, parent, parent.parent)) {
-                if (node.kind === 175 /* SyntaxKind.MethodDeclaration */ && !nodeIsPresent(getBody(node)))
+                if (node.kind === 176 /* SyntaxKind.MethodDeclaration */ && !nodeIsPresent(getBody(node)))
                     return grammarErrorOnFirstToken(g, node, 199 /* Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload */);
                 return grammarErrorOnFirstToken(g, node, 160 /* Diagnostics.Decorators_are_not_valid_here */);
             }
-            else if (g.legacyDecorators && (node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */)) {
+            else if (g.legacyDecorators && (node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* SyntaxKind.SetAccessor */)) {
                 const first = getFirstAccessorOfPair(g.c, node);
                 if (first !== node && hasDecorators(first))
                     return grammarErrorOnFirstToken(g, node, 161 /* Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name */);
@@ -409,8 +410,8 @@ function checkGrammarModifiers(g, node) {
             if (hasLeadingDecorators && (flags & 98303 /* ModifierFlags.Modifier */) !== 0) {
                 if (g.hasParseErrors)
                     return false;
-                const diagnostic = g.c.error(modifier, 1767 /* Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export */);
-                addRelated(diagnostic, firstDecorator, 401 /* Diagnostics.Decorator_used_before_export_here */);
+                const diagnostic = g.c.error(modifier, 1787 /* Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export */);
+                addRelated(diagnostic, firstDecorator, 399 /* Diagnostics.Decorator_used_before_export_here */);
                 return true;
             }
             flags |= 32768 /* ModifierFlags.Decorator */;
@@ -425,21 +426,21 @@ function checkGrammarModifiers(g, node) {
         const kind = modifier.kind;
         const reparsed = (modifier.flags & 8 /* NodeFlags.Reparsed */) !== 0;
         if (kind !== 148 /* SyntaxKind.ReadonlyKeyword */) {
-            if (node.kind === 172 /* SyntaxKind.PropertySignature */ || node.kind === 174 /* SyntaxKind.MethodSignature */)
+            if (node.kind === 173 /* SyntaxKind.PropertySignature */ || node.kind === 175 /* SyntaxKind.MethodSignature */)
                 return grammarErrorOnNode(g, modifier, 54 /* Diagnostics.X_0_modifier_cannot_appear_on_a_type_member */, tokenToString(kind));
-            if (node.kind === 182 /* SyntaxKind.IndexSignature */ && (kind !== 125 /* SyntaxKind.StaticKeyword */ || !isClassLike(parent)))
+            if (node.kind === 183 /* SyntaxKind.IndexSignature */ && (kind !== 125 /* SyntaxKind.StaticKeyword */ || !isClassLike(parent)))
                 return grammarErrorOnNode(g, modifier, 55 /* Diagnostics.X_0_modifier_cannot_appear_on_an_index_signature */, tokenToString(kind));
         }
         if (kind !== 102 /* SyntaxKind.InKeyword */ &&
             kind !== 147 /* SyntaxKind.OutKeyword */ &&
             kind !== 86 /* SyntaxKind.ConstKeyword */ &&
-            node.kind === 169 /* SyntaxKind.TypeParameter */)
+            node.kind === 170 /* SyntaxKind.TypeParameter */)
             return grammarErrorOnNode(g, modifier, 222 /* Diagnostics.X_0_modifier_cannot_appear_on_a_type_parameter */, tokenToString(kind));
         switch (kind) {
             case 86 /* SyntaxKind.ConstKeyword */:
-                if (node.kind !== 267 /* SyntaxKind.EnumDeclaration */ && node.kind !== 169 /* SyntaxKind.TypeParameter */)
+                if (node.kind !== 268 /* SyntaxKind.EnumDeclaration */ && node.kind !== 170 /* SyntaxKind.TypeParameter */)
                     return grammarErrorOnNode(g, node, 198 /* Diagnostics.A_class_member_cannot_have_the_0_keyword */, tokenToString(kind));
-                if (node.kind === 169 /* SyntaxKind.TypeParameter */ && !isConstTypeParameterContainer(parent))
+                if (node.kind === 170 /* SyntaxKind.TypeParameter */ && !isConstTypeParameterContainer(parent))
                     return grammarErrorOnNode(g, modifier, 226 /* Diagnostics.X_0_modifier_can_only_appear_on_a_type_parameter_of_a_function_method_or_class */, tokenToString(kind));
                 break;
             case 164 /* SyntaxKind.OverrideKeyword */:
@@ -473,7 +474,7 @@ function checkGrammarModifiers(g, node) {
                     return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'readonly');
                 if ((flags & 1024 /* ModifierFlags.Async */) !== 0 && !reparsed)
                     return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'async');
-                if (parent.kind === 269 /* SyntaxKind.ModuleBlock */ || parent.kind === 307 /* SyntaxKind.SourceFile */)
+                if (parent.kind === 270 /* SyntaxKind.ModuleBlock */ || parent.kind === 308 /* SyntaxKind.SourceFile */)
                     return grammarErrorOnNode(g, modifier, 32 /* Diagnostics.X_0_modifier_cannot_appear_on_a_module_or_namespace_element */, text);
                 if ((flags & 64 /* ModifierFlags.Abstract */) !== 0) {
                     if (kind === 122 /* SyntaxKind.PrivateKeyword */)
@@ -482,7 +483,7 @@ function checkGrammarModifiers(g, node) {
                         return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'abstract');
                 }
                 else if (isPrivateIdentifierClassElementDeclaration(node))
-                    return grammarErrorOnNode(g, modifier, 1832 /* Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier */);
+                    return grammarErrorOnNode(g, modifier, 1852 /* Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier */);
                 flags |= modifierToFlag(kind);
                 break;
             }
@@ -495,9 +496,9 @@ function checkGrammarModifiers(g, node) {
                     return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'static', 'async');
                 if ((flags & 512 /* ModifierFlags.Accessor */) !== 0 && !reparsed)
                     return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'static', 'accessor');
-                if (parent.kind === 269 /* SyntaxKind.ModuleBlock */ || parent.kind === 307 /* SyntaxKind.SourceFile */)
+                if (parent.kind === 270 /* SyntaxKind.ModuleBlock */ || parent.kind === 308 /* SyntaxKind.SourceFile */)
                     return grammarErrorOnNode(g, modifier, 32 /* Diagnostics.X_0_modifier_cannot_appear_on_a_module_or_namespace_element */, 'static');
-                if (node.kind === 170 /* SyntaxKind.Parameter */)
+                if (node.kind === 171 /* SyntaxKind.Parameter */)
                     return grammarErrorOnNode(g, modifier, 59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */, 'static');
                 if ((flags & 64 /* ModifierFlags.Abstract */) !== 0)
                     return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'static', 'abstract');
@@ -513,7 +514,7 @@ function checkGrammarModifiers(g, node) {
                     return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'accessor', 'readonly');
                 if ((flags & 128 /* ModifierFlags.Ambient */) !== 0)
                     return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'accessor', 'declare');
-                if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+                if (node.kind !== 174 /* SyntaxKind.PropertyDeclaration */)
                     return grammarErrorOnNode(g, modifier, 224 /* Diagnostics.X_accessor_modifier_can_only_appear_on_a_property_declaration */);
                 flags |= 512 /* ModifierFlags.Accessor */;
                 break;
@@ -521,10 +522,10 @@ function checkGrammarModifiers(g, node) {
                 if ((flags & 8 /* ModifierFlags.Readonly */) !== 0)
                     return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'readonly');
                 // Parameters that aren't parameter properties are reported by the parameter check.
-                if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */ &&
-                    node.kind !== 172 /* SyntaxKind.PropertySignature */ &&
-                    node.kind !== 182 /* SyntaxKind.IndexSignature */ &&
-                    node.kind !== 170 /* SyntaxKind.Parameter */)
+                if (node.kind !== 174 /* SyntaxKind.PropertyDeclaration */ &&
+                    node.kind !== 173 /* SyntaxKind.PropertySignature */ &&
+                    node.kind !== 183 /* SyntaxKind.IndexSignature */ &&
+                    node.kind !== 171 /* SyntaxKind.Parameter */)
                     return grammarErrorOnNode(g, modifier, 19 /* Diagnostics.X_readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature */);
                 if ((flags & 512 /* ModifierFlags.Accessor */) !== 0)
                     return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'readonly', 'accessor');
@@ -533,10 +534,10 @@ function checkGrammarModifiers(g, node) {
             case 94 /* SyntaxKind.ExportKeyword */:
                 if (g.c.compilerOptions.verbatimModuleSyntax === true &&
                     (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
-                    node.kind !== 266 /* SyntaxKind.TypeAliasDeclaration */ &&
-                    node.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
-                    node.kind !== 268 /* SyntaxKind.ModuleDeclaration */ &&
-                    parent.kind === 307 /* SyntaxKind.SourceFile */ &&
+                    node.kind !== 267 /* SyntaxKind.TypeAliasDeclaration */ &&
+                    node.kind !== 266 /* SyntaxKind.InterfaceDeclaration */ &&
+                    node.kind !== 269 /* SyntaxKind.ModuleDeclaration */ &&
+                    parent.kind === 308 /* SyntaxKind.SourceFile */ &&
                     getEmitModuleFormat(g) === ModuleKind.CommonJS)
                     return grammarErrorOnNode(g, modifier, 236 /* Diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled */);
                 if ((flags & 32 /* ModifierFlags.Export */) !== 0)
@@ -547,24 +548,24 @@ function checkGrammarModifiers(g, node) {
                     return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'export', 'abstract');
                 if ((flags & 1024 /* ModifierFlags.Async */) !== 0 && !reparsed)
                     return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'export', 'async');
-                if (isClassLike(parent) && node.kind !== 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+                if (isClassLike(parent) && node.kind !== 346 /* SyntaxKind.JSTypeAliasDeclaration */)
                     return grammarErrorOnNode(g, modifier, 24 /* Diagnostics.X_0_modifier_cannot_appear_on_class_elements_of_this_kind */, 'export');
-                if (node.kind === 170 /* SyntaxKind.Parameter */)
+                if (node.kind === 171 /* SyntaxKind.Parameter */)
                     return grammarErrorOnNode(g, modifier, 59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */, 'export');
                 if (blockScopeKind === 4 /* NodeFlags.Using */)
-                    return grammarErrorOnNode(g, modifier, 406 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'export');
+                    return grammarErrorOnNode(g, modifier, 404 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'export');
                 if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
-                    return grammarErrorOnNode(g, modifier, 410 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'export');
+                    return grammarErrorOnNode(g, modifier, 408 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'export');
                 flags |= 32 /* ModifierFlags.Export */;
                 break;
             case 89 /* SyntaxKind.DefaultKeyword */: {
-                const container = parent.kind === 307 /* SyntaxKind.SourceFile */ ? parent : parent.parent;
-                if (container.kind === 268 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container))
+                const container = parent.kind === 308 /* SyntaxKind.SourceFile */ ? parent : parent.parent;
+                if (container.kind === 269 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container))
                     return grammarErrorOnNode(g, modifier, 255 /* Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module */);
                 if (blockScopeKind === 4 /* NodeFlags.Using */)
-                    return grammarErrorOnNode(g, modifier, 406 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'default');
+                    return grammarErrorOnNode(g, modifier, 404 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'default');
                 if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
-                    return grammarErrorOnNode(g, modifier, 410 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'default');
+                    return grammarErrorOnNode(g, modifier, 408 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'default');
                 if ((flags & 32 /* ModifierFlags.Export */) === 0 && !reparsed)
                     return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'export', 'default');
                 if (sawExportBeforeDecorators)
@@ -579,18 +580,18 @@ function checkGrammarModifiers(g, node) {
                     return grammarErrorOnNode(g, modifier, 30 /* Diagnostics.X_0_modifier_cannot_be_used_in_an_ambient_context */, 'async');
                 if ((flags & 16 /* ModifierFlags.Override */) !== 0)
                     return grammarErrorOnNode(g, modifier, 30 /* Diagnostics.X_0_modifier_cannot_be_used_in_an_ambient_context */, 'override');
-                if (isClassLike(parent) && node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+                if (isClassLike(parent) && node.kind !== 174 /* SyntaxKind.PropertyDeclaration */)
                     return grammarErrorOnNode(g, modifier, 24 /* Diagnostics.X_0_modifier_cannot_appear_on_class_elements_of_this_kind */, 'declare');
-                if (node.kind === 170 /* SyntaxKind.Parameter */)
+                if (node.kind === 171 /* SyntaxKind.Parameter */)
                     return grammarErrorOnNode(g, modifier, 59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */, 'declare');
                 if (blockScopeKind === 4 /* NodeFlags.Using */)
-                    return grammarErrorOnNode(g, modifier, 406 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'declare');
+                    return grammarErrorOnNode(g, modifier, 404 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'declare');
                 if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
-                    return grammarErrorOnNode(g, modifier, 410 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'declare');
-                if ((parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && parent.kind === 269 /* SyntaxKind.ModuleBlock */)
+                    return grammarErrorOnNode(g, modifier, 408 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'declare');
+                if ((parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && parent.kind === 270 /* SyntaxKind.ModuleBlock */)
                     return grammarErrorOnNode(g, modifier, 28 /* Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context */);
                 if (isPrivateIdentifierClassElementDeclaration(node))
-                    return grammarErrorOnNode(g, modifier, 1841 /* Diagnostics.X_0_modifier_cannot_be_used_with_a_private_identifier */, 'declare');
+                    return grammarErrorOnNode(g, modifier, 1861 /* Diagnostics.X_0_modifier_cannot_be_used_with_a_private_identifier */, 'declare');
                 if ((flags & 512 /* ModifierFlags.Accessor */) !== 0)
                     return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'declare', 'accessor');
                 flags |= 128 /* ModifierFlags.Ambient */;
@@ -599,14 +600,14 @@ function checkGrammarModifiers(g, node) {
             case 127 /* SyntaxKind.AbstractKeyword */: {
                 if ((flags & 64 /* ModifierFlags.Abstract */) !== 0)
                     return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'abstract');
-                if (node.kind !== 264 /* SyntaxKind.ClassDeclaration */ && node.kind !== 186 /* SyntaxKind.ConstructorType */) {
-                    if (node.kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
-                        node.kind !== 173 /* SyntaxKind.PropertyDeclaration */ &&
-                        node.kind !== 178 /* SyntaxKind.GetAccessor */ &&
-                        node.kind !== 179 /* SyntaxKind.SetAccessor */)
+                if (node.kind !== 265 /* SyntaxKind.ClassDeclaration */ && node.kind !== 187 /* SyntaxKind.ConstructorType */) {
+                    if (node.kind !== 176 /* SyntaxKind.MethodDeclaration */ &&
+                        node.kind !== 174 /* SyntaxKind.PropertyDeclaration */ &&
+                        node.kind !== 179 /* SyntaxKind.GetAccessor */ &&
+                        node.kind !== 180 /* SyntaxKind.SetAccessor */)
                         return grammarErrorOnNode(g, modifier, 192 /* Diagnostics.X_abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration */);
-                    if (!(parent.kind === 264 /* SyntaxKind.ClassDeclaration */ && hasSyntacticModifier(parent, 64 /* ModifierFlags.Abstract */)))
-                        return grammarErrorOnNode(g, modifier, node.kind === 173 /* SyntaxKind.PropertyDeclaration */
+                    if (!(parent.kind === 265 /* SyntaxKind.ClassDeclaration */ && hasSyntacticModifier(parent, 64 /* ModifierFlags.Abstract */)))
+                        return grammarErrorOnNode(g, modifier, node.kind === 174 /* SyntaxKind.PropertyDeclaration */
                             ? 203 /* Diagnostics.Abstract_properties_can_only_appear_within_an_abstract_class */
                             : 194 /* Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class */);
                     if ((flags & 256 /* ModifierFlags.Static */) !== 0)
@@ -622,7 +623,7 @@ function checkGrammarModifiers(g, node) {
                 }
                 const name = getName(node);
                 if (name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
-                    return grammarErrorOnNode(g, modifier, 1841 /* Diagnostics.X_0_modifier_cannot_be_used_with_a_private_identifier */, 'abstract');
+                    return grammarErrorOnNode(g, modifier, 1861 /* Diagnostics.X_0_modifier_cannot_be_used_with_a_private_identifier */, 'abstract');
                 flags |= 64 /* ModifierFlags.Abstract */;
                 break;
             }
@@ -631,7 +632,7 @@ function checkGrammarModifiers(g, node) {
                     return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'async');
                 if ((flags & 128 /* ModifierFlags.Ambient */) !== 0 || (parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
                     return grammarErrorOnNode(g, modifier, 30 /* Diagnostics.X_0_modifier_cannot_be_used_in_an_ambient_context */, 'async');
-                if (node.kind === 170 /* SyntaxKind.Parameter */)
+                if (node.kind === 171 /* SyntaxKind.Parameter */)
                     return grammarErrorOnNode(g, modifier, 59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */, 'async');
                 if ((flags & 64 /* ModifierFlags.Abstract */) !== 0)
                     return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'async', 'abstract');
@@ -642,11 +643,11 @@ function checkGrammarModifiers(g, node) {
             case 147 /* SyntaxKind.OutKeyword */: {
                 const inOutFlag = kind === 102 /* SyntaxKind.InKeyword */ ? 8192 /* ModifierFlags.In */ : 16384 /* ModifierFlags.Out */;
                 const inOutText = kind === 102 /* SyntaxKind.InKeyword */ ? 'in' : 'out';
-                if (node.kind !== 169 /* SyntaxKind.TypeParameter */ ||
-                    !(parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
+                if (node.kind !== 170 /* SyntaxKind.TypeParameter */ ||
+                    !(parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */ ||
                         isClassLike(parent) ||
-                        parent.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ ||
-                        parent.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */))
+                        parent.kind === 267 /* SyntaxKind.TypeAliasDeclaration */ ||
+                        parent.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */))
                     return grammarErrorOnNode(g, modifier, 223 /* Diagnostics.X_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias */, inOutText);
                 if ((flags & inOutFlag) !== 0)
                     return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, inOutText);
@@ -657,7 +658,7 @@ function checkGrammarModifiers(g, node) {
             }
         }
     }
-    if (node.kind === 177 /* SyntaxKind.Constructor */) {
+    if (node.kind === 178 /* SyntaxKind.Constructor */) {
         if ((flags & 256 /* ModifierFlags.Static */) !== 0)
             return grammarErrorOnNode(g, lastStatic, 58 /* Diagnostics.X_0_modifier_cannot_appear_on_a_constructor_declaration */, 'static');
         if ((flags & 16 /* ModifierFlags.Override */) !== 0)
@@ -666,12 +667,12 @@ function checkGrammarModifiers(g, node) {
             return grammarErrorOnNode(g, lastAsync, 58 /* Diagnostics.X_0_modifier_cannot_appear_on_a_constructor_declaration */, 'async');
         return false;
     }
-    if ((node.kind === 273 /* SyntaxKind.ImportDeclaration */ ||
-        node.kind === 346 /* SyntaxKind.JSImportDeclaration */ ||
-        node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */) &&
+    if ((node.kind === 274 /* SyntaxKind.ImportDeclaration */ ||
+        node.kind === 347 /* SyntaxKind.JSImportDeclaration */ ||
+        node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */) &&
         (flags & 128 /* ModifierFlags.Ambient */) !== 0)
         return grammarErrorOnNode(g, lastDeclare, 56 /* Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration */, 'declare');
-    if (node.kind === 170 /* SyntaxKind.Parameter */ && (flags & 31 /* ModifierFlags.ParameterPropertyModifier */) !== 0) {
+    if (node.kind === 171 /* SyntaxKind.Parameter */ && (flags & 31 /* ModifierFlags.ParameterPropertyModifier */) !== 0) {
         const parameter = node;
         if (isBindingPattern(parameter.name))
             return grammarErrorOnNode(g, node, 143 /* Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern */);
@@ -684,11 +685,11 @@ function checkGrammarModifiers(g, node) {
 }
 function isConstTypeParameterContainer(parent) {
     switch (parent.kind) {
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 181 /* SyntaxKind.ConstructSignature */:
-        case 174 /* SyntaxKind.MethodSignature */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 175 /* SyntaxKind.MethodSignature */:
             return true;
     }
     return isFunctionLikeDeclarationKind(parent.kind) || isClassLike(parent);
@@ -709,47 +710,47 @@ function findFirstModifierExcept(modifiers, allowedModifier) {
 }
 function findFirstIllegalModifier(node, modifiers) {
     switch (node.kind) {
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 279 /* SyntaxKind.ExportDeclaration */:
-        case 278 /* SyntaxKind.ExportAssignment */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 169 /* SyntaxKind.TypeParameter */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 170 /* SyntaxKind.TypeParameter */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
             return undefined;
-        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
-        case 283 /* SyntaxKind.MissingDeclaration */:
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 284 /* SyntaxKind.MissingDeclaration */:
             return findFirstModifier(modifiers);
     }
     const parent = node.parent;
-    if (parent.kind === 269 /* SyntaxKind.ModuleBlock */ || parent.kind === 307 /* SyntaxKind.SourceFile */)
+    if (parent.kind === 270 /* SyntaxKind.ModuleBlock */ || parent.kind === 308 /* SyntaxKind.SourceFile */)
         return undefined;
     switch (node.kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
             return findFirstModifierExcept(modifiers, 133 /* SyntaxKind.AsyncKeyword */);
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 186 /* SyntaxKind.ConstructorType */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 187 /* SyntaxKind.ConstructorType */:
             return findFirstModifierExcept(modifiers, 127 /* SyntaxKind.AbstractKeyword */);
-        case 244 /* SyntaxKind.VariableStatement */:
+        case 245 /* SyntaxKind.VariableStatement */:
             if ((node.declarationList.flags & 4 /* NodeFlags.Using */) !== 0)
                 return findFirstModifierExcept(modifiers, 134 /* SyntaxKind.AwaitKeyword */);
             return findFirstModifier(modifiers);
-        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
             return findFirstModifierExcept(modifiers, 86 /* SyntaxKind.ConstKeyword */);
     }
     // Class expressions, interfaces and type aliases.
@@ -759,16 +760,16 @@ function reportObviousDecoratorErrors(g, node, modifiers) {
     if (!canHaveIllegalDecorators(node))
         return false;
     for (const modifier of modifiers.nodes)
-        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+        if (modifier.kind === 172 /* SyntaxKind.Decorator */)
             return grammarErrorOnFirstToken(g, modifier, 160 /* Diagnostics.Decorators_are_not_valid_here */);
     return false;
 }
 function checkGrammarAsyncModifier(g, node, asyncModifier) {
     switch (node.kind) {
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return false;
     }
     return grammarErrorOnNode(g, asyncModifier, 31 /* Diagnostics.X_0_modifier_cannot_be_used_here */, 'async');
@@ -778,7 +779,7 @@ function hasDecorators(node) {
     if (modifiers === undefined)
         return false;
     for (const modifier of modifiers.nodes)
-        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+        if (modifier.kind === 172 /* SyntaxKind.Decorator */)
             return true;
     return false;
 }
@@ -789,30 +790,30 @@ function nodeCanBeDecorated(legacy, node, parent, grandparent) {
     if (legacy && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
         return false;
     switch (node.kind) {
-        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
             return true;
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
             return !legacy;
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             return (parent !== undefined &&
                 (legacy
-                    ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */
+                    ? parent.kind === 265 /* SyntaxKind.ClassDeclaration */
                     : isClassLike(parent) && !hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */ | 128 /* ModifierFlags.Ambient */)));
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             return (parent !== undefined &&
                 getBody(node) !== undefined &&
-                (legacy ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */ : isClassLike(parent)));
-        case 170 /* SyntaxKind.Parameter */:
+                (legacy ? parent.kind === 265 /* SyntaxKind.ClassDeclaration */ : isClassLike(parent)));
+        case 171 /* SyntaxKind.Parameter */:
             if (!legacy || parent === undefined || getBody(parent) === undefined)
                 return false;
-            return ((parent.kind === 177 /* SyntaxKind.Constructor */ ||
-                parent.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-                parent.kind === 179 /* SyntaxKind.SetAccessor */) &&
+            return ((parent.kind === 178 /* SyntaxKind.Constructor */ ||
+                parent.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+                parent.kind === 180 /* SyntaxKind.SetAccessor */) &&
                 getThisParameter(parent) !== node &&
                 grandparent !== undefined &&
-                grandparent.kind === 264 /* SyntaxKind.ClassDeclaration */);
+                grandparent.kind === 265 /* SyntaxKind.ClassDeclaration */);
     }
     return false;
 }
@@ -821,7 +822,7 @@ function getFirstAccessorOfPair(c, node) {
     const symbol = getSymbolOfDeclaration(c, node);
     if (symbol === undefined)
         return node;
-    const otherKind = node.kind === 178 /* SyntaxKind.GetAccessor */ ? 179 /* SyntaxKind.SetAccessor */ : 178 /* SyntaxKind.GetAccessor */;
+    const otherKind = node.kind === 179 /* SyntaxKind.GetAccessor */ ? 180 /* SyntaxKind.SetAccessor */ : 179 /* SyntaxKind.GetAccessor */;
     for (const declaration of getDeclarations(symbol))
         if (declaration.kind === otherKind && declaration.pos < node.pos)
             return declaration;
@@ -834,7 +835,7 @@ function checkGrammarDecorators(g, node) {
     if (!nodeCanBeDecorated(g.legacyDecorators, node, node.parent, node.parent.parent))
         return;
     for (const modifier of getModifiers(node).nodes)
-        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+        if (modifier.kind === 172 /* SyntaxKind.Decorator */)
             checkGrammarDecorator(g, modifier);
 }
 function checkGrammarDecorator(g, decorator) {
@@ -842,18 +843,18 @@ function checkGrammarDecorator(g, decorator) {
         return false;
     let node = decorator.expression;
     // `@(expression)`
-    if (node.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    if (node.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         return false;
     let canHaveCallExpression = true;
     let errorNode;
     for (;;) {
         // Non-null assertions and instantiation expressions are allowed.
-        if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */ || node.kind === 236 /* SyntaxKind.NonNullExpression */) {
+        if (node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */ || node.kind === 237 /* SyntaxKind.NonNullExpression */) {
             node = getExpression(node);
             continue;
         }
         // `@member.expression(arguments)`
-        if (node.kind === 214 /* SyntaxKind.CallExpression */) {
+        if (node.kind === 215 /* SyntaxKind.CallExpression */) {
             const call = node;
             if (!canHaveCallExpression)
                 errorNode = node;
@@ -865,7 +866,7 @@ function checkGrammarDecorator(g, decorator) {
             continue;
         }
         // `@identifier`, `@member.name` and `@member.#name`
-        if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
             const access = node;
             if (access.questionDotToken !== undefined)
                 errorNode = access.questionDotToken;
@@ -879,8 +880,8 @@ function checkGrammarDecorator(g, decorator) {
     }
     if (errorNode === undefined)
         return false;
-    const diagnostic = g.c.error(decorator.expression, 412 /* Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator */);
-    addRelated(diagnostic, errorNode, 413 /* Diagnostics.Invalid_syntax_in_decorator */);
+    const diagnostic = g.c.error(decorator.expression, 410 /* Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator */);
+    addRelated(diagnostic, errorNode, 411 /* Diagnostics.Invalid_syntax_in_decorator */);
     return true;
 }
 // ---- Functions and parameters
@@ -933,7 +934,7 @@ function checkGrammarForUseStrictSimpleParameterList(g, node) {
     if (g.c.languageVersion < ScriptTarget.ES2016)
         return false;
     const body = getBody(node);
-    if (body === undefined || body.kind !== 242 /* SyntaxKind.Block */)
+    if (body === undefined || body.kind !== 243 /* SyntaxKind.Block */)
         return false;
     const useStrictDirective = findUseStrictPrologue(g.file, getStatements(body).nodes);
     if (useStrictDirective === undefined)
@@ -952,11 +953,11 @@ function checkGrammarForUseStrictSimpleParameterList(g, node) {
     }
     const diagnostic = g.c.error(useStrictDirective, 281 /* Diagnostics.X_use_strict_directive_cannot_be_used_with_non_simple_parameter_list */);
     for (let i = 0; i < nonSimpleParameters.length; i++)
-        addRelated(diagnostic, nonSimpleParameters[i], i === 0 ? 282 /* Diagnostics.Non_simple_parameter_declared_here */ : 1357 /* Diagnostics.X_and_here */);
+        addRelated(diagnostic, nonSimpleParameters[i], i === 0 ? 282 /* Diagnostics.Non_simple_parameter_declared_here */ : 1368 /* Diagnostics.X_and_here */);
     return true;
 }
 function checkGrammarArrowFunction(g, node) {
-    if (node.kind !== 220 /* SyntaxKind.ArrowFunction */)
+    if (node.kind !== 221 /* SyntaxKind.ArrowFunction */)
         return false;
     const arrow = node;
     const typeParameters = arrow.typeParameters;
@@ -965,7 +966,7 @@ function checkGrammarArrowFunction(g, node) {
         const hasConstraint = nodes.length > 0 && nodes[0].constraint !== undefined;
         if (!(nodes.length > 1 || typeParameters.hasTrailingComma() || hasConstraint) &&
             fileExtensionIsOneOf(g.file.fileName, ['.mts', '.cts']))
-            grammarErrorOnNode(g, nodes[0], 1731 /* Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint */);
+            grammarErrorOnNode(g, nodes[0], 1750 /* Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint */);
     }
     const arrowToken = arrow.equalsGreaterThanToken;
     if (arrowToken === undefined)
@@ -998,7 +999,7 @@ function checkGrammarForGenerator(g, node) {
     return false;
 }
 function isThisParameter(node) {
-    if (node.kind !== 170 /* SyntaxKind.Parameter */)
+    if (node.kind !== 171 /* SyntaxKind.Parameter */)
         return false;
     const name = node.name;
     return name instanceof Identifier && name.text === 'this';
@@ -1012,7 +1013,7 @@ function getThisParameter(signature) {
 }
 function isBindingPattern(node) {
     return (node !== undefined &&
-        (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
+        (node.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 209 /* SyntaxKind.ArrayBindingPattern */));
 }
 // ---- Signatures and members
 function checkGrammarIndexSignatureParameters(g, node) {
@@ -1069,7 +1070,7 @@ function checkGrammarTypeArguments(g, typeArguments) {
 }
 function checkGrammarExpressionWithTypeArguments(g, node) {
     const typeArguments = getTypeArguments(node);
-    if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */ &&
+    if (node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */ &&
         node.expression.kind === 101 /* SyntaxKind.ImportKeyword */ &&
         typeArguments !== undefined)
         return grammarErrorOnNode(g, node, 262 /* Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments */);
@@ -1091,14 +1092,14 @@ function checkGrammarClassDeclaration(g, node) {
     if (g.legacyDecorators && modifiers !== undefined) {
         let firstDecorator;
         for (const modifier of modifiers.nodes)
-            if (modifier.kind === 171 /* SyntaxKind.Decorator */) {
+            if (modifier.kind === 172 /* SyntaxKind.Decorator */) {
                 firstDecorator = modifier;
                 break;
             }
         if (firstDecorator !== undefined)
             for (const member of getMembers(node).nodes)
                 if (hasSyntacticModifier(member, 256 /* ModifierFlags.Static */) && isPrivateIdentifierClassElementDeclaration(member)) {
-                    grammarErrorOnNode(g, firstDecorator, 1853 /* Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator */);
+                    grammarErrorOnNode(g, firstDecorator, 1873 /* Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator */);
                     break;
                 }
     }
@@ -1133,11 +1134,6 @@ function checkGrammarClassDeclarationHeritageClauses(g, node) {
                 return grammarErrorOnFirstToken(g, clause, 129 /* Diagnostics.X_extends_clause_must_precede_implements_clause */);
             if (clause.types.nodes.length > 1)
                 return grammarErrorOnFirstToken(g, clause.types.nodes[1], 130 /* Diagnostics.Classes_can_only_extend_a_single_class */);
-            if (clause.types.nodes.length > 0) {
-                const mismatch = findMismatchedAugmentsTag(node, clause.types.nodes[0]);
-                if (mismatch !== undefined)
-                    return grammarErrorOnNode(g, mismatch.name, 1752 /* Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause */, mismatch.tagName, mismatch.className, mismatch.extendsName);
-            }
             seenExtendsClause = true;
         }
         else {
@@ -1179,10 +1175,10 @@ function checkGrammarInterfaceDeclaration(g, node) {
                     checkGrammarTypeArguments(g, getTypeArguments(type));
 }
 function checkGrammarComputedPropertyName(g, node) {
-    if (node.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+    if (node.kind !== 169 /* SyntaxKind.ComputedPropertyName */)
         return false;
     const expression = node.expression;
-    return (expression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    return (expression.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         expression.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ &&
         grammarErrorOnNode(g, expression, 127 /* Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name */));
 }
@@ -1201,13 +1197,13 @@ function isNonBindableDynamicName(c, node) {
     if (!isDynamicName(node))
         return false;
     let expression;
-    if (node.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (node.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         expression = getExpression(node);
     else if (node instanceof ElementAccessExpression)
         expression = node.argumentExpression;
     if (expression === undefined || !isEntityNameExpression(expression, false))
         return true;
-    const t = node.kind === 168 /* SyntaxKind.ComputedPropertyName */
+    const t = node.kind === 169 /* SyntaxKind.ComputedPropertyName */
         ? checkComputedPropertyName(c, node)
         : checkExpressionCached(c, expression);
     return !isTypeUsableAsPropertyName(t);
@@ -1219,7 +1215,7 @@ function checkGrammarForInvalidDynamicName(g, node, message) {
     return !isEntityNameExpression(expression, false) && grammarErrorOnNode(g, node, message);
 }
 function checkGrammarMethodDeclaration(g, node) {
-    if (node.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */) {
+    if (node.parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */) {
         // `checkObjectLiteralMethod` checks the method, then checks it again as a function expression.
         checkGrammarMethod(g, node);
         checkGrammarFunctionLikeDeclaration(g, node);
@@ -1233,14 +1229,14 @@ function checkGrammarMethodDeclaration(g, node) {
     }
     checkGrammarDecorators(g, node);
     if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */ && getContainingClass(node) === undefined)
-        g.c.error(node, 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+        g.c.error(node, 1858 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
 }
 function checkGrammarMethod(g, node) {
     if (checkGrammarFunctionLikeDeclaration(g, node))
         return true;
     const parent = node.parent;
-    if (node.kind === 175 /* SyntaxKind.MethodDeclaration */) {
-        if (parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */) {
+    if (node.kind === 176 /* SyntaxKind.MethodDeclaration */) {
+        if (parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */) {
             // Only `async` is allowed on object literal methods.
             const modifiers = getModifiers(node);
             if (modifiers !== undefined &&
@@ -1263,13 +1259,13 @@ function checkGrammarMethod(g, node) {
         // those report other errors first.
         if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
             return checkGrammarForInvalidDynamicName(g, name, 122 /* Diagnostics.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */);
-        if (node.kind === 175 /* SyntaxKind.MethodDeclaration */ && getBody(node) === undefined)
+        if (node.kind === 176 /* SyntaxKind.MethodDeclaration */ && getBody(node) === undefined)
             return checkGrammarForInvalidDynamicName(g, name, 124 /* Diagnostics.A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */);
     }
-    else if (parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
+    else if (parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */) {
         return checkGrammarForInvalidDynamicName(g, name, 125 /* Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */);
     }
-    else if (parent.kind === 188 /* SyntaxKind.TypeLiteral */) {
+    else if (parent.kind === 189 /* SyntaxKind.TypeLiteral */) {
         return checkGrammarForInvalidDynamicName(g, name, 126 /* Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */);
     }
     return false;
@@ -1290,7 +1286,7 @@ function checkGrammarAccessorDeclaration(g, node) {
 function checkGrammarAccessor(g, accessor) {
     const body = getBody(accessor);
     const parent = accessor.parent;
-    const inTypeMember = parent.kind === 188 /* SyntaxKind.TypeLiteral */ || parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */;
+    const inTypeMember = parent.kind === 189 /* SyntaxKind.TypeLiteral */ || parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */;
     const isAbstract = hasSyntacticModifier(accessor, 64 /* ModifierFlags.Abstract */);
     if ((accessor.flags & 8388608 /* NodeFlags.Ambient */) === 0 && !inTypeMember && body === undefined && !isAbstract)
         return grammarErrorAtPos(g, accessor.end - 1, 1, 2 /* Diagnostics.X_0_expected */, '{');
@@ -1304,7 +1300,7 @@ function checkGrammarAccessor(g, accessor) {
     if (getTypeParameters(accessor) !== undefined)
         return grammarErrorOnNode(g, name, 63 /* Diagnostics.An_accessor_cannot_have_type_parameters */);
     const parameters = getParameters(accessor).nodes;
-    const isGetter = accessor.kind === 178 /* SyntaxKind.GetAccessor */;
+    const isGetter = accessor.kind === 179 /* SyntaxKind.GetAccessor */;
     // A `this` parameter only counts with the right number of other parameters.
     const hasThisParameter = parameters.length === (isGetter ? 1 : 2) && isThisParameter(parameters[0]);
     if (!hasThisParameter && parameters.length !== (isGetter ? 0 : 1))
@@ -1331,29 +1327,29 @@ function checkGrammarPropertyDeclaration(g, node) {
 function checkGrammarProperty(g, node) {
     const name = getName(node);
     const parent = node.parent;
-    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */) {
+    if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */) {
         const expression = name.expression;
-        if (expression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        if (expression.kind === 228 /* SyntaxKind.BinaryExpression */ &&
             expression.operatorToken.kind === 102 /* SyntaxKind.InKeyword */)
-            return grammarErrorOnNode(g, getMembers(parent).nodes[0], 1732 /* Diagnostics.A_mapped_type_may_not_declare_properties_or_methods */);
+            return grammarErrorOnNode(g, getMembers(parent).nodes[0], 1751 /* Diagnostics.A_mapped_type_may_not_declare_properties_or_methods */);
     }
     if (isClassLike(parent)) {
         if (name instanceof StringLiteral && name.text === 'constructor')
-            return grammarErrorOnNode(g, name, 1829 /* Diagnostics.Classes_may_not_have_a_field_named_constructor */);
+            return grammarErrorOnNode(g, name, 1849 /* Diagnostics.Classes_may_not_have_a_field_named_constructor */);
         if (checkGrammarForInvalidDynamicName(g, name, 123 /* Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type */))
             return true;
         if (isAutoAccessorPropertyDeclaration(node) &&
             checkGrammarForInvalidQuestionMark(g, getPostfixToken(node), 225 /* Diagnostics.An_accessor_property_cannot_be_declared_optional */))
             return true;
     }
-    else if (parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
+    else if (parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */) {
         if (checkGrammarForInvalidDynamicName(g, name, 125 /* Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */))
             return true;
         const initializer = getInitializer(node);
         if (initializer !== undefined)
             return grammarErrorOnNode(g, initializer, 196 /* Diagnostics.An_interface_property_cannot_have_an_initializer */);
     }
-    else if (parent.kind === 188 /* SyntaxKind.TypeLiteral */) {
+    else if (parent.kind === 189 /* SyntaxKind.TypeLiteral */) {
         if (checkGrammarForInvalidDynamicName(g, name, 126 /* Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */))
             return true;
         const initializer = getInitializer(node);
@@ -1362,7 +1358,7 @@ function checkGrammarProperty(g, node) {
     }
     if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
         checkAmbientInitializer(g, node);
-    if (node.kind === 173 /* SyntaxKind.PropertyDeclaration */) {
+    if (node.kind === 174 /* SyntaxKind.PropertyDeclaration */) {
         const property = node;
         const postfixToken = property.postfixToken;
         if (postfixToken !== undefined && postfixToken.kind === 53 /* SyntaxKind.ExclamationToken */) {
@@ -1388,7 +1384,7 @@ function checkAmbientInitializer(g, node) {
         initializer.kind === 111 /* SyntaxKind.TrueKeyword */ ||
         initializer.kind === 96 /* SyntaxKind.FalseKeyword */ ||
         isInitializerBigIntLiteralExpression(initializer));
-    const isConstOrReadonly = isDeclarationReadonly(node) || (node.kind === 261 /* SyntaxKind.VariableDeclaration */ && isVarConstLike(node));
+    const isConstOrReadonly = isDeclarationReadonly(node) || (node.kind === 262 /* SyntaxKind.VariableDeclaration */ && isVarConstLike(node));
     if (!isConstOrReadonly || getType(node) !== undefined)
         return grammarErrorOnNode(g, initializer, 29 /* Diagnostics.Initializers_are_not_allowed_in_ambient_contexts */);
     if (isInvalidInitializer)
@@ -1397,7 +1393,7 @@ function checkAmbientInitializer(g, node) {
 }
 function isDeclarationReadonly(node) {
     return ((getCombinedModifierFlags(node) & 8 /* ModifierFlags.Readonly */) !== 0 &&
-        !(node.kind === 170 /* SyntaxKind.Parameter */ && node.parent.kind === 177 /* SyntaxKind.Constructor */));
+        !(node.kind === 171 /* SyntaxKind.Parameter */ && node.parent.kind === 178 /* SyntaxKind.Constructor */));
 }
 function isVarConstLike(node) {
     const blockScopeKind = getCombinedNodeFlags(node) & 7 /* NodeFlags.BlockScoped */;
@@ -1409,7 +1405,7 @@ function isInitializerStringOrNumberLiteralExpression(expression) {
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
         case 8 /* SyntaxKind.NumericLiteral */:
             return true;
-        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+        case 226 /* SyntaxKind.PrefixUnaryExpression */: {
             const unary = expression;
             return unary.operator === 40 /* SyntaxKind.MinusToken */ && unary.operand.kind === 8 /* SyntaxKind.NumericLiteral */;
         }
@@ -1419,13 +1415,13 @@ function isInitializerStringOrNumberLiteralExpression(expression) {
 function isInitializerBigIntLiteralExpression(expression) {
     if (expression.kind === 9 /* SyntaxKind.BigIntLiteral */)
         return true;
-    if (expression.kind !== 225 /* SyntaxKind.PrefixUnaryExpression */)
+    if (expression.kind !== 226 /* SyntaxKind.PrefixUnaryExpression */)
         return false;
     const unary = expression;
     return unary.operator === 40 /* SyntaxKind.MinusToken */ && unary.operand.kind === 9 /* SyntaxKind.BigIntLiteral */;
 }
 function isInitializerSimpleLiteralEnumReference(c, expression) {
-    if (expression.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    if (expression.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         return (checkExpressionCached(c, expression).flags & 98304 /* TypeFlags.EnumLike */) !== 0;
     if (expression instanceof ElementAccessExpression)
         return (isInitializerStringOrNumberLiteralExpression(expression.argumentExpression) &&
@@ -1446,9 +1442,9 @@ function checkGrammarStatementInAmbientContext(g, node) {
         return reported;
     }
     // Report once per block; statements nested in other statements are covered by their parent.
-    if (parent.kind === 242 /* SyntaxKind.Block */ ||
-        parent.kind === 269 /* SyntaxKind.ModuleBlock */ ||
-        parent.kind === 307 /* SyntaxKind.SourceFile */) {
+    if (parent.kind === 243 /* SyntaxKind.Block */ ||
+        parent.kind === 270 /* SyntaxKind.ModuleBlock */ ||
+        parent.kind === 308 /* SyntaxKind.SourceFile */) {
         const parentId = getNodeId(parent);
         if (!g.reportedAmbientStatements.has(parentId)) {
             const reported = grammarErrorOnFirstToken(g, node, 27 /* Diagnostics.Statements_are_not_allowed_in_ambient_contexts */);
@@ -1460,7 +1456,7 @@ function checkGrammarStatementInAmbientContext(g, node) {
     return false;
 }
 function isAccessor(node) {
-    return node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */;
+    return node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* SyntaxKind.SetAccessor */;
 }
 function checkGrammarVariableStatement(g, node) {
     if (!checkGrammarModifiers(g, node) && !checkGrammarVariableDeclarationList(g, node.declarationList))
@@ -1485,15 +1481,15 @@ function checkGrammarForDisallowedBlockScopedVariableStatement(g, node) {
 }
 function containerAllowsBlockScopedVariable(parent) {
     switch (parent.kind) {
-        case 246 /* SyntaxKind.IfStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
-        case 255 /* SyntaxKind.WithStatement */:
-        case 249 /* SyntaxKind.ForStatement */:
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 247 /* SyntaxKind.IfStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
+        case 256 /* SyntaxKind.WithStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             return false;
-        case 257 /* SyntaxKind.LabeledStatement */:
+        case 258 /* SyntaxKind.LabeledStatement */:
             return containerAllowsBlockScopedVariable(parent.parent);
     }
     return true;
@@ -1508,19 +1504,19 @@ function checkGrammarVariableDeclarationList(g, list) {
     const parent = list.parent;
     if (blockScopeFlags === 4 /* NodeFlags.Using */ || blockScopeFlags === 6 /* NodeFlags.AwaitUsing */) {
         const isUsing = blockScopeFlags === 4 /* NodeFlags.Using */;
-        if (parent.kind === 250 /* SyntaxKind.ForInStatement */)
+        if (parent.kind === 251 /* SyntaxKind.ForInStatement */)
             return grammarErrorOnNode(g, list, isUsing
-                ? 408 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration */
-                : 409 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration */);
+                ? 406 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration */
+                : 407 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration */);
         if ((list.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
             return grammarErrorOnNode(g, list, isUsing
-                ? 460 /* Diagnostics.X_using_declarations_are_not_allowed_in_ambient_contexts */
-                : 461 /* Diagnostics.X_await_using_declarations_are_not_allowed_in_ambient_contexts */);
-        if (parent.kind === 244 /* SyntaxKind.VariableStatement */ &&
-            (parent.parent.kind === 297 /* SyntaxKind.CaseClause */ || parent.parent.kind === 298 /* SyntaxKind.DefaultClause */))
+                ? 458 /* Diagnostics.X_using_declarations_are_not_allowed_in_ambient_contexts */
+                : 459 /* Diagnostics.X_await_using_declarations_are_not_allowed_in_ambient_contexts */);
+        if (parent.kind === 245 /* SyntaxKind.VariableStatement */ &&
+            (parent.parent.kind === 298 /* SyntaxKind.CaseClause */ || parent.parent.kind === 299 /* SyntaxKind.DefaultClause */))
             return grammarErrorOnNode(g, list, isUsing
-                ? 462 /* Diagnostics.X_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block */
-                : 463 /* Diagnostics.X_await_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block */);
+                ? 460 /* Diagnostics.X_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block */
+                : 461 /* Diagnostics.X_await_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block */);
     }
     if (blockScopeFlags === 6 /* NodeFlags.AwaitUsing */)
         return checkGrammarAwaitOrAwaitUsing(g, list);
@@ -1532,12 +1528,12 @@ function checkGrammarVariableDeclaration(g, node) {
     const name = node.name;
     if (isBindingPattern(name)) {
         if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
-            return grammarErrorOnNode(g, node, 407 /* Diagnostics.X_0_declarations_may_not_have_binding_patterns */, 'await using');
+            return grammarErrorOnNode(g, node, 405 /* Diagnostics.X_0_declarations_may_not_have_binding_patterns */, 'await using');
         if (blockScopeKind === 4 /* NodeFlags.Using */)
-            return grammarErrorOnNode(g, node, 407 /* Diagnostics.X_0_declarations_may_not_have_binding_patterns */, 'using');
+            return grammarErrorOnNode(g, node, 405 /* Diagnostics.X_0_declarations_may_not_have_binding_patterns */, 'using');
     }
     const statement = node.parent.parent;
-    if (statement.kind !== 250 /* SyntaxKind.ForInStatement */ && statement.kind !== 251 /* SyntaxKind.ForOfStatement */) {
+    if (statement.kind !== 251 /* SyntaxKind.ForInStatement */ && statement.kind !== 252 /* SyntaxKind.ForOfStatement */) {
         if ((nodeFlags & 8388608 /* NodeFlags.Ambient */) !== 0)
             checkAmbientInitializer(g, node);
         else if (node.initializer === undefined) {
@@ -1553,7 +1549,7 @@ function checkGrammarVariableDeclaration(g, node) {
     }
     const exclamationToken = node.exclamationToken;
     if (exclamationToken !== undefined &&
-        (statement.kind !== 244 /* SyntaxKind.VariableStatement */ ||
+        (statement.kind !== 245 /* SyntaxKind.VariableStatement */ ||
             node.type === undefined ||
             node.initializer !== undefined ||
             (nodeFlags & 8388608 /* NodeFlags.Ambient */) !== 0)) {
@@ -1586,7 +1582,7 @@ function checkGrammarNameInLetOrConstDeclarations(g, name) {
     if (name instanceof Identifier) {
         const identifier = name;
         if (identifier.text === 'let')
-            return grammarErrorOnNode(g, name, 643 /* Diagnostics.X_let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations */);
+            return grammarErrorOnNode(g, name, 650 /* Diagnostics.X_let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations */);
         return false;
     }
     for (const element of getElements(name).nodes) {
@@ -1600,10 +1596,10 @@ function checkGrammarBindingElement(g, node) {
     if (node.dotDotDotToken !== undefined) {
         const elements = getElements(node.parent);
         if (node !== elements.nodes[elements.nodes.length - 1])
-            return grammarErrorOnNode(g, node, 628 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
+            return grammarErrorOnNode(g, node, 635 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
         checkGrammarForDisallowedTrailingComma(g, elements, 9 /* Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma */);
         if (node.propertyName !== undefined)
-            return grammarErrorOnNode(g, node.name, 720 /* Diagnostics.A_rest_element_cannot_have_a_property_name */);
+            return grammarErrorOnNode(g, node.name, 727 /* Diagnostics.A_rest_element_cannot_have_a_property_name */);
         // Report on the `=` before the initializer.
         if (node.initializer !== undefined)
             return grammarErrorAtPos(g, node.initializer.pos - 1, 1, 142 /* Diagnostics.A_rest_element_cannot_have_an_initializer */);
@@ -1614,10 +1610,10 @@ function checkGrammarForInOrForOfStatement(g, node) {
     checkGrammarForInOrForOfStatementWorker(g, node);
     // `checkForOfStatement` reports `for await` in static blocks after the statement's grammar.
     const awaitModifier = node.awaitModifier;
-    if (node.kind === 251 /* SyntaxKind.ForOfStatement */ && awaitModifier !== undefined) {
+    if (node.kind === 252 /* SyntaxKind.ForOfStatement */ && awaitModifier !== undefined) {
         const container = getContainingFunctionOrClassStaticBlock(node);
-        if (container !== undefined && container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
-            grammarErrorOnNode(g, awaitModifier, 1855 /* Diagnostics.X_for_await_loops_cannot_be_used_inside_a_class_static_block */);
+        if (container !== undefined && container.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
+            grammarErrorOnNode(g, awaitModifier, 1875 /* Diagnostics.X_for_await_loops_cannot_be_used_inside_a_class_static_block */);
     }
     return false;
 }
@@ -1625,7 +1621,7 @@ function checkGrammarForInOrForOfStatementWorker(g, node) {
     if (checkGrammarStatementInAmbientContext(g, node))
         return true;
     const awaitModifier = node.awaitModifier;
-    if (node.kind === 251 /* SyntaxKind.ForOfStatement */ &&
+    if (node.kind === 252 /* SyntaxKind.ForOfStatement */ &&
         awaitModifier !== undefined &&
         (node.flags & 8192 /* NodeFlags.AwaitContext */) === 0) {
         if (isInTopLevelContext(node)) {
@@ -1643,21 +1639,21 @@ function checkGrammarForInOrForOfStatementWorker(g, node) {
             // `for await` in a function that isn't async.
             const diagnostic = createDiagnosticForNode(awaitModifier, 72 /* Diagnostics.X_for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */, []);
             const containingFunction = getContainingFunction(node);
-            if (containingFunction !== undefined && containingFunction.kind !== 177 /* SyntaxKind.Constructor */)
+            if (containingFunction !== undefined && containingFunction.kind !== 178 /* SyntaxKind.Constructor */)
                 addRelated(diagnostic, containingFunction, 290 /* Diagnostics.Did_you_mean_to_mark_this_function_as_async */);
             g.c.addDiagnostic(diagnostic);
             return true;
         }
     }
     const initializer = node.initializer;
-    if (node.kind === 251 /* SyntaxKind.ForOfStatement */ &&
+    if (node.kind === 252 /* SyntaxKind.ForOfStatement */ &&
         (node.flags & 8192 /* NodeFlags.AwaitContext */) === 0 &&
         initializer instanceof Identifier &&
         initializer.text === 'async') {
         grammarErrorOnNode(g, initializer, 75 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async */);
         return false;
     }
-    if (initializer.kind !== 262 /* SyntaxKind.VariableDeclarationList */)
+    if (initializer.kind !== 263 /* SyntaxKind.VariableDeclarationList */)
         return false;
     const list = initializer;
     if (checkGrammarVariableDeclarationList(g, list))
@@ -1666,7 +1662,7 @@ function checkGrammarForInOrForOfStatementWorker(g, node) {
     const declarations = list.declarations.nodes;
     if (declarations.length === 0)
         return false;
-    const isForIn = node.kind === 250 /* SyntaxKind.ForInStatement */;
+    const isForIn = node.kind === 251 /* SyntaxKind.ForInStatement */;
     if (declarations.length > 1)
         return grammarErrorOnFirstToken(g, declarations[1], isForIn
             ? 60 /* Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement */
@@ -1678,8 +1674,8 @@ function checkGrammarForInOrForOfStatementWorker(g, node) {
             : 146 /* Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer */);
     if (first.type !== undefined)
         return grammarErrorOnNode(g, first, isForIn
-            ? 575 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation */
-            : 645 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation */);
+            ? 582 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation */
+            : 652 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation */);
     return false;
 }
 /** Whether the module and target options allow top-level `await`. */
@@ -1698,11 +1694,11 @@ function checkTopLevelAwaitModule(g) {
 }
 function checkGrammarBreakOrContinueStatement(g, node) {
     const targetLabel = getLabel(node);
-    const isBreak = node.kind === 253 /* SyntaxKind.BreakStatement */;
+    const isBreak = node.kind === 254 /* SyntaxKind.BreakStatement */;
     for (let current = node; current !== undefined; current = current.parent) {
-        if (isFunctionLike(current) || current.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+        if (isFunctionLike(current) || current.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
             return grammarErrorOnNode(g, node, 76 /* Diagnostics.Jump_target_cannot_cross_function_boundary */);
-        if (current.kind === 257 /* SyntaxKind.LabeledStatement */) {
+        if (current.kind === 258 /* SyntaxKind.LabeledStatement */) {
             const labeled = current;
             if (targetLabel !== undefined && labeled.label.text === getText(targetLabel)) {
                 // `continue` can only target labels of iteration statements.
@@ -1711,7 +1707,7 @@ function checkGrammarBreakOrContinueStatement(g, node) {
                 return false;
             }
         }
-        else if (current.kind === 256 /* SyntaxKind.SwitchStatement */) {
+        else if (current.kind === 257 /* SyntaxKind.SwitchStatement */) {
             if (isBreak && targetLabel === undefined)
                 return false;
         }
@@ -1729,13 +1725,13 @@ function checkGrammarBreakOrContinueStatement(g, node) {
 }
 function isIterationStatement(node, lookInLabeledStatements) {
     switch (node.kind) {
-        case 249 /* SyntaxKind.ForStatement */:
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
             return true;
-        case 257 /* SyntaxKind.LabeledStatement */:
+        case 258 /* SyntaxKind.LabeledStatement */:
             return lookInLabeledStatements && isIterationStatement(node.statement, true);
     }
     return false;
@@ -1745,8 +1741,8 @@ function checkGrammarReturnStatement(g, node) {
     if (checkGrammarStatementInAmbientContext(g, node))
         return false;
     const container = getContainingFunctionOrClassStaticBlock(node);
-    if (container !== undefined && container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */) {
-        grammarErrorOnFirstToken(g, node, 1857 /* Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block */);
+    if (container !== undefined && container.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */) {
+        grammarErrorOnFirstToken(g, node, 1877 /* Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block */);
         return false;
     }
     if (container === undefined) {
@@ -1761,13 +1757,13 @@ function checkGrammarWithStatement(g, node) {
     // The body of a `with` statement isn't checked.
     g.visitNode(node.expression);
     const start = skipTrivia(g.file.text, node.pos);
-    grammarErrorAtPos(g, start, node.statement.pos - start, 581 /* Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any */);
+    grammarErrorAtPos(g, start, node.statement.pos - start, 588 /* Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any */);
 }
 function checkGrammarSwitchStatement(g, node) {
     checkGrammarStatementInAmbientContext(g, node);
     let seenDefaultClause = false;
     for (const clause of node.caseBlock.clauses.nodes) {
-        if (clause.kind !== 298 /* SyntaxKind.DefaultClause */)
+        if (clause.kind !== 299 /* SyntaxKind.DefaultClause */)
             continue;
         if (!seenDefaultClause)
             seenDefaultClause = true;
@@ -1782,7 +1778,7 @@ function checkGrammarLabeledStatement(g, node) {
         return;
     const label = node.label;
     for (let current = node.parent; current !== undefined && !isFunctionLike(current); current = current.parent)
-        if (current.kind === 257 /* SyntaxKind.LabeledStatement */ && current.label.text === label.text) {
+        if (current.kind === 258 /* SyntaxKind.LabeledStatement */ && current.label.text === label.text) {
             grammarErrorOnNode(g, label, 82 /* Diagnostics.Duplicate_label_0 */, label.text);
             return;
         }
@@ -1810,7 +1806,7 @@ function checkGrammarCatchClause(g, node) {
             if (blockLocal !== undefined &&
                 blockLocal.valueDeclaration !== undefined &&
                 (blockLocal.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0)
-                grammarErrorOnNode(g, blockLocal.valueDeclaration, 652 /* Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause */, caughtName);
+                grammarErrorOnNode(g, blockLocal.valueDeclaration, 659 /* Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause */, caughtName);
         }
     }
 }
@@ -1822,25 +1818,25 @@ function getContainingFunction(node) {
 }
 export function getContainingFunctionOrClassStaticBlock(node) {
     let current = node.parent;
-    while (current !== undefined && !isFunctionLike(current) && current.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+    while (current !== undefined && !isFunctionLike(current) && current.kind !== 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
         current = current.parent;
     return current;
 }
 // ---- Modules, imports and exports
 function checkGrammarTopLevelElementsForRequiredDeclareModifier(g, file) {
     for (const statement of file.statements.nodes) {
-        if (!isDeclarationNode(statement) && statement.kind !== 244 /* SyntaxKind.VariableStatement */)
+        if (!isDeclarationNode(statement) && statement.kind !== 245 /* SyntaxKind.VariableStatement */)
             continue;
         // Everything but interfaces, type aliases, imports and exports needs `declare` or `export`.
         switch (statement.kind) {
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 273 /* SyntaxKind.ImportDeclaration */:
-            case 346 /* SyntaxKind.JSImportDeclaration */:
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-            case 279 /* SyntaxKind.ExportDeclaration */:
-            case 278 /* SyntaxKind.ExportAssignment */:
-            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
+            case 279 /* SyntaxKind.ExportAssignment */:
+            case 272 /* SyntaxKind.NamespaceExportDeclaration */:
                 continue;
         }
         if (hasSyntacticModifier(statement, 128 /* ModifierFlags.Ambient */ | 32 /* ModifierFlags.Export */ | 2048 /* ModifierFlags.Default */))
@@ -1852,17 +1848,44 @@ function checkGrammarTopLevelElementsForRequiredDeclareModifier(g, file) {
 }
 function checkGrammarModuleElementContext(g, node, message) {
     const parent = node.parent;
-    const isInAppropriateContext = parent.kind === 307 /* SyntaxKind.SourceFile */ ||
-        parent.kind === 269 /* SyntaxKind.ModuleBlock */ ||
-        parent.kind === 268 /* SyntaxKind.ModuleDeclaration */;
+    const isInAppropriateContext = parent.kind === 308 /* SyntaxKind.SourceFile */ ||
+        parent.kind === 270 /* SyntaxKind.ModuleBlock */ ||
+        parent.kind === 269 /* SyntaxKind.ModuleDeclaration */;
     if (!isInAppropriateContext)
         grammarErrorOnFirstToken(g, node, message);
     return !isInAppropriateContext;
 }
+/** An ambient module's import attributes type: property signatures with string literal types, each required,
+ * not readonly, named by an identifier or a string other than `resolution-mode`. */
+function checkGrammarImportAttributesType(g, attributes) {
+    for (const member of attributes.members.nodes) {
+        if (member.kind !== 173 /* SyntaxKind.PropertySignature */)
+            return grammarErrorOnNode(g, member, 465 /* Diagnostics.An_import_attributes_type_may_only_contain_property_signatures */);
+        const property = member;
+        for (const modifier of property.modifiers?.nodes ?? [])
+            if (modifier.kind === 148 /* SyntaxKind.ReadonlyKeyword */)
+                return grammarErrorOnNode(g, modifier, 471 /* Diagnostics.An_import_attributes_property_cannot_have_a_readonly_modifier */);
+        if (property.type === undefined)
+            return grammarErrorOnNode(g, member, 466 /* Diagnostics.An_import_attributes_property_must_have_a_type_annotation */);
+        if (property.postfixToken?.kind === 57 /* SyntaxKind.QuestionToken */)
+            return grammarErrorOnNode(g, member, 469 /* Diagnostics.An_import_attributes_property_cannot_be_optional */);
+        const name = property.name;
+        if (!isStringLiteralLike(name) && name.kind !== 79 /* SyntaxKind.Identifier */)
+            return grammarErrorOnNode(g, name, 467 /* Diagnostics.An_import_attributes_property_must_have_a_string_literal_or_identifier_name */);
+        if (getText(name) === 'resolution-mode')
+            return grammarErrorOnNode(g, name, 470 /* Diagnostics.X_0_is_not_a_valid_key_for_an_import_attributes_type */, getText(name));
+        const type = property.type;
+        if (type.kind !== 203 /* SyntaxKind.LiteralType */ || type.literal.kind !== 10 /* SyntaxKind.StringLiteral */)
+            return grammarErrorOnNode(g, type, 468 /* Diagnostics.An_import_attributes_property_must_have_a_string_literal_type_annotation */);
+    }
+    return false;
+}
 function checkGrammarModuleDeclaration(g, node) {
+    if (node.attributes !== undefined)
+        checkGrammarImportAttributesType(g, node.attributes);
     // The declaration check reports an illegal context and skips the rest.
     const parent = node.parent.kind;
-    if (parent !== 307 /* SyntaxKind.SourceFile */ && parent !== 269 /* SyntaxKind.ModuleBlock */ && parent !== 268 /* SyntaxKind.ModuleDeclaration */)
+    if (parent !== 308 /* SyntaxKind.SourceFile */ && parent !== 270 /* SyntaxKind.ModuleBlock */ && parent !== 269 /* SyntaxKind.ModuleDeclaration */)
         return true;
     if (!checkGrammarModifiers(g, node) &&
         (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
@@ -1881,9 +1904,9 @@ function checkExternalImportOrExportDeclaration(g, node) {
         return false;
     }
     const parent = node.parent;
-    const inAmbientExternalModule = parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
-    if (parent.kind !== 307 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule) {
-        g.c.error(moduleName, node.kind === 279 /* SyntaxKind.ExportDeclaration */
+    const inAmbientExternalModule = parent.kind === 270 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
+    if (parent.kind !== 308 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule) {
+        g.c.error(moduleName, node.kind === 280 /* SyntaxKind.ExportDeclaration */
             ? 150 /* Diagnostics.Export_declarations_are_not_permitted_in_a_namespace */
             : 112 /* Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module */);
         return false;
@@ -1892,34 +1915,38 @@ function checkExternalImportOrExportDeclaration(g, node) {
         isExternalModuleNameRelative(moduleName.text) &&
         !isModuleAugmentationExternal(parent.parent)) {
         // Module augmentations report relative names when checking the augmentation.
-        g.c.error(node, 607 /* Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name */);
+        g.c.error(node, 614 /* Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name */);
         return false;
     }
-    if (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */)
+    if (node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */)
         return true;
     const attributes = getImportAttributes(node);
-    if (attributes === undefined)
-        return true;
+    return attributes === undefined || !checkGrammarImportAttributeValues(g, attributes);
+}
+/** Reports attribute values that are not string literals, and returns whether there are any. */
+function checkGrammarImportAttributeValues(g, node) {
     let hasError = false;
-    for (const attribute of attributes.attributes.nodes) {
+    for (const attribute of node.attributes.nodes) {
         const value = attribute.value;
         if (value.kind !== 10 /* SyntaxKind.StringLiteral */) {
             hasError = true;
-            g.c.error(value, 978 /* Diagnostics.Import_attribute_values_must_be_string_literal_expressions */);
+            g.c.error(value, 985 /* Diagnostics.Import_attribute_values_must_be_string_literal_expressions */);
         }
     }
-    return !hasError;
+    return hasError;
 }
 function getImportAttributes(node) {
-    if (node.kind === 273 /* SyntaxKind.ImportDeclaration */ || node.kind === 346 /* SyntaxKind.JSImportDeclaration */)
+    if (node.kind === 274 /* SyntaxKind.ImportDeclaration */ || node.kind === 347 /* SyntaxKind.JSImportDeclaration */)
+        return node.attributes;
+    if (node.kind === 280 /* SyntaxKind.ExportDeclaration */)
         return node.attributes;
-    if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+    if (node.kind === 207 /* SyntaxKind.ImportType */)
         return node.attributes;
     return undefined;
 }
 function checkGrammarImportDeclaration(g, node) {
     if (checkGrammarModuleElementContext(g, node, isInJSFile(node)
-        ? 388 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module */
+        ? 386 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module */
         : 182 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module */))
         return;
     if (!checkGrammarModifiers(g, node) && node.modifiers !== undefined)
@@ -1934,35 +1961,48 @@ function checkGrammarImportClause(g, node) {
     if (node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */) {
         if ((node.flags & 4194304 /* NodeFlags.JSDoc */) === 0 && node.name !== undefined && namedBindings !== undefined)
             return grammarErrorOnNode(g, node, 297 /* Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both */);
-        if (namedBindings !== undefined && namedBindings.kind === 276 /* SyntaxKind.NamedImports */)
+        if (namedBindings !== undefined && namedBindings.kind === 277 /* SyntaxKind.NamedImports */)
             return checkGrammarTypeOnlyNamedImportsOrExports(g, namedBindings);
     }
     else if (node.phaseModifier === 166 /* SyntaxKind.DeferKeyword */) {
         if (node.name !== undefined)
-            return grammarErrorOnNode(g, node, 1873 /* Diagnostics.Default_imports_are_not_allowed_in_a_deferred_import */);
-        if (namedBindings !== undefined && namedBindings.kind === 276 /* SyntaxKind.NamedImports */)
-            return grammarErrorOnNode(g, node, 1874 /* Diagnostics.Named_imports_are_not_allowed_in_a_deferred_import */);
-        if (g.moduleKind !== ModuleKind.ESNext && g.moduleKind !== ModuleKind.Preserve)
-            return grammarErrorOnNode(g, node, 1875 /* Diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve */);
+            return grammarErrorOnNode(g, node, 1893 /* Diagnostics.Default_imports_are_not_allowed_in_a_deferred_import */);
+        if (namedBindings === undefined)
+            return grammarErrorOnNode(g, node, 1952 /* Diagnostics.A_deferred_import_must_specify_a_namespace_binding */);
+        if (namedBindings.kind === 277 /* SyntaxKind.NamedImports */)
+            return grammarErrorOnNode(g, node, 1894 /* Diagnostics.Named_imports_are_not_allowed_in_a_deferred_import */);
+        if (!supportsDeferredImports(g.moduleKind))
+            return grammarErrorOnNode(g, node, 1895 /* Diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve */);
+    }
+    else if (node.phaseModifier === 167 /* SyntaxKind.SourceKeyword */) {
+        if (namedBindings !== undefined)
+            return grammarErrorOnNode(g, node, 1947 /* Diagnostics.Named_and_namespace_imports_are_not_allowed_in_a_source_phase_import */);
+        if (node.name === undefined)
+            return grammarErrorOnNode(g, node, 1946 /* Diagnostics.A_source_phase_import_must_specify_a_local_binding */);
+        if (!supportsSourcePhaseImports(g.moduleKind))
+            return grammarErrorOnNode(g, node, 1948 /* Diagnostics.Source_phase_imports_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve */);
+        const moduleSpecifier = node.parent.moduleSpecifier;
+        if (getEmitSyntaxForModuleSpecifierExpression(g.c, moduleSpecifier) === ModuleKind.CommonJS)
+            return grammarErrorOnNode(g, node, 1950 /* Diagnostics.Source_phase_imports_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls */);
     }
     return false;
 }
 function checkGrammarTypeOnlyNamedImportsOrExports(g, namedBindings) {
-    const isImport = namedBindings.kind === 276 /* SyntaxKind.NamedImports */;
+    const isImport = namedBindings.kind === 277 /* SyntaxKind.NamedImports */;
     for (const specifier of getElements(namedBindings).nodes)
         if (getIsTypeOnly(specifier))
             return grammarErrorOnFirstToken(g, specifier, isImport
-                ? 471 /* Diagnostics.The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement */
-                : 472 /* Diagnostics.The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement */);
+                ? 478 /* Diagnostics.The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement */
+                : 479 /* Diagnostics.The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement */);
     return false;
 }
 function checkGrammarImportEqualsDeclaration(g, node) {
     if (checkGrammarModuleElementContext(g, node, isInJSFile(node)
-        ? 388 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module */
+        ? 386 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module */
         : 182 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module */))
         return;
     checkGrammarModifiers(g, node);
-    const isExternal = node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */;
+    const isExternal = node.moduleReference.kind === 285 /* SyntaxKind.ExternalModuleReference */;
     if (!isExternal) {
         if (node.isTypeOnly) {
             const symbol = getSymbolOfDeclaration(g.c, node);
@@ -1985,23 +2025,23 @@ function checkGrammarExportDeclaration(g, node) {
     if (!checkGrammarModifiers(g, node) && node.modifiers !== undefined)
         grammarErrorOnFirstToken(g, node, 149 /* Diagnostics.An_export_declaration_cannot_have_modifiers */);
     const clause = node.exportClause;
-    if (node.isTypeOnly && clause !== undefined && clause.kind === 280 /* SyntaxKind.NamedExports */)
+    if (node.isTypeOnly && clause !== undefined && clause.kind === 281 /* SyntaxKind.NamedExports */)
         checkGrammarTypeOnlyNamedImportsOrExports(g, clause);
     const hasModuleSpecifier = node.moduleSpecifier !== undefined;
     if ((!hasModuleSpecifier || checkExternalImportOrExportDeclaration(g, node)) &&
         clause !== undefined &&
-        clause.kind === 280 /* SyntaxKind.NamedExports */) {
+        clause.kind === 281 /* SyntaxKind.NamedExports */) {
         for (const specifier of getElements(clause).nodes) {
             checkGrammarModuleExportName(g, specifier.propertyName, hasModuleSpecifier);
             checkGrammarModuleExportName(g, specifier.name, true);
         }
         const parent = node.parent;
-        const inAmbientExternalModule = parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
+        const inAmbientExternalModule = parent.kind === 270 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
         const inAmbientNamespaceDeclaration = !inAmbientExternalModule &&
-            parent.kind === 269 /* SyntaxKind.ModuleBlock */ &&
+            parent.kind === 270 /* SyntaxKind.ModuleBlock */ &&
             !hasModuleSpecifier &&
             (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
-        if (parent.kind !== 307 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule && !inAmbientNamespaceDeclaration)
+        if (parent.kind !== 308 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule && !inAmbientNamespaceDeclaration)
             g.c.error(node, 150 /* Diagnostics.Export_declarations_are_not_permitted_in_a_namespace */);
     }
     checkGrammarImportAttributes(g, node);
@@ -2012,7 +2052,7 @@ function checkGrammarModuleExportName(g, name, allowStringLiteral) {
     if (!allowStringLiteral)
         grammarErrorOnNode(g, name, 1 /* Diagnostics.Identifier_expected */);
     else if ((g.moduleKind === ModuleKind.ES2015 || g.moduleKind === ModuleKind.ES2020) && !g.file.isDeclarationFile)
-        grammarErrorOnNode(g, name, 1872 /* Diagnostics.String_literal_import_and_export_names_are_not_supported_when_the_module_flag_is_set_to_es2015_or_es2020 */);
+        grammarErrorOnNode(g, name, 1892 /* Diagnostics.String_literal_import_and_export_names_are_not_supported_when_the_module_flag_is_set_to_es2015_or_es2020 */);
 }
 /** Returns whether the export's expression is checked. */
 function checkGrammarExportAssignment(g, node) {
@@ -2022,8 +2062,8 @@ function checkGrammarExportAssignment(g, node) {
         : 207 /* Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration */))
         return false;
     const parent = node.parent;
-    const container = parent.kind === 307 /* SyntaxKind.SourceFile */ ? parent : parent.parent;
-    if (container.kind === 268 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container)) {
+    const container = parent.kind === 308 /* SyntaxKind.SourceFile */ ? parent : parent.parent;
+    if (container.kind === 269 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container)) {
         g.c.error(node, isExportEquals
             ? 48 /* Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace */
             : 255 /* Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module */);
@@ -2033,7 +2073,7 @@ function checkGrammarExportAssignment(g, node) {
         grammarErrorOnFirstToken(g, node, 88 /* Diagnostics.An_export_assignment_cannot_have_modifiers */);
     const isAmbient = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
     if (isAmbient && !isEntityNameExpression(node.expression, false))
-        grammarErrorOnNode(g, node.expression, 846 /* Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context */);
+        grammarErrorOnNode(g, node.expression, 853 /* Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context */);
     if (isExportEquals) {
         const impliedFormat = getImpliedNodeFormatForEmit(g.file.fileName, g.moduleKind, g.metadata);
         // Export assignments aren't supported in ECMAScript modules.
@@ -2069,7 +2109,7 @@ function checkGrammarTypeReference(g, node) {
     const scanner = g.getScanner();
     scanner.resetTokenState(node.typeName.end);
     if (scanner.scan() === 24 /* SyntaxKind.DotToken */)
-        grammarErrorAtPos(g, skipTrivia(g.file.text, node.typeName.end), 1, 1749 /* Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments */);
+        grammarErrorAtPos(g, skipTrivia(g.file.text, node.typeName.end), 1, 1769 /* Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments */);
 }
 function checkGrammarTypeOperatorNode(g, node) {
     const innerType = node.type;
@@ -2077,25 +2117,25 @@ function checkGrammarTypeOperatorNode(g, node) {
         if (innerType.kind !== 155 /* SyntaxKind.SymbolKeyword */)
             return grammarErrorOnNode(g, innerType, 2 /* Diagnostics.X_0_expected */, tokenToString(155 /* SyntaxKind.SymbolKeyword */));
         let parent = node.parent;
-        while (parent.kind === 197 /* SyntaxKind.ParenthesizedType */)
+        while (parent.kind === 198 /* SyntaxKind.ParenthesizedType */)
             parent = parent.parent;
         switch (parent.kind) {
-            case 261 /* SyntaxKind.VariableDeclaration */: {
+            case 262 /* SyntaxKind.VariableDeclaration */: {
                 const declaration = parent;
                 if (declaration.name.kind !== 79 /* SyntaxKind.Identifier */)
                     return grammarErrorOnNode(g, node, 269 /* Diagnostics.X_unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name */);
-                if (!(declaration.parent.kind === 262 /* SyntaxKind.VariableDeclarationList */ &&
-                    declaration.parent.parent.kind === 244 /* SyntaxKind.VariableStatement */))
+                if (!(declaration.parent.kind === 263 /* SyntaxKind.VariableDeclarationList */ &&
+                    declaration.parent.parent.kind === 245 /* SyntaxKind.VariableStatement */))
                     return grammarErrorOnNode(g, node, 270 /* Diagnostics.X_unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement */);
                 if ((declaration.parent.flags & 2 /* NodeFlags.Const */) === 0)
                     return grammarErrorOnNode(g, declaration.name, 268 /* Diagnostics.A_variable_whose_type_is_a_unique_symbol_type_must_be_const */);
                 return false;
             }
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (!isStatic(parent) || !hasSyntacticModifier(parent, 8 /* ModifierFlags.Readonly */))
                     return grammarErrorOnNode(g, getName(parent), 267 /* Diagnostics.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly */);
                 return false;
-            case 172 /* SyntaxKind.PropertySignature */:
+            case 173 /* SyntaxKind.PropertySignature */:
                 if (!hasSyntacticModifier(parent, 8 /* ModifierFlags.Readonly */))
                     return grammarErrorOnNode(g, getName(parent), 266 /* Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly */);
                 return false;
@@ -2103,8 +2143,8 @@ function checkGrammarTypeOperatorNode(g, node) {
         return grammarErrorOnNode(g, node, 271 /* Diagnostics.X_unique_symbol_types_are_not_allowed_here */);
     }
     if (node.operator === 148 /* SyntaxKind.ReadonlyKeyword */ &&
-        innerType.kind !== 189 /* SyntaxKind.ArrayType */ &&
-        innerType.kind !== 190 /* SyntaxKind.TupleType */)
+        innerType.kind !== 190 /* SyntaxKind.ArrayType */ &&
+        innerType.kind !== 191 /* SyntaxKind.TupleType */)
         return grammarErrorOnFirstToken(g, node, 288 /* Diagnostics.X_readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types */, tokenToString(155 /* SyntaxKind.SymbolKeyword */));
     return false;
 }
@@ -2112,7 +2152,7 @@ function checkGrammarInferType(g, node) {
     for (let current = node; current !== undefined; current = current.parent) {
         const parent = current.parent;
         if (parent !== undefined &&
-            parent.kind === 195 /* SyntaxKind.ConditionalType */ &&
+            parent.kind === 196 /* SyntaxKind.ConditionalType */ &&
             parent.extendsType === current)
             return;
     }
@@ -2153,47 +2193,35 @@ function checkGrammarTupleType(g, node) {
 }
 function checkGrammarNamedTupleMember(g, node) {
     if (node.dotDotDotToken !== undefined && node.questionToken !== undefined)
-        grammarErrorOnNode(g, node, 1159 /* Diagnostics.A_tuple_member_cannot_be_both_optional_and_rest */);
-    if (node.type.kind === 191 /* SyntaxKind.OptionalType */)
-        grammarErrorOnNode(g, node.type, 1160 /* Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type */);
-    if (node.type.kind === 192 /* SyntaxKind.RestType */)
-        grammarErrorOnNode(g, node.type, 1161 /* Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type */);
+        grammarErrorOnNode(g, node, 1166 /* Diagnostics.A_tuple_member_cannot_be_both_optional_and_rest */);
+    if (node.type.kind === 192 /* SyntaxKind.OptionalType */)
+        grammarErrorOnNode(g, node.type, 1167 /* Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type */);
+    if (node.type.kind === 193 /* SyntaxKind.RestType */)
+        grammarErrorOnNode(g, node.type, 1168 /* Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type */);
 }
 /** JSDoc-only type syntax in TypeScript code. */
 function checkGrammarJSDocTypeInTypeScript(g, node) {
     if ((node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0)
         return;
-    if (node.kind !== 312 /* SyntaxKind.JSDocNonNullableType */ && node.kind !== 311 /* SyntaxKind.JSDocNullableType */) {
-        grammarErrorOnNode(g, node, 1749 /* Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments */);
+    if (node.kind !== 313 /* SyntaxKind.JSDocNonNullableType */ && node.kind !== 312 /* SyntaxKind.JSDocNullableType */) {
+        grammarErrorOnNode(g, node, 1769 /* Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments */);
         return;
     }
-    const isNullable = node.kind === 311 /* SyntaxKind.JSDocNullableType */;
+    const isNullable = node.kind === 312 /* SyntaxKind.JSDocNullableType */;
     const typeNode = getType(node);
     const postfix = node.pos === typeNode.pos;
     let t = getTypeFromTypeNode(g.c, typeNode);
     if (isNullable && t !== g.c.neverType && t !== g.c.voidType)
         t = getNullableType(g.c, t, postfix ? 4 /* TypeFlags.Undefined */ : 12 /* TypeFlags.Nullable */);
     grammarErrorOnNode(g, node, postfix
-        ? 1822 /* Diagnostics.X_0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 */
-        : 1823 /* Diagnostics.X_0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 */, isNullable ? '?' : '!', typeToString(g.c, t));
+        ? 1842 /* Diagnostics.X_0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 */
+        : 1843 /* Diagnostics.X_0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 */, isNullable ? '?' : '!', typeToString(g.c, t));
 }
-/** The `resolution-mode` of import type attributes, as tsgo's `getResolutionModeOverride`. */
+/** The `resolution-mode` of import type attributes, as tsgo's `GetResolutionModeOverride`. */
 function getResolutionModeOverride(g, node, reportErrors) {
-    const attributes = node.attributes.nodes;
-    if (attributes.length !== 1) {
-        if (reportErrors)
-            grammarErrorOnNode(g, node, 384 /* Diagnostics.Type_import_attributes_should_have_exactly_one_key_resolution_mode_with_value_import_or_require */);
+    const attribute = resolutionModeAttribute(node);
+    if (attribute === undefined)
         return ModuleKind.None;
-    }
-    const attribute = attributes[0];
-    const name = attribute.name;
-    if (name === undefined || !isStringLiteralLike(name))
-        return ModuleKind.None;
-    if (getText(name) !== 'resolution-mode') {
-        if (reportErrors)
-            grammarErrorOnNode(g, name, 383 /* Diagnostics.X_resolution_mode_is_the_only_valid_key_for_type_import_attributes */);
-        return ModuleKind.None;
-    }
     const value = attribute.value;
     if (!isStringLiteralLike(value))
         return ModuleKind.None;
@@ -2211,36 +2239,32 @@ function checkGrammarImportAttributes(g, declaration) {
     const node = getImportAttributes(declaration);
     if (node === undefined)
         return;
-    const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(declaration);
+    const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(declaration) || declaration.kind === 207 /* SyntaxKind.ImportType */;
     const override = getResolutionModeOverride(g, node, isTypeOnly);
-    // Other checks don't apply to type-only imports with a resolution mode.
-    if (isTypeOnly && override !== ModuleKind.None)
+    // Other checks don't apply to type-only imports and import types.
+    if (isTypeOnly)
         return;
     const moduleKind = g.moduleKind;
     if (!((moduleKind >= ModuleKind.Node18 && moduleKind <= ModuleKind.NodeNext) ||
         moduleKind === ModuleKind.Preserve ||
         moduleKind === ModuleKind.ESNext)) {
-        grammarErrorOnNode(g, node, 954 /* Diagnostics.Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext_or_preserve */);
+        grammarErrorOnNode(g, node, 961 /* Diagnostics.Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext_or_preserve */);
         return;
     }
     const moduleSpecifier = getExternalModuleName(declaration);
     if (moduleSpecifier !== undefined &&
         isStringLiteralLike(moduleSpecifier) &&
         getEmitSyntaxOfImportOrExport(g) === ModuleKind.CommonJS) {
-        grammarErrorOnNode(g, node, 976 /* Diagnostics.Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls */);
-        return;
-    }
-    if (isTypeOnly) {
-        grammarErrorOnNode(g, node, 977 /* Diagnostics.Import_attributes_cannot_be_used_with_type_only_imports_or_exports */);
+        grammarErrorOnNode(g, node, 983 /* Diagnostics.Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls */);
         return;
     }
     if (override !== ModuleKind.None)
         grammarErrorOnNode(g, node, 375 /* Diagnostics.X_resolution_mode_can_only_be_set_for_type_only_imports */);
 }
 function isExclusivelyTypeOnlyImportOrExport(node) {
-    if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+    if (node.kind === 280 /* SyntaxKind.ExportDeclaration */)
         return node.isTypeOnly;
-    if (node.kind !== 273 /* SyntaxKind.ImportDeclaration */ && node.kind !== 346 /* SyntaxKind.JSImportDeclaration */)
+    if (node.kind !== 274 /* SyntaxKind.ImportDeclaration */ && node.kind !== 347 /* SyntaxKind.JSImportDeclaration */)
         return false;
     const clause = node.importClause;
     return clause !== undefined && clause.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
@@ -2255,22 +2279,23 @@ function getEmitSyntaxOfImportOrExport(g) {
     return ModuleKind.None;
 }
 function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
-    const seen = new Map();
+    // An object literal with one property can't repeat a name, so it needs no table of names.
+    const seen = node.properties.nodes.length > 1 ? new Map() : undefined;
     for (const property of node.properties.nodes) {
-        if (property.kind === 305 /* SyntaxKind.SpreadAssignment */) {
+        if (property.kind === 306 /* SyntaxKind.SpreadAssignment */) {
             if (inDestructuring) {
                 // A rest property can't be destructured further.
                 const expression = skipParentheses(getExpression(property));
-                if (expression.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ ||
-                    expression.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
-                    return grammarErrorOnNode(g, getExpression(property), 661 /* Diagnostics.A_rest_element_cannot_contain_a_binding_pattern */);
+                if (expression.kind === 211 /* SyntaxKind.ArrayLiteralExpression */ ||
+                    expression.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
+                    return grammarErrorOnNode(g, getExpression(property), 668 /* Diagnostics.A_rest_element_cannot_contain_a_binding_pattern */);
             }
             continue;
         }
         const name = getName(property);
-        if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
             checkGrammarComputedPropertyName(g, name);
-        if (property.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ && !inDestructuring) {
+        if (property.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */ && !inDestructuring) {
             // An initializer is only valid in a destructuring pattern; report on the `=`.
             const shorthand = property;
             const equalsToken = shorthand.equalsToken;
@@ -2278,32 +2303,32 @@ function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
                 grammarErrorOnFirstToken(g, equalsToken !== undefined ? equalsToken : shorthand.name, 248 /* Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern */);
         }
         if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
-            grammarErrorOnNode(g, name, 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+            grammarErrorOnNode(g, name, 1858 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
         // Only `async` is allowed, and only on methods.
         const modifiers = getModifiers(property);
         if (modifiers !== undefined)
             for (const modifier of modifiers.nodes)
                 if (isModifierKind(modifier.kind) &&
-                    (modifier.kind !== 133 /* SyntaxKind.AsyncKeyword */ || property.kind !== 175 /* SyntaxKind.MethodDeclaration */))
+                    (modifier.kind !== 133 /* SyntaxKind.AsyncKeyword */ || property.kind !== 176 /* SyntaxKind.MethodDeclaration */))
                     grammarErrorOnNode(g, modifier, 31 /* Diagnostics.X_0_modifier_cannot_be_used_here */, getTextOfNodeFromSourceText(g.file.text, modifier));
         // Duplicate data properties are errors in strict mode only, but accessors and data
         // properties never mix, and get/set accessors can't repeat (ECMA-262 11.1.5).
         let currentKind;
         switch (property.kind) {
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-            case 303 /* SyntaxKind.PropertyAssignment */: {
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */: {
                 const postfixToken = getPostfixToken(property);
                 checkGrammarForInvalidExclamationToken(g, postfixToken, 205 /* Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context */);
                 checkGrammarForInvalidQuestionMark(g, postfixToken, 119 /* Diagnostics.An_object_member_cannot_be_declared_optional */);
                 if (name.kind === 9 /* SyntaxKind.BigIntLiteral */)
-                    g.c.addDiagnostic(createDiagnosticForNode(name, 454 /* Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name */, []));
+                    g.c.addDiagnostic(createDiagnosticForNode(name, 452 /* Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name */, []));
                 currentKind = 4 /* DeclarationMeaning.PropertyAssignment */;
                 break;
             }
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 currentKind = 8 /* DeclarationMeaning.Method */;
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 currentKind = 1 /* DeclarationMeaning.GetAccessor */;
                 break;
             default:
@@ -2313,7 +2338,7 @@ function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
         if (inDestructuring)
             continue;
         const effectiveName = getEffectivePropertyNameForPropertyNameNode(g.c, name);
-        if (effectiveName === undefined)
+        if (effectiveName === undefined || seen === undefined)
             continue;
         const existingKind = seen.get(effectiveName);
         if (existingKind === undefined) {
@@ -2321,7 +2346,7 @@ function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
             continue;
         }
         if ((currentKind & 8 /* DeclarationMeaning.Method */) !== 0 && (existingKind & 8 /* DeclarationMeaning.Method */) !== 0)
-            grammarErrorOnNode(g, name, 478 /* Diagnostics.Duplicate_identifier_0 */, getTextOfNodeFromSourceText(g.file.text, name));
+            grammarErrorOnNode(g, name, 485 /* Diagnostics.Duplicate_identifier_0 */, getTextOfNodeFromSourceText(g.file.text, name));
         else if ((currentKind & 4 /* DeclarationMeaning.PropertyAssignment */) !== 0 &&
             (existingKind & 4 /* DeclarationMeaning.PropertyAssignment */) !== 0)
             grammarErrorOnNode(g, name, 85 /* Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name */, getTextOfNodeFromSourceText(g.file.text, name));
@@ -2348,14 +2373,14 @@ function getEffectivePropertyNameForPropertyNameNode(c, name) {
         case 8 /* SyntaxKind.NumericLiteral */:
         case 9 /* SyntaxKind.BigIntLiteral */:
             return getText(name);
-        case 168 /* SyntaxKind.ComputedPropertyName */: {
+        case 169 /* SyntaxKind.ComputedPropertyName */: {
             const expression = name.expression;
             switch (expression.kind) {
                 case 10 /* SyntaxKind.StringLiteral */:
                 case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
                 case 8 /* SyntaxKind.NumericLiteral */:
                     return getText(expression);
-                case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+                case 226 /* SyntaxKind.PrefixUnaryExpression */: {
                     const unary = expression;
                     if (unary.operand.kind === 8 /* SyntaxKind.NumericLiteral */ &&
                         (unary.operator === 40 /* SyntaxKind.MinusToken */ || unary.operator === 39 /* SyntaxKind.PlusToken */))
@@ -2373,11 +2398,7 @@ function getEffectivePropertyNameForPropertyNameNode(c, name) {
 }
 function checkGrammarCallExpression(g, node) {
     const callee = node.expression;
-    const isImportCall = callee.kind === 101 /* SyntaxKind.ImportKeyword */ ||
-        (callee.kind === 237 /* SyntaxKind.MetaProperty */ &&
-            callee.keywordToken === 101 /* SyntaxKind.ImportKeyword */ &&
-            callee.name.text === 'defer');
-    if (isImportCall)
+    if (callee.kind === 101 /* SyntaxKind.ImportKeyword */ || isImportPhaseMetaProperty(callee))
         checkGrammarImportCallExpression(g, node);
     else
         checkGrammarTypeArguments(g, callTypeArguments(node));
@@ -2388,12 +2409,19 @@ function checkGrammarImportCallExpression(g, node) {
         return grammarErrorOnNode(g, node, fileExtensionIsOneOf(g.file.fileName, ['.cts', '.cjs'])
             ? 235 /* Diagnostics.ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax */
             : 244 /* Diagnostics.ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax_Adjust_the_type_field_in_the_nearest_package_json_to_make_this_file_an_ECMAScript_module_or_adjust_your_verbatimModuleSyntax_module_and_moduleResolution_settings_in_TypeScript */);
-    if (node.expression.kind === 237 /* SyntaxKind.MetaProperty */) {
-        if (moduleKind !== ModuleKind.ESNext && moduleKind !== ModuleKind.Preserve)
-            return grammarErrorOnNode(g, node, 1875 /* Diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve */);
+    if (isImportSourceMetaProperty(node.expression)) {
+        if (!supportsSourcePhaseImports(moduleKind))
+            return grammarErrorOnNode(g, node, 1948 /* Diagnostics.Source_phase_imports_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve */);
+    }
+    else if (isImportDeferMetaProperty(node.expression)) {
+        if (!supportsDeferredImports(moduleKind))
+            return grammarErrorOnNode(g, node, 1895 /* Diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve */);
     }
     else if (moduleKind === ModuleKind.ES2015)
         return grammarErrorOnNode(g, node, 259 /* Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_node20_or_nodenext */);
+    const questionDotToken = callQuestionDotToken(node);
+    if (questionDotToken !== undefined && isSourcePhaseImportCall(node))
+        return grammarErrorOnNode(g, questionDotToken, 1949 /* Diagnostics.Optional_chaining_cannot_be_used_with_import_source */);
     if (callTypeArguments(node) !== undefined)
         return grammarErrorOnNode(g, node, 262 /* Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments */);
     const args = node.arguments;
@@ -2410,7 +2438,7 @@ function checkGrammarImportCallExpression(g, node) {
         return grammarErrorOnNode(g, node, 372 /* Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_set_of_attributes_as_arguments */);
     // Arguments are parsed like array elements, which allows spreads.
     for (const argument of argumentNodes)
-        if (argument.kind === 231 /* SyntaxKind.SpreadElement */)
+        if (argument.kind === 232 /* SyntaxKind.SpreadElement */)
             return grammarErrorOnNode(g, argument, 261 /* Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element */);
     return false;
 }
@@ -2424,32 +2452,32 @@ function checkGrammarMetaProperty(g, node) {
     const nameText = name.text;
     if (node.keywordToken === 104 /* SyntaxKind.NewKeyword */) {
         if (nameText !== 'target')
-            return grammarErrorOnNode(g, name, 1815 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2 */, nameText, tokenToString(node.keywordToken), 'target');
+            return grammarErrorOnNode(g, name, 1835 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2 */, nameText, tokenToString(node.keywordToken), 'target');
     }
     else if (node.keywordToken === 101 /* SyntaxKind.ImportKeyword */ && nameText !== 'meta') {
         const parent = node.parent;
-        const isCallee = parent.kind === 214 /* SyntaxKind.CallExpression */ && parent.expression === node;
-        if (nameText === 'defer') {
+        const isCallee = parent.kind === 215 /* SyntaxKind.CallExpression */ && parent.expression === node;
+        if (isImportPhaseMetaProperty(node)) {
             if (!isCallee)
                 return grammarErrorAtPos(g, node.end, 0, 2 /* Diagnostics.X_0_expected */, '(');
         }
         else {
             if (isCallee)
-                return grammarErrorOnNode(g, name, 1876 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_or_defer */, nameText);
-            return grammarErrorOnNode(g, name, 1815 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2 */, nameText, tokenToString(node.keywordToken), 'meta');
+                return grammarErrorOnNode(g, name, 1896 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_defer_or_source */, nameText);
+            return grammarErrorOnNode(g, name, 1835 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2 */, nameText, tokenToString(node.keywordToken), 'meta');
         }
     }
     return false;
 }
 function checkGrammarAwaitOrAwaitUsing(g, node) {
-    const isAwaitExpression = node.kind === 224 /* SyntaxKind.AwaitExpression */;
+    const isAwaitExpression = node.kind === 225 /* SyntaxKind.AwaitExpression */;
     let hasError = false;
     const container = getContainingFunctionOrClassStaticBlock(node);
-    if (container !== undefined && container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */) {
+    if (container !== undefined && container.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */) {
         // Reported even with parse errors.
         g.c.error(node, isAwaitExpression
-            ? 1854 /* Diagnostics.X_await_expression_cannot_be_used_inside_a_class_static_block */
-            : 1869 /* Diagnostics.X_await_using_statements_cannot_be_used_inside_a_class_static_block */);
+            ? 1874 /* Diagnostics.X_await_expression_cannot_be_used_inside_a_class_static_block */
+            : 1889 /* Diagnostics.X_await_using_statements_cannot_be_used_inside_a_class_static_block */);
         hasError = true;
     }
     else if ((node.flags & 8192 /* NodeFlags.AwaitContext */) === 0) {
@@ -2458,7 +2486,7 @@ function checkGrammarAwaitOrAwaitUsing(g, node) {
                 if (!isEffectiveExternalModule(g)) {
                     g.c.addDiagnostic(diagnosticAtFirstToken(g, node, isAwaitExpression
                         ? 304 /* Diagnostics.X_await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module */
-                        : 973 /* Diagnostics.X_await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module */));
+                        : 980 /* Diagnostics.X_await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module */));
                     hasError = true;
                 }
                 const support = checkTopLevelAwaitModule(g);
@@ -2469,7 +2497,7 @@ function checkGrammarAwaitOrAwaitUsing(g, node) {
                 else if (support === 2 /* TopLevelAwaitSupport.Unsupported */) {
                     g.c.addDiagnostic(diagnosticAtFirstToken(g, node, isAwaitExpression
                         ? 307 /* Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher */
-                        : 974 /* Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher */));
+                        : 981 /* Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher */));
                     hasError = true;
                 }
             }
@@ -2478,9 +2506,9 @@ function checkGrammarAwaitOrAwaitUsing(g, node) {
             // `await` in a function that isn't async.
             const diagnostic = diagnosticAtFirstToken(g, node, isAwaitExpression
                 ? 246 /* Diagnostics.X_await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */
-                : 972 /* Diagnostics.X_await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */);
+                : 979 /* Diagnostics.X_await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */);
             if (container !== undefined &&
-                container.kind !== 177 /* SyntaxKind.Constructor */ &&
+                container.kind !== 178 /* SyntaxKind.Constructor */ &&
                 !hasSyntacticModifier(container, 1024 /* ModifierFlags.Async */))
                 addRelated(diagnostic, container, 290 /* Diagnostics.Did_you_mean_to_mark_this_function_as_async */);
             g.c.addDiagnostic(diagnostic);
@@ -2489,7 +2517,7 @@ function checkGrammarAwaitOrAwaitUsing(g, node) {
     }
     if (isAwaitExpression && isInParameterInitializerBeforeContainingFunction(node)) {
         // Reported even with parse errors.
-        g.c.error(node, 683 /* Diagnostics.X_await_expressions_cannot_be_used_in_a_parameter_initializer */);
+        g.c.error(node, 690 /* Diagnostics.X_await_expressions_cannot_be_used_in_a_parameter_initializer */);
         hasError = true;
     }
     return hasError;
@@ -2501,19 +2529,19 @@ function checkGrammarYieldExpression(g, node) {
         hasError = true;
     }
     if (isInParameterInitializerBeforeContainingFunction(node)) {
-        g.c.error(node, 682 /* Diagnostics.X_yield_expressions_cannot_be_used_in_a_parameter_initializer */);
+        g.c.error(node, 689 /* Diagnostics.X_yield_expressions_cannot_be_used_in_a_parameter_initializer */);
         hasError = true;
     }
     return hasError;
 }
-function isInParameterInitializerBeforeContainingFunction(node) {
+export function isInParameterInitializerBeforeContainingFunction(node) {
     let inBindingInitializer = false;
     let current = node;
     while (current.parent !== undefined && !isFunctionLike(current.parent)) {
         const parent = current.parent;
-        if (parent.kind === 170 /* SyntaxKind.Parameter */ && (inBindingInitializer || getInitializer(parent) === current))
+        if (parent.kind === 171 /* SyntaxKind.Parameter */ && (inBindingInitializer || getInitializer(parent) === current))
             return true;
-        if (parent.kind === 209 /* SyntaxKind.BindingElement */ && getInitializer(parent) === current)
+        if (parent.kind === 210 /* SyntaxKind.BindingElement */ && getInitializer(parent) === current)
             inBindingInitializer = true;
         current = parent;
     }
@@ -2522,15 +2550,19 @@ function isInParameterInitializerBeforeContainingFunction(node) {
 /** A private name in an expression, which is only valid as `#x in obj`. */
 function checkGrammarPrivateIdentifierExpression(g, node) {
     const parent = node.parent;
-    // Names of members and property accesses aren't expressions.
-    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || getName(parent) === node)
+    // Names of members, property accesses, qualified names (`typeof this.#x`) and destructured properties aren't
+    // expressions.
+    if (parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */ ||
+        parent.kind === 168 /* SyntaxKind.QualifiedName */ ||
+        getName(parent) === node ||
+        (parent.kind === 210 /* SyntaxKind.BindingElement */ && parent.propertyName === node))
         return false;
-    const isForIn = parent.kind === 250 /* SyntaxKind.ForInStatement */;
+    const isForIn = parent.kind === 251 /* SyntaxKind.ForInStatement */;
     if (getContainingClass(node) === undefined)
-        return grammarErrorOnNode(g, node, 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+        return grammarErrorOnNode(g, node, 1858 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
     if (isForIn)
         return false;
-    const isLeftOfIn = parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    const isLeftOfIn = parent.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         parent.left === node &&
         parent.operatorToken.kind === 102 /* SyntaxKind.InKeyword */;
     if (!isLeftOfIn)
@@ -2542,13 +2574,13 @@ function checkGrammarBigIntLiteral(g, node) {
     // Like tsgo, only BigInt literals checked as expressions are reported, not property or member names.
     if (getName(parent) === node)
         return false;
-    const isLiteralType = parent.kind === 202 /* SyntaxKind.LiteralType */ ||
-        (parent.kind === 225 /* SyntaxKind.PrefixUnaryExpression */ && parent.parent.kind === 202 /* SyntaxKind.LiteralType */);
+    const isLiteralType = parent.kind === 203 /* SyntaxKind.LiteralType */ ||
+        (parent.kind === 226 /* SyntaxKind.PrefixUnaryExpression */ && parent.parent.kind === 203 /* SyntaxKind.LiteralType */);
     // BigInt literals are fine in types and ambient contexts.
     return (!isLiteralType &&
         (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
         g.c.languageVersion < ScriptTarget.ES2020 &&
-        grammarErrorOnNode(g, node, 869 /* Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020 */));
+        grammarErrorOnNode(g, node, 876 /* Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020 */));
 }
 /** Reports the errors of rescanning a regular expression; spelling suggestions become related information. */
 class RegularExpressionErrorReporter extends ScannerErrorReporter {