tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/parser.js

@@ -1,4 +1,4 @@
-// The TypeScript/JavaScript/JSX/JSON parser, a port of TypeScript 7.0.2's (tsgo) parser with its
+// The TypeScript/JavaScript/JSX/JSON parser, a port of TypeScript 7.1's (tsgo) parser with its
 // error recovery, parse diagnostics and JavaScript-specific reparsing.
 //
 // ```ts
@@ -6,7 +6,7 @@
 // for (const statement of file.statements.nodes) console.log(statement.kind);
 // ```
 import { appendToList, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntLiteral, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, CheckJsDirective, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, emptyCommentDirectives, emptyDiagnostics, emptyFileReferences, emptyNodes, emptyPragmas, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleIndicatorOptions, ExternalModuleReference, FileReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocAllType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, KeywordExpression, KeywordTypeNode, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, MissingNodeList, ModifierList, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NoSubstitutionTemplateLiteral, NodeList, NodeVisitor, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PostfixUnaryExpression, Pragma, PragmaArgument, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReferenceIdentifier, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisTypeNode, ThrowStatement, Token, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, getBody, getIsTypeOnly, getModifiers, getName, getPostfixToken, getQuestionToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, newCallExpression, newPropertyAssignment, } from './ast.js';
-import { canHaveDecorators, canHaveIllegalDecorators, compareNodePositions, getBinaryOperatorPrecedence, getExternalModuleName, getImportTypeNodeLiteral, getTextOfNodeFromSourceText, isAmbientModule, isAnyImportOrReExport, isAssignmentOperator, isClassMemberModifier, isFunctionLike, isImportCall, isImportMeta, isInJSFile, isKeyword, isKeywordOrPunctuation, isLeftHandSideExpression, isModifierKind, isRequireCall, isReservedWord, isStringLiteralLike, modifierToFlag, modifiersToFlags, nodeIsMissing, nodeIsPresent, tagNamesAreEquivalent, tokenIsIdentifierOrKeyword, tokenIsIdentifierOrKeywordOrGreaterThan, } from './ast-utilities.js';
+import { canHaveDecorators, canHaveIllegalDecorators, compareNodePositions, getBinaryOperatorPrecedence, getExternalModuleName, getImportTypeNodeLiteral, getTextOfNodeFromSourceText, isAmbientModule, isAnyImportOrReExport, isAssignmentOperator, isClassMemberModifier, isFunctionLike, isImportCall, isImportMeta, isImportPhaseMetaProperty, isInJSFile, isKeyword, isKeywordOrPunctuation, isLeftHandSideExpression, isModifierKind, isRequireCall, isReservedWord, isStringLiteralLike, modifierToFlag, modifiersToFlags, nodeIsMissing, nodeIsPresent, tagNamesAreEquivalent, tokenIsIdentifierOrKeyword, tokenIsIdentifierOrKeywordOrGreaterThan, } from './ast-utilities.js';
 import { isLineBreak } from './character-codes.js';
 import { Diagnostic, messageCode } from './diagnostics.js';
 import { JSDocParser } from './jsdoc.js';
@@ -15,6 +15,11 @@ import { isDeclarationFileName, isExternalModuleNameRelative } from './path.js';
 import { Scanner, ScannerErrorReporter, ScannerState, getLeadingCommentRanges, getViableKeywordSuggestions, skipTrivia, tokenToString, } from './scanner.js';
 import { getSpellingSuggestion } from './spelling.js';
 const noArgs = [];
+/** Whether `operator` binds before an operator of `currentPrecedence`: at equal precedence, only the right-associative `**`. */
+function shouldConsumeBinaryOperator(operator, operatorPrecedence, currentPrecedence) {
+    return (operatorPrecedence > currentPrecedence ||
+        (operatorPrecedence === currentPrecedence && operator === 42 /* SyntaxKind.AsteriskAsteriskToken */));
+}
 /** Parser state saved by `mark` for speculative parsing. */
 export class ParserState extends ScannerState {
     contextFlags;
@@ -80,7 +85,7 @@ export function parseSourceFile(fileName, text, options) {
 export function parseIsolatedEntityName(text) {
     const p = new Parser('/', '/', text, 1 /* ScriptKind.JS */, new ExternalModuleIndicatorOptions(false, false));
     p.nextToken();
-    const entityName = p.parseEntityName(true, undefined);
+    const entityName = p.parseEntityName(true, false, undefined);
     return p.token() === 1 /* SyntaxKind.EndOfFile */ && p.diagnostics.length === 0 ? entityName : undefined;
 }
 export function getScriptKindFromFileName(fileName) {
@@ -570,40 +575,44 @@ export class Parser extends ScannerErrorReporter {
             case 7 /* ListElement.ClassElement */:
                 return this.parseClassElement();
             case 8 /* ListElement.HeritageClause */:
-                return this.parseHeritageClause();
-            case 9 /* ListElement.ExpressionWithTypeArguments */:
+                return this.parseHeritageClause(false);
+            case 9 /* ListElement.InterfaceHeritageClause */:
+                return this.parseHeritageClause(true);
+            case 10 /* ListElement.ExpressionWithTypeArguments */:
                 return this.parseExpressionWithTypeArguments();
-            case 10 /* ListElement.EnumMember */:
+            case 11 /* ListElement.TypeHeritageClauseElement */:
+                return this.parseTypeHeritageClauseElement();
+            case 12 /* ListElement.EnumMember */:
                 return this.parseEnumMember();
-            case 11 /* ListElement.ImportSpecifier */:
+            case 13 /* ListElement.ImportSpecifier */:
                 return this.parseImportSpecifier();
-            case 12 /* ListElement.ExportSpecifier */:
+            case 14 /* ListElement.ExportSpecifier */:
                 return this.parseExportSpecifier();
-            case 13 /* ListElement.Type */:
+            case 15 /* ListElement.Type */:
                 return this.parseType();
-            case 14 /* ListElement.ImportAttribute */:
+            case 16 /* ListElement.ImportAttribute */:
                 return this.parseImportAttribute();
-            case 15 /* ListElement.TypeMember */:
+            case 17 /* ListElement.TypeMember */:
                 return this.parseTypeMember();
-            case 16 /* ListElement.TypeParameter */:
+            case 18 /* ListElement.TypeParameter */:
                 return this.parseTypeParameter();
-            case 17 /* ListElement.Parameter */:
+            case 19 /* ListElement.Parameter */:
                 return this.parseParameter();
-            case 18 /* ListElement.SignatureParameter */: {
+            case 20 /* ListElement.SignatureParameter */: {
                 const parameter = this.parseParameterEx(this.signatureParameterInAwaitContext, this.signatureParameterAllowAmbiguity);
                 if (parameter !== this.noElement && (this.signatureParameterFlags & 4 /* ParseFlags.Type */) === 0)
                     this.checkJSSyntax(parameter);
                 return parameter;
             }
-            case 19 /* ListElement.TupleElement */:
+            case 21 /* ListElement.TupleElement */:
                 return this.parseTupleElementNameOrTupleElementType();
-            case 20 /* ListElement.JsxAttribute */:
+            case 22 /* ListElement.JsxAttribute */:
                 return this.parseJsxAttribute();
-            case 21 /* ListElement.ArgumentExpression */:
+            case 23 /* ListElement.ArgumentExpression */:
                 return this.parseArgumentExpression();
-            case 22 /* ListElement.ArrayLiteralElement */:
+            case 24 /* ListElement.ArrayLiteralElement */:
                 return this.parseArgumentOrArrayLiteralElement();
-            case 23 /* ListElement.ObjectLiteralElement */:
+            case 25 /* ListElement.ObjectLiteralElement */:
                 return this.parseObjectLiteralElement();
         }
     }
@@ -623,7 +632,7 @@ export class Parser extends ScannerErrorReporter {
                 if (reparseList.length !== 0) {
                     for (const e of reparseList) {
                         // Propagate @typedef aliases and @import declarations to a context that permits them.
-                        if ((e.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */ || e.kind === 346 /* SyntaxKind.JSImportDeclaration */) &&
+                        if ((e.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */ || e.kind === 347 /* SyntaxKind.JSImportDeclaration */) &&
                             kind !== 0 /* ParsingContext.SourceElements */ &&
                             kind !== 1 /* ParsingContext.BlockStatements */)
                             outerReparseList.push(e);
@@ -831,7 +840,7 @@ export class Parser extends ScannerErrorReporter {
                 this.parseErrorAtCurrentToken(1 /* Diagnostics.Identifier_expected */);
                 break;
             case 24 /* ParsingContext.ImportAttributes */:
-                this.parseErrorAtCurrentToken(393 /* Diagnostics.Identifier_or_string_literal_expected */);
+                this.parseErrorAtCurrentToken(391 /* Diagnostics.Identifier_or_string_literal_expected */);
                 break;
             default:
                 throw new Error('Unhandled case in parsingContextErrors');
@@ -1217,7 +1226,7 @@ export class Parser extends ScannerErrorReporter {
             this.finishNode(result, pos);
             this.withJSDoc(result, jsdoc);
             if (this.token() === 63 /* SyntaxKind.EqualsToken */) {
-                this.parseErrorAtCurrentToken(940 /* Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_whole_assignment_in_parentheses */);
+                this.parseErrorAtCurrentToken(947 /* Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_whole_assignment_in_parentheses */);
                 this.nextToken();
             }
             return result;
@@ -1309,12 +1318,12 @@ export class Parser extends ScannerErrorReporter {
             const expression = this.parseAssignmentExpressionOrHigher();
             this.contextFlags = saveContextFlags;
             this.parseExpected(21 /* SyntaxKind.CloseParenToken */);
-            result = new ForInOrOfStatement(251 /* SyntaxKind.ForOfStatement */, awaitToken, initializer, expression, this.parseStatement());
+            result = new ForInOrOfStatement(252 /* SyntaxKind.ForOfStatement */, awaitToken, initializer, expression, this.parseStatement());
         }
         else if (this.parseOptional(102 /* SyntaxKind.InKeyword */)) {
             const expression = this.parseExpressionAllowIn();
             this.parseExpected(21 /* SyntaxKind.CloseParenToken */);
-            result = new ForInOrOfStatement(250 /* SyntaxKind.ForInStatement */, undefined, initializer, expression, this.parseStatement());
+            result = new ForInOrOfStatement(251 /* SyntaxKind.ForInStatement */, undefined, initializer, expression, this.parseStatement());
         }
         else {
             this.parseExpected(26 /* SyntaxKind.SemicolonToken */);
@@ -1376,7 +1385,7 @@ export class Parser extends ScannerErrorReporter {
         const expression = this.parseExpressionAllowIn();
         this.parseExpected(58 /* SyntaxKind.ColonToken */);
         const statements = this.parseList(3 /* ParsingContext.SwitchClauseStatements */, 0 /* ListElement.Statement */);
-        return this.finishWithJSDoc(new CaseOrDefaultClause(297 /* SyntaxKind.CaseClause */, expression, statements), pos, jsdoc);
+        return this.finishWithJSDoc(new CaseOrDefaultClause(298 /* SyntaxKind.CaseClause */, expression, statements), pos, jsdoc);
     }
     parseDefaultClause() {
         const pos = this.nodePos();
@@ -1384,7 +1393,7 @@ export class Parser extends ScannerErrorReporter {
         this.parseExpected(89 /* SyntaxKind.DefaultKeyword */);
         this.parseExpected(58 /* SyntaxKind.ColonToken */);
         const statements = this.parseList(3 /* ParsingContext.SwitchClauseStatements */, 0 /* ListElement.Statement */);
-        return this.finishWithJSDoc(new CaseOrDefaultClause(298 /* SyntaxKind.DefaultClause */, undefined, statements), pos, jsdoc);
+        return this.finishWithJSDoc(new CaseOrDefaultClause(299 /* SyntaxKind.DefaultClause */, undefined, statements), pos, jsdoc);
     }
     parseCaseOrDefaultClause() {
         return this.token() === 83 /* SyntaxKind.CaseKeyword */ ? this.parseCaseClause() : this.parseDefaultClause();
@@ -1430,7 +1439,7 @@ export class Parser extends ScannerErrorReporter {
         // Without a catch clause there must be a finally clause; parse one regardless.
         let finallyBlock;
         if (catchClause === undefined || this.token() === 97 /* SyntaxKind.FinallyKeyword */) {
-            this.parseExpectedWithDiagnostic(97 /* SyntaxKind.FinallyKeyword */, 387 /* Diagnostics.X_catch_or_finally_expected */, true);
+            this.parseExpectedWithDiagnostic(97 /* SyntaxKind.FinallyKeyword */, 385 /* Diagnostics.X_catch_or_finally_expected */, true);
             finallyBlock = this.parseBlock(false, undefined);
         }
         return this.finishWithJSDoc(new TryStatement(tryBlock, catchClause, finallyBlock), pos, jsdoc);
@@ -1529,7 +1538,7 @@ export class Parser extends ScannerErrorReporter {
     parseVariableDeclarationWorker(allowExclamation) {
         const pos = this.nodePos();
         const jsdoc = this.jsdocScannerInfo();
-        const name = this.parseIdentifierOrPatternWithDiagnostic(1846 /* Diagnostics.Private_identifiers_are_not_allowed_in_variable_declarations */);
+        const name = this.parseIdentifierOrPatternWithDiagnostic(1866 /* Diagnostics.Private_identifiers_are_not_allowed_in_variable_declarations */);
         let exclamationToken;
         if (allowExclamation &&
             name.kind === 79 /* SyntaxKind.Identifier */ &&
@@ -1563,7 +1572,7 @@ export class Parser extends ScannerErrorReporter {
         const elements = this.parseDelimitedList(10 /* ParsingContext.ArrayBindingElements */, 5 /* ListElement.ArrayBindingElement */);
         this.contextFlags = saveContextFlags;
         this.parseExpected(23 /* SyntaxKind.CloseBracketToken */);
-        return this.finishNode(new BindingPattern(208 /* SyntaxKind.ArrayBindingPattern */, elements), pos);
+        return this.finishNode(new BindingPattern(209 /* SyntaxKind.ArrayBindingPattern */, elements), pos);
     }
     parseArrayBindingElement() {
         const pos = this.nodePos();
@@ -1586,7 +1595,7 @@ export class Parser extends ScannerErrorReporter {
         const elements = this.parseDelimitedList(9 /* ParsingContext.ObjectBindingElements */, 6 /* ListElement.ObjectBindingElement */);
         this.contextFlags = saveContextFlags;
         this.parseExpected(19 /* SyntaxKind.CloseBraceToken */);
-        return this.finishNode(new BindingPattern(207 /* SyntaxKind.ObjectBindingPattern */, elements), pos);
+        return this.finishNode(new BindingPattern(208 /* SyntaxKind.ObjectBindingPattern */, elements), pos);
     }
     parseObjectBindingElement() {
         const pos = this.nodePos();
@@ -1645,10 +1654,10 @@ export class Parser extends ScannerErrorReporter {
         return result;
     }
     parseClassDeclaration(pos, jsdoc, modifiers) {
-        return this.parseClassDeclarationOrExpression(pos, jsdoc, modifiers, 264 /* SyntaxKind.ClassDeclaration */);
+        return this.parseClassDeclarationOrExpression(pos, jsdoc, modifiers, 265 /* SyntaxKind.ClassDeclaration */);
     }
     parseClassExpression() {
-        return this.parseClassDeclarationOrExpression(this.nodePos(), this.jsdocScannerInfo(), undefined, 232 /* SyntaxKind.ClassExpression */);
+        return this.parseClassDeclarationOrExpression(this.nodePos(), this.jsdocScannerInfo(), undefined, 233 /* SyntaxKind.ClassExpression */);
     }
     parseClassDeclarationOrExpression(pos, jsdoc, modifiers, kind) {
         const saveContextFlags = this.contextFlags;
@@ -1657,9 +1666,16 @@ export class Parser extends ScannerErrorReporter {
         // The name isn't parsed in an await context; the checker reports `await` names.
         const name = this.parseNameOfClassDeclarationOrExpression();
         const typeParameters = this.parseTypeParameters();
-        if (modifiers !== undefined && hasModifierOfKind(modifiers, 94 /* SyntaxKind.ExportKeyword */))
+        // An exported class at the top level of a module, not one nested in a block or a namespace, has its
+        // heritage clauses and members parsed in an await context.
+        if (modifiers !== undefined &&
+            (this.parsingContexts & (1 << 0 /* ParsingContext.SourceElements */)) !== 0 &&
+            (this.parsingContexts &
+                ((1 << 1 /* ParsingContext.BlockStatements */) | (1 << 3 /* ParsingContext.SwitchClauseStatements */))) ===
+                0 &&
+            hasModifierOfKind(modifiers, 94 /* SyntaxKind.ExportKeyword */))
             this.setContextFlags(8192 /* NodeFlags.AwaitContext */, true);
-        const heritageClauses = this.parseHeritageClauses();
+        const heritageClauses = this.parseHeritageClauses(false);
         let members;
         if (this.parseExpected(18 /* SyntaxKind.OpenBraceToken */)) {
             members = this.parseList(5 /* ParsingContext.ClassMembers */, 7 /* ListElement.ClassElement */);
@@ -1671,7 +1687,7 @@ export class Parser extends ScannerErrorReporter {
         this.contextFlags = saveContextFlags;
         if (modifiers !== undefined && (modifiersToFlags(modifiers.nodes) & 128 /* ModifierFlags.Ambient */) !== 0)
             this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
-        const result = kind === 264 /* SyntaxKind.ClassDeclaration */
+        const result = kind === 265 /* SyntaxKind.ClassDeclaration */
             ? new ClassDeclaration(modifiers, name, typeParameters, heritageClauses, members)
             : new ClassExpression(modifiers, name, typeParameters, heritageClauses, members);
         this.finishWithJSDoc(result, pos, jsdoc);
@@ -1699,18 +1715,39 @@ export class Parser extends ScannerErrorReporter {
     isImplementsClause() {
         return this.token() === 118 /* SyntaxKind.ImplementsKeyword */ && this.lookAhead(nextTokenIsIdentifierOrKeyword);
     }
-    parseHeritageClauses() {
+    parseHeritageClauses(isInterface) {
         return this.isHeritageClause()
-            ? this.parseList(22 /* ParsingContext.HeritageClauses */, 8 /* ListElement.HeritageClause */)
+            ? this.parseList(22 /* ParsingContext.HeritageClauses */, isInterface ? 9 /* ListElement.InterfaceHeritageClause */ : 8 /* ListElement.HeritageClause */)
             : undefined;
     }
-    parseHeritageClause() {
+    parseHeritageClause(isInterface) {
         const pos = this.nodePos();
         const kind = this.token();
         this.nextToken();
-        const types = this.parseDelimitedList(7 /* ParsingContext.HeritageClauseElement */, 9 /* ListElement.ExpressionWithTypeArguments */);
+        // A class's `implements` and an interface's `extends` name types: their elements are type references.
+        const isTypeClause = isInterface ? kind === 95 /* SyntaxKind.ExtendsKeyword */ : kind === 118 /* SyntaxKind.ImplementsKeyword */;
+        const types = this.parseDelimitedList(7 /* ParsingContext.HeritageClauseElement */, isTypeClause ? 11 /* ListElement.TypeHeritageClauseElement */ : 10 /* ListElement.ExpressionWithTypeArguments */);
         return this.checkJSSyntax(this.finishNode(new HeritageClause(kind, types), pos));
     }
+    /** A type reference when the element is an entity name with optional type arguments, otherwise the
+     * `ExpressionWithTypeArguments`, which the checker reports. */
+    parseTypeHeritageClauseElement() {
+        const pos = this.nodePos();
+        const element = this.parseExpressionWithTypeArguments();
+        if (!isValidHeritageTypeReferenceExpression(element.expression))
+            return element;
+        const typeName = this.convertEntityNameExpressionToEntityName(element.expression);
+        return this.finishNode(new TypeReferenceNode(typeName, element.typeArguments), pos);
+    }
+    /** The `QualifiedName` chain for an identifier or a chain of property accesses, spanning the same text. */
+    convertEntityNameExpressionToEntityName(node) {
+        if (node instanceof Identifier)
+            return node;
+        const access = node;
+        // The name can be a private name, as upstream's.
+        const result = new QualifiedName(this.convertEntityNameExpressionToEntityName(access.expression), access.name);
+        return this.finishNodeWithEnd(result, node.pos, node.end);
+    }
     parseExpressionWithTypeArguments() {
         const pos = this.nodePos();
         const expression = this.parseLeftHandSideExpressionOrHigher();
@@ -1730,9 +1767,9 @@ export class Parser extends ScannerErrorReporter {
         if (this.token() === 125 /* SyntaxKind.StaticKeyword */ && this.lookAhead(nextTokenIsOpenBrace))
             return this.parseClassStaticBlockDeclaration(pos, jsdoc, modifiers);
         if (this.parseContextualModifier(138 /* SyntaxKind.GetKeyword */))
-            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 178 /* SyntaxKind.GetAccessor */, 0 /* ParseFlags.None */);
+            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 179 /* SyntaxKind.GetAccessor */, 0 /* ParseFlags.None */);
         if (this.parseContextualModifier(153 /* SyntaxKind.SetKeyword */))
-            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 179 /* SyntaxKind.SetAccessor */, 0 /* ParseFlags.None */);
+            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 180 /* SyntaxKind.SetAccessor */, 0 /* ParseFlags.None */);
         if (this.token() === 136 /* SyntaxKind.ConstructorKeyword */ || this.token() === 10 /* SyntaxKind.StringLiteral */) {
             const constructorDeclaration = this.tryParseConstructorDeclaration(pos, jsdoc, modifiers);
             if (constructorDeclaration !== undefined)
@@ -1883,17 +1920,17 @@ export class Parser extends ScannerErrorReporter {
                 // A declaration that failed to parse already reported a diagnostic.
                 return;
             case 'interface':
-                this.parseErrorForInvalidName(596 /* Diagnostics.Interface_name_cannot_be_0 */, 364 /* Diagnostics.Interface_must_be_given_a_name */, 18 /* SyntaxKind.OpenBraceToken */);
+                this.parseErrorForInvalidName(603 /* Diagnostics.Interface_name_cannot_be_0 */, 364 /* Diagnostics.Interface_must_be_given_a_name */, 18 /* SyntaxKind.OpenBraceToken */);
                 return;
             case 'is':
                 this.parseErrorAt(pos, this.scanner.getTokenStart(), 178 /* Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods */);
                 return;
             case 'module':
             case 'namespace':
-                this.parseErrorForInvalidName(950 /* Diagnostics.Namespace_name_cannot_be_0 */, 363 /* Diagnostics.Namespace_must_be_given_a_name */, 18 /* SyntaxKind.OpenBraceToken */);
+                this.parseErrorForInvalidName(957 /* Diagnostics.Namespace_name_cannot_be_0 */, 363 /* Diagnostics.Namespace_must_be_given_a_name */, 18 /* SyntaxKind.OpenBraceToken */);
                 return;
             case 'type':
-                this.parseErrorForInvalidName(623 /* Diagnostics.Type_alias_name_cannot_be_0 */, 365 /* Diagnostics.Type_alias_must_be_given_a_name */, 63 /* SyntaxKind.EqualsToken */);
+                this.parseErrorForInvalidName(630 /* Diagnostics.Type_alias_name_cannot_be_0 */, 365 /* Diagnostics.Type_alias_must_be_given_a_name */, 63 /* SyntaxKind.EqualsToken */);
                 return;
         }
         // A misspelled keyword, or a missing space after one.
@@ -1920,7 +1957,7 @@ export class Parser extends ScannerErrorReporter {
         this.parseExpected(119 /* SyntaxKind.InterfaceKeyword */);
         const name = this.parseIdentifier(1 /* IdentifierUse.Name */);
         const typeParameters = this.parseTypeParameters();
-        const heritageClauses = this.parseHeritageClauses();
+        const heritageClauses = this.parseHeritageClauses(true);
         const members = this.parseObjectTypeMembers();
         const result = this.finishWithJSDoc(new InterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members), pos, jsdoc);
         this.checkJSSyntax(result);
@@ -1937,7 +1974,7 @@ export class Parser extends ScannerErrorReporter {
             ? this.parseKeywordTypeNode()
             : this.parseType();
         this.parseSemicolon();
-        const result = this.finishWithJSDoc(new TypeAliasDeclaration(266 /* SyntaxKind.TypeAliasDeclaration */, modifiers, name, typeParameters, type), pos, jsdoc);
+        const result = this.finishWithJSDoc(new TypeAliasDeclaration(267 /* SyntaxKind.TypeAliasDeclaration */, modifiers, name, typeParameters, type), pos, jsdoc);
         this.checkJSSyntax(result);
         return result;
     }
@@ -1961,7 +1998,7 @@ export class Parser extends ScannerErrorReporter {
         if (this.parseExpected(18 /* SyntaxKind.OpenBraceToken */)) {
             const saveContextFlags = this.contextFlags;
             this.setContextFlags(2048 /* NodeFlags.YieldContext */ | 8192 /* NodeFlags.AwaitContext */, false);
-            members = this.parseDelimitedList(6 /* ParsingContext.EnumMembers */, 10 /* ListElement.EnumMember */);
+            members = this.parseDelimitedList(6 /* ParsingContext.EnumMembers */, 12 /* ListElement.EnumMember */);
             this.contextFlags = saveContextFlags;
             this.parseExpected(19 /* SyntaxKind.CloseBraceToken */);
         }
@@ -2001,12 +2038,16 @@ export class Parser extends ScannerErrorReporter {
         else {
             name = this.parseLiteralExpression(true);
         }
+        // `declare module "*.ext" with { type: "..." }`: the import attributes the module matches.
+        const attributes = keyword === 144 /* SyntaxKind.ModuleKeyword */ && this.parseOptional(117 /* SyntaxKind.WithKeyword */)
+            ? this.parseTypeLiteral()
+            : undefined;
         let body;
         if (this.token() === 18 /* SyntaxKind.OpenBraceToken */)
             body = this.parseModuleBlock();
         else
             this.parseSemicolon();
-        const result = this.finishWithJSDoc(new ModuleDeclaration(modifiers, keyword, name, body), pos, jsdoc);
+        const result = this.finishWithJSDoc(new ModuleDeclaration(modifiers, keyword, name, attributes, body), pos, jsdoc);
         this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
         return result;
     }
@@ -2037,7 +2078,7 @@ export class Parser extends ScannerErrorReporter {
         else {
             body = this.parseModuleBlock();
         }
-        const result = this.finishWithJSDoc(new ModuleDeclaration(modifiers, keyword, name, body), pos, jsdoc);
+        const result = this.finishWithJSDoc(new ModuleDeclaration(modifiers, keyword, name, undefined, body), pos, jsdoc);
         this.checkJSSyntax(result);
         this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
         return result;
@@ -2047,6 +2088,7 @@ export class Parser extends ScannerErrorReporter {
         const afterImportPos = this.nodePos();
         // The identifier isn't parsed in an await context; the checker reports `await`.
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
+        const phaseModifierCandidate = this.currentImportPhaseModifier();
         let identifier = this.isIdentifier() ? this.parseIdentifier(1 /* IdentifierUse.Name */) : undefined;
         let phaseModifier = 0 /* SyntaxKind.Unknown */;
         if (identifier !== undefined &&
@@ -2057,18 +2099,16 @@ export class Parser extends ScannerErrorReporter {
             phaseModifier = 156 /* SyntaxKind.TypeKeyword */;
             identifier = this.isIdentifier() ? this.parseIdentifier(1 /* IdentifierUse.Name */) : undefined;
         }
-        else if (identifier !== undefined && identifier.text === 'defer') {
-            const shouldParseAsDeferModifier = this.token() === 161 /* SyntaxKind.FromKeyword */
-                ? !this.lookAhead(nextTokenIsTokenStringLiteral)
-                : this.token() !== 27 /* SyntaxKind.CommaToken */ && this.token() !== 63 /* SyntaxKind.EqualsToken */;
-            if (shouldParseAsDeferModifier) {
-                phaseModifier = 166 /* SyntaxKind.DeferKeyword */;
-                identifier = this.isIdentifier() ? this.parseIdentifier(1 /* IdentifierUse.Name */) : undefined;
-            }
+        else if (identifier !== undefined &&
+            phaseModifierCandidate !== 0 /* SyntaxKind.Unknown */ &&
+            this.shouldParseImportPhaseModifier()) {
+            phaseModifier = phaseModifierCandidate;
+            identifier = this.isIdentifier() ? this.parseIdentifier(1 /* IdentifierUse.Name */) : undefined;
         }
         if (identifier !== undefined &&
             !this.tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() &&
-            phaseModifier !== 166 /* SyntaxKind.DeferKeyword */) {
+            phaseModifier !== 166 /* SyntaxKind.DeferKeyword */ &&
+            phaseModifier !== 167 /* SyntaxKind.SourceKeyword */) {
             const importEquals = this.checkJSSyntax(this.parseImportEqualsDeclaration(pos, jsdoc, modifiers, identifier, phaseModifier === 156 /* SyntaxKind.TypeKeyword */));
             // Import= declarations are always parsed in an await context; no reparse needed.
             this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
@@ -2080,13 +2120,35 @@ export class Parser extends ScannerErrorReporter {
         const moduleSpecifier = this.parseModuleSpecifier();
         const attributes = this.tryParseImportAttributes();
         this.parseSemicolon();
-        const result = this.finishWithJSDoc(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, modifiers, importClause, moduleSpecifier, attributes), pos, jsdoc);
+        const result = this.finishWithJSDoc(new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, modifiers, importClause, moduleSpecifier, attributes), pos, jsdoc);
         this.checkJSSyntax(result);
         return result;
     }
     tokenAfterImportDefinitelyProducesImportDeclaration() {
         return this.token() === 41 /* SyntaxKind.AsteriskToken */ || this.token() === 18 /* SyntaxKind.OpenBraceToken */;
     }
+    /** In `import defer ___` or `import source ___`, whether `defer` or `source` is a phase modifier rather than the
+     * default import's name. */
+    shouldParseImportPhaseModifier() {
+        switch (this.token()) {
+            case 27 /* SyntaxKind.CommaToken */:
+            case 63 /* SyntaxKind.EqualsToken */:
+                return false;
+            case 161 /* SyntaxKind.FromKeyword */:
+                return !this.lookAhead(nextTokenIsTokenStringLiteral);
+        }
+        return true;
+    }
+    /** The phase modifier the current token's text spells, written without escapes, or `Unknown`. */
+    currentImportPhaseModifier() {
+        switch (this.scanner.getTokenText()) {
+            case 'defer':
+                return 166 /* SyntaxKind.DeferKeyword */;
+            case 'source':
+                return 167 /* SyntaxKind.SourceKeyword */;
+        }
+        return 0 /* SyntaxKind.Unknown */;
+    }
     /** In `import id ___`, whether the token makes this an ImportDeclaration rather than ImportEqualsDeclaration. */
     tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() {
         return this.token() === 27 /* SyntaxKind.CommaToken */ || this.token() === 161 /* SyntaxKind.FromKeyword */;
@@ -2100,7 +2162,7 @@ export class Parser extends ScannerErrorReporter {
     parseModuleReference() {
         if (this.token() === 149 /* SyntaxKind.RequireKeyword */ && this.lookAhead(nextTokenIsOpenParen))
             return this.parseExternalModuleReference();
-        return this.parseEntityName(false, undefined);
+        return this.parseEntityName(false, false, undefined);
     }
     parseExternalModuleReference() {
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
@@ -2129,6 +2191,9 @@ export class Parser extends ScannerErrorReporter {
             this.parseExpected(161 /* SyntaxKind.FromKeyword */);
             return importClause;
         }
+        // A phase modifier without bindings still makes an import clause; the checker reports it.
+        if (phaseModifier === 166 /* SyntaxKind.DeferKeyword */ || phaseModifier === 167 /* SyntaxKind.SourceKeyword */)
+            return this.finishNode(new ImportClause(phaseModifier, undefined, undefined), pos);
         return undefined;
     }
     parseImportClause(identifier, pos, phaseModifier, skipJSDocLeadingAsterisks) {
@@ -2159,22 +2224,22 @@ export class Parser extends ScannerErrorReporter {
     }
     parseNamedImports() {
         const pos = this.nodePos();
-        const imports = this.parseBracketedList(23 /* ParsingContext.ImportOrExportSpecifiers */, 11 /* ListElement.ImportSpecifier */, 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */);
+        const imports = this.parseBracketedList(23 /* ParsingContext.ImportOrExportSpecifiers */, 13 /* ListElement.ImportSpecifier */, 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */);
         return this.finishNode(new NamedImports(imports), pos);
     }
     parseImportSpecifier() {
-        return this.parseImportOrExportSpecifier(277 /* SyntaxKind.ImportSpecifier */);
+        return this.parseImportOrExportSpecifier(278 /* SyntaxKind.ImportSpecifier */);
     }
     parseExportSpecifier() {
-        return this.parseImportOrExportSpecifier(282 /* SyntaxKind.ExportSpecifier */);
+        return this.parseImportOrExportSpecifier(283 /* SyntaxKind.ExportSpecifier */);
     }
     parseImportOrExportSpecifier(kind) {
         // ImportSpecifier: BindingIdentifier | ModuleExportName as BindingIdentifier
         // ExportSpecifier: ModuleExportName | ModuleExportName as ModuleExportName
         const pos = this.nodePos();
-        const jsdoc = kind === 282 /* SyntaxKind.ExportSpecifier */ ? this.jsdocScannerInfo() : 0 /* JSDocScannerInfo.None */;
+        const jsdoc = kind === 283 /* SyntaxKind.ExportSpecifier */ ? this.jsdocScannerInfo() : 0 /* JSDocScannerInfo.None */;
         let canParseAsKeyword = true;
-        const disallowKeywords = kind === 277 /* SyntaxKind.ImportSpecifier */;
+        const disallowKeywords = kind === 278 /* SyntaxKind.ImportSpecifier */;
         let isTypeOnly = false;
         let propertyName;
         let nameOk = this.isModuleExportNameOk(disallowKeywords);
@@ -2232,7 +2297,7 @@ export class Parser extends ScannerErrorReporter {
         }
         if (!nameOk)
             this.parseErrorAt(skipTrivia(this.sourceText, name.pos), name.end, 1 /* Diagnostics.Identifier_expected */);
-        if (kind === 282 /* SyntaxKind.ExportSpecifier */) {
+        if (kind === 283 /* SyntaxKind.ExportSpecifier */) {
             const result = this.finishWithJSDoc(new ExportSpecifier(isTypeOnly, propertyName, name), pos, jsdoc);
             this.checkJSSyntax(result);
             return result;
@@ -2265,7 +2330,7 @@ export class Parser extends ScannerErrorReporter {
         if (this.token() === 117 /* SyntaxKind.WithKeyword */ ||
             (this.token() === 131 /* SyntaxKind.AssertKeyword */ && !this.hasPrecedingLineBreak())) {
             if (this.token() === 131 /* SyntaxKind.AssertKeyword */)
-                this.parseErrorAtCurrentToken(1000 /* Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert */);
+                this.parseErrorAtCurrentToken(1007 /* Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert */);
             return this.parseImportAttributes(this.token(), false);
         }
         return undefined;
@@ -2326,7 +2391,7 @@ export class Parser extends ScannerErrorReporter {
             (this.token() === 117 /* SyntaxKind.WithKeyword */ || this.token() === 131 /* SyntaxKind.AssertKeyword */) &&
             !this.hasPrecedingLineBreak()) {
             if (this.token() === 131 /* SyntaxKind.AssertKeyword */)
-                this.parseErrorAtCurrentToken(1000 /* Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert */);
+                this.parseErrorAtCurrentToken(1007 /* Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert */);
             attributes = this.parseImportAttributes(this.token(), false);
         }
         this.parseSemicolon();
@@ -2342,7 +2407,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseNamedExports() {
         const pos = this.nodePos();
-        const exports = this.parseBracketedList(23 /* ParsingContext.ImportOrExportSpecifiers */, 12 /* ListElement.ExportSpecifier */, 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */);
+        const exports = this.parseBracketedList(23 /* ParsingContext.ImportOrExportSpecifiers */, 14 /* ListElement.ExportSpecifier */, 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */);
         return this.finishNode(new NamedExports(exports), pos);
     }
     // Types
@@ -2631,10 +2696,13 @@ export class Parser extends ScannerErrorReporter {
         return this.finishNode(new TypeReferenceNode(this.parseEntityNameOfTypeReference(), this.parseTypeArgumentsOfTypeReference()), pos);
     }
     parseEntityNameOfTypeReference() {
-        return this.parseEntityName(true, 79 /* Diagnostics.Type_expected */);
+        return this.parseEntityName(true, false, 79 /* Diagnostics.Type_expected */);
     }
-    /** An entity name; `use` is for its first identifier, the qualified names' right sides are names. */
-    parseEntityName(allowReservedWords, diagnosticMessage, use = 1 /* IdentifierUse.Name */) {
+    /**
+     * An entity name; `use` is for its first identifier, the qualified names' right sides are names.
+     * Only a type query allows private names on the right (`typeof this.#x`).
+     */
+    parseEntityName(allowReservedWords, allowPrivateName, diagnosticMessage, use = 1 /* IdentifierUse.Name */) {
         const pos = this.nodePos();
         let entity = allowReservedWords
             ? this.parseIdentifierNameWithDiagnostic(diagnosticMessage, use)
@@ -2643,7 +2711,7 @@ export class Parser extends ScannerErrorReporter {
             // A JSDoc-style generic; the checker reports the gap between the name and the type arguments.
             if (this.token() === 29 /* SyntaxKind.LessThanToken */)
                 break;
-            entity = this.finishNode(new QualifiedName(entity, this.parseRightSideOfDotIdentifier(allowReservedWords, true)), pos);
+            entity = this.finishNode(new QualifiedName(entity, this.parseRightSideOfDot(allowReservedWords, allowPrivateName, true)), pos);
         }
         return entity;
     }
@@ -2737,7 +2805,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseTypeArguments() {
         if (this.token() === 29 /* SyntaxKind.LessThanToken */)
-            return this.parseBracketedList(20 /* ParsingContext.TypeArguments */, 13 /* ListElement.Type */, 29 /* SyntaxKind.LessThanToken */, 31 /* SyntaxKind.GreaterThanToken */);
+            return this.parseBracketedList(20 /* ParsingContext.TypeArguments */, 15 /* ListElement.Type */, 29 /* SyntaxKind.LessThanToken */, 31 /* SyntaxKind.GreaterThanToken */);
         return undefined;
     }
     parseImportType() {
@@ -2754,7 +2822,7 @@ export class Parser extends ScannerErrorReporter {
             const currentToken = this.token();
             if (currentToken === 117 /* SyntaxKind.WithKeyword */ || currentToken === 131 /* SyntaxKind.AssertKeyword */) {
                 if (currentToken === 131 /* SyntaxKind.AssertKeyword */)
-                    this.parseErrorAtCurrentToken(1000 /* Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert */);
+                    this.parseErrorAtCurrentToken(1007 /* Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert */);
                 this.nextToken();
             }
             else {
@@ -2790,7 +2858,7 @@ export class Parser extends ScannerErrorReporter {
         if (name !== undefined)
             this.parseExpected(58 /* SyntaxKind.ColonToken */);
         else
-            this.parseErrorAtCurrentToken(393 /* Diagnostics.Identifier_or_string_literal_expected */);
+            this.parseErrorAtCurrentToken(391 /* Diagnostics.Identifier_or_string_literal_expected */);
         const value = this.parseAssignmentExpressionOrHigher();
         return this.finishNode(new ImportAttribute(name, value), pos);
     }
@@ -2803,7 +2871,7 @@ export class Parser extends ScannerErrorReporter {
         const openBracePosition = this.scanner.getTokenStart();
         if (this.parseExpected(18 /* SyntaxKind.OpenBraceToken */)) {
             multiLine = this.hasPrecedingLineBreak();
-            elements = this.parseDelimitedList(24 /* ParsingContext.ImportAttributes */, 14 /* ListElement.ImportAttribute */);
+            elements = this.parseDelimitedList(24 /* ParsingContext.ImportAttributes */, 16 /* ListElement.ImportAttribute */);
             if (!this.parseExpected(19 /* SyntaxKind.CloseBraceToken */))
                 this.addMatchingBraceRelatedInfo(openBracePosition);
         }
@@ -2817,7 +2885,7 @@ export class Parser extends ScannerErrorReporter {
     parseTypeQuery() {
         const pos = this.nodePos();
         this.parseExpected(113 /* SyntaxKind.TypeOfKeyword */);
-        const entityName = this.parseEntityName(true, undefined, 0 /* IdentifierUse.Reference */);
+        const entityName = this.parseEntityName(true, true, undefined, 0 /* IdentifierUse.Reference */);
         // ASI: don't parse the next line's type arguments as part of an instantiation expression.
         const typeArguments = this.hasPrecedingLineBreak() ? undefined : this.parseTypeArguments();
         return this.finishNode(new TypeQueryNode(entityName, typeArguments), pos);
@@ -2847,7 +2915,7 @@ export class Parser extends ScannerErrorReporter {
         }
         const type = this.parseTypeAnnotation();
         this.parseSemicolon();
-        const members = this.parseList(4 /* ParsingContext.TypeMembers */, 15 /* ListElement.TypeMember */);
+        const members = this.parseList(4 /* ParsingContext.TypeMembers */, 17 /* ListElement.TypeMember */);
         this.parseExpected(19 /* SyntaxKind.CloseBraceToken */);
         return this.finishNode(new MappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members), pos);
     }
@@ -2862,16 +2930,16 @@ export class Parser extends ScannerErrorReporter {
     }
     parseTypeMember() {
         if (this.token() === 20 /* SyntaxKind.OpenParenToken */ || this.token() === 29 /* SyntaxKind.LessThanToken */)
-            return this.parseSignatureMember(180 /* SyntaxKind.CallSignature */);
+            return this.parseSignatureMember(181 /* SyntaxKind.CallSignature */);
         if (this.token() === 104 /* SyntaxKind.NewKeyword */ && this.lookAhead(nextTokenIsOpenParenOrLessThan))
-            return this.parseSignatureMember(181 /* SyntaxKind.ConstructSignature */);
+            return this.parseSignatureMember(182 /* SyntaxKind.ConstructSignature */);
         const pos = this.nodePos();
         const jsdoc = this.jsdocScannerInfo();
         const modifiers = this.parseModifiers();
         if (this.parseContextualModifier(138 /* SyntaxKind.GetKeyword */))
-            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 178 /* SyntaxKind.GetAccessor */, 4 /* ParseFlags.Type */);
+            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 179 /* SyntaxKind.GetAccessor */, 4 /* ParseFlags.Type */);
         if (this.parseContextualModifier(153 /* SyntaxKind.SetKeyword */))
-            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 179 /* SyntaxKind.SetAccessor */, 4 /* ParseFlags.Type */);
+            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 180 /* SyntaxKind.SetAccessor */, 4 /* ParseFlags.Type */);
         if (this.isIndexSignature())
             return this.parseIndexSignatureDeclaration(pos, jsdoc, modifiers);
         return this.parsePropertyOrMethodSignature(pos, jsdoc, modifiers);
@@ -2879,20 +2947,20 @@ export class Parser extends ScannerErrorReporter {
     parseSignatureMember(kind) {
         const pos = this.nodePos();
         const jsdoc = this.jsdocScannerInfo();
-        if (kind === 181 /* SyntaxKind.ConstructSignature */)
+        if (kind === 182 /* SyntaxKind.ConstructSignature */)
             this.parseExpected(104 /* SyntaxKind.NewKeyword */);
         const typeParameters = this.parseTypeParameters();
         const parameters = this.parseParameters(4 /* ParseFlags.Type */);
         const type = this.parseReturnType(58 /* SyntaxKind.ColonToken */, true);
         this.parseTypeMemberSemicolon();
-        const result = kind === 180 /* SyntaxKind.CallSignature */
+        const result = kind === 181 /* SyntaxKind.CallSignature */
             ? new CallSignatureDeclaration(typeParameters, parameters, type)
             : new ConstructSignatureDeclaration(typeParameters, parameters, type);
         return this.finishWithJSDoc(result, pos, jsdoc);
     }
     parseTypeParameters() {
         if (this.token() === 29 /* SyntaxKind.LessThanToken */)
-            return this.parseBracketedList(19 /* ParsingContext.TypeParameters */, 16 /* ListElement.TypeParameter */, 29 /* SyntaxKind.LessThanToken */, 31 /* SyntaxKind.GreaterThanToken */);
+            return this.parseBracketedList(19 /* ParsingContext.TypeParameters */, 18 /* ListElement.TypeParameter */, 29 /* SyntaxKind.LessThanToken */, 31 /* SyntaxKind.GreaterThanToken */);
         return undefined;
     }
     parseTypeParameter() {
@@ -2932,7 +3000,7 @@ export class Parser extends ScannerErrorReporter {
         const saveContextFlags = this.contextFlags;
         this.setContextFlags(2048 /* NodeFlags.YieldContext */, (flags & 1 /* ParseFlags.Yield */) !== 0);
         this.setContextFlags(8192 /* NodeFlags.AwaitContext */, (flags & 2 /* ParseFlags.Await */) !== 0);
-        const parameters = this.parseDelimitedList(16 /* ParsingContext.Parameters */, 18 /* ListElement.SignatureParameter */);
+        const parameters = this.parseDelimitedList(16 /* ParsingContext.Parameters */, 20 /* ListElement.SignatureParameter */);
         this.contextFlags = saveContextFlags;
         this.signatureParameterInAwaitContext = saveInAwaitContext;
         this.signatureParameterAllowAmbiguity = saveAllowAmbiguity;
@@ -2976,7 +3044,7 @@ export class Parser extends ScannerErrorReporter {
             this.token() === 18 /* SyntaxKind.OpenBraceToken */);
     }
     parseNameOfParameter(modifiers) {
-        const name = this.parseIdentifierOrPatternWithDiagnostic(1831 /* Diagnostics.Private_identifiers_cannot_be_used_as_parameters */);
+        const name = this.parseIdentifierOrPatternWithDiagnostic(1851 /* Diagnostics.Private_identifiers_cannot_be_used_as_parameters */);
         if (name.end - name.pos === 0 && modifiers === undefined && isModifierKind(this.token())) {
             // In `function foo(static)`, `static` is a modifier but not a strict-mode identifier: the name
             // is missing and the token didn't change, so advance to avoid looping forever.
@@ -3030,7 +3098,7 @@ export class Parser extends ScannerErrorReporter {
         const returnType = this.parseReturnType(58 /* SyntaxKind.ColonToken */, false);
         const body = this.parseFunctionBlockOrSemicolon(flags, undefined);
         // Type parameters (and setter return types) are kept for the grammar checker.
-        const result = kind === 178 /* SyntaxKind.GetAccessor */
+        const result = kind === 179 /* SyntaxKind.GetAccessor */
             ? new GetAccessorDeclaration(modifiers, name, typeParameters, parameters, returnType, undefined, body)
             : new SetAccessorDeclaration(modifiers, name, typeParameters, parameters, returnType, undefined, body);
         this.finishWithJSDoc(result, pos, jsdoc);
@@ -3091,7 +3159,7 @@ export class Parser extends ScannerErrorReporter {
         return this.token() === 22 /* SyntaxKind.OpenBracketToken */ && this.lookAhead(nextIsUnambiguouslyIndexSignature);
     }
     parseIndexSignatureDeclaration(pos, jsdoc, modifiers) {
-        const parameters = this.parseBracketedList(16 /* ParsingContext.Parameters */, 17 /* ListElement.Parameter */, 22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */);
+        const parameters = this.parseBracketedList(16 /* ParsingContext.Parameters */, 19 /* ListElement.Parameter */, 22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */);
         const type = this.parseTypeAnnotation();
         this.parseTypeMemberSemicolon();
         return this.finishWithJSDoc(new IndexSignatureDeclaration(modifiers, parameters, type), pos, jsdoc);
@@ -3122,7 +3190,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseObjectTypeMembers() {
         if (this.parseExpected(18 /* SyntaxKind.OpenBraceToken */)) {
-            const members = this.parseList(4 /* ParsingContext.TypeMembers */, 15 /* ListElement.TypeMember */);
+            const members = this.parseList(4 /* ParsingContext.TypeMembers */, 17 /* ListElement.TypeMember */);
             this.parseExpected(19 /* SyntaxKind.CloseBraceToken */);
             return members;
         }
@@ -3130,7 +3198,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseTupleType() {
         const pos = this.nodePos();
-        return this.finishNode(new TupleTypeNode(this.parseBracketedList(21 /* ParsingContext.TupleElementTypes */, 19 /* ListElement.TupleElement */, 22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */)), pos);
+        return this.finishNode(new TupleTypeNode(this.parseBracketedList(21 /* ParsingContext.TupleElementTypes */, 21 /* ListElement.TupleElement */, 22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */)), pos);
     }
     parseTupleElementNameOrTupleElementType() {
         if (this.lookAhead(scanStartOfNamedTupleElement)) {
@@ -3231,7 +3299,7 @@ export class Parser extends ScannerErrorReporter {
         if (this.isStartOfFunctionTypeOrConstructorType()) {
             const type = this.parseFunctionOrConstructorType();
             let diagnostic;
-            if (type.kind === 185 /* SyntaxKind.FunctionType */)
+            if (type.kind === 186 /* SyntaxKind.FunctionType */)
                 diagnostic = isInUnionType
                     ? 312 /* Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_a_union_type */
                     : 314 /* Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type */;
@@ -3778,8 +3846,7 @@ export class Parser extends ScannerErrorReporter {
             // Take a left-associative operator when its precedence is higher than the current one (so
             // `a - b - c` returns `b` as the right operand of the first `-`), and `**` (right
             // associative) when it is at least as high.
-            const consumeCurrentOperator = operator === 42 /* SyntaxKind.AsteriskAsteriskToken */ ? newPrecedence >= precedence : newPrecedence > precedence;
-            if (!consumeCurrentOperator)
+            if (!shouldConsumeBinaryOperator(operator, newPrecedence, precedence))
                 break;
             if (operator === 102 /* SyntaxKind.InKeyword */ && this.inDisallowInContext())
                 break;
@@ -3788,7 +3855,7 @@ export class Parser extends ScannerErrorReporter {
                 if (this.hasPrecedingLineBreak())
                     break;
                 this.nextToken();
-                // In `a ## b as T`, stop at a following operator with a higher precedence than `##`: the
+                // In `a ## b as T $$ c`, stop when `$$` would bind before `##` once the `as` is erased: the
                 // `as` couldn't be erased without changing the meaning (TypeScript#63527).
                 const lastPrecedence = lastOperand instanceof BinaryExpression
                     ? getBinaryOperatorPrecedence(lastOperand.operatorToken.kind)
@@ -3797,7 +3864,8 @@ export class Parser extends ScannerErrorReporter {
                     operator === 152 /* SyntaxKind.SatisfiesKeyword */
                         ? this.makeSatisfiesExpression(leftOperand, this.parseType())
                         : this.makeAsExpression(leftOperand, this.parseType());
-                if (getBinaryOperatorPrecedence(this.reScanGreaterThanToken()) > lastPrecedence)
+                const nextOperator = this.reScanGreaterThanToken();
+                if (shouldConsumeBinaryOperator(nextOperator, getBinaryOperatorPrecedence(nextOperator), lastPrecedence))
                     break;
             }
             else {
@@ -3831,10 +3899,10 @@ export class Parser extends ScannerErrorReporter {
         if (this.token() === 42 /* SyntaxKind.AsteriskAsteriskToken */) {
             const pos = skipTrivia(this.sourceText, simpleUnaryExpression.pos);
             const end = simpleUnaryExpression.end;
-            if (simpleUnaryExpression.kind === 217 /* SyntaxKind.TypeAssertionExpression */)
-                this.parseErrorAt(pos, end, 1810 /* Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses */);
+            if (simpleUnaryExpression.kind === 218 /* SyntaxKind.TypeAssertionExpression */)
+                this.parseErrorAt(pos, end, 1830 /* Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses */);
             else
-                this.parseErrorAt(pos, end, 1809 /* Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses */, [tokenToString(unaryOperator)]);
+                this.parseErrorAt(pos, end, 1829 /* Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses */, [tokenToString(unaryOperator)]);
         }
         return simpleUnaryExpression;
     }
@@ -3913,14 +3981,14 @@ export class Parser extends ScannerErrorReporter {
                         tagNamesAreEquivalent(closingElement.tagName, openingTag.tagName)) {
                         // The opening matched its parent's closing: report it on the opening.
                         const tagName = opening.tagName;
-                        this.parseErrorAt(tagName.pos, tagName.end, 1811 /* Diagnostics.JSX_element_0_has_no_corresponding_closing_tag */, [
+                        this.parseErrorAt(tagName.pos, tagName.end, 1831 /* Diagnostics.JSX_element_0_has_no_corresponding_closing_tag */, [
                             getTextOfNodeFromSourceText(this.sourceText, tagName),
                         ]);
                     }
                     else {
                         // Other mismatches are reported on the closing.
                         const tagName = closingElement.tagName;
-                        this.parseErrorAt(tagName.pos, tagName.end, 1806 /* Diagnostics.Expected_corresponding_JSX_closing_tag_for_0 */, [
+                        this.parseErrorAt(tagName.pos, tagName.end, 1826 /* Diagnostics.Expected_corresponding_JSX_closing_tag_for_0 */, [
                             getTextOfNodeFromSourceText(this.sourceText, opening.tagName),
                         ]);
                     }
@@ -3934,7 +4002,7 @@ export class Parser extends ScannerErrorReporter {
             const children = this.parseJsxChildren(opening);
             result = this.finishNode(new JsxFragment(opening, children, this.parseJsxClosingFragment(inExpressionContext)), pos);
         }
-        else if (opening.kind === 286 /* SyntaxKind.JsxSelfClosingElement */) {
+        else if (opening.kind === 287 /* SyntaxKind.JsxSelfClosingElement */) {
             result = opening;
         }
         else {
@@ -3949,7 +4017,7 @@ export class Parser extends ScannerErrorReporter {
             const operatorToken = new Token(27 /* SyntaxKind.CommaToken */);
             operatorToken.pos = invalidElement.pos;
             operatorToken.end = invalidElement.pos;
-            this.parseErrorAt(skipTrivia(this.sourceText, topBadPos), invalidElement.end, 791 /* Diagnostics.JSX_expressions_must_have_one_parent_element */);
+            this.parseErrorAt(skipTrivia(this.sourceText, topBadPos), invalidElement.end, 798 /* Diagnostics.JSX_expressions_must_have_one_parent_element */);
             result = this.finishNode(new BinaryExpression(undefined, result, undefined, operatorToken, invalidElement), pos);
         }
         return result;
@@ -3981,13 +4049,13 @@ export class Parser extends ScannerErrorReporter {
             case 1 /* SyntaxKind.EndOfFile */:
                 // Report at the tag without a closing element rather than at the end of the file.
                 if (openingTag instanceof JsxOpeningFragment) {
-                    this.parseErrorAt(openingTag.pos, openingTag.end, 1817 /* Diagnostics.JSX_fragment_has_no_corresponding_closing_tag */);
+                    this.parseErrorAt(openingTag.pos, openingTag.end, 1837 /* Diagnostics.JSX_fragment_has_no_corresponding_closing_tag */);
                 }
                 else if (openingTag instanceof JsxOpeningElement) {
                     // Only cover `Foo.Bar` in `< Foo.Bar >`.
                     const tag = openingTag.tagName;
                     const start = Math.min(skipTrivia(this.sourceText, tag.pos), tag.end);
-                    this.parseErrorAt(start, tag.end, 1811 /* Diagnostics.JSX_element_0_has_no_corresponding_closing_tag */, [
+                    this.parseErrorAt(start, tag.end, 1831 /* Diagnostics.JSX_element_0_has_no_corresponding_closing_tag */, [
                         getTextOfNodeFromSourceText(this.sourceText, tag),
                     ]);
                 }
@@ -4114,7 +4182,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseJsxAttributes() {
         const pos = this.nodePos();
-        const result = new JsxAttributes(this.parseList(13 /* ParsingContext.JsxAttributes */, 20 /* ListElement.JsxAttribute */));
+        const result = new JsxAttributes(this.parseList(13 /* ParsingContext.JsxAttributes */, 22 /* ListElement.JsxAttribute */));
         this.finishNode(result, pos);
         return result;
     }
@@ -4149,8 +4217,9 @@ export class Parser extends ScannerErrorReporter {
                 return this.parseLiteralExpression(false);
             if (this.token() === 18 /* SyntaxKind.OpenBraceToken */)
                 return this.parseJsxExpression(true);
+            // An attribute value is a single element: sibling-element recovery must not wrap it in a binary expression.
             if (this.token() === 29 /* SyntaxKind.LessThanToken */)
-                return this.parseJsxElementOrSelfClosingElementOrFragment(true, -1, undefined, false);
+                return this.parseJsxElementOrSelfClosingElementOrFragment(true, -1, undefined, true);
             this.parseErrorAtCurrentToken(110 /* Diagnostics.X_or_JSX_element_expected */);
         }
         return undefined;
@@ -4158,7 +4227,7 @@ export class Parser extends ScannerErrorReporter {
     parseJsxClosingFragment(inExpressionContext) {
         const pos = this.nodePos();
         this.parseExpected(30 /* SyntaxKind.LessThanSlashToken */);
-        if (this.parseExpectedWithDiagnostic(31 /* SyntaxKind.GreaterThanToken */, 1818 /* Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment */, false)) {
+        if (this.parseExpectedWithDiagnostic(31 /* SyntaxKind.GreaterThanToken */, 1838 /* Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment */, false)) {
             // Advance manually to scan JSX text inside JSX.
             if (inExpressionContext)
                 this.nextToken();
@@ -4257,9 +4326,9 @@ export class Parser extends ScannerErrorReporter {
                 // An `import.*` meta property, such as `import.meta`.
                 this.nextToken();
                 this.nextToken();
-                const name = this.parseIdentifierName(1 /* IdentifierUse.Name */);
+                const name = this.parseImportMetaPropertyName();
                 expression = this.finishNode(new MetaProperty(101 /* SyntaxKind.ImportKeyword */, name), pos);
-                if (name.text === 'defer') {
+                if (isImportPhaseMetaProperty(expression)) {
                     if (this.token() === 20 /* SyntaxKind.OpenParenToken */ || this.token() === 29 /* SyntaxKind.LessThanToken */)
                         this.sourceFlags |= 524288 /* NodeFlags.PossiblyContainsDynamicImport */;
                 }
@@ -4280,6 +4349,13 @@ export class Parser extends ScannerErrorReporter {
         // We may have consumed the start of a call or optional expression; consume the rest.
         return this.parseCallExpressionRest(pos, expression);
     }
+    /** The name after `import.`; `defer` and `source` written with escapes are reported. */
+    parseImportMetaPropertyName() {
+        if ((this.token() === 166 /* SyntaxKind.DeferKeyword */ || this.token() === 167 /* SyntaxKind.SourceKeyword */) &&
+            this.currentImportPhaseModifier() === 0 /* SyntaxKind.Unknown */)
+            this.parseErrorAtCurrentToken(209 /* Diagnostics.Keywords_cannot_contain_escape_characters */);
+        return this.parseIdentifierName(1 /* IdentifierUse.Name */);
+    }
     parseSuperExpression() {
         const pos = this.nodePos();
         let expression = this.parseKeywordExpression();
@@ -4287,7 +4363,7 @@ export class Parser extends ScannerErrorReporter {
             const startPos = this.nodePos();
             const typeArguments = this.tryParseTypeArgumentsInExpression();
             if (typeArguments !== undefined) {
-                this.parseErrorAt(startPos, this.nodePos(), 886 /* Diagnostics.X_super_may_not_use_type_arguments */);
+                this.parseErrorAt(startPos, this.nodePos(), 893 /* Diagnostics.X_super_may_not_use_type_arguments */);
                 if (!this.isTemplateStartOfTaggedTemplate())
                     expression = this.finishNode(new ExpressionWithTypeArguments(expression, typeArguments), pos);
             }
@@ -4312,7 +4388,7 @@ export class Parser extends ScannerErrorReporter {
         const state = this.mark();
         if (this.reScanLessThanToken() === 29 /* SyntaxKind.LessThanToken */) {
             this.nextToken();
-            const typeArguments = this.parseDelimitedList(20 /* ParsingContext.TypeArguments */, 13 /* ListElement.Type */);
+            const typeArguments = this.parseDelimitedList(20 /* ParsingContext.TypeArguments */, 15 /* ListElement.Type */);
             // Without the closing `>` it's not a type argument list.
             if (this.reScanGreaterThanToken() === 31 /* SyntaxKind.GreaterThanToken */) {
                 this.nextToken();
@@ -4408,11 +4484,11 @@ export class Parser extends ScannerErrorReporter {
         const isOptionalChain = questionDotToken !== undefined || this.tryReparseOptionalChain(expression);
         const propertyAccess = new PropertyAccessExpression(expression, questionDotToken, name, isOptionalChain ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */);
         if (isOptionalChain && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
-            this.parseErrorAt(skipTrivia(this.sourceText, name.pos), name.end, 1847 /* Diagnostics.An_optional_chain_cannot_contain_private_identifiers */);
+            this.parseErrorAt(skipTrivia(this.sourceText, name.pos), name.end, 1867 /* Diagnostics.An_optional_chain_cannot_contain_private_identifiers */);
         if (expression instanceof ExpressionWithTypeArguments) {
             const typeArguments = expression.typeArguments;
             if (typeArguments !== undefined)
-                this.parseErrorAt(typeArguments.pos - 1, skipTrivia(this.sourceText, typeArguments.end) + 1, 392 /* Diagnostics.An_instantiation_expression_cannot_be_followed_by_a_property_access */);
+                this.parseErrorAt(typeArguments.pos - 1, skipTrivia(this.sourceText, typeArguments.end) + 1, 390 /* Diagnostics.An_instantiation_expression_cannot_be_followed_by_a_property_access */);
         }
         return this.finishNode(propertyAccess, pos);
     }
@@ -4439,10 +4515,15 @@ export class Parser extends ScannerErrorReporter {
     parseElementAccessExpressionRest(pos, expression, questionDotToken) {
         let argumentExpression;
         if (this.token() === 23 /* SyntaxKind.CloseBracketToken */) {
-            this.parseErrorAt(this.nodePos(), this.nodePos(), 7 /* Diagnostics.An_element_access_expression_should_take_an_argument */);
+            // The missing argument is created before the error, so the error marks the element access.
             argumentExpression = this.createMissingIdentifier();
+            this.parseErrorAt(this.nodePos(), this.nodePos(), 7 /* Diagnostics.An_element_access_expression_should_take_an_argument */);
         }
         else {
+            // tsgo creates the missing argument first and drops it when there is one. Finishing that node takes the
+            // error flag of an error before the argument (`i[01]`), so the argument doesn't get it.
+            this.identifierCount++;
+            this.hasParseError = false;
             const argument = this.parseExpressionAllowIn();
             if (argument.kind === 10 /* SyntaxKind.StringLiteral */ ||
                 argument.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ ||
@@ -4491,7 +4572,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseArgumentList() {
         this.parseExpected(20 /* SyntaxKind.OpenParenToken */);
-        const result = this.parseDelimitedList(11 /* ParsingContext.ArgumentExpressions */, 21 /* ListElement.ArgumentExpression */);
+        const result = this.parseDelimitedList(11 /* ParsingContext.ArgumentExpressions */, 23 /* ListElement.ArgumentExpression */);
         this.parseExpected(21 /* SyntaxKind.CloseParenToken */);
         return result;
     }
@@ -4614,7 +4695,7 @@ export class Parser extends ScannerErrorReporter {
         const openBracketPosition = this.scanner.getTokenStart();
         const openBracketParsed = this.parseExpected(22 /* SyntaxKind.OpenBracketToken */);
         const multiLine = this.hasPrecedingLineBreak();
-        const elements = this.parseDelimitedList(15 /* ParsingContext.ArrayLiteralMembers */, 22 /* ListElement.ArrayLiteralElement */);
+        const elements = this.parseDelimitedList(15 /* ParsingContext.ArrayLiteralMembers */, 24 /* ListElement.ArrayLiteralElement */);
         this.parseExpectedMatchingBrackets(22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */, openBracketParsed, openBracketPosition);
         return this.finishNode(new ArrayLiteralExpression(elements, multiLine), pos);
     }
@@ -4623,7 +4704,7 @@ export class Parser extends ScannerErrorReporter {
         const openBracePosition = this.scanner.getTokenStart();
         const openBraceParsed = this.parseExpected(18 /* SyntaxKind.OpenBraceToken */);
         const multiLine = this.hasPrecedingLineBreak();
-        const properties = this.parseDelimitedList(12 /* ParsingContext.ObjectLiteralMembers */, 23 /* ListElement.ObjectLiteralElement */);
+        const properties = this.parseDelimitedList(12 /* ParsingContext.ObjectLiteralMembers */, 25 /* ListElement.ObjectLiteralElement */);
         this.parseExpectedMatchingBrackets(18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */, openBraceParsed, openBracePosition);
         return this.finishNode(new ObjectLiteralExpression(properties, multiLine), pos);
     }
@@ -4636,9 +4717,9 @@ export class Parser extends ScannerErrorReporter {
         }
         const modifiers = this.parseModifiersEx(true, false, false);
         if (this.parseContextualModifier(138 /* SyntaxKind.GetKeyword */))
-            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 178 /* SyntaxKind.GetAccessor */, 0 /* ParseFlags.None */);
+            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 179 /* SyntaxKind.GetAccessor */, 0 /* ParseFlags.None */);
         if (this.parseContextualModifier(153 /* SyntaxKind.SetKeyword */))
-            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 179 /* SyntaxKind.SetAccessor */, 0 /* ParseFlags.None */);
+            return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 180 /* SyntaxKind.SetAccessor */, 0 /* ParseFlags.None */);
         const asteriskToken = this.parseOptionalToken(41 /* SyntaxKind.AsteriskToken */);
         const tokenIsIdentifier = this.isIdentifier();
         const name = this.parsePropertyName(2 /* IdentifierUse.ElementName */);
@@ -4703,7 +4784,7 @@ export class Parser extends ScannerErrorReporter {
         const jsdoc = this.jsdocScannerInfo();
         const modifiers = this.parseModifiersEx(true, false, false);
         if (this.token() === 85 /* SyntaxKind.ClassKeyword */)
-            return this.parseClassDeclarationOrExpression(pos, jsdoc, modifiers, 232 /* SyntaxKind.ClassExpression */);
+            return this.parseClassDeclarationOrExpression(pos, jsdoc, modifiers, 233 /* SyntaxKind.ClassExpression */);
         this.parseErrorAt(this.nodePos(), this.nodePos(), 78 /* Diagnostics.Expression_expected */);
         return this.finishNode(new MissingDeclaration(modifiers), pos);
     }
@@ -4776,7 +4857,7 @@ export class Parser extends ScannerErrorReporter {
     // Identifiers
     parseIdentifierNameErrorOnUnicodeEscapeSequence(use = 0 /* IdentifierUse.Reference */) {
         if (this.scanner.hasUnicodeEscape() || this.scanner.hasExtendedUnicodeEscape())
-            this.parseErrorAtCurrentToken(1824 /* Diagnostics.Unicode_escape_sequence_cannot_appear_here */);
+            this.parseErrorAtCurrentToken(1844 /* Diagnostics.Unicode_escape_sequence_cannot_appear_here */);
         return this.createIdentifier(tokenIsIdentifierOrKeyword(this.token()), use);
     }
     parseBindingIdentifier() {
@@ -4818,7 +4899,7 @@ export class Parser extends ScannerErrorReporter {
         if (this.token() === 80 /* SyntaxKind.PrivateIdentifier */) {
             this.parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage !== undefined
                 ? privateIdentifierDiagnosticMessage
-                : 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+                : 1858 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
             return this.createIdentifier(true, use);
         }
         // Report at the current position only at the end of the file: elsewhere the error would land
@@ -5268,14 +5349,14 @@ export class Parser extends ScannerErrorReporter {
         const modifiers = modifierList.nodes;
         if (canHaveIllegalDecorators(node)) {
             for (const modifier of modifiers)
-                if (modifier.kind === 171 /* SyntaxKind.Decorator */) {
+                if (modifier.kind === 172 /* SyntaxKind.Decorator */) {
                     this.jsErrorAt(modifier.pos, modifier.end, 160 /* Diagnostics.Decorators_are_not_valid_here */);
                     break;
                 }
         }
         else if (canHaveDecorators(node)) {
-            const decoratorIndex = findKindIndex(modifiers, 171 /* SyntaxKind.Decorator */, 0);
-            if (decoratorIndex >= 0 && node.kind === 264 /* SyntaxKind.ClassDeclaration */) {
+            const decoratorIndex = findKindIndex(modifiers, 172 /* SyntaxKind.Decorator */, 0);
+            if (decoratorIndex >= 0 && node.kind === 265 /* SyntaxKind.ClassDeclaration */) {
                 const exportIndex = findKindIndex(modifiers, 94 /* SyntaxKind.ExportKeyword */, 0);
                 if (exportIndex >= 0) {
                     const defaultIndex = findKindIndex(modifiers, 89 /* SyntaxKind.DefaultKeyword */, 0);
@@ -5286,12 +5367,12 @@ export class Parser extends ScannerErrorReporter {
                     }
                     else if (decoratorIndex < exportIndex) {
                         // A trailing decorator after `export`.
-                        const trailingDecoratorIndex = findKindIndex(modifiers, 171 /* SyntaxKind.Decorator */, exportIndex);
+                        const trailingDecoratorIndex = findKindIndex(modifiers, 172 /* SyntaxKind.Decorator */, exportIndex);
                         if (trailingDecoratorIndex >= 0) {
                             const trailing = modifiers[trailingDecoratorIndex];
                             const leading = modifiers[decoratorIndex];
-                            const diagnostic = new Diagnostic(undefined, skipTrivia(this.sourceText, trailing.pos), trailing.end, 1767 /* Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export */, noArgs);
-                            diagnostic.addRelatedInfo(new Diagnostic(undefined, skipTrivia(this.sourceText, leading.pos), leading.end, 401 /* Diagnostics.Decorator_used_before_export_here */, noArgs));
+                            const diagnostic = new Diagnostic(undefined, skipTrivia(this.sourceText, trailing.pos), trailing.end, 1787 /* Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export */, noArgs);
+                            diagnostic.addRelatedInfo(new Diagnostic(undefined, skipTrivia(this.sourceText, leading.pos), leading.end, 399 /* Diagnostics.Decorator_used_before_export_here */, noArgs));
                             this.jsDiagnostics.push(diagnostic);
                         }
                     }
@@ -5304,150 +5385,150 @@ export class Parser extends ScannerErrorReporter {
         if ((node.flags & 65536 /* NodeFlags.JavaScriptFile */) === 0 || (node.flags & (4194304 /* NodeFlags.JSDoc */ | 8 /* NodeFlags.Reparsed */)) !== 0)
             return node;
         switch (node.kind) {
-            case 170 /* SyntaxKind.Parameter */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 174 /* SyntaxKind.MethodSignature */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 182 /* SyntaxKind.IndexSignature */: {
-                if (node.kind === 170 /* SyntaxKind.Parameter */ ||
-                    node.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
-                    node.kind === 175 /* SyntaxKind.MethodDeclaration */) {
+            case 171 /* SyntaxKind.Parameter */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 175 /* SyntaxKind.MethodSignature */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
+            case 183 /* SyntaxKind.IndexSignature */: {
+                if (node.kind === 171 /* SyntaxKind.Parameter */ ||
+                    node.kind === 174 /* SyntaxKind.PropertyDeclaration */ ||
+                    node.kind === 176 /* SyntaxKind.MethodDeclaration */) {
                     const token = getQuestionTokenOfNode(node);
                     if (token !== undefined &&
                         (token.flags & 8 /* NodeFlags.Reparsed */) === 0 &&
                         token.kind === 57 /* SyntaxKind.QuestionToken */)
-                        this.jsErrorAt(token.pos, token.end, 1741 /* Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files */, [
+                        this.jsErrorAt(token.pos, token.end, 1761 /* Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files */, [
                             '?',
                         ]);
                 }
                 const type = getType(node);
                 if (isFunctionLike(node) && getBody(node) === undefined)
-                    this.jsErrorAt(node.pos, node.end, 1747 /* Diagnostics.Signature_declarations_can_only_be_used_in_TypeScript_files */);
+                    this.jsErrorAt(node.pos, node.end, 1767 /* Diagnostics.Signature_declarations_can_only_be_used_in_TypeScript_files */);
                 else if (type !== undefined && (type.flags & 8 /* NodeFlags.Reparsed */) === 0)
-                    this.jsErrorAt(type.pos, type.end, 1742 /* Diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files */);
+                    this.jsErrorAt(type.pos, type.end, 1762 /* Diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files */);
                 break;
             }
-            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
                 if (node instanceof ImportDeclaration) {
                     const clause = node.importClause;
                     if (clause !== undefined && clause.phaseModifier === 156 /* SyntaxKind.TypeKeyword */)
-                        this.jsErrorAt(node.pos, node.end, 1739 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, ['import type']);
+                        this.jsErrorAt(node.pos, node.end, 1759 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, ['import type']);
                 }
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 if (getIsTypeOnly(node))
-                    this.jsErrorAt(node.pos, node.end, 1739 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [
+                    this.jsErrorAt(node.pos, node.end, 1759 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [
                         'export type',
                     ]);
                 break;
-            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
                 if (getIsTypeOnly(node))
-                    this.jsErrorAt(node.pos, node.end, 1739 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [
+                    this.jsErrorAt(node.pos, node.end, 1759 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [
                         'import...type',
                     ]);
                 break;
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 if (getIsTypeOnly(node))
-                    this.jsErrorAt(node.pos, node.end, 1739 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [
+                    this.jsErrorAt(node.pos, node.end, 1759 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [
                         'export...type',
                     ]);
                 break;
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-                this.jsErrorAt(node.pos, node.end, 1735 /* Diagnostics.X_import_can_only_be_used_in_TypeScript_files */);
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+                this.jsErrorAt(node.pos, node.end, 1755 /* Diagnostics.X_import_can_only_be_used_in_TypeScript_files */);
                 break;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 if (node instanceof ExportAssignment && node.isExportEquals)
-                    this.jsErrorAt(node.pos, node.end, 1736 /* Diagnostics.X_export_can_only_be_used_in_TypeScript_files */);
+                    this.jsErrorAt(node.pos, node.end, 1756 /* Diagnostics.X_export_can_only_be_used_in_TypeScript_files */);
                 break;
-            case 299 /* SyntaxKind.HeritageClause */:
+            case 300 /* SyntaxKind.HeritageClause */:
                 if (node instanceof HeritageClause && node.token === 118 /* SyntaxKind.ImplementsKeyword */)
-                    this.jsErrorAt(node.pos, node.end, 1738 /* Diagnostics.X_implements_clauses_can_only_be_used_in_TypeScript_files */);
+                    this.jsErrorAt(node.pos, node.end, 1758 /* Diagnostics.X_implements_clauses_can_only_be_used_in_TypeScript_files */);
                 break;
-            case 265 /* SyntaxKind.InterfaceDeclaration */: {
+            case 266 /* SyntaxKind.InterfaceDeclaration */: {
                 const name = getName(node);
-                this.jsErrorAt(name.pos, name.end, 1739 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [
+                this.jsErrorAt(name.pos, name.end, 1759 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [
                     'interface',
                 ]);
                 break;
             }
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 if (node instanceof ModuleDeclaration)
-                    this.jsErrorAt(node.name.pos, node.name.end, 1739 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [tokenToString(node.keyword)]);
+                    this.jsErrorAt(node.name.pos, node.name.end, 1759 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, [tokenToString(node.keyword)]);
                 break;
-            case 266 /* SyntaxKind.TypeAliasDeclaration */: {
+            case 267 /* SyntaxKind.TypeAliasDeclaration */: {
                 const name = getName(node);
-                this.jsErrorAt(name.pos, name.end, 1740 /* Diagnostics.Type_aliases_can_only_be_used_in_TypeScript_files */);
+                this.jsErrorAt(name.pos, name.end, 1760 /* Diagnostics.Type_aliases_can_only_be_used_in_TypeScript_files */);
                 break;
             }
-            case 267 /* SyntaxKind.EnumDeclaration */: {
+            case 268 /* SyntaxKind.EnumDeclaration */: {
                 const name = getName(node);
-                this.jsErrorAt(name.pos, name.end, 1739 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, ['enum']);
+                this.jsErrorAt(name.pos, name.end, 1759 /* Diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files */, ['enum']);
                 break;
             }
-            case 236 /* SyntaxKind.NonNullExpression */:
-                this.jsErrorAt(node.pos, node.end, 1745 /* Diagnostics.Non_null_assertions_can_only_be_used_in_TypeScript_files */);
+            case 237 /* SyntaxKind.NonNullExpression */:
+                this.jsErrorAt(node.pos, node.end, 1765 /* Diagnostics.Non_null_assertions_can_only_be_used_in_TypeScript_files */);
                 break;
-            case 235 /* SyntaxKind.AsExpression */: {
+            case 236 /* SyntaxKind.AsExpression */: {
                 const type = getType(node);
-                this.jsErrorAt(type.pos, type.end, 1746 /* Diagnostics.Type_assertion_expressions_can_only_be_used_in_TypeScript_files */);
+                this.jsErrorAt(type.pos, type.end, 1766 /* Diagnostics.Type_assertion_expressions_can_only_be_used_in_TypeScript_files */);
                 break;
             }
-            case 239 /* SyntaxKind.SatisfiesExpression */: {
+            case 240 /* SyntaxKind.SatisfiesExpression */: {
                 const type = getType(node);
-                this.jsErrorAt(type.pos, type.end, 1766 /* Diagnostics.Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files */);
+                this.jsErrorAt(type.pos, type.end, 1786 /* Diagnostics.Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files */);
                 break;
             }
         }
         this.checkJSDecoratorSyntax(node);
         // Type parameters, type arguments and TypeScript-only modifiers.
         switch (node.kind) {
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 244 /* SyntaxKind.VariableStatement */:
-            case 173 /* SyntaxKind.PropertyDeclaration */: {
-                if (node.kind !== 244 /* SyntaxKind.VariableStatement */ && node.kind !== 173 /* SyntaxKind.PropertyDeclaration */) {
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 245 /* SyntaxKind.VariableStatement */:
+            case 174 /* SyntaxKind.PropertyDeclaration */: {
+                if (node.kind !== 245 /* SyntaxKind.VariableStatement */ && node.kind !== 174 /* SyntaxKind.PropertyDeclaration */) {
                     const list = getTypeParameters(node);
                     if (list !== undefined && hasNonReparsedNode(list.nodes))
-                        this.jsErrorAt(list.pos, list.end, 1737 /* Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files */);
+                        this.jsErrorAt(list.pos, list.end, 1757 /* Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files */);
                 }
                 const modifiers = getModifiers(node);
                 if (modifiers !== undefined)
                     for (const modifier of modifiers.nodes)
                         if ((modifier.flags & 8 /* NodeFlags.Reparsed */) === 0 &&
-                            modifier.kind !== 171 /* SyntaxKind.Decorator */ &&
+                            modifier.kind !== 172 /* SyntaxKind.Decorator */ &&
                             (modifierToFlag(modifier.kind) & 3872 /* ModifierFlags.JavaScript */) === 0)
-                            this.jsErrorAt(modifier.pos, modifier.end, 1741 /* Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files */, [tokenToString(modifier.kind)]);
+                            this.jsErrorAt(modifier.pos, modifier.end, 1761 /* Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files */, [tokenToString(modifier.kind)]);
                 break;
             }
-            case 170 /* SyntaxKind.Parameter */: {
+            case 171 /* SyntaxKind.Parameter */: {
                 const modifiers = getModifiers(node);
                 if (modifiers !== undefined && hasModifierNode(modifiers.nodes))
-                    this.jsErrorAt(modifiers.pos, modifiers.end, 1744 /* Diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files */);
+                    this.jsErrorAt(modifiers.pos, modifiers.end, 1764 /* Diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files */);
                 break;
             }
-            case 214 /* SyntaxKind.CallExpression */:
-            case 215 /* SyntaxKind.NewExpression */:
-            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
-            case 286 /* SyntaxKind.JsxSelfClosingElement */:
-            case 287 /* SyntaxKind.JsxOpeningElement */:
-            case 216 /* SyntaxKind.TaggedTemplateExpression */: {
+            case 215 /* SyntaxKind.CallExpression */:
+            case 216 /* SyntaxKind.NewExpression */:
+            case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
+            case 287 /* SyntaxKind.JsxSelfClosingElement */:
+            case 288 /* SyntaxKind.JsxOpeningElement */:
+            case 217 /* SyntaxKind.TaggedTemplateExpression */: {
                 const list = getTypeArguments(node);
                 if (list !== undefined && hasNonReparsedNode(list.nodes))
-                    this.jsErrorAt(list.pos, list.end, 1743 /* Diagnostics.Type_arguments_can_only_be_used_in_TypeScript_files */);
+                    this.jsErrorAt(list.pos, list.end, 1763 /* Diagnostics.Type_arguments_can_only_be_used_in_TypeScript_files */);
                 break;
             }
         }
@@ -5521,7 +5602,9 @@ export class Parser extends ScannerErrorReporter {
         return result;
     }
     jsonError(node, message) {
-        this.diagnostics.push(new Diagnostic(undefined, skipTrivia(this.sourceText, node.pos), node.end, message, noArgs));
+        // A missing node (a property without a value) keeps its position: trivia after it isn't its own.
+        const pos = nodeIsMissing(node) ? node.pos : skipTrivia(this.sourceText, node.pos);
+        this.diagnostics.push(new Diagnostic(undefined, pos, node.end, message, noArgs));
     }
     validateJsonValue(sourceFile, value) {
         switch (value.kind) {
@@ -5534,17 +5617,17 @@ export class Parser extends ScannerErrorReporter {
                 if (!isDoubleQuotedString(value))
                     this.jsonError(value, 263 /* Diagnostics.String_literal_with_double_quotes_expected */);
                 return;
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
                 if (value instanceof PrefixUnaryExpression &&
                     value.operator === 40 /* SyntaxKind.MinusToken */ &&
                     value.operand.kind === 8 /* SyntaxKind.NumericLiteral */)
                     return;
                 break;
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
                 if (value instanceof ObjectLiteralExpression)
                     this.validateJsonObjectLiteral(sourceFile, value);
                 return;
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
                 if (value instanceof ArrayLiteralExpression)
                     for (const element of value.elements.nodes)
                         this.validateJsonValue(sourceFile, element);
@@ -5705,7 +5788,7 @@ export function getAttachedJSDoc(node) {
             break;
         root = parent;
     }
-    if (root.kind !== 307 /* SyntaxKind.SourceFile */)
+    if (root.kind !== 308 /* SyntaxKind.SourceFile */)
         return undefined;
     const jsDocs = root.jsDocs;
     const attached = jsDocs === undefined ? undefined : jsDocs.get(node.id);
@@ -5861,6 +5944,15 @@ function nextTokenIsIdentifier(p) {
 function nextTokenIsOpenParen(p) {
     return p.nextToken() === 20 /* SyntaxKind.OpenParenToken */;
 }
+/** An identifier or a chain of property accesses without optional chaining, each name present. */
+function isValidHeritageTypeReferenceExpression(node) {
+    if (node instanceof Identifier)
+        return nodeIsPresent(node);
+    if (!(node instanceof PropertyAccessExpression) || (node.flags & 32 /* NodeFlags.OptionalChain */) !== 0)
+        return false;
+    return (nodeIsPresent(node.name) &&
+        isValidHeritageTypeReferenceExpression(node.expression));
+}
 function nextTokenIsOpenBrace(p) {
     return p.nextToken() === 18 /* SyntaxKind.OpenBraceToken */;
 }
@@ -6297,7 +6389,7 @@ class PositionFinder extends NodeVisitor {
     }
 }
 function nodeContainsPosition(node, position) {
-    return (node.kind >= 167 /* SyntaxKind.FirstNode */ &&
+    return (node.kind >= 168 /* SyntaxKind.FirstNode */ &&
         node.pos <= position &&
         (position < node.end || (position === node.end && node.kind === 1 /* SyntaxKind.EndOfFile */)));
 }
@@ -6324,7 +6416,7 @@ export function getNodeAtPosition(file, position, includeJSDoc) {
             current.forEachChild(finder);
             child = finder.found;
         }
-        if (child === undefined || child.kind === 237 /* SyntaxKind.MetaProperty */)
+        if (child === undefined || child.kind === 238 /* SyntaxKind.MetaProperty */)
             return current;
         current = child;
     }
@@ -6332,9 +6424,9 @@ export function getNodeAtPosition(file, position, includeJSDoc) {
 class JsxTagFinder extends NodeVisitor {
     found = undefined;
     visitNode(node) {
-        if (node.kind === 287 /* SyntaxKind.JsxOpeningElement */ ||
-            node.kind === 286 /* SyntaxKind.JsxSelfClosingElement */ ||
-            node.kind === 289 /* SyntaxKind.JsxFragment */) {
+        if (node.kind === 288 /* SyntaxKind.JsxOpeningElement */ ||
+            node.kind === 287 /* SyntaxKind.JsxSelfClosingElement */ ||
+            node.kind === 290 /* SyntaxKind.JsxFragment */) {
             this.found = node;
             return true;
         }
@@ -6354,10 +6446,10 @@ class ImportMetaFinder extends NodeVisitor {
 function isAnExternalModuleIndicatorNode(node) {
     return (hasModifierFlag(node, 32 /* ModifierFlags.Export */) ||
         (node instanceof ImportEqualsDeclaration &&
-            node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */) ||
-        node.kind === 273 /* SyntaxKind.ImportDeclaration */ ||
-        node.kind === 278 /* SyntaxKind.ExportAssignment */ ||
-        node.kind === 279 /* SyntaxKind.ExportDeclaration */);
+            node.moduleReference.kind === 285 /* SyntaxKind.ExternalModuleReference */) ||
+        node.kind === 274 /* SyntaxKind.ImportDeclaration */ ||
+        node.kind === 279 /* SyntaxKind.ExportAssignment */ ||
+        node.kind === 280 /* SyntaxKind.ExportDeclaration */);
 }
 function getExternalModuleIndicator(file) {
     if (file.scriptKind === 6 /* ScriptKind.JSON */)
@@ -6394,7 +6486,7 @@ export function isNodeCoreModule(moduleName) {
         (moduleName.startsWith('node:') && unprefixedNodeCoreModules.has(moduleName.substring(5))));
 }
 // `require('module').builtinModules`, without and with only the `node:` prefix.
-const unprefixedNodeCoreModules = new Set([
+export const unprefixedNodeCoreModules = new Set([
     'assert',
     'assert/strict',
     'async_hooks',
@@ -6450,7 +6542,7 @@ const unprefixedNodeCoreModules = new Set([
     'worker_threads',
     'zlib',
 ]);
-const exclusivelyPrefixedNodeCoreModules = new Set([
+export const exclusivelyPrefixedNodeCoreModules = new Set([
     'node:quic',
     'node:sea',
     'node:sqlite',