# Variable declaration

var a = b
  , c = d;
const [x] = y = 3;

==>

Script(
  VariableDeclaration(var,VariableDefinition,Equals,VariableName,VariableDefinition,Equals,VariableName),
  VariableDeclaration(const,ArrayPattern(VariableDefinition),Equals,AssignmentExpression(VariableName,Equals,Number)))

# Function declaration

function a(a, b) { return 3; }
function b({b}, c = d, e = f) {}

==>

Script(
  FunctionDeclaration(function,VariableDefinition,ParamList(VariableDefinition,VariableDefinition),Block(ReturnStatement(return,Number))),
  FunctionDeclaration(function,VariableDefinition,ParamList(
    ObjectPattern(PatternProperty(PropertyName)),VariableDefinition,Equals,VariableName,VariableDefinition,Equals,VariableName),Block))

# Async functions

async function foo() {}

class Foo { async bar() {} }

async (a) => { return foo; };

==>

Script(
  FunctionDeclaration(async,function,VariableDefinition,ParamList,Block),
  ClassDeclaration(class,VariableDefinition,ClassBody(MethodDeclaration(async,PropertyDefinition,ParamList,Block))),
  ExpressionStatement(ArrowFunction(async,ParamList(VariableDefinition),Arrow,Block(ReturnStatement(return,VariableName)))))

# If statements

if (x) log(y);

if (a.b) {
  d;
}

if (a) {
  c;
  d;
} else {
  e;
}

if (1) if (2) b; else c;

==>

Script(
  IfStatement(if,ParenthesizedExpression(VariableName),ExpressionStatement(CallExpression(VariableName,ArgList(VariableName)))),
  IfStatement(if,ParenthesizedExpression(MemberExpression(VariableName,PropertyName)),Block(ExpressionStatement(VariableName))),
  IfStatement(if,ParenthesizedExpression(VariableName),Block(ExpressionStatement(VariableName),ExpressionStatement(VariableName)),
    else,Block(ExpressionStatement(VariableName))),
  IfStatement(if,ParenthesizedExpression(Number),IfStatement(if,ParenthesizedExpression(Number),ExpressionStatement(VariableName),
    else,ExpressionStatement(VariableName))))

# While loop

while (1) debugger;
while (2) {
  a;
  b;
}

==>

Script(
  WhileStatement(while,ParenthesizedExpression(Number),DebuggerStatement(debugger)),
  WhileStatement(while,ParenthesizedExpression(Number),Block(ExpressionStatement(VariableName),ExpressionStatement(VariableName))))

# Labels

foo: 1;
foo: while(2) break foo;

==>

Script(
  LabeledStatement(Label,ExpressionStatement(Number)),
  LabeledStatement(Label,WhileStatement(while,ParenthesizedExpression(Number),BreakStatement(break,Label))))

# Try

try { throw new Error; } catch {}
try { 1; } catch (x) { 2; } finally { 3; }

==>

Script(
  TryStatement(try,Block(ThrowStatement(throw,NewExpression(new,VariableName))),CatchClause(catch,Block)),
  TryStatement(try,Block(ExpressionStatement(Number)),
    CatchClause(catch,VariableDefinition,Block(ExpressionStatement(Number))),
    FinallyClause(finally,Block(ExpressionStatement(Number)))))

# Switch

switch (x) {
  case 1:
    return true;
  case 2:
  case 50 * 3:
    console.log("ok");
  default:
    return false;
}

==>

Script(SwitchStatement(switch,ParenthesizedExpression(VariableName),SwitchBody(
  CaseLabel(case,Number),
  ReturnStatement(return,BooleanLiteral),
  CaseLabel(case,Number),
  CaseLabel(case,BinaryExpression(Number,ArithOp,Number)),
  ExpressionStatement(CallExpression(MemberExpression(VariableName,PropertyName),ArgList(String))),
  DefaultLabel(default),
  ReturnStatement(return,BooleanLiteral))))

# For

for (let x = 1; x < 10; x++) {}
for (const y of z) {}
for (var m in n) {}
for (q in r) {}
for (var a, b; c; d) continue;
for (i = 0, init(); i < 10; i++) {}
for (;;) {}
for (const {thing} in things) thing;
for await (let x of stream) {}

==>

Script(
  ForStatement(for,ForSpec(VariableDeclaration(let,VariableDefinition,Equals,Number),
    BinaryExpression(VariableName,CompareOp,Number),PostfixExpression(VariableName,ArithOp)),Block),
  ForStatement(for,ForOfSpec(const,VariableDefinition,of,VariableName),Block),
  ForStatement(for,ForInSpec(var,VariableDefinition,in,VariableName),Block),
  ForStatement(for,ForInSpec(VariableName,in,VariableName),Block),
  ForStatement(for,ForSpec(VariableDeclaration(var,VariableDefinition,VariableDefinition),VariableName,VariableName),ContinueStatement(continue)),
  ForStatement(for,ForSpec(SequenceExpression(AssignmentExpression(VariableName,Equals,Number),
    CallExpression(VariableName,ArgList)),BinaryExpression(VariableName,CompareOp,Number),PostfixExpression(VariableName,ArithOp)),Block),
  ForStatement(for,ForSpec,Block),
  ForStatement(for,ForInSpec(const,ObjectPattern(PatternProperty(PropertyName)),in,VariableName),ExpressionStatement(VariableName)),
  ForStatement(for,await,ForOfSpec(let,VariableDefinition,of,VariableName),Block))

# Labeled statements

theLoop: for (;;) {
  if (a) {
    break theLoop;
  }
}

==>

Script(LabeledStatement(Label,ForStatement(for,ForSpec,Block(
  IfStatement(if,ParenthesizedExpression(VariableName),Block(BreakStatement(break,Label)))))))

# Classes

class Foo {
  static one(a) { return a; };
  two(b) { return b; }
  finally() {}
}

class Foo extends require('another-class') {
  constructor() { super(); }
  bar() { super.a(); }
  prop;
  etc = 20;
  static { f() }
}

==>

Script(
  ClassDeclaration(class,VariableDefinition,ClassBody(
    MethodDeclaration(static,PropertyDefinition,ParamList(VariableDefinition),Block(ReturnStatement(return,VariableName))),
    MethodDeclaration(PropertyDefinition,ParamList(VariableDefinition),Block(ReturnStatement(return,VariableName))),
    MethodDeclaration(PropertyDefinition,ParamList,Block))),
  ClassDeclaration(class,VariableDefinition,extends,CallExpression(VariableName,ArgList(String)),ClassBody(
    MethodDeclaration(PropertyDefinition,ParamList,Block(ExpressionStatement(CallExpression(super,ArgList)))),
    MethodDeclaration(PropertyDefinition,ParamList,Block(ExpressionStatement(CallExpression(MemberExpression(super,PropertyName),ArgList)))),
    PropertyDeclaration(PropertyDefinition),
    PropertyDeclaration(PropertyDefinition,Equals,Number),
    StaticBlock(static, Block(ExpressionStatement(CallExpression(VariableName,ArgList)))))))

# Private properties

class Foo {
  #bar() { this.#a() + this?.#prop == #prop in this; }
  #prop;
  #etc = 20;
}

==>

Script(ClassDeclaration(class,VariableDefinition,ClassBody(
  MethodDeclaration(PrivatePropertyDefinition,ParamList,Block(
    ExpressionStatement(BinaryExpression(
       BinaryExpression(
         CallExpression(MemberExpression(this,PrivatePropertyName),ArgList),
         ArithOp,
         MemberExpression(this,PrivatePropertyName)),
       CompareOp,
       BinaryExpression(PrivatePropertyName, in, this))))),
  PropertyDeclaration(PrivatePropertyDefinition),
  PropertyDeclaration(PrivatePropertyDefinition,Equals,Number))))

# Computed properties

class Foo {
  [x] = 44;
  [Symbol.iterator]() {}
}

==>

Script(ClassDeclaration(class,VariableDefinition,ClassBody(
  PropertyDeclaration(VariableName,Equals,Number),
  MethodDeclaration(MemberExpression(VariableName,PropertyName),ParamList,Block))))

# Imports

import defaultMember from "module-name";
import * as name from "module-name";
import { member } from "module-name";
import { member1, member2 as alias2 } from "module-name";
import defaultMember, { member1, member2 as alias2, } from "module-name";
import "module-name";

==>

Script(
  ImportDeclaration(import,VariableDefinition,from,String),
  ImportDeclaration(import,Star,as,VariableDefinition,from,String),
  ImportDeclaration(import,ImportGroup(VariableDefinition),from,String),
  ImportDeclaration(import,ImportGroup(VariableDefinition,VariableName,as,VariableDefinition),from,String),
  ImportDeclaration(import,VariableDefinition,ImportGroup(VariableDefinition,VariableName,as,VariableDefinition),from,String),
  ImportDeclaration(import,String))

# Exports

export { name1, name2, name3 as x, nameN };
export let a, b = 2;
export default 2 + 2;
export default function() { }
export default async function name1() { }
export { name1 as default, } from "foo";
export * from 'foo';

==>

Script(
  ExportDeclaration(export,ExportGroup(VariableName,VariableName,VariableName,as,VariableName,VariableName)),
  ExportDeclaration(export,VariableDeclaration(let,VariableDefinition,VariableDefinition,Equals,Number)),
  ExportDeclaration(export,default,BinaryExpression(Number,ArithOp,Number)),
  ExportDeclaration(export,default,FunctionDeclaration(function,ParamList,Block)),
  ExportDeclaration(export,default,FunctionDeclaration(async,function,VariableDefinition,ParamList,Block)),
  ExportDeclaration(export,ExportGroup(VariableName,as,VariableName),from,String),
  ExportDeclaration(export,Star,from,String))

# Empty statements

if (true) { ; };;;

==>

Script(IfStatement(if,ParenthesizedExpression(BooleanLiteral),Block))

# Comments

/* a */
one;

/* b **/
two;

/* c ***/
three;

/* d

***/
four;

y // comment
  * z;

==>

Script(
  BlockComment,
  ExpressionStatement(VariableName),
  BlockComment,
  ExpressionStatement(VariableName),
  BlockComment,
  ExpressionStatement(VariableName),
  BlockComment,
  ExpressionStatement(VariableName),
  ExpressionStatement(BinaryExpression(VariableName,LineComment,ArithOp,VariableName)))

# Recover from invalid char

const {foobar} = {};

==>

Script(VariableDeclaration(
  const,
  ObjectPattern("{",PatternProperty(PropertyName,⚠),"}"),
  Equals,
  ObjectExpression))

# Sync back to statement

function f() {
  log(a b --c)
}
function g() {}

==>

Script(
  FunctionDeclaration(function,VariableDefinition,ParamList,Block(ExpressionStatement(CallExpression(VariableName,ArgList(...))))),
  FunctionDeclaration(function,VariableDefinition,ParamList,Block))

# Destructuring

({x} = y);
[u, v] = w;
let [a,, b = 0] = c;
let {x, y: z = 1} = d;
let {[f]: m} = e;

==>

Script(
  ExpressionStatement(ParenthesizedExpression(AssignmentExpression(
    ObjectPattern(PatternProperty(PropertyName)),Equals,VariableName))),
  ExpressionStatement(AssignmentExpression(ArrayPattern(VariableDefinition,VariableDefinition),Equals,VariableName)),
  VariableDeclaration(let,ArrayPattern(VariableDefinition,VariableDefinition,Equals,Number),Equals,VariableName),
  VariableDeclaration(let,ObjectPattern(
    PatternProperty(PropertyName),
    PatternProperty(PropertyName,VariableDefinition,Equals,Number)
  ),Equals,VariableName),
  VariableDeclaration(let,ObjectPattern(PatternProperty(VariableName,VariableDefinition)),Equals,VariableName))

# Generators

function* foo() { yield 1 }

class B {
  *method() {}
}

({*x() {}})

==>

Script(
  FunctionDeclaration(function,Star,VariableDefinition,ParamList,Block(
    ExpressionStatement(YieldExpression(yield,Number)))),
  ClassDeclaration(class,VariableDefinition,ClassBody(
    MethodDeclaration(Star,PropertyDefinition,ParamList,Block))),
  ExpressionStatement(ParenthesizedExpression(ObjectExpression(Property(Star,PropertyDefinition,ParamList,Block)))))

# Hashbang

#!/bin/env node
foo()

==>

Script(Hashbang,ExpressionStatement(CallExpression(VariableName,ArgList)))
