About

Incorrect AST manipulation leads to silent code generation bugs: malformed output, lost scope bindings, or invalid syntax that only surfaces at runtime. This tool implements a full recursive-descent parser conforming to the ESTree specification, producing the same node types (Program, FunctionExpression, MemberExpression, etc.) used by Esprima, Acorn, and Babel. It parses raw JavaScript source into a complete AST, renders the tree as inspectable JSON, and regenerates valid source code via a recursive walker. The parser handles ES6+ constructs including arrow functions, template literals, destructuring, spread operators, classes, and computed properties. A CSS-like selector engine lets you query nodes (e.g., function > id or call[callee = "require"]) for targeted inspection. Note: this parser approximates a subset of ECMAScript 2020. Edge cases involving obscure automatic semicolon insertion rules or exotic Unicode escapes may produce divergent results compared to V8's internal parser.

Formulas

The parser operates as a two-phase pipeline. Phase 1 is lexical analysis (tokenization). The source string S of length n is scanned character-by-character producing a token stream T.

S → tokenize(S) = T = [t₀, t₁, …, t_m]

Each token t_i carries a type (keyword, identifier, literal, punctuator) and value. Phase 2 applies a Pratt parser (top-down operator precedence). Each token type has a binding power bp and optional null-denotation (nud) and left-denotation (led) functions.

parseExpr(rbp) = left ← nud(t) ; while bp(next) > rbp : left ← led(left, next)

Source regeneration walks the AST recursively. For each node type, a visitor function emits the corresponding JavaScript syntax with proper indentation depth d.

toSource(node, d) = emit(node.type, node.children, d)

Where S = source string, n = source length, T = token array, m = token count, t_i = individual token, bp = binding power (integer precedence), rbp = right binding power threshold, nud = null denotation (prefix handler), led = left denotation (infix handler), d = indentation depth.

Reference Data

Short Name	ESTree Node Type	Description	Example
program	Program	Root node of any parsed source	var x = 1;
var	VariableDeclaration	Variable declaration with kind	let a = 5
decl	VariableDeclarator	Single declarator within a declaration	a = 5 (inside var)
function	FunctionExpression	Anonymous or named function expression	function(x){}
functiondecl	FunctionDeclaration	Named function declaration (hoisted)	function foo(){}
arrow	ArrowFunctionExpression	ES6 arrow function	x => x+1
call	CallExpression	Function invocation	foo(1, 2)
member	MemberExpression	Property access (dot or bracket)	obj.prop
object	ObjectExpression	Object literal	{a: 1}
array	ArrayExpression	Array literal	[1, 2, 3]
binary	BinaryExpression	Binary operator expression	a + b
logical	LogicalExpression	Logical operator expression	a && b
unary	UnaryExpression	Unary prefix operator	!x
update	UpdateExpression	Increment or decrement	i++
assign	AssignmentExpression	Assignment with operator	x = 10
conditional	ConditionalExpression	Ternary operator	a ? b : c
if	IfStatement	Conditional branching	if(x){}
for	ForStatement	C-style for loop	for(;;){}
forin	ForInStatement	For-in enumeration	for(k in o){}
while	WhileStatement	While loop	while(x){}
dowhile	DoWhileStatement	Do-while loop	do{}while(x)
return	ReturnStatement	Return from function	return x;
throw	ThrowStatement	Throw an exception	throw e;
try	TryStatement	Try-catch-finally	try{}catch(e){}
switch	SwitchStatement	Switch statement	switch(x){}
case	SwitchCase	Case clause in switch	case 1:
this	ThisExpression	Reference to this	this
new	NewExpression	Constructor invocation	new Foo()
sequence	SequenceExpression	Comma-separated expressions	a, b, c
property	Property	Key-value pair in object	key: val
literal	Literal	Primitive value	42, "hello"
identifier	Identifier	Named reference	myVar
template	TemplateLiteral	Template string	`hello ${x}`
spread	SpreadElement	Spread operator	...args
class	ClassDeclaration	ES6 class	class Foo{}

Frequently Asked Questions

The parser implements a simplified ASI model. When a newline is encountered before a token that cannot continue the current statement (such as a closing brace, another statement keyword, or end of input), the parser inserts a virtual semicolon. This covers the majority of real-world code but may diverge from V8's behavior in edge cases involving return/throw followed by a newline before their argument.

The parser supports arrow functions (including concise body), template literals with expression interpolation, let/const declarations, destructuring assignment (object and array patterns), spread/rest operators, shorthand property syntax, computed property names, class declarations with constructors and methods, for-of loops, default parameter values, and getter/setter properties. Generator functions (function*) and async/await are recognized at the token level but have limited AST support.

The selector engine maps ESTree node types to short aliases (e.g., function maps to FunctionExpression and FunctionDeclaration). Descendant selectors (space-separated) traverse the full subtree. Child selectors (>) require direct parent-child relationships in the AST. Attribute selectors like [callee = "require"] match against stringified property values. Pseudo-classes :first and :last-child filter by position within parent arrays. The .property syntax selects named children (e.g., function.params selects the params array of function nodes).

The code generator (toSource) produces canonically formatted output. It normalizes whitespace, applies consistent 2-space indentation, adds semicolons explicitly, and uses a fixed brace style. Comments are not preserved in the AST (per ESTree convention) and therefore do not appear in regenerated source. Parenthesization follows operator precedence rules and may add or remove parentheses compared to the original. The semantic meaning is preserved even when surface syntax differs.

Inputs under 10 KB parse in under 50 ms on modern hardware and execute on the main thread. For inputs between 10 KB and 500 KB, parsing is offloaded to a Web Worker to prevent UI blocking. The AST tree view uses lazy rendering: only visible nodes are rendered to the DOM. Inputs exceeding 500 KB may produce ASTs with hundreds of thousands of nodes; the JSON output remains accurate but the tree visualization will only render the first 5000 nodes with a truncation notice.

No. This parser targets standard ECMAScript. TypeScript type annotations (: string, interface, type) and JSX elements () are not recognized and will produce parse errors. For TypeScript, the source must first be transpiled to plain JavaScript. JSX requires a dedicated transform pass (e.g., converting

to React.createElement calls) before this parser can process it.