newParser(tokens: { Token }, sourceName: string, module: boolean?) → Parser

peek(self: Parser, ahead: number?) → Token

next(self: Parser) → Token

atEnd(self: Parser) → boolean

raise(self: Parser, msg: string, tok: Token?) → never

isPunct(self: Parser, value: string, ahead: number?) → boolean

Match a punct token by exact value without consuming.

isKeyword(self: Parser, value: string, ahead: number?) → boolean

expectPunct(self: Parser, value: string) → Token

Consume a punct token whose value must equal `value`, else raise.

node(type_: string, tok: { line: number, col: number, [string]: any }, fields: { [string]: any }) → Node

Base node factory. line/col come from the node's first token. `tok` is only read for its position, and callers pass whatever carries one: a lexer token where the construct starts at a token, and an already-built node where it starts at a sub-expression (`a.b`, `a[b]`, a call on a callee).

toPattern(self: Parser, expr: Node) → Node

parseArguments(self: Parser) → void

Parse a comma-separated argument list up to the closing paren. Supports `...spread`. Assumes the opening `(` is already consumed.

parseBlock(self: Parser) → Node

Parse a `{ ... }` statement block of any statements.

parseFunctionExpr(self: Parser, kwTok: Token, isAsync: boolean) → Node

Parse a `function` expression, with the `function` keyword already consumed.

parseParamList(self: Parser) → void

Parse a `(...)` parameter list into patterns, opening `(` already consumed.

parseBindingTarget(self: Parser) → Node

Parse a single binding target (identifier or nested destructuring pattern).

arrowAhead(self: Parser) → boolean

Determine whether the parenthesised group starting at the current `(` is an arrow parameter list, by scanning to its matching `)` and checking for `=>`.

finishArrow(self: Parser, startTok: Token, params: { Node }, isAsync: boolean) → Node

Parse an arrow function tail from an already-parsed parameter list. The `=>` is at the cursor.

parseObjectLit(self: Parser, openTok: Token) → Node

Parse an object literal, opening `{` already consumed.

parsePropertyKey(self: Parser) → void

Parse an object-literal property key, returning (keyNode, computed).

parseArrayLit(self: Parser, openTok: Token) → Node

Parse an array literal, opening `[` already consumed.

parseTemplateToken(self: Parser, tok: Token) → Node

Parse a template literal token into a Template node, re-parsing each embedded expression's token array with a nested parser.

parsePrimary(self: Parser) → Node

Parse a primary (leaf) expression.

parseKeywordPrimary(self: Parser, tok: Token) → Node

Parse keyword-led primaries: literals, this, function expressions, arrows.

parseParenOrArrow(self: Parser, openTok: Token, isAsync: boolean) → Node

Parse a parenthesised expression or an arrow function. `isAsync` marks an `async (...)` head. The `(` is at the cursor (not yet consumed).

parseNew(self: Parser, newTok: Token) → Node

Parse `new` expressions. `new` binds tighter than call chains: it consumes a member expression as the callee, then an optional single argument list.

parseMemberTail(self: Parser, expr: Node) → Node

Parse the member-access tail of an expression (`.x` and `[e]`), without consuming call parens. Used for `new` callees.

parseCallTail(self: Parser, expr: Node, allowCall: boolean) → Node

Parse the full call/member tail: `.x`, `[e]`, `(args)`, and reject tagged templates. `allowCall` gates whether call parens are consumed here.

parsePostfix(self: Parser) → Node

Parse a postfix expression: a primary/new followed by member/call tails and a trailing `++`/`--`.

parseUnary(self: Parser) → void

Parse a unary/prefix expression, returning the node and whether it was a unary form (used to forbid a unary operand directly on the left of `**`).

parseExponent(self: Parser) → Node

Parse an exponentiation expression: `unary ** exponent`, right-associative. A unary operand on the left of `**` is a SyntaxError.

parseBinary(self: Parser, minBp: number, noIn: boolean?) → Node

Parse binary/logical operators by precedence climbing from binding power `minBp`. When `noIn` is true the `in` operator is treated as unrecognised, which is required inside for-head initialisers (ECMA-262 §14.7.4). Parentheses reset the flag — `parseParenOrArrow` calls back without it.

parseConditional(self: Parser, noIn: boolean?) → Node

Parse a conditional (ternary) expression.

parseAssign(self: Parser, noIn: boolean?) → Node

Parse an assignment expression (right-associative), converting object/array literal targets to patterns.

parseExpression(self: Parser, noIn: boolean?) → Node

Parse a full expression, including comma sequences.

expectSemicolon(self: Parser) → void

Automatic Semicolon Insertion. Accept an explicit `;`; otherwise a statement may end before `}`, at eof, or before a token that begins a new line.

parseStatement(self: Parser) → Node

Parse a single statement. Keyword-led statements dispatch here; anything else is a labeled statement or an expression statement.

parseVarDecl(self: Parser, inForHead: boolean?, noIn: boolean?) → Node

Parse a `var`/`let`/`const` declaration head, up to but not including its terminator. The declaration keyword is at the cursor. `inForHead` allows a `const` declarator without an initializer, as a for-in/for-of head requires. `noIn` suppresses the `in` operator inside declarator initialisers, which is required when this declaration appears as the init clause of a c-style for.

parseFunctionDecl(self: Parser, startTok: Token, isAsync: boolean) → Node

Parse a function declaration, `function` keyword already consumed.

parseIf(self: Parser, startTok: Token) → Node

Parse an `if`/`else` statement. A trailing `else` binds to this `if`, so a dangling `else` attaches to the nearest unmatched `if`.

parseWhile(self: Parser, startTok: Token) → Node

Parse a `while` loop.

parseDoWhile(self: Parser, startTok: Token) → Node

Parse a `do`/`while` loop.

parseFor(self: Parser, startTok: Token) → Node

Parse the four `for` forms: c-style, for-in, and for-of, with either a declaration head or a bare-pattern/expression head.

parseSwitch(self: Parser, startTok: Token) → Node

Parse a `switch` statement. Case bodies are statement lists that run until the next `case`/`default`/closing brace. A `default` clause carries a nil test.

parseTry(self: Parser, startTok: Token) → Node

Parse a `try` statement with any of an optional catch (with or without a binding param) and an optional finally.

parseClassDecl(self: Parser, startTok: Token) → Node

Parse a class declaration (id required).

parseClassExpr(self: Parser) → Node

Parse a class expression (id optional), `class` keyword at the cursor.

parseClassHeritage(self: Parser) → Node

Parse an optional `extends <LeftHandSideExpression>` heritage clause.

parseClassBody(self: Parser) → void

Parse a `{ ... }` class body into a list of class members.

parseClassMember(self: Parser) → Node

Parse one class member: a method, accessor, or field, with optional `static`, `async`, and `get`/`set` prefixes.

memberPrefixEndsHere(self: Parser) → boolean

A `static`/`async`/`get`/`set` word is a member name rather than a prefix when the next token is a member terminator (`(`, `=`, `;`, `}`) or a line break.

collectPatternNames(pat: Node, out: { string }) → void

Collect the binding names a declaration pattern introduces, recursing through array, object, assignment, and rest patterns.

isContextual(self: Parser, word: string) → boolean

Match a contextual word (`from`, `as`) that lexes as a plain identifier.

expectContextual(self: Parser, word: string) → Token

Consume a contextual word, raising if the current token is not it.

parseModuleName(self: Parser) → string

Read a module import/export name: an identifier, a keyword used as a name, or a string-literal name.

parseBindingName(self: Parser) → string

Read a local binding identifier for an import specifier.

recordExport(self: Parser, name: string, tok: Token?) → void

Record an exported name onto the module surface, rejecting a duplicate export of the same name.

parseModuleDeclaration(self: Parser) → Node

Dispatch a top-level module item to the import or export parser.

parseNamedImports(self: Parser, specifiers: { any }) → void

Parse the `{ a, b as c }` clause of an import, appending named specifiers.

finishImport(self: Parser, kwTok: Token, source: string, specifiers: { any }) → Node

Build an ImportDecl node and record its specifier on the module surface.

parseImportDecl(self: Parser) → Node

Parse an `import` declaration in each of its forms: side-effect-only, default, namespace, named, and default combined with namespace or named.

parseExportDecl(self: Parser) → Node

Parse an `export` declaration, dispatching to default, named/re-export, and declaration forms, and rejecting `export *`.

parseExportDefault(self: Parser, kwTok: Token) → Node

Parse `export default <expression|function|class>`.

parseExportNamed(self: Parser, kwTok: Token) → Node

Parse `export { a, b as c }` and its `from "s"` re-export variant. A re-export creates no local binding.

parseExportDeclaration(self: Parser, kwTok: Token) → Node

Parse `export <var/let/const/function/class declaration>`. The declaration also binds locally, and each bound name becomes an exported name.

parseProgram(self: Parser) → Node

Parse a whole program: a list of statements terminated by eof.

parse(src: string, options: (string | ParseOptions) → void

parseExpr(src: string) → Node