xbintsc 0.1.0

package/dist/src/parser/parser.js

@@ -0,0 +1,2334 @@
+import { DiagnosticCode } from "../diagnostics/diagnostic.js";
+import { Scanner } from "../lexer/scanner.js";
+import { isOfKeyword, TokenKind } from "../lexer/token.js";
+import { AssignmentOperator, BinaryOperator, ModifierKind, NodeFlags, PostfixUnaryOperator, PrefixUnaryOperator, SyntaxKind, TypeOperator, } from "../ast/nodes.js";
+/**
+ * Recursive-descent parser for TypeScript.
+ *
+ * Type syntax is parsed for structure but erased before code generation; the
+ * parser is therefore permissive about types while the backend focuses on the
+ * value-level language.
+ */
+export class Parser {
+    scanner;
+    diagnostics;
+    source;
+    tokens;
+    index = 0;
+    /** Non-zero while a speculative parse is running; errors abort the attempt. */
+    speculating = 0;
+    /** Monotonic count of tokens consumed; used to detect lack of progress. */
+    consumed = 0;
+    constructor(source, diagnostics) {
+        this.source = source;
+        this.diagnostics = diagnostics;
+        this.scanner = new Scanner(source, diagnostics);
+        this.tokens = [this.scanner.nextToken()];
+    }
+    // -- token access ---------------------------------------------------------
+    get token() {
+        return this.tokens[this.index];
+    }
+    /**
+     * Compare the current token kind without triggering TypeScript's control-flow
+     * narrowing of `this.token.kind`, which would otherwise be invalidated by the
+     * calls to `nextToken()` that occur between checks.
+     */
+    at(kind) {
+        return this.tokens[this.index].kind === kind;
+    }
+    atAhead(k, kind) {
+        return this.lookAhead(k).kind === kind;
+    }
+    lookAhead(k) {
+        while (this.tokens.length <= this.index + k) {
+            this.tokens.push(this.scanner.nextToken());
+        }
+        return this.tokens[this.index + k];
+    }
+    nextToken() {
+        this.consumed++;
+        const current = this.token;
+        if (this.index + 1 < this.tokens.length) {
+            this.index++;
+        }
+        else {
+            this.tokens = [this.scanner.nextToken()];
+            this.index = 0;
+        }
+        return current;
+    }
+    parseExpected(kind, message) {
+        if (this.token.kind === kind)
+            return this.nextToken();
+        this.error(DiagnosticCode.ExpectedToken, message ?? `Expected '${kind}' but found '${this.token.text || this.token.kind}'`, this.token);
+        return this.token;
+    }
+    error(code, message, token = this.token) {
+        this.diagnostics.error(code, message, { start: token.start, end: token.end }, this.source.fileName);
+        if (this.speculating > 0)
+            throw new SpeculationError();
+    }
+    /**
+     * Run `fn` speculatively. Any diagnostic raised while it runs (which aborts
+     * the attempt via `SpeculationError`) is rolled back along with the scanner
+     * position, so the parser can try a different production cleanly.
+     */
+    tryParse(fn) {
+        const mark = this.diagnostics.mark();
+        const state = this.saveState();
+        this.speculating++;
+        let result;
+        let ok = false;
+        try {
+            result = fn();
+            ok = true;
+        }
+        catch (error) {
+            if (!(error instanceof SpeculationError))
+                throw error;
+        }
+        finally {
+            this.speculating--;
+        }
+        if (!ok) {
+            this.diagnostics.reset(mark);
+            this.restoreState(state);
+            return undefined;
+        }
+        return result;
+    }
+    isIdentifierLike(token) {
+        if (token.kind === TokenKind.Identifier)
+            return true;
+        switch (token.kind) {
+            case TokenKind.AsKeyword:
+            case TokenKind.SatisfiesKeyword:
+            case TokenKind.FromKeyword:
+            case TokenKind.TypeKeyword:
+            case TokenKind.GetKeyword:
+            case TokenKind.SetKeyword:
+            case TokenKind.AsyncKeyword:
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseIdentifier(allowKeywords = false) {
+        const token = this.token;
+        if (token.kind === TokenKind.Identifier || (allowKeywords && this.isIdentifierLike(token))) {
+            this.nextToken();
+            return { kind: SyntaxKind.Identifier, text: token.text, start: token.start, end: token.end };
+        }
+        this.error(DiagnosticCode.ExpectedIdentifier, `Expected identifier but found '${token.text || token.kind}'`);
+        if (token.kind !== TokenKind.EndOfFile)
+            this.nextToken();
+        return { kind: SyntaxKind.Identifier, text: token.text || "missing", start: token.start, end: token.end };
+    }
+    parseIdentifierName() {
+        return this.parseIdentifier(/* allowKeywords */ true);
+    }
+    parseSemicolon() {
+        if (this.at(TokenKind.Semicolon)) {
+            this.nextToken();
+            return;
+        }
+        if (this.canInsertSemicolon())
+            return;
+        this.error(DiagnosticCode.ExpectedToken, "Expected ';'", this.token);
+    }
+    canInsertSemicolon() {
+        return this.at(TokenKind.EndOfFile) || this.at(TokenKind.CloseBrace) || this.token.precededByLineBreak;
+    }
+    parseDelimitedList(close, parseElement) {
+        const items = [];
+        while (this.token.kind !== close && !this.at(TokenKind.EndOfFile)) {
+            const before = this.consumed;
+            items.push(parseElement());
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+            if (this.consumed === before && this.token.kind !== close)
+                this.nextToken();
+        }
+        this.parseExpected(close);
+        return items;
+    }
+    // -- entry point ----------------------------------------------------------
+    parseSourceFile() {
+        const statements = [];
+        while (!this.at(TokenKind.EndOfFile)) {
+            const before = this.consumed;
+            const beforePos = this.scanner.position;
+            const statement = this.parseStatement();
+            if (statement)
+                statements.push(statement);
+            if (this.consumed === before) {
+                this.error(DiagnosticCode.UnexpectedToken, `Unexpected token '${this.token.text}'`, this.token);
+                this.nextToken();
+            }
+        }
+        return {
+            kind: SyntaxKind.SourceFile,
+            statements,
+            fileName: this.source.fileName,
+            text: this.source.text,
+            start: 0,
+            end: this.source.text.length,
+        };
+    }
+    // -- modifiers ------------------------------------------------------------
+    tryParseModifiers() {
+        const modifiers = [];
+        for (;;) {
+            const kind = this.token.kind;
+            let modifierKind;
+            switch (kind) {
+                case TokenKind.ExportKeyword:
+                    modifierKind = ModifierKind.Export;
+                    break;
+                case TokenKind.DefaultKeyword:
+                    if (this.atAhead(1, TokenKind.FunctionKeyword) || this.atAhead(1, TokenKind.ClassKeyword)) {
+                        modifierKind = ModifierKind.Default;
+                    }
+                    break;
+                case TokenKind.DeclareKeyword:
+                    modifierKind = ModifierKind.Declare;
+                    break;
+                case TokenKind.AbstractKeyword:
+                    modifierKind = ModifierKind.Abstract;
+                    break;
+                case TokenKind.PublicKeyword:
+                    modifierKind = ModifierKind.Public;
+                    break;
+                case TokenKind.PrivateKeyword:
+                    modifierKind = ModifierKind.Private;
+                    break;
+                case TokenKind.ProtectedKeyword:
+                    modifierKind = ModifierKind.Protected;
+                    break;
+                case TokenKind.StaticKeyword:
+                    modifierKind = ModifierKind.Static;
+                    break;
+                case TokenKind.ReadonlyKeyword:
+                    modifierKind = ModifierKind.Readonly;
+                    break;
+                case TokenKind.AsyncKeyword:
+                    if (!this.lookAhead(1).precededByLineBreak)
+                        modifierKind = ModifierKind.Async;
+                    break;
+                default:
+                    break;
+            }
+            if (!modifierKind)
+                break;
+            const token = this.nextToken();
+            modifiers.push({ kind: SyntaxKind.Unknown, modifierKind, start: token.start, end: token.end });
+        }
+        return modifiers;
+    }
+    hasModifier(modifiers, kind) {
+        return modifiers.some((m) => m.modifierKind === kind);
+    }
+    // -- statements -----------------------------------------------------------
+    parseStatement() {
+        const token = this.token;
+        switch (token.kind) {
+            case TokenKind.OpenBrace:
+                return this.parseBlock();
+            case TokenKind.Semicolon: {
+                const t = this.nextToken();
+                return { kind: SyntaxKind.EmptyStatement, start: t.start, end: t.end };
+            }
+            case TokenKind.VarKeyword:
+            case TokenKind.LetKeyword:
+            case TokenKind.ConstKeyword:
+                return this.parseVariableStatement([]);
+            case TokenKind.FunctionKeyword:
+                return this.parseFunctionDeclaration([]);
+            case TokenKind.AsyncKeyword:
+                if (this.atAhead(1, TokenKind.FunctionKeyword) && !this.lookAhead(1).precededByLineBreak) {
+                    const asyncMod = this.tryParseModifiers();
+                    return this.parseFunctionDeclaration(asyncMod);
+                }
+                break;
+            case TokenKind.ClassKeyword:
+                return this.parseClassDeclaration([]);
+            case TokenKind.IfKeyword:
+                return this.parseIfStatement();
+            case TokenKind.WhileKeyword:
+                return this.parseWhileStatement();
+            case TokenKind.DoKeyword:
+                return this.parseDoStatement();
+            case TokenKind.ForKeyword:
+                return this.parseForStatement();
+            case TokenKind.ReturnKeyword:
+                return this.parseReturnStatement();
+            case TokenKind.BreakKeyword:
+                return this.parseBreakStatement();
+            case TokenKind.ContinueKeyword:
+                return this.parseContinueStatement();
+            case TokenKind.ThrowKeyword:
+                return this.parseThrowStatement();
+            case TokenKind.TryKeyword:
+                return this.parseTryStatement();
+            case TokenKind.SwitchKeyword:
+                return this.parseSwitchStatement();
+            case TokenKind.DebuggerKeyword: {
+                const t = this.nextToken();
+                this.parseSemicolon();
+                return { kind: SyntaxKind.DebuggerStatement, start: t.start, end: t.end };
+            }
+            case TokenKind.ImportKeyword:
+                if (this.atAhead(1, TokenKind.OpenParen) || this.atAhead(1, TokenKind.Dot))
+                    break;
+                return this.parseImportDeclaration();
+            case TokenKind.ExportKeyword:
+                return this.parseExportDeclaration();
+            case TokenKind.InterfaceKeyword:
+                return this.parseInterfaceDeclaration([]);
+            case TokenKind.TypeKeyword:
+                if (this.isIdentifierLike(this.lookAhead(1)))
+                    return this.parseTypeAliasDeclaration([]);
+                break;
+            case TokenKind.EnumKeyword:
+                return this.parseEnumDeclaration([]);
+            case TokenKind.NamespaceKeyword:
+            case TokenKind.ModuleKeyword:
+                return this.parseModuleDeclaration([]);
+            case TokenKind.DeclareKeyword: {
+                const modifiers = this.tryParseModifiers();
+                return this.parseStatementWithModifiers(modifiers);
+            }
+            default:
+                break;
+        }
+        return this.parseExpressionStatement();
+    }
+    parseStatementWithModifiers(modifiers) {
+        switch (this.token.kind) {
+            case TokenKind.FunctionKeyword:
+                return this.parseFunctionDeclaration(modifiers);
+            case TokenKind.ClassKeyword:
+                return this.parseClassDeclaration(modifiers);
+            case TokenKind.InterfaceKeyword:
+                return this.parseInterfaceDeclaration(modifiers);
+            case TokenKind.TypeKeyword:
+                return this.parseTypeAliasDeclaration(modifiers);
+            case TokenKind.EnumKeyword:
+                return this.parseEnumDeclaration(modifiers);
+            case TokenKind.NamespaceKeyword:
+            case TokenKind.ModuleKeyword:
+                return this.parseModuleDeclaration(modifiers);
+            default:
+                return this.parseExpressionStatement();
+        }
+    }
+    parseBlock() {
+        const open = this.parseExpected(TokenKind.OpenBrace);
+        const statements = [];
+        while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+            const before = this.consumed;
+            const beforePos = this.scanner.position;
+            const s = this.parseStatement();
+            if (s)
+                statements.push(s);
+            if (this.consumed === before) {
+                this.error(DiagnosticCode.UnexpectedToken, `Unexpected token '${this.token.text}'`, this.token);
+                this.nextToken();
+            }
+        }
+        const close = this.parseExpected(TokenKind.CloseBrace);
+        return { kind: SyntaxKind.Block, statements, start: open.start, end: close.end };
+    }
+    parseVariableStatement(modifiers) {
+        const declList = this.parseVariableDeclarationList();
+        this.parseSemicolon();
+        return { kind: SyntaxKind.VariableStatement, declarationList: declList, modifiers, start: declList.start, end: declList.end };
+    }
+    parseVariableDeclarationList() {
+        const keyword = this.nextToken();
+        const declarationKind = keyword.kind === TokenKind.ConstKeyword ? "const" : keyword.kind === TokenKind.LetKeyword ? "let" : "var";
+        const declarations = [];
+        do {
+            declarations.push(this.parseVariableDeclaration());
+        } while (this.at(TokenKind.Comma) && this.nextToken());
+        return {
+            kind: SyntaxKind.VariableDeclarationList,
+            declarations,
+            declarationKind,
+            start: keyword.start,
+            end: declarations[declarations.length - 1]?.end ?? keyword.end,
+        };
+    }
+    parseVariableDeclaration() {
+        const name = this.parseIdentifier();
+        let exclamation = false;
+        if (this.at(TokenKind.Exclamation)) {
+            this.nextToken();
+            exclamation = true;
+        }
+        let type;
+        if (this.at(TokenKind.Colon)) {
+            this.nextToken();
+            type = this.parseType();
+        }
+        let initializer;
+        if (this.at(TokenKind.Equals)) {
+            this.nextToken();
+            initializer = this.parseAssignmentExpression();
+        }
+        return {
+            kind: SyntaxKind.VariableDeclaration,
+            name,
+            exclamation,
+            type,
+            initializer,
+            start: name.start,
+            end: initializer?.end ?? type?.end ?? name.end,
+        };
+    }
+    parseIfStatement() {
+        const start = this.parseExpected(TokenKind.IfKeyword).start;
+        this.parseExpected(TokenKind.OpenParen);
+        const condition = this.parseExpression();
+        this.parseExpected(TokenKind.CloseParen);
+        const thenStatement = this.parseStatement();
+        let elseStatement;
+        if (this.at(TokenKind.ElseKeyword)) {
+            this.nextToken();
+            elseStatement = this.parseStatement();
+        }
+        return { kind: SyntaxKind.IfStatement, condition, thenStatement, elseStatement, start, end: elseStatement?.end ?? thenStatement.end };
+    }
+    parseWhileStatement() {
+        const start = this.parseExpected(TokenKind.WhileKeyword).start;
+        this.parseExpected(TokenKind.OpenParen);
+        const condition = this.parseExpression();
+        this.parseExpected(TokenKind.CloseParen);
+        const statement = this.parseStatement();
+        return { kind: SyntaxKind.WhileStatement, condition, statement, start, end: statement.end };
+    }
+    parseDoStatement() {
+        const start = this.parseExpected(TokenKind.DoKeyword).start;
+        const statement = this.parseStatement();
+        this.parseExpected(TokenKind.WhileKeyword);
+        this.parseExpected(TokenKind.OpenParen);
+        const condition = this.parseExpression();
+        const close = this.parseExpected(TokenKind.CloseParen);
+        this.parseSemicolon();
+        return { kind: SyntaxKind.DoStatement, condition, statement, start, end: close.end };
+    }
+    parseForStatement() {
+        const start = this.parseExpected(TokenKind.ForKeyword).start;
+        let awaitModifier = false;
+        if (this.at(TokenKind.AwaitKeyword)) {
+            this.nextToken();
+            awaitModifier = true;
+        }
+        this.parseExpected(TokenKind.OpenParen);
+        let initializer;
+        if (!this.at(TokenKind.Semicolon)) {
+            if (this.at(TokenKind.VarKeyword) || this.at(TokenKind.LetKeyword) || this.at(TokenKind.ConstKeyword)) {
+                initializer = this.parseVariableDeclarationList();
+            }
+            else {
+                initializer = this.parseExpression(/* noIn */ true);
+            }
+        }
+        if (isOfKeyword(this.token)) {
+            this.nextToken();
+            const expression = this.parseAssignmentExpression();
+            this.parseExpected(TokenKind.CloseParen);
+            const statement = this.parseStatement();
+            return { kind: SyntaxKind.ForOfStatement, initializer: initializer, expression, statement, awaitModifier, start, end: statement.end };
+        }
+        if (this.at(TokenKind.InKeyword)) {
+            this.nextToken();
+            const expression = this.parseExpression();
+            this.parseExpected(TokenKind.CloseParen);
+            const statement = this.parseStatement();
+            return { kind: SyntaxKind.ForInStatement, initializer: initializer, expression, statement, start, end: statement.end };
+        }
+        this.parseExpected(TokenKind.Semicolon);
+        let condition;
+        if (!this.at(TokenKind.Semicolon))
+            condition = this.parseExpression();
+        this.parseExpected(TokenKind.Semicolon);
+        let incrementor;
+        if (!this.at(TokenKind.CloseParen))
+            incrementor = this.parseExpression();
+        this.parseExpected(TokenKind.CloseParen);
+        const statement = this.parseStatement();
+        return { kind: SyntaxKind.ForStatement, initializer, condition, incrementor, statement, start, end: statement.end };
+    }
+    parseReturnStatement() {
+        const start = this.parseExpected(TokenKind.ReturnKeyword).start;
+        let expression;
+        if (!this.at(TokenKind.Semicolon) && !this.canInsertSemicolon())
+            expression = this.parseExpression();
+        this.parseSemicolon();
+        return { kind: SyntaxKind.ReturnStatement, expression, start, end: expression?.end ?? start + 6 };
+    }
+    parseBreakStatement() {
+        const start = this.parseExpected(TokenKind.BreakKeyword).start;
+        let label;
+        if (!this.canInsertSemicolon() && !this.at(TokenKind.Semicolon))
+            label = this.parseIdentifier();
+        this.parseSemicolon();
+        return { kind: SyntaxKind.BreakStatement, label, start, end: label?.end ?? start + 5 };
+    }
+    parseContinueStatement() {
+        const start = this.parseExpected(TokenKind.ContinueKeyword).start;
+        let label;
+        if (!this.canInsertSemicolon() && !this.at(TokenKind.Semicolon))
+            label = this.parseIdentifier();
+        this.parseSemicolon();
+        return { kind: SyntaxKind.ContinueStatement, label, start, end: label?.end ?? start + 8 };
+    }
+    parseThrowStatement() {
+        const start = this.parseExpected(TokenKind.ThrowKeyword).start;
+        const expression = this.parseExpression();
+        this.parseSemicolon();
+        return { kind: SyntaxKind.ThrowStatement, expression, start, end: expression.end };
+    }
+    parseTryStatement() {
+        const start = this.parseExpected(TokenKind.TryKeyword).start;
+        const tryBlock = this.parseBlock();
+        let catchClause;
+        if (this.at(TokenKind.CatchKeyword)) {
+            const catchStart = this.nextToken().start;
+            let variable;
+            let type;
+            if (this.at(TokenKind.OpenParen)) {
+                this.nextToken();
+                variable = this.parseIdentifier();
+                if (this.at(TokenKind.Colon)) {
+                    this.nextToken();
+                    type = this.parseType();
+                }
+                this.parseExpected(TokenKind.CloseParen);
+            }
+            const block = this.parseBlock();
+            catchClause = { kind: SyntaxKind.CatchClause, variable, type, block, start: catchStart, end: block.end };
+        }
+        let finallyBlock;
+        if (this.at(TokenKind.FinallyKeyword)) {
+            this.nextToken();
+            finallyBlock = this.parseBlock();
+        }
+        return { kind: SyntaxKind.TryStatement, tryBlock, catchClause, finallyBlock, start, end: finallyBlock?.end ?? catchClause?.end ?? tryBlock.end };
+    }
+    parseSwitchStatement() {
+        const start = this.parseExpected(TokenKind.SwitchKeyword).start;
+        this.parseExpected(TokenKind.OpenParen);
+        const expression = this.parseExpression();
+        this.parseExpected(TokenKind.CloseParen);
+        this.parseExpected(TokenKind.OpenBrace);
+        const clauses = [];
+        while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+            if (this.at(TokenKind.CaseKeyword)) {
+                const caseStart = this.nextToken().start;
+                const caseExpression = this.parseExpression();
+                this.parseExpected(TokenKind.Colon);
+                const statements = [];
+                while (!this.at(TokenKind.CaseKeyword) &&
+                    !this.at(TokenKind.DefaultKeyword) &&
+                    !this.at(TokenKind.CloseBrace) &&
+                    !this.at(TokenKind.EndOfFile)) {
+                    const s = this.parseStatement();
+                    if (s)
+                        statements.push(s);
+                }
+                clauses.push({ kind: SyntaxKind.CaseClause, expression: caseExpression, statements, start: caseStart, end: statements[statements.length - 1]?.end ?? caseExpression.end });
+            }
+            else if (this.at(TokenKind.DefaultKeyword)) {
+                const defaultStart = this.nextToken().start;
+                this.parseExpected(TokenKind.Colon);
+                const statements = [];
+                while (!this.at(TokenKind.CaseKeyword) && !this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+                    const s = this.parseStatement();
+                    if (s)
+                        statements.push(s);
+                }
+                clauses.push({ kind: SyntaxKind.DefaultClause, statements, start: defaultStart, end: statements[statements.length - 1]?.end ?? defaultStart });
+            }
+            else {
+                this.error(DiagnosticCode.UnexpectedToken, `Unexpected token '${this.token.text}' in switch body`);
+                this.nextToken();
+            }
+        }
+        const close = this.parseExpected(TokenKind.CloseBrace);
+        return { kind: SyntaxKind.SwitchStatement, expression, clauses, start, end: close.end };
+    }
+    parseExpressionStatement() {
+        const expression = this.parseExpression();
+        this.parseSemicolon();
+        return { kind: SyntaxKind.ExpressionStatement, expression, start: expression.start, end: expression.end };
+    }
+    // -- declarations ---------------------------------------------------------
+    parseFunctionDeclaration(modifiers) {
+        const start = this.parseExpected(TokenKind.FunctionKeyword).start;
+        let flags = NodeFlags.None;
+        if (this.at(TokenKind.Asterisk)) {
+            this.nextToken();
+            flags |= NodeFlags.Generator;
+        }
+        if (this.hasModifier(modifiers, ModifierKind.Async))
+            flags |= NodeFlags.Async;
+        if (this.hasModifier(modifiers, ModifierKind.Declare))
+            flags |= NodeFlags.Declare;
+        let name;
+        if (!this.at(TokenKind.OpenParen) && !this.at(TokenKind.LessThan))
+            name = this.parseIdentifier();
+        const typeParameters = this.parseTypeParameters();
+        const parameters = this.parseParameters();
+        let returnType;
+        if (this.at(TokenKind.Colon)) {
+            this.nextToken();
+            returnType = this.parseReturnType();
+        }
+        let body;
+        if (this.at(TokenKind.OpenBrace))
+            body = this.parseBlock();
+        else
+            this.parseSemicolon();
+        return {
+            kind: SyntaxKind.FunctionDeclaration,
+            name,
+            modifiers,
+            typeParameters,
+            parameters,
+            returnType,
+            body,
+            flags,
+            start,
+            end: body?.end ?? returnType?.end ?? parameters[parameters.length - 1]?.end ?? start,
+        };
+    }
+    parseTypeParameters() {
+        if (!this.at(TokenKind.LessThan))
+            return [];
+        this.nextToken();
+        const params = [];
+        while (!this.at(TokenKind.GreaterThan) && !this.at(TokenKind.EndOfFile)) {
+            const name = this.parseIdentifier();
+            let constraint;
+            if (this.at(TokenKind.ExtendsKeyword)) {
+                this.nextToken();
+                constraint = this.parseType();
+            }
+            let defaultType;
+            if (this.at(TokenKind.Equals)) {
+                this.nextToken();
+                defaultType = this.parseType();
+            }
+            params.push({ kind: SyntaxKind.TypeParameterDeclaration, name, constraint, default: defaultType, start: name.start, end: defaultType?.end ?? constraint?.end ?? name.end });
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        this.parseGreaterThan();
+        return params;
+    }
+    /** Consume a `>` that may have been lexed as `>>` / `>>>`, splitting it. */
+    parseGreaterThan() {
+        const token = this.token;
+        if (token.kind === TokenKind.GreaterThan) {
+            this.nextToken();
+            return;
+        }
+        if (token.kind === TokenKind.GreaterThanGreaterThan || token.kind === TokenKind.GreaterThanGreaterThanGreaterThan) {
+            const extra = token.kind === TokenKind.GreaterThanGreaterThan ? 1 : 2;
+            this.tokens[this.index] = {
+                kind: extra === 1 ? TokenKind.GreaterThan : TokenKind.GreaterThanGreaterThan,
+                start: token.start + 1,
+                end: token.end,
+                text: token.text.slice(1),
+                precededByLineBreak: false,
+            };
+            return;
+        }
+        this.parseExpected(TokenKind.GreaterThan);
+    }
+    parseParameters() {
+        this.parseExpected(TokenKind.OpenParen);
+        const params = [];
+        while (!this.at(TokenKind.CloseParen) && !this.at(TokenKind.EndOfFile)) {
+            const start = this.token.start;
+            const modifiers = this.tryParseModifiers();
+            let dotDotDotToken = false;
+            if (this.at(TokenKind.DotDotDot)) {
+                this.nextToken();
+                dotDotDotToken = true;
+            }
+            const name = this.parseIdentifier();
+            let questionToken = false;
+            if (this.at(TokenKind.Question)) {
+                this.nextToken();
+                questionToken = true;
+            }
+            let type;
+            if (this.at(TokenKind.Colon)) {
+                this.nextToken();
+                type = this.parseType();
+            }
+            let initializer;
+            if (this.at(TokenKind.Equals)) {
+                this.nextToken();
+                initializer = this.parseAssignmentExpression();
+            }
+            params.push({ kind: SyntaxKind.Parameter, name, modifiers, dotDotDotToken, questionToken, type, initializer, start, end: initializer?.end ?? type?.end ?? name.end });
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        this.parseExpected(TokenKind.CloseParen);
+        return params;
+    }
+    parseReturnType() {
+        if (this.at(TokenKind.AssertsKeyword)) {
+            const start = this.nextToken().start;
+            let paramName;
+            if (this.isIdentifierLike(this.token) || this.at(TokenKind.ThisKeyword))
+                paramName = this.parseIdentifierName();
+            let predicateType;
+            if (this.at(TokenKind.IsKeyword)) {
+                this.nextToken();
+                predicateType = this.parseType();
+            }
+            const stub = { kind: SyntaxKind.Identifier, text: paramName?.text ?? "this", start: paramName?.start ?? start, end: paramName?.end ?? start };
+            return { kind: SyntaxKind.TypePredicate, parameterName: stub, type: predicateType, start, end: predicateType?.end ?? start };
+        }
+        if (this.isIdentifierLike(this.token) && this.atAhead(1, TokenKind.IsKeyword)) {
+            const paramName = this.parseIdentifierName();
+            this.nextToken();
+            const predicateType = this.parseType();
+            return { kind: SyntaxKind.TypePredicate, parameterName: paramName, type: predicateType, start: paramName.start, end: predicateType.end };
+        }
+        return this.parseType();
+    }
+    parseClassDeclaration(modifiers) {
+        const start = this.parseExpected(TokenKind.ClassKeyword).start;
+        let name;
+        if (!this.at(TokenKind.OpenBrace) && !this.at(TokenKind.ExtendsKeyword) && !this.at(TokenKind.ImplementsKeyword)) {
+            name = this.parseIdentifier();
+        }
+        const typeParameters = this.parseTypeParameters();
+        const heritage = this.parseHeritageClauses();
+        const members = this.parseClassMembers();
+        return { kind: SyntaxKind.ClassDeclaration, name, modifiers, typeParameters, heritage, members, start, end: members[members.length - 1]?.end ?? start };
+    }
+    parseHeritageClauses() {
+        const clauses = [];
+        while (this.at(TokenKind.ExtendsKeyword) || this.at(TokenKind.ImplementsKeyword)) {
+            const token = this.nextToken();
+            const tokenKind = token.kind === TokenKind.ExtendsKeyword ? "extends" : "implements";
+            const types = [];
+            do {
+                const expression = this.parseLeftHandSideExpression();
+                const typeArguments = this.at(TokenKind.LessThan) ? this.parseTypeArguments() : [];
+                types.push({ kind: SyntaxKind.ExpressionWithTypeArguments, expression, typeArguments, start: expression.start, end: typeArguments[typeArguments.length - 1]?.end ?? expression.end });
+            } while (this.at(TokenKind.Comma) && this.nextToken());
+            clauses.push({ kind: SyntaxKind.HeritageClause, token: tokenKind, types, start: token.start, end: types[types.length - 1]?.end ?? token.end });
+        }
+        return clauses;
+    }
+    parseClassMembers() {
+        this.parseExpected(TokenKind.OpenBrace);
+        const members = [];
+        while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+            const before = this.consumed;
+            const member = this.parseClassElement();
+            if (member)
+                members.push(member);
+            if (this.consumed === before)
+                this.nextToken();
+        }
+        this.parseExpected(TokenKind.CloseBrace);
+        return members;
+    }
+    parseClassElement() {
+        const start = this.token.start;
+        const modifiers = this.tryParseModifiers();
+        if (this.at(TokenKind.Semicolon)) {
+            this.nextToken();
+            return undefined;
+        }
+        if (this.at(TokenKind.ConstructorKeyword)) {
+            const name = this.nextToken();
+            const parameters = this.parseParameters();
+            let body;
+            if (this.at(TokenKind.OpenBrace))
+                body = this.parseBlock();
+            else
+                this.parseSemicolon();
+            const ctor = { kind: SyntaxKind.ConstructorDeclaration, modifiers, parameters, body, start, end: body?.end ?? name.end };
+            return ctor;
+        }
+        let flags = NodeFlags.None;
+        if (this.at(TokenKind.Asterisk)) {
+            this.nextToken();
+            flags |= NodeFlags.Generator;
+        }
+        if (this.hasModifier(modifiers, ModifierKind.Async))
+            flags |= NodeFlags.Async;
+        const name = this.parsePropertyName();
+        let questionToken = false;
+        let exclamationToken = false;
+        if (this.at(TokenKind.Question)) {
+            this.nextToken();
+            questionToken = true;
+        }
+        if (this.at(TokenKind.Exclamation)) {
+            this.nextToken();
+            exclamationToken = true;
+        }
+        const typeParameters = this.at(TokenKind.LessThan) ? this.parseTypeParameters() : [];
+        if (this.at(TokenKind.OpenParen)) {
+            const parameters = this.parseParameters();
+            let returnType;
+            if (this.at(TokenKind.Colon)) {
+                this.nextToken();
+                returnType = this.parseReturnType();
+            }
+            let body;
+            if (this.at(TokenKind.OpenBrace))
+                body = this.parseBlock();
+            else
+                this.parseSemicolon();
+            const method = {
+                kind: SyntaxKind.MethodDeclaration,
+                name,
+                modifiers,
+                typeParameters,
+                parameters,
+                returnType,
+                body,
+                flags,
+                optional: questionToken,
+                start,
+                end: body?.end ?? returnType?.end ?? name.end,
+            };
+            return method;
+        }
+        let type;
+        if (this.at(TokenKind.Colon)) {
+            this.nextToken();
+            type = this.parseType();
+        }
+        let initializer;
+        if (this.at(TokenKind.Equals)) {
+            this.nextToken();
+            initializer = this.parseAssignmentExpression();
+        }
+        this.parseSemicolon();
+        const property = {
+            kind: SyntaxKind.PropertyDeclaration,
+            name,
+            modifiers,
+            questionToken,
+            exclamationToken,
+            type,
+            initializer,
+            start,
+            end: initializer?.end ?? type?.end ?? name.end,
+        };
+        return property;
+    }
+    parsePropertyName() {
+        const token = this.token;
+        if (token.kind === TokenKind.StringLiteral) {
+            this.nextToken();
+            return { kind: SyntaxKind.StringLiteral, text: token.text, raw: token.text, value: String(token.value ?? ""), start: token.start, end: token.end };
+        }
+        if (token.kind === TokenKind.NumericLiteral) {
+            this.nextToken();
+            return { kind: SyntaxKind.NumericLiteral, text: token.text, value: Number(token.value ?? 0), start: token.start, end: token.end };
+        }
+        if (token.kind === TokenKind.OpenBracket) {
+            this.nextToken();
+            const expr = this.parseAssignmentExpression();
+            this.parseExpected(TokenKind.CloseBracket);
+            const name = expressionToPropertyName(expr);
+            if (name)
+                return name;
+            this.error(DiagnosticCode.InvalidTypeSyntax, "Computed property names are not supported by xbintsc");
+            return { kind: SyntaxKind.Identifier, text: "<computed>", start: expr.start, end: expr.end };
+        }
+        return this.parseIdentifierName();
+    }
+    parseInterfaceDeclaration(modifiers) {
+        const start = this.parseExpected(TokenKind.InterfaceKeyword).start;
+        const name = this.parseIdentifier();
+        const typeParameters = this.parseTypeParameters();
+        const heritage = this.parseHeritageClauses();
+        const members = this.parseTypeMembers();
+        return { kind: SyntaxKind.InterfaceDeclaration, name, modifiers, typeParameters, heritage, members, start, end: members[members.length - 1]?.end ?? name.end };
+    }
+    parseTypeAliasDeclaration(modifiers) {
+        const start = this.parseExpected(TokenKind.TypeKeyword).start;
+        const name = this.parseIdentifier();
+        const typeParameters = this.parseTypeParameters();
+        this.parseExpected(TokenKind.Equals);
+        const type = this.parseType();
+        this.parseSemicolon();
+        return { kind: SyntaxKind.TypeAliasDeclaration, name, modifiers, typeParameters, type, start, end: type.end };
+    }
+    parseEnumDeclaration(modifiers) {
+        const start = this.parseExpected(TokenKind.EnumKeyword).start;
+        const name = this.parseIdentifier();
+        this.parseExpected(TokenKind.OpenBrace);
+        const members = [];
+        while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+            const memberName = this.parsePropertyName();
+            let initializer;
+            if (this.at(TokenKind.Equals)) {
+                this.nextToken();
+                initializer = this.parseAssignmentExpression();
+            }
+            members.push({ kind: SyntaxKind.EnumMember, name: memberName, initializer, start: memberName.start, end: initializer?.end ?? memberName.end });
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        const close = this.parseExpected(TokenKind.CloseBrace);
+        return { kind: SyntaxKind.EnumDeclaration, name, modifiers, members, start, end: close.end };
+    }
+    parseModuleDeclaration(modifiers) {
+        const start = this.nextToken().start;
+        let name;
+        if (this.at(TokenKind.StringLiteral)) {
+            const token = this.nextToken();
+            name = { kind: SyntaxKind.StringLiteral, text: token.text, raw: token.text, value: String(token.value ?? ""), start: token.start, end: token.end };
+        }
+        else {
+            name = this.parseIdentifierName();
+        }
+        while (this.at(TokenKind.Dot)) {
+            this.nextToken();
+            this.parseIdentifierName();
+        }
+        let body;
+        if (this.at(TokenKind.OpenBrace))
+            body = this.parseBlock();
+        else
+            this.parseSemicolon();
+        return { kind: SyntaxKind.ModuleDeclaration, name, modifiers, body, start, end: body?.end ?? name.end };
+    }
+    parseTypeMembers() {
+        this.parseExpected(TokenKind.OpenBrace);
+        const members = [];
+        while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+            const before = this.consumed;
+            const member = this.parseTypeMember();
+            if (member)
+                members.push(member);
+            if (this.consumed === before)
+                this.nextToken();
+        }
+        this.parseExpected(TokenKind.CloseBrace);
+        return members;
+    }
+    parseTypeMember() {
+        const start = this.token.start;
+        const readonlyToken = this.at(TokenKind.ReadonlyKeyword);
+        if (readonlyToken)
+            this.nextToken();
+        if (this.at(TokenKind.OpenParen) || this.at(TokenKind.LessThan)) {
+            const typeParameters = this.parseTypeParameters();
+            const parameters = this.parseParameters();
+            let returnType;
+            if (this.at(TokenKind.Colon)) {
+                this.nextToken();
+                returnType = this.parseType();
+            }
+            this.parseSemicolonOrComma();
+            const name = { kind: SyntaxKind.Identifier, text: "__call", start, end: start };
+            return { kind: SyntaxKind.MethodSignature, name, questionToken: false, typeParameters, parameters, returnType, start, end: returnType?.end ?? start };
+        }
+        if (this.at(TokenKind.OpenBracket) && this.atAhead(1, TokenKind.Identifier)) {
+            const saveIndex = this.index;
+            const savePos = this.scanner.position;
+            const savedTokens = this.tokens.slice();
+            this.nextToken();
+            const parameters = [];
+            let ok = true;
+            try {
+                const paramName = this.parseIdentifier();
+                let type;
+                if (this.at(TokenKind.Colon)) {
+                    this.nextToken();
+                    type = this.parseType();
+                }
+                else
+                    ok = false;
+                this.parseExpected(TokenKind.CloseBracket);
+                parameters.push({ kind: SyntaxKind.Parameter, name: paramName, modifiers: [], dotDotDotToken: false, questionToken: false, type, start: paramName.start, end: type?.end ?? paramName.end });
+            }
+            catch {
+                ok = false;
+            }
+            if (ok && this.at(TokenKind.Colon)) {
+                this.nextToken();
+                const type = this.parseType();
+                this.parseSemicolonOrComma();
+                return { kind: SyntaxKind.IndexSignature, parameters, type, start, end: type.end };
+            }
+            this.index = saveIndex;
+            this.tokens = savedTokens;
+            this.scanner.seek(savePos);
+        }
+        const name = this.parsePropertyName();
+        let questionToken = false;
+        if (this.at(TokenKind.Question)) {
+            this.nextToken();
+            questionToken = true;
+        }
+        const typeParameters = this.at(TokenKind.LessThan) ? this.parseTypeParameters() : [];
+        if (this.at(TokenKind.OpenParen) || typeParameters.length > 0) {
+            const parameters = this.parseParameters();
+            let returnType;
+            if (this.at(TokenKind.Colon)) {
+                this.nextToken();
+                returnType = this.parseType();
+            }
+            this.parseSemicolonOrComma();
+            const sig = { kind: SyntaxKind.MethodSignature, name, questionToken, typeParameters, parameters, returnType, start, end: returnType?.end ?? name.end };
+            return sig;
+        }
+        let type;
+        if (this.at(TokenKind.Colon)) {
+            this.nextToken();
+            type = this.parseType();
+        }
+        this.parseSemicolonOrComma();
+        const signature = { kind: SyntaxKind.PropertySignature, name, questionToken, readonlyToken, type, start, end: type?.end ?? name.end };
+        return signature;
+    }
+    parseSemicolonOrComma() {
+        if (this.at(TokenKind.Semicolon) || this.at(TokenKind.Comma))
+            this.nextToken();
+    }
+    // -- modules --------------------------------------------------------------
+    parseImportDeclaration() {
+        const start = this.parseExpected(TokenKind.ImportKeyword).start;
+        let importClause;
+        if (!this.at(TokenKind.StringLiteral)) {
+            const clauseStart = this.token.start;
+            let isTypeOnly = false;
+            if (this.at(TokenKind.TypeKeyword) && !this.lookAhead(1).precededByLineBreak) {
+                const next = this.lookAhead(1);
+                if (this.isIdentifierLike(next) || next.kind === TokenKind.OpenBrace || next.kind === TokenKind.Asterisk) {
+                    this.nextToken();
+                    isTypeOnly = true;
+                }
+            }
+            let name;
+            let namedBindings;
+            if (this.isIdentifierLike(this.token)) {
+                name = this.parseIdentifierName();
+                if (this.at(TokenKind.Comma))
+                    this.nextToken();
+            }
+            if (this.at(TokenKind.Asterisk)) {
+                this.nextToken();
+                this.parseExpected(TokenKind.AsKeyword);
+                const nsName = this.parseIdentifier();
+                namedBindings = { kind: SyntaxKind.NamespaceImport, name: nsName, start: nsName.start, end: nsName.end };
+            }
+            else if (this.at(TokenKind.OpenBrace)) {
+                namedBindings = this.parseNamedImports();
+            }
+            importClause = { kind: SyntaxKind.ImportClause, name, namedBindings, isTypeOnly, start: clauseStart, end: namedBindings?.end ?? name?.end ?? clauseStart };
+        }
+        this.parseExpected(TokenKind.FromKeyword);
+        const moduleToken = this.parseExpected(TokenKind.StringLiteral);
+        const moduleSpecifier = this.stringLiteralFromToken(moduleToken);
+        const attributes = [];
+        if (this.at(TokenKind.WithKeyword) || (this.at(TokenKind.Identifier) && this.token.text === "assert")) {
+            this.nextToken();
+            this.parseExpected(TokenKind.OpenBrace);
+            while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+                const key = this.parsePropertyName();
+                this.parseExpected(TokenKind.Colon);
+                const valueToken = this.parseExpected(TokenKind.StringLiteral);
+                attributes.push({ name: propertyNameText(key), value: String(valueToken.value ?? "") });
+                if (this.at(TokenKind.Comma))
+                    this.nextToken();
+                else
+                    break;
+            }
+            this.parseExpected(TokenKind.CloseBrace);
+        }
+        this.parseSemicolon();
+        return { kind: SyntaxKind.ImportDeclaration, importClause, moduleSpecifier, attributes, start, end: moduleSpecifier.end };
+    }
+    parseNamedImports() {
+        const open = this.parseExpected(TokenKind.OpenBrace);
+        const elements = [];
+        while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+            const specStart = this.token.start;
+            let isTypeOnly = false;
+            if (this.at(TokenKind.TypeKeyword)) {
+                this.nextToken();
+                isTypeOnly = true;
+            }
+            const first = this.parseIdentifierName();
+            let propertyName;
+            let name = first;
+            if (this.at(TokenKind.AsKeyword)) {
+                this.nextToken();
+                propertyName = first;
+                name = this.parseIdentifierName();
+            }
+            elements.push({ kind: SyntaxKind.ImportSpecifier, propertyName, name, isTypeOnly, start: specStart, end: name.end });
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        const close = this.parseExpected(TokenKind.CloseBrace);
+        return { kind: SyntaxKind.NamedImports, elements, start: open.start, end: close.end };
+    }
+    parseExportDeclaration() {
+        const start = this.parseExpected(TokenKind.ExportKeyword).start;
+        if (this.at(TokenKind.Equals)) {
+            this.nextToken();
+            const expression = this.parseExpression();
+            this.parseSemicolon();
+            const assignment = { kind: SyntaxKind.ExportAssignment, isExportEquals: true, expression, start, end: expression.end };
+            return assignment;
+        }
+        if (this.at(TokenKind.DefaultKeyword)) {
+            this.nextToken();
+            if (this.at(TokenKind.FunctionKeyword) || this.at(TokenKind.ClassKeyword) || this.at(TokenKind.InterfaceKeyword)) {
+                return this.parseStatementWithModifiers([{ kind: SyntaxKind.Unknown, modifierKind: ModifierKind.Default, start, end: this.token.start }]);
+            }
+            const expression = this.parseAssignmentExpression();
+            this.parseSemicolon();
+            const assignment = { kind: SyntaxKind.ExportAssignment, isExportEquals: false, expression, start, end: expression.end };
+            return assignment;
+        }
+        if (this.at(TokenKind.Asterisk)) {
+            this.nextToken();
+            let nsName;
+            if (this.at(TokenKind.AsKeyword)) {
+                this.nextToken();
+                nsName = this.parseIdentifierName();
+            }
+            let moduleSpecifier;
+            if (this.at(TokenKind.FromKeyword)) {
+                this.nextToken();
+                moduleSpecifier = this.stringLiteralFromToken(this.nextToken());
+            }
+            this.parseSemicolon();
+            const decl = {
+                kind: SyntaxKind.ExportDeclaration,
+                modifiers: [],
+                exportClause: nsName ? { kind: SyntaxKind.NamespaceImport, name: nsName, start: nsName.start, end: nsName.end } : undefined,
+                moduleSpecifier,
+                isTypeOnly: false,
+                start,
+                end: moduleSpecifier?.end ?? nsName?.end ?? start,
+            };
+            return decl;
+        }
+        if (this.at(TokenKind.OpenBrace)) {
+            const namedExports = this.parseNamedExports();
+            let moduleSpecifier;
+            if (this.at(TokenKind.FromKeyword)) {
+                this.nextToken();
+                if (this.at(TokenKind.StringLiteral))
+                    moduleSpecifier = this.stringLiteralFromToken(this.nextToken());
+            }
+            this.parseSemicolon();
+            const decl = { kind: SyntaxKind.ExportDeclaration, modifiers: [], exportClause: namedExports, moduleSpecifier, isTypeOnly: false, start, end: moduleSpecifier?.end ?? namedExports.end };
+            return decl;
+        }
+        const modifiers = this.tryParseModifiers();
+        modifiers.push({ kind: SyntaxKind.Unknown, modifierKind: ModifierKind.Export, start, end: this.token.start });
+        return this.parseStatementWithModifiers(modifiers);
+    }
+    parseNamedExports() {
+        const open = this.parseExpected(TokenKind.OpenBrace);
+        const elements = [];
+        while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+            const specStart = this.token.start;
+            let isTypeOnly = false;
+            if (this.at(TokenKind.TypeKeyword)) {
+                this.nextToken();
+                isTypeOnly = true;
+            }
+            const first = this.parseIdentifierName();
+            let propertyName;
+            let name = first;
+            if (this.at(TokenKind.AsKeyword)) {
+                this.nextToken();
+                propertyName = first;
+                name = this.parseIdentifierName();
+            }
+            elements.push({ kind: SyntaxKind.ExportSpecifier, propertyName, name, isTypeOnly, start: specStart, end: name.end });
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        const close = this.parseExpected(TokenKind.CloseBrace);
+        return { kind: SyntaxKind.NamedExports, elements, start: open.start, end: close.end };
+    }
+    stringLiteralFromToken(token) {
+        return { kind: SyntaxKind.StringLiteral, text: token.text, raw: token.text, value: String(token.value ?? ""), start: token.start, end: token.end };
+    }
+    // -- state save / restore (for speculative parsing) -----------------------
+    saveState() {
+        return { index: this.index, tokens: this.tokens.slice(), pos: this.scanner.position, consumed: this.consumed };
+    }
+    restoreState(state) {
+        this.index = state.index;
+        this.tokens = state.tokens;
+        this.scanner.seek(state.pos);
+        this.consumed = state.consumed;
+    }
+    // -- expressions ----------------------------------------------------------
+    parseExpression(noIn = false) {
+        return this.parseAssignmentExpression(noIn);
+    }
+    parseAssignmentExpression(noIn = false) {
+        const arrow = this.tryParseArrowFunction();
+        if (arrow)
+            return arrow;
+        const start = this.token.start;
+        const left = this.parseConditionalExpression(noIn);
+        const token = this.token;
+        const op = assignmentOperator(token.kind);
+        if (op) {
+            if (!isAssignmentTarget(left)) {
+                this.error(DiagnosticCode.InvalidAssignmentTarget, "Invalid assignment target", token);
+            }
+            this.nextToken();
+            const right = this.parseAssignmentExpression(noIn);
+            const assignment = {
+                kind: SyntaxKind.BinaryExpression,
+                left,
+                operator: op,
+                right,
+                operatorToken: token,
+                start,
+                end: right.end,
+            };
+            return assignment;
+        }
+        return left;
+    }
+    tryParseArrowFunction() {
+        const start = this.token.start;
+        let flags = NodeFlags.None;
+        let async = false;
+        let cursor = 0;
+        if (this.at(TokenKind.AsyncKeyword) && !this.lookAhead(1).precededByLineBreak) {
+            const next = this.lookAhead(1);
+            if (next.kind === TokenKind.OpenParen || this.isIdentifierLike(next))
+                async = true;
+        }
+        if (async)
+            cursor = 1;
+        const afterTypeParams = this.countTypeParameterTokens(cursor);
+        if (afterTypeParams >= 0)
+            cursor = afterTypeParams;
+        const first = this.lookAhead(cursor);
+        if (first.kind === TokenKind.OpenParen) {
+            const closeIndex = this.findMatchingParen(cursor);
+            if (closeIndex < 0)
+                return undefined;
+            let arrowIndex = closeIndex + 1;
+            if (this.lookAhead(arrowIndex).kind === TokenKind.Colon) {
+                arrowIndex = this.skipTypeTokens(arrowIndex + 1);
+                if (arrowIndex < 0)
+                    return undefined;
+            }
+            if (this.lookAhead(arrowIndex).kind !== TokenKind.EqualsGreaterThan)
+                return undefined;
+        }
+        else if (this.isIdentifierLike(first)) {
+            if (this.lookAhead(cursor + 1).kind !== TokenKind.EqualsGreaterThan)
+                return undefined;
+        }
+        else {
+            return undefined;
+        }
+        if (async) {
+            this.nextToken();
+            flags |= NodeFlags.Async;
+        }
+        const typeParams = this.at(TokenKind.LessThan) ? this.parseTypeParameters() : [];
+        let parameters;
+        if (this.at(TokenKind.OpenParen)) {
+            parameters = this.parseParameters();
+        }
+        else {
+            const paramStart = this.token.start;
+            const name = this.parseIdentifierName();
+            parameters = [{ kind: SyntaxKind.Parameter, name, modifiers: [], dotDotDotToken: false, questionToken: false, start: paramStart, end: name.end }];
+        }
+        let returnType;
+        if (this.at(TokenKind.Colon)) {
+            this.nextToken();
+            returnType = this.parseReturnType();
+        }
+        this.parseExpected(TokenKind.EqualsGreaterThan);
+        const body = this.at(TokenKind.OpenBrace) ? this.parseBlock() : this.parseAssignmentExpression();
+        return { kind: SyntaxKind.ArrowFunction, typeParameters: typeParams, parameters, returnType, body, flags, start, end: body.end };
+    }
+    countTypeParameterTokens(cursor) {
+        if (this.lookAhead(cursor).kind !== TokenKind.LessThan)
+            return -1;
+        let depth = 0;
+        for (let i = cursor;; i++) {
+            const t = this.lookAhead(i);
+            if (t.kind === TokenKind.EndOfFile)
+                return -1;
+            if (t.kind === TokenKind.LessThan)
+                depth++;
+            else if (t.kind === TokenKind.GreaterThan) {
+                depth--;
+                if (depth === 0)
+                    return i + 1;
+            }
+            else if (t.kind === TokenKind.GreaterThanGreaterThan || t.kind === TokenKind.GreaterThanGreaterThanGreaterThan) {
+                depth -= t.kind === TokenKind.GreaterThanGreaterThan ? 2 : 3;
+                if (depth <= 0)
+                    return i + 1;
+            }
+            else if (t.kind === TokenKind.Semicolon) {
+                return -1;
+            }
+        }
+    }
+    findMatchingParen(cursor) {
+        let depth = 0;
+        for (let i = cursor;; i++) {
+            const t = this.lookAhead(i);
+            if (t.kind === TokenKind.EndOfFile)
+                return -1;
+            if (t.kind === TokenKind.OpenParen)
+                depth++;
+            else if (t.kind === TokenKind.CloseParen) {
+                depth--;
+                if (depth === 0)
+                    return i;
+            }
+        }
+    }
+    skipTypeTokens(startIndex) {
+        let depth = 0;
+        for (let i = startIndex;; i++) {
+            const t = this.lookAhead(i);
+            if (t.kind === TokenKind.EndOfFile)
+                return -1;
+            if (t.kind === TokenKind.OpenParen || t.kind === TokenKind.OpenBracket || t.kind === TokenKind.OpenBrace)
+                depth++;
+            else if (t.kind === TokenKind.CloseParen || t.kind === TokenKind.CloseBracket || t.kind === TokenKind.CloseBrace)
+                depth--;
+            else if (t.kind === TokenKind.EqualsGreaterThan && depth === 0)
+                return i;
+            else if (t.kind === TokenKind.Semicolon && depth === 0)
+                return -1;
+        }
+    }
+    parseConditionalExpression(noIn) {
+        const start = this.token.start;
+        const condition = this.parseBinaryExpression(0, noIn);
+        if (this.at(TokenKind.Question)) {
+            this.nextToken();
+            const whenTrue = this.parseAssignmentExpression();
+            this.parseExpected(TokenKind.Colon);
+            const whenFalse = this.parseAssignmentExpression(noIn);
+            const node = { kind: SyntaxKind.ConditionalExpression, condition, whenTrue, whenFalse, start, end: whenFalse.end };
+            return node;
+        }
+        return condition;
+    }
+    parseBinaryExpression(minPrecedence, noIn) {
+        let left = this.parseUnaryExpression();
+        for (;;) {
+            const token = this.token;
+            // `expr as Type` / `expr satisfies Type` bind at the relational level.
+            if (token.kind === TokenKind.AsKeyword || token.kind === TokenKind.SatisfiesKeyword) {
+                if (AS_PRECEDENCE < minPrecedence)
+                    break;
+                this.nextToken();
+                const type = this.parseType();
+                left =
+                    token.kind === TokenKind.AsKeyword
+                        ? { kind: SyntaxKind.AsExpression, expression: left, type, start: left.start, end: type.end }
+                        : { kind: SyntaxKind.SatisfiesExpression, expression: left, type, start: left.start, end: type.end };
+                continue;
+            }
+            if (token.kind === TokenKind.InKeyword && noIn)
+                break;
+            const op = binaryOperator(token.kind);
+            if (!op)
+                break;
+            const precedence = binaryPrecedence(op);
+            if (precedence < minPrecedence)
+                break;
+            const nextMin = op === BinaryOperator.Exponent ? precedence : precedence + 1;
+            this.nextToken();
+            const right = this.parseBinaryExpression(nextMin, noIn);
+            const binary = { kind: SyntaxKind.BinaryExpression, left, operator: op, right, operatorToken: token, start: left.start, end: right.end };
+            left = binary;
+        }
+        return left;
+    }
+    parseUnaryExpression() {
+        const token = this.token;
+        const prefix = prefixUnaryOperator(token.kind);
+        if (prefix) {
+            this.nextToken();
+            if (prefix === PrefixUnaryOperator.Await) {
+                const expression = this.parseUnaryExpression();
+                return { kind: SyntaxKind.AwaitExpression, expression, start: token.start, end: expression.end };
+            }
+            if (prefix === PrefixUnaryOperator.Delete) {
+                const expression = this.parseUnaryExpression();
+                return { kind: SyntaxKind.DeleteExpression, expression, start: token.start, end: expression.end };
+            }
+            if (prefix === PrefixUnaryOperator.Void) {
+                const expression = this.parseUnaryExpression();
+                return { kind: SyntaxKind.VoidExpression, expression, start: token.start, end: expression.end };
+            }
+            if (prefix === PrefixUnaryOperator.TypeOf) {
+                const expression = this.parseUnaryExpression();
+                return { kind: SyntaxKind.TypeOfExpression, expression, start: token.start, end: expression.end };
+            }
+            const operand = this.parseUnaryExpression();
+            return { kind: SyntaxKind.PrefixUnaryExpression, operator: prefix, operand, start: token.start, end: operand.end };
+        }
+        if (token.kind === TokenKind.YieldKeyword) {
+            this.nextToken();
+            let delegate = false;
+            let expression;
+            if (this.at(TokenKind.Asterisk)) {
+                this.nextToken();
+                delegate = true;
+            }
+            if (!this.canInsertSemicolon() && !this.at(TokenKind.Semicolon) && !this.at(TokenKind.CloseParen)) {
+                expression = this.parseAssignmentExpression();
+            }
+            return { kind: SyntaxKind.YieldExpression, expression, delegate, start: token.start, end: expression?.end ?? token.end };
+        }
+        if (token.kind === TokenKind.LessThan) {
+            const assertion = this.tryParse(() => {
+                const type = this.parseType();
+                const expression = this.parseUnaryExpression();
+                return { kind: SyntaxKind.AsExpression, expression, type, start: token.start, end: expression.end };
+            });
+            if (assertion)
+                return assertion;
+        }
+        return this.parsePostfixExpression();
+    }
+    parsePostfixExpression() {
+        const start = this.token.start;
+        const expression = this.parseLeftHandSideExpression();
+        const token = this.token;
+        if ((token.kind === TokenKind.PlusPlus || token.kind === TokenKind.MinusMinus) && !token.precededByLineBreak) {
+            this.nextToken();
+            const operator = token.kind === TokenKind.PlusPlus ? PostfixUnaryOperator.PlusPlus : PostfixUnaryOperator.MinusMinus;
+            return { kind: SyntaxKind.PostfixUnaryExpression, operator, operand: expression, start, end: token.end };
+        }
+        return expression;
+    }
+    parseLeftHandSideExpression() {
+        const expression = this.at(TokenKind.NewKeyword) ? this.parseNewExpression() : this.parsePrimaryExpression();
+        return this.parseCallAndMemberTail(expression);
+    }
+    parseNewExpression() {
+        const start = this.parseExpected(TokenKind.NewKeyword).start;
+        const callee = this.parseMemberOnlyExpression();
+        const typeArguments = this.at(TokenKind.LessThan) ? this.parseTypeArguments() : [];
+        const args = this.at(TokenKind.OpenParen) ? this.parseArguments() : [];
+        return { kind: SyntaxKind.NewExpression, expression: callee, typeArguments, arguments: args, start, end: args[args.length - 1]?.end ?? callee.end };
+    }
+    parseMemberOnlyExpression() {
+        let expression = this.parsePrimaryExpression();
+        for (;;) {
+            if (this.at(TokenKind.Dot) || this.at(TokenKind.QuestionDot)) {
+                expression = this.parsePropertyAccess(expression);
+            }
+            else if (this.at(TokenKind.OpenBracket)) {
+                this.nextToken();
+                const argument = this.parseExpression();
+                const close = this.parseExpected(TokenKind.CloseBracket);
+                expression = { kind: SyntaxKind.ElementAccessExpression, expression, argumentExpression: argument, optional: false, start: expression.start, end: close.end };
+            }
+            else {
+                break;
+            }
+        }
+        return expression;
+    }
+    parsePrimaryExpression() {
+        const token = this.token;
+        switch (token.kind) {
+            case TokenKind.NumericLiteral: {
+                this.nextToken();
+                const node = { kind: SyntaxKind.NumericLiteral, text: token.text, value: Number(token.value ?? 0), start: token.start, end: token.end };
+                return node;
+            }
+            case TokenKind.BigIntLiteral:
+                this.nextToken();
+                return { kind: SyntaxKind.BigIntLiteral, text: token.text, value: BigInt(token.value ?? 0n), start: token.start, end: token.end };
+            case TokenKind.StringLiteral:
+                this.nextToken();
+                return this.stringLiteralFromToken(token);
+            case TokenKind.TrueKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.TrueKeyword, value: true, start: token.start, end: token.end };
+            case TokenKind.FalseKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.FalseKeyword, value: false, start: token.start, end: token.end };
+            case TokenKind.NullKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.NullKeyword, start: token.start, end: token.end };
+            case TokenKind.UndefinedKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.UndefinedKeyword, start: token.start, end: token.end };
+            case TokenKind.ThisKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.ThisKeyword, start: token.start, end: token.end };
+            case TokenKind.OpenParen: {
+                this.nextToken();
+                const expression = this.parseExpression();
+                const close = this.parseExpected(TokenKind.CloseParen);
+                const paren = { kind: SyntaxKind.ParenthesizedExpression, expression, start: token.start, end: close.end };
+                return paren;
+            }
+            case TokenKind.OpenBracket:
+                return this.parseArrayLiteral();
+            case TokenKind.OpenBrace:
+                return this.parseObjectLiteral();
+            case TokenKind.FunctionKeyword:
+                return this.parseFunctionExpression();
+            case TokenKind.ClassKeyword:
+                return this.parseClassExpression();
+            case TokenKind.AsyncKeyword:
+                if (this.atAhead(1, TokenKind.FunctionKeyword) && !this.lookAhead(1).precededByLineBreak)
+                    return this.parseFunctionExpression();
+                break;
+            case TokenKind.Backtick:
+            case TokenKind.TemplateHead:
+            case TokenKind.NoSubstitutionTemplateLiteral:
+                return this.parseTemplateLiteral();
+            case TokenKind.Slash:
+                return this.parseRegularExpression();
+            default:
+                break;
+        }
+        if (this.isIdentifierLike(token))
+            return this.parseIdentifierName();
+        this.error(DiagnosticCode.UnexpectedToken, `Unexpected token '${token.text || token.kind}'`);
+        if (token.kind !== TokenKind.EndOfFile)
+            this.nextToken();
+        return { kind: SyntaxKind.Identifier, text: "<error>", start: token.start, end: token.end };
+    }
+    parseCallAndMemberTail(base) {
+        let expression = base;
+        for (;;) {
+            const token = this.token;
+            if (token.kind === TokenKind.Dot || token.kind === TokenKind.QuestionDot) {
+                expression = this.parsePropertyAccess(expression);
+                continue;
+            }
+            if (token.kind === TokenKind.OpenBracket) {
+                this.nextToken();
+                const argument = this.parseExpression();
+                const close = this.parseExpected(TokenKind.CloseBracket);
+                expression = { kind: SyntaxKind.ElementAccessExpression, expression, argumentExpression: argument, optional: false, start: expression.start, end: close.end };
+                continue;
+            }
+            if (token.kind === TokenKind.OpenParen) {
+                const args = this.parseArguments();
+                const call = { kind: SyntaxKind.CallExpression, expression, typeArguments: [], arguments: args, optional: false, start: expression.start, end: this.previousEnd(args, expression.end) };
+                expression = call;
+                continue;
+            }
+            if (token.kind === TokenKind.LessThan) {
+                const call = this.tryParse(() => {
+                    const typeArguments = this.parseTypeArguments();
+                    if (!this.at(TokenKind.OpenParen))
+                        throw new SpeculationError();
+                    const args = this.parseArguments();
+                    return { kind: SyntaxKind.CallExpression, expression, typeArguments, arguments: args, optional: false, start: expression.start, end: this.previousEnd(args, this.token.start) };
+                });
+                if (call) {
+                    expression = call;
+                    continue;
+                }
+            }
+            if (this.at(TokenKind.Backtick) || this.at(TokenKind.TemplateHead) || this.at(TokenKind.NoSubstitutionTemplateLiteral)) {
+                const template = this.parseTemplateLiteral();
+                expression = { kind: SyntaxKind.TaggedTemplateExpression, tag: expression, template, start: expression.start, end: template.end };
+                continue;
+            }
+            return expression;
+        }
+    }
+    previousEnd(args, fallback) {
+        return args[args.length - 1]?.end ?? fallback;
+    }
+    parsePropertyAccess(expression) {
+        const token = this.nextToken();
+        const optional = token.kind === TokenKind.QuestionDot;
+        if (optional && this.at(TokenKind.OpenParen)) {
+            const args = this.parseArguments();
+            return { kind: SyntaxKind.CallExpression, expression, typeArguments: [], arguments: args, optional: true, start: expression.start, end: this.previousEnd(args, token.start) };
+        }
+        if (optional && this.at(TokenKind.OpenBracket)) {
+            this.nextToken();
+            const argument = this.parseExpression();
+            const close = this.parseExpected(TokenKind.CloseBracket);
+            return { kind: SyntaxKind.ElementAccessExpression, expression, argumentExpression: argument, optional: true, start: expression.start, end: close.end };
+        }
+        const name = this.parseIdentifierName();
+        return { kind: SyntaxKind.PropertyAccessExpression, expression, name, optional, start: expression.start, end: name.end };
+    }
+    parseArguments() {
+        this.parseExpected(TokenKind.OpenParen);
+        const args = [];
+        while (!this.at(TokenKind.CloseParen) && !this.at(TokenKind.EndOfFile)) {
+            if (this.at(TokenKind.DotDotDot)) {
+                const start = this.nextToken().start;
+                const expression = this.parseAssignmentExpression();
+                args.push({ kind: SyntaxKind.SpreadElement, expression, start, end: expression.end });
+            }
+            else {
+                args.push(this.parseAssignmentExpression());
+            }
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        this.parseExpected(TokenKind.CloseParen);
+        return args;
+    }
+    parseArrayLiteral() {
+        const open = this.parseExpected(TokenKind.OpenBracket);
+        const elements = [];
+        while (!this.at(TokenKind.CloseBracket) && !this.at(TokenKind.EndOfFile)) {
+            if (this.at(TokenKind.Comma)) {
+                // Elision: represent as an undefined literal hole.
+                elements.push({ kind: SyntaxKind.UndefinedKeyword, start: this.token.start, end: this.token.start });
+                this.nextToken();
+                continue;
+            }
+            if (this.at(TokenKind.DotDotDot)) {
+                const start = this.nextToken().start;
+                const expression = this.parseAssignmentExpression();
+                elements.push({ kind: SyntaxKind.SpreadElement, expression, start, end: expression.end });
+            }
+            else {
+                elements.push(this.parseAssignmentExpression());
+            }
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        const close = this.parseExpected(TokenKind.CloseBracket);
+        return { kind: SyntaxKind.ArrayLiteralExpression, elements, start: open.start, end: close.end };
+    }
+    parseObjectLiteral() {
+        const open = this.parseExpected(TokenKind.OpenBrace);
+        const properties = [];
+        while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+            if (this.at(TokenKind.DotDotDot)) {
+                const start = this.nextToken().start;
+                const expression = this.parseAssignmentExpression();
+                properties.push({ kind: SyntaxKind.SpreadElement, expression, start, end: expression.end });
+            }
+            else {
+                const start = this.token.start;
+                const name = this.parsePropertyName();
+                if (this.at(TokenKind.Colon)) {
+                    this.nextToken();
+                    const initializer = this.parseAssignmentExpression();
+                    properties.push({ kind: SyntaxKind.PropertyAssignment, name, initializer, start, end: initializer.end });
+                }
+                else if (this.at(TokenKind.OpenParen) || this.at(TokenKind.LessThan)) {
+                    const typeParameters = this.at(TokenKind.LessThan) ? this.parseTypeParameters() : [];
+                    const parameters = this.parseParameters();
+                    let returnType;
+                    if (this.at(TokenKind.Colon)) {
+                        this.nextToken();
+                        returnType = this.parseReturnType();
+                    }
+                    const body = this.parseBlock();
+                    const fn = { kind: SyntaxKind.FunctionExpression, typeParameters, parameters, returnType, body, flags: NodeFlags.None, start, end: body.end };
+                    properties.push({ kind: SyntaxKind.PropertyAssignment, name, initializer: fn, start, end: body.end });
+                }
+                else if (name.kind === SyntaxKind.Identifier) {
+                    const shorthand = { kind: SyntaxKind.ShorthandPropertyAssignment, name, start, end: name.end };
+                    properties.push(shorthand);
+                }
+                else {
+                    this.error(DiagnosticCode.UnexpectedToken, "Invalid object literal member");
+                    this.nextToken();
+                }
+            }
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        const close = this.parseExpected(TokenKind.CloseBrace);
+        return { kind: SyntaxKind.ObjectLiteralExpression, properties, start: open.start, end: close.end };
+    }
+    parseFunctionExpression() {
+        const start = this.parseExpected(TokenKind.FunctionKeyword).start;
+        let flags = NodeFlags.None;
+        if (this.at(TokenKind.Asterisk)) {
+            this.nextToken();
+            flags |= NodeFlags.Generator;
+        }
+        let name;
+        if (this.at(TokenKind.Identifier))
+            name = this.parseIdentifier();
+        const typeParameters = this.parseTypeParameters();
+        const parameters = this.parseParameters();
+        let returnType;
+        if (this.at(TokenKind.Colon)) {
+            this.nextToken();
+            returnType = this.parseReturnType();
+        }
+        const body = this.parseBlock();
+        return { kind: SyntaxKind.FunctionExpression, name, typeParameters, parameters, returnType, body, flags, start, end: body.end };
+    }
+    parseClassExpression() {
+        const start = this.parseExpected(TokenKind.ClassKeyword).start;
+        let name;
+        if (this.at(TokenKind.Identifier))
+            name = this.parseIdentifier();
+        const typeParameters = this.parseTypeParameters();
+        const heritage = this.parseHeritageClauses();
+        const members = this.parseClassMembers();
+        return { kind: SyntaxKind.ClassExpression, name, typeParameters, heritage, members, start, end: members[members.length - 1]?.end ?? start };
+    }
+    parseTemplateLiteral() {
+        const startToken = this.token;
+        if (startToken.kind === TokenKind.NoSubstitutionTemplateLiteral) {
+            this.nextToken();
+            return { kind: SyntaxKind.NoSubstitutionTemplateLiteral, text: startToken.text, value: String(startToken.value ?? ""), start: startToken.start, end: startToken.end };
+        }
+        if (startToken.kind === TokenKind.Backtick) {
+            // Re-scan from the backtick so the scanner produces a TemplateHead.
+            this.scanner.seek(startToken.start);
+            this.tokens = [this.scanner.nextToken()];
+            this.index = 0;
+            return this.parseTemplateLiteral();
+        }
+        const head = String(startToken.value ?? "");
+        this.nextToken();
+        const spans = [];
+        for (;;) {
+            const expression = this.parseExpression();
+            if (!this.at(TokenKind.CloseBrace)) {
+                this.error(DiagnosticCode.UnterminatedTemplate, "Expected '}' to close template substitution");
+                return { kind: SyntaxKind.TemplateLiteral, head, spans, start: startToken.start, end: this.token.end };
+            }
+            // The `}` terminates a substitution; re-read it as template text without
+            // first scanning the following (template) characters as normal tokens.
+            const closeStart = this.token.start;
+            this.tokens = [this.scanner.continueTemplate(closeStart)];
+            this.index = 0;
+            const literalToken = this.token;
+            if (literalToken.kind === TokenKind.NoSubstitutionTemplateLiteral) {
+                this.nextToken();
+                spans.push({ kind: SyntaxKind.TemplateSpan, expression, literal: String(literalToken.value ?? ""), isTail: true, start: expression.start, end: literalToken.end });
+                return { kind: SyntaxKind.TemplateLiteral, head, spans, start: startToken.start, end: literalToken.end };
+            }
+            if (literalToken.kind === TokenKind.TemplateHead) {
+                this.nextToken();
+                spans.push({ kind: SyntaxKind.TemplateSpan, expression, literal: String(literalToken.value ?? ""), isTail: false, start: expression.start, end: literalToken.end });
+                continue;
+            }
+            this.error(DiagnosticCode.UnterminatedTemplate, "Unterminated template literal", literalToken);
+            return { kind: SyntaxKind.TemplateLiteral, head, spans, start: startToken.start, end: literalToken.end };
+        }
+    }
+    parseRegularExpression() {
+        const token = this.token;
+        const text = this.source.text;
+        let i = token.start + 1;
+        let inClass = false;
+        let pattern = "";
+        for (; i < text.length; i++) {
+            const ch = text[i];
+            if (ch === "\\") {
+                pattern += ch + (text[i + 1] ?? "");
+                i++;
+                continue;
+            }
+            if (ch === "[")
+                inClass = true;
+            else if (ch === "]")
+                inClass = false;
+            else if (ch === "/" && !inClass)
+                break;
+            else if (ch === "\n")
+                break;
+            pattern += ch;
+        }
+        if (text[i] !== "/") {
+            this.error(DiagnosticCode.InvalidCharacter, "Unterminated regular expression");
+            this.nextToken();
+            return { kind: SyntaxKind.RegularExpressionLiteral, text: token.text, pattern: "", flags: "", start: token.start, end: token.end };
+        }
+        i++;
+        const flagsStart = i;
+        while (i < text.length && /[a-z]/i.test(text[i]))
+            i++;
+        const flags = text.slice(flagsStart, i);
+        this.scanner.seek(i);
+        this.tokens = [this.scanner.nextToken()];
+        this.index = 0;
+        return { kind: SyntaxKind.RegularExpressionLiteral, text: text.slice(token.start, i), pattern, flags, start: token.start, end: i };
+    }
+    parseTypeArguments() {
+        this.parseExpected(TokenKind.LessThan);
+        const types = [];
+        while (!this.at(TokenKind.GreaterThan) && !this.at(TokenKind.EndOfFile)) {
+            types.push(this.parseType());
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        this.parseGreaterThan();
+        return types;
+    }
+    // -- types ----------------------------------------------------------------
+    parseType() {
+        const start = this.token.start;
+        const checkType = this.parseUnionType();
+        if (this.at(TokenKind.ExtendsKeyword)) {
+            this.nextToken();
+            const extendsType = this.parseUnionType();
+            this.parseExpected(TokenKind.Question);
+            const trueType = this.parseType();
+            this.parseExpected(TokenKind.Colon);
+            const falseType = this.parseType();
+            return { kind: SyntaxKind.ConditionalType, checkType, extendsType, trueType, falseType, start, end: falseType.end };
+        }
+        return checkType;
+    }
+    parseUnionType() {
+        const start = this.token.start;
+        const leading = this.at(TokenKind.Bar);
+        if (leading)
+            this.nextToken();
+        const first = this.parseIntersectionType();
+        if (!this.at(TokenKind.Bar))
+            return first;
+        const types = [first];
+        while (this.at(TokenKind.Bar)) {
+            this.nextToken();
+            types.push(this.parseIntersectionType());
+        }
+        return { kind: SyntaxKind.UnionType, types, start, end: types[types.length - 1].end };
+    }
+    parseIntersectionType() {
+        const start = this.token.start;
+        const leading = this.at(TokenKind.Ampersand);
+        if (leading)
+            this.nextToken();
+        const first = this.parseTypeOperatorOrHigher();
+        if (!this.at(TokenKind.Ampersand))
+            return first;
+        const types = [first];
+        while (this.at(TokenKind.Ampersand)) {
+            this.nextToken();
+            types.push(this.parseTypeOperatorOrHigher());
+        }
+        return { kind: SyntaxKind.IntersectionType, types, start, end: types[types.length - 1].end };
+    }
+    parseTypeOperatorOrHigher() {
+        const start = this.token.start;
+        if (this.at(TokenKind.KeyOfKeyword)) {
+            this.nextToken();
+            const type = this.parseTypeOperatorOrHigher();
+            return { kind: SyntaxKind.TypeOperator, operator: TypeOperator.KeyOf, type, start, end: type.end };
+        }
+        if (this.at(TokenKind.UniqueKeyword)) {
+            this.nextToken();
+            const type = this.parseTypeOperatorOrHigher();
+            return { kind: SyntaxKind.TypeOperator, operator: TypeOperator.Unique, type, start, end: type.end };
+        }
+        if (this.at(TokenKind.ReadonlyKeyword)) {
+            this.nextToken();
+            const type = this.parseTypeOperatorOrHigher();
+            return { kind: SyntaxKind.TypeOperator, operator: TypeOperator.Readonly, type, start, end: type.end };
+        }
+        if (this.at(TokenKind.InferKeyword)) {
+            this.nextToken();
+            const name = this.parseIdentifier();
+            let constraint;
+            if (this.at(TokenKind.ExtendsKeyword)) {
+                this.nextToken();
+                constraint = this.parseType();
+            }
+            const typeParameter = { kind: SyntaxKind.TypeParameterDeclaration, name, constraint, start: name.start, end: constraint?.end ?? name.end };
+            return { kind: SyntaxKind.InferType, typeParameter, start, end: typeParameter.end };
+        }
+        return this.parsePostfixType();
+    }
+    parsePostfixType() {
+        const start = this.token.start;
+        let type = this.parsePrimaryType();
+        for (;;) {
+            if (this.at(TokenKind.OpenBracket)) {
+                this.nextToken();
+                if (this.at(TokenKind.CloseBracket)) {
+                    const close = this.nextToken();
+                    type = { kind: SyntaxKind.ArrayType, elementType: type, start, end: close.end };
+                }
+                else {
+                    const indexType = this.parseType();
+                    const close = this.parseExpected(TokenKind.CloseBracket);
+                    type = { kind: SyntaxKind.IndexedAccessType, objectType: type, indexType, start, end: close.end };
+                }
+                continue;
+            }
+            if (this.at(TokenKind.Question) && this.atAhead(1, TokenKind.Colon)) {
+                // Optional tuple member, handled inside tuples only.
+            }
+            return type;
+        }
+    }
+    parsePrimaryType() {
+        const token = this.token;
+        const start = token.start;
+        switch (token.kind) {
+            case TokenKind.AnyKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.AnyKeywordType, start, end: token.end };
+            case TokenKind.UnknownKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.UnknownKeywordType, start, end: token.end };
+            case TokenKind.NumberKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.NumberKeywordType, start, end: token.end };
+            case TokenKind.BigIntKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.BigIntKeywordType, start, end: token.end };
+            case TokenKind.StringKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.StringKeywordType, start, end: token.end };
+            case TokenKind.BooleanKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.BooleanKeywordType, start, end: token.end };
+            case TokenKind.SymbolKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.SymbolKeywordType, start, end: token.end };
+            case TokenKind.VoidKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.VoidKeywordType, start, end: token.end };
+            case TokenKind.UndefinedKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.UndefinedKeywordType, start, end: token.end };
+            case TokenKind.NullKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.NullKeywordType, start, end: token.end };
+            case TokenKind.NeverKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.NeverKeywordType, start, end: token.end };
+            case TokenKind.ObjectKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.ObjectKeywordType, start, end: token.end };
+            case TokenKind.ThisKeyword:
+                this.nextToken();
+                return { kind: SyntaxKind.ThisKeywordType, start, end: token.end };
+            case TokenKind.TypeOfKeyword: {
+                this.nextToken();
+                const exprName = this.parseEntityName();
+                const typeArguments = this.at(TokenKind.LessThan) ? this.parseTypeArguments() : [];
+                return { kind: SyntaxKind.TypeQuery, exprName, typeArguments, start, end: this.token.start };
+            }
+            case TokenKind.OpenBrace:
+                return this.parseTypeLiteral();
+            case TokenKind.OpenBracket:
+                return this.parseTupleType();
+            case TokenKind.OpenParen: {
+                const closeIndex = this.findMatchingParen(0);
+                if (closeIndex >= 0 && this.lookAhead(closeIndex + 1).kind === TokenKind.EqualsGreaterThan) {
+                    return this.parseFunctionType();
+                }
+                this.nextToken();
+                const type = this.parseType();
+                const close = this.parseExpected(TokenKind.CloseParen);
+                return { kind: SyntaxKind.ParenthesizedType, type, start, end: close.end };
+            }
+            case TokenKind.LessThan:
+                return this.parseFunctionType();
+            case TokenKind.NewKeyword: {
+                this.nextToken();
+                return this.parseFunctionType(start);
+            }
+            case TokenKind.StringLiteral: {
+                this.nextToken();
+                const literal = this.stringLiteralFromToken(token);
+                return { kind: SyntaxKind.LiteralType, literal, start, end: token.end };
+            }
+            case TokenKind.NumericLiteral: {
+                this.nextToken();
+                const literal = { kind: SyntaxKind.NumericLiteral, text: token.text, value: Number(token.value ?? 0), start, end: token.end };
+                return { kind: SyntaxKind.LiteralType, literal, start, end: token.end };
+            }
+            case TokenKind.TrueKeyword: {
+                this.nextToken();
+                const literal = { kind: SyntaxKind.TrueKeyword, value: true, start, end: token.end };
+                return { kind: SyntaxKind.LiteralType, literal, start, end: token.end };
+            }
+            case TokenKind.FalseKeyword: {
+                this.nextToken();
+                const literal = { kind: SyntaxKind.FalseKeyword, value: false, start, end: token.end };
+                return { kind: SyntaxKind.LiteralType, literal, start, end: token.end };
+            }
+            case TokenKind.Minus: {
+                this.nextToken();
+                const num = this.parseExpected(TokenKind.NumericLiteral);
+                const literal = { kind: SyntaxKind.NumericLiteral, text: `-${num.text}`, value: -Number(num.value ?? 0), start, end: num.end };
+                return { kind: SyntaxKind.LiteralType, literal, start, end: num.end };
+            }
+            case TokenKind.ImportKeyword: {
+                // import("...").T - parse loosely and degrade to `any`.
+                this.nextToken();
+                if (this.at(TokenKind.OpenParen)) {
+                    this.nextToken();
+                    if (this.at(TokenKind.StringLiteral))
+                        this.nextToken();
+                    this.parseExpected(TokenKind.CloseParen);
+                }
+                while (this.at(TokenKind.Dot)) {
+                    this.nextToken();
+                    this.parseIdentifierName();
+                }
+                const typeArguments = this.at(TokenKind.LessThan) ? this.parseTypeArguments() : [];
+                return { kind: SyntaxKind.AnyKeywordType, start, end: this.token.start, typeArguments };
+            }
+            default:
+                break;
+        }
+        if (this.isIdentifierLike(token)) {
+            const typeName = this.parseEntityName();
+            const typeArguments = this.at(TokenKind.LessThan) ? this.parseTypeArguments() : [];
+            return { kind: SyntaxKind.TypeReference, typeName, typeArguments, start, end: this.previousTypeEnd(typeArguments, typeName.end) };
+        }
+        this.error(DiagnosticCode.InvalidTypeSyntax, `Expected a type but found '${token.text || token.kind}'`);
+        if (token.kind !== TokenKind.EndOfFile)
+            this.nextToken();
+        return { kind: SyntaxKind.AnyKeywordType, start, end: token.end };
+    }
+    previousTypeEnd(typeArguments, fallback) {
+        return typeArguments[typeArguments.length - 1]?.end ?? fallback;
+    }
+    parseEntityName() {
+        let left = this.parseIdentifierName();
+        while (this.at(TokenKind.Dot)) {
+            this.nextToken();
+            const right = this.parseIdentifierName();
+            left = { kind: SyntaxKind.QualifiedName, left, right, start: left.start, end: right.end };
+        }
+        return left;
+    }
+    parseFunctionType(explicitStart) {
+        const start = explicitStart ?? this.token.start;
+        const typeParameters = this.at(TokenKind.LessThan) ? this.parseTypeParameters() : [];
+        const parameters = this.parseParameters();
+        this.parseExpected(TokenKind.EqualsGreaterThan);
+        const returnType = this.parseReturnType();
+        return { kind: SyntaxKind.FunctionType, typeParameters, parameters, returnType, start, end: returnType.end };
+    }
+    parseTupleType() {
+        const open = this.parseExpected(TokenKind.OpenBracket);
+        const elements = [];
+        while (!this.at(TokenKind.CloseBracket) && !this.at(TokenKind.EndOfFile)) {
+            let element;
+            if (this.at(TokenKind.DotDotDot)) {
+                const restStart = this.nextToken().start;
+                const type = this.parseType();
+                element = { kind: SyntaxKind.RestType, type, start: restStart, end: type.end };
+            }
+            else {
+                element = this.parseType();
+            }
+            if (this.at(TokenKind.Question)) {
+                const end = this.nextToken().end;
+                element = { kind: SyntaxKind.OptionalType, type: element, start: element.start, end };
+            }
+            elements.push(element);
+            if (this.at(TokenKind.Comma))
+                this.nextToken();
+            else
+                break;
+        }
+        const close = this.parseExpected(TokenKind.CloseBracket);
+        return { kind: SyntaxKind.TupleType, elements, start: open.start, end: close.end };
+    }
+    parseTypeLiteral() {
+        const start = this.token.start;
+        // Detect mapped type: { [K in T]: U }
+        let cursor = 0;
+        if (this.atAhead(1, TokenKind.OpenBracket)) {
+            cursor = 1;
+            if (this.atAhead(2, TokenKind.Identifier)) {
+                let i = 3;
+                if (this.lookAhead(i).kind === TokenKind.InKeyword) {
+                    const open = this.parseExpected(TokenKind.OpenBrace);
+                    this.parseExpected(TokenKind.OpenBracket);
+                    const name = this.parseIdentifier();
+                    this.parseExpected(TokenKind.InKeyword);
+                    let constraint = this.parseType();
+                    this.parseExpected(TokenKind.CloseBracket);
+                    let questionToken = false;
+                    if (this.at(TokenKind.Question)) {
+                        this.nextToken();
+                        questionToken = true;
+                    }
+                    else if (this.at(TokenKind.Plus)) {
+                        this.nextToken();
+                        this.nextToken();
+                        questionToken = "+";
+                    }
+                    else if (this.at(TokenKind.Minus)) {
+                        this.nextToken();
+                        this.nextToken();
+                        questionToken = "-";
+                    }
+                    let type;
+                    if (this.at(TokenKind.Colon)) {
+                        this.nextToken();
+                        type = this.parseType();
+                    }
+                    this.parseSemicolonOrComma();
+                    const close = this.parseExpected(TokenKind.CloseBrace);
+                    const typeParameter = { kind: SyntaxKind.TypeParameterDeclaration, name, constraint, start: name.start, end: constraint.end };
+                    return { kind: SyntaxKind.MappedType, readonlyToken: false, typeParameter, questionToken, type, start: open.start, end: close.end };
+                }
+            }
+        }
+        void cursor;
+        const members = this.parseTypeMembers();
+        return { kind: SyntaxKind.TypeLiteral, members, start, end: this.token.start };
+    }
+}
+function expressionToPropertyName(expr) {
+    switch (expr.kind) {
+        case SyntaxKind.StringLiteral:
+            return expr;
+        case SyntaxKind.NumericLiteral:
+            return expr;
+        case SyntaxKind.Identifier:
+            return expr;
+        default:
+            return undefined;
+    }
+}
+function propertyNameText(name) {
+    switch (name.kind) {
+        case SyntaxKind.Identifier:
+        case SyntaxKind.PrivateIdentifier:
+            return name.text;
+        case SyntaxKind.StringLiteral:
+            return name.value;
+        case SyntaxKind.NumericLiteral:
+            return name.text;
+        default:
+            return "";
+    }
+}
+function isAssignmentTarget(expr) {
+    return (expr.kind === SyntaxKind.Identifier ||
+        expr.kind === SyntaxKind.PropertyAccessExpression ||
+        expr.kind === SyntaxKind.ElementAccessExpression ||
+        expr.kind === SyntaxKind.ParenthesizedExpression);
+}
+function assignmentOperator(kind) {
+    switch (kind) {
+        case TokenKind.Equals:
+            return AssignmentOperator.Assign;
+        case TokenKind.PlusEquals:
+            return AssignmentOperator.AddAssign;
+        case TokenKind.MinusEquals:
+            return AssignmentOperator.SubtractAssign;
+        case TokenKind.AsteriskEquals:
+            return AssignmentOperator.MultiplyAssign;
+        case TokenKind.SlashEquals:
+            return AssignmentOperator.DivideAssign;
+        case TokenKind.PercentEquals:
+            return AssignmentOperator.RemainderAssign;
+        case TokenKind.AsteriskAsteriskEquals:
+            return AssignmentOperator.ExponentAssign;
+        case TokenKind.LessThanLessThanEquals:
+            return AssignmentOperator.LessThanLessThanAssign;
+        case TokenKind.GreaterThanGreaterThanEquals:
+            return AssignmentOperator.GreaterThanGreaterThanAssign;
+        case TokenKind.GreaterThanGreaterThanGreaterThanEquals:
+            return AssignmentOperator.GreaterThanGreaterThanGreaterThanAssign;
+        case TokenKind.AmpersandEquals:
+            return AssignmentOperator.AmpersandAssign;
+        case TokenKind.BarEquals:
+            return AssignmentOperator.BarAssign;
+        case TokenKind.CaretEquals:
+            return AssignmentOperator.CaretAssign;
+        case TokenKind.AmpersandAmpersandEquals:
+            return AssignmentOperator.AmpersandAmpersandAssign;
+        case TokenKind.BarBarEquals:
+            return AssignmentOperator.BarBarAssign;
+        case TokenKind.QuestionQuestionEquals:
+            return AssignmentOperator.QuestionQuestionAssign;
+        default:
+            return undefined;
+    }
+}
+/** `as` / `satisfies` share the relational precedence level. */
+const AS_PRECEDENCE = 8;
+function binaryOperator(kind) {
+    switch (kind) {
+        case TokenKind.Plus:
+            return BinaryOperator.Add;
+        case TokenKind.Minus:
+            return BinaryOperator.Subtract;
+        case TokenKind.Asterisk:
+            return BinaryOperator.Multiply;
+        case TokenKind.Slash:
+            return BinaryOperator.Divide;
+        case TokenKind.Percent:
+            return BinaryOperator.Remainder;
+        case TokenKind.AsteriskAsterisk:
+            return BinaryOperator.Exponent;
+        case TokenKind.LessThan:
+            return BinaryOperator.LessThan;
+        case TokenKind.LessThanEquals:
+            return BinaryOperator.LessThanEquals;
+        case TokenKind.GreaterThan:
+            return BinaryOperator.GreaterThan;
+        case TokenKind.GreaterThanEquals:
+            return BinaryOperator.GreaterThanEquals;
+        case TokenKind.EqualsEquals:
+            return BinaryOperator.EqualsEquals;
+        case TokenKind.ExclamationEquals:
+            return BinaryOperator.ExclamationEquals;
+        case TokenKind.EqualsEqualsEquals:
+            return BinaryOperator.EqualsEqualsEquals;
+        case TokenKind.ExclamationEqualsEquals:
+            return BinaryOperator.ExclamationEqualsEquals;
+        case TokenKind.AmpersandAmpersand:
+            return BinaryOperator.AmpersandAmpersand;
+        case TokenKind.BarBar:
+            return BinaryOperator.BarBar;
+        case TokenKind.QuestionQuestion:
+            return BinaryOperator.QuestionQuestion;
+        case TokenKind.Ampersand:
+            return BinaryOperator.Ampersand;
+        case TokenKind.Bar:
+            return BinaryOperator.Bar;
+        case TokenKind.Caret:
+            return BinaryOperator.Caret;
+        case TokenKind.LessThanLessThan:
+            return BinaryOperator.LessThanLessThan;
+        case TokenKind.GreaterThanGreaterThan:
+            return BinaryOperator.GreaterThanGreaterThan;
+        case TokenKind.GreaterThanGreaterThanGreaterThan:
+            return BinaryOperator.GreaterThanGreaterThanGreaterThan;
+        case TokenKind.InKeyword:
+            return BinaryOperator.In;
+        case TokenKind.InstanceOfKeyword:
+            return BinaryOperator.InstanceOf;
+        default:
+            return undefined;
+    }
+}
+function binaryPrecedence(op) {
+    switch (op) {
+        case BinaryOperator.QuestionQuestion:
+            return 1;
+        case BinaryOperator.BarBar:
+            return 2;
+        case BinaryOperator.AmpersandAmpersand:
+            return 3;
+        case BinaryOperator.Bar:
+            return 4;
+        case BinaryOperator.Caret:
+            return 5;
+        case BinaryOperator.Ampersand:
+            return 6;
+        case BinaryOperator.EqualsEquals:
+        case BinaryOperator.ExclamationEquals:
+        case BinaryOperator.EqualsEqualsEquals:
+        case BinaryOperator.ExclamationEqualsEquals:
+            return 7;
+        case BinaryOperator.LessThan:
+        case BinaryOperator.LessThanEquals:
+        case BinaryOperator.GreaterThan:
+        case BinaryOperator.GreaterThanEquals:
+        case BinaryOperator.In:
+        case BinaryOperator.InstanceOf:
+            return 8;
+        case BinaryOperator.LessThanLessThan:
+        case BinaryOperator.GreaterThanGreaterThan:
+        case BinaryOperator.GreaterThanGreaterThanGreaterThan:
+            return 9;
+        case BinaryOperator.Add:
+        case BinaryOperator.Subtract:
+            return 10;
+        case BinaryOperator.Multiply:
+        case BinaryOperator.Divide:
+        case BinaryOperator.Remainder:
+            return 11;
+        case BinaryOperator.Exponent:
+            return 12;
+        default:
+            return -1;
+    }
+}
+function prefixUnaryOperator(kind) {
+    switch (kind) {
+        case TokenKind.Plus:
+            return PrefixUnaryOperator.Plus;
+        case TokenKind.Minus:
+            return PrefixUnaryOperator.Minus;
+        case TokenKind.Tilde:
+            return PrefixUnaryOperator.Tilde;
+        case TokenKind.Exclamation:
+            return PrefixUnaryOperator.Exclamation;
+        case TokenKind.TypeOfKeyword:
+            return PrefixUnaryOperator.TypeOf;
+        case TokenKind.VoidKeyword:
+            return PrefixUnaryOperator.Void;
+        case TokenKind.DeleteKeyword:
+            return PrefixUnaryOperator.Delete;
+        case TokenKind.PlusPlus:
+            return PrefixUnaryOperator.PlusPlus;
+        case TokenKind.MinusMinus:
+            return PrefixUnaryOperator.MinusMinus;
+        case TokenKind.AwaitKeyword:
+            return PrefixUnaryOperator.Await;
+        default:
+            return undefined;
+    }
+}
+/** Thrown internally to unwind a speculative parse; never escapes the parser. */
+class SpeculationError extends Error {
+    constructor() {
+        super("speculation failed");
+        this.name = "SpeculationError";
+    }
+}
+//# sourceMappingURL=parser.js.map