diffdown.com
Diffdown is a real-time collaborative Markdown editor/previewer built on the AT Protocol
diffdown.com
1# Variable declaration
2
3var a = b
4 , c = d;
5const [x] = y = 3;
6
7==>
8
9Script(
10 VariableDeclaration(var,VariableDefinition,Equals,VariableName,VariableDefinition,Equals,VariableName),
11 VariableDeclaration(const,ArrayPattern(VariableDefinition),Equals,AssignmentExpression(VariableName,Equals,Number)))
12
13# Function declaration
14
15function a(a, b) { return 3; }
16function b({b}, c = d, e = f) {}
17
18==>
19
20Script(
21 FunctionDeclaration(function,VariableDefinition,ParamList(VariableDefinition,VariableDefinition),Block(ReturnStatement(return,Number))),
22 FunctionDeclaration(function,VariableDefinition,ParamList(
23 ObjectPattern(PatternProperty(PropertyName)),VariableDefinition,Equals,VariableName,VariableDefinition,Equals,VariableName),Block))
24
25# Async functions
26
27async function foo() {}
28
29class Foo { async bar() {} }
30
31async (a) => { return foo; };
32
33==>
34
35Script(
36 FunctionDeclaration(async,function,VariableDefinition,ParamList,Block),
37 ClassDeclaration(class,VariableDefinition,ClassBody(MethodDeclaration(async,PropertyDefinition,ParamList,Block))),
38 ExpressionStatement(ArrowFunction(async,ParamList(VariableDefinition),Arrow,Block(ReturnStatement(return,VariableName)))))
39
40# If statements
41
42if (x) log(y);
43
44if (a.b) {
45 d;
46}
47
48if (a) {
49 c;
50 d;
51} else {
52 e;
53}
54
55if (1) if (2) b; else c;
56
57==>
58
59Script(
60 IfStatement(if,ParenthesizedExpression(VariableName),ExpressionStatement(CallExpression(VariableName,ArgList(VariableName)))),
61 IfStatement(if,ParenthesizedExpression(MemberExpression(VariableName,PropertyName)),Block(ExpressionStatement(VariableName))),
62 IfStatement(if,ParenthesizedExpression(VariableName),Block(ExpressionStatement(VariableName),ExpressionStatement(VariableName)),
63 else,Block(ExpressionStatement(VariableName))),
64 IfStatement(if,ParenthesizedExpression(Number),IfStatement(if,ParenthesizedExpression(Number),ExpressionStatement(VariableName),
65 else,ExpressionStatement(VariableName))))
66
67# While loop
68
69while (1) debugger;
70while (2) {
71 a;
72 b;
73}
74
75==>
76
77Script(
78 WhileStatement(while,ParenthesizedExpression(Number),DebuggerStatement(debugger)),
79 WhileStatement(while,ParenthesizedExpression(Number),Block(ExpressionStatement(VariableName),ExpressionStatement(VariableName))))
80
81# Labels
82
83foo: 1;
84foo: while(2) break foo;
85
86==>
87
88Script(
89 LabeledStatement(Label,ExpressionStatement(Number)),
90 LabeledStatement(Label,WhileStatement(while,ParenthesizedExpression(Number),BreakStatement(break,Label))))
91
92# Try
93
94try { throw new Error; } catch {}
95try { 1; } catch (x) { 2; } finally { 3; }
96
97==>
98
99Script(
100 TryStatement(try,Block(ThrowStatement(throw,NewExpression(new,VariableName))),CatchClause(catch,Block)),
101 TryStatement(try,Block(ExpressionStatement(Number)),
102 CatchClause(catch,VariableDefinition,Block(ExpressionStatement(Number))),
103 FinallyClause(finally,Block(ExpressionStatement(Number)))))
104
105# Switch
106
107switch (x) {
108 case 1:
109 return true;
110 case 2:
111 case 50 * 3:
112 console.log("ok");
113 default:
114 return false;
115}
116
117==>
118
119Script(SwitchStatement(switch,ParenthesizedExpression(VariableName),SwitchBody(
120 CaseLabel(case,Number),
121 ReturnStatement(return,BooleanLiteral),
122 CaseLabel(case,Number),
123 CaseLabel(case,BinaryExpression(Number,ArithOp,Number)),
124 ExpressionStatement(CallExpression(MemberExpression(VariableName,PropertyName),ArgList(String))),
125 DefaultLabel(default),
126 ReturnStatement(return,BooleanLiteral))))
127
128# For
129
130for (let x = 1; x < 10; x++) {}
131for (const y of z) {}
132for (var m in n) {}
133for (q in r) {}
134for (var a, b; c; d) continue;
135for (i = 0, init(); i < 10; i++) {}
136for (;;) {}
137for (const {thing} in things) thing;
138for await (let x of stream) {}
139
140==>
141
142Script(
143 ForStatement(for,ForSpec(VariableDeclaration(let,VariableDefinition,Equals,Number),
144 BinaryExpression(VariableName,CompareOp,Number),PostfixExpression(VariableName,ArithOp)),Block),
145 ForStatement(for,ForOfSpec(const,VariableDefinition,of,VariableName),Block),
146 ForStatement(for,ForInSpec(var,VariableDefinition,in,VariableName),Block),
147 ForStatement(for,ForInSpec(VariableName,in,VariableName),Block),
148 ForStatement(for,ForSpec(VariableDeclaration(var,VariableDefinition,VariableDefinition),VariableName,VariableName),ContinueStatement(continue)),
149 ForStatement(for,ForSpec(SequenceExpression(AssignmentExpression(VariableName,Equals,Number),
150 CallExpression(VariableName,ArgList)),BinaryExpression(VariableName,CompareOp,Number),PostfixExpression(VariableName,ArithOp)),Block),
151 ForStatement(for,ForSpec,Block),
152 ForStatement(for,ForInSpec(const,ObjectPattern(PatternProperty(PropertyName)),in,VariableName),ExpressionStatement(VariableName)),
153 ForStatement(for,await,ForOfSpec(let,VariableDefinition,of,VariableName),Block))
154
155# Labeled statements
156
157theLoop: for (;;) {
158 if (a) {
159 break theLoop;
160 }
161}
162
163==>
164
165Script(LabeledStatement(Label,ForStatement(for,ForSpec,Block(
166 IfStatement(if,ParenthesizedExpression(VariableName),Block(BreakStatement(break,Label)))))))
167
168# Classes
169
170class Foo {
171 static one(a) { return a; };
172 two(b) { return b; }
173 finally() {}
174}
175
176class Foo extends require('another-class') {
177 constructor() { super(); }
178 bar() { super.a(); }
179 prop;
180 etc = 20;
181 static { f() }
182}
183
184==>
185
186Script(
187 ClassDeclaration(class,VariableDefinition,ClassBody(
188 MethodDeclaration(static,PropertyDefinition,ParamList(VariableDefinition),Block(ReturnStatement(return,VariableName))),
189 MethodDeclaration(PropertyDefinition,ParamList(VariableDefinition),Block(ReturnStatement(return,VariableName))),
190 MethodDeclaration(PropertyDefinition,ParamList,Block))),
191 ClassDeclaration(class,VariableDefinition,extends,CallExpression(VariableName,ArgList(String)),ClassBody(
192 MethodDeclaration(PropertyDefinition,ParamList,Block(ExpressionStatement(CallExpression(super,ArgList)))),
193 MethodDeclaration(PropertyDefinition,ParamList,Block(ExpressionStatement(CallExpression(MemberExpression(super,PropertyName),ArgList)))),
194 PropertyDeclaration(PropertyDefinition),
195 PropertyDeclaration(PropertyDefinition,Equals,Number),
196 StaticBlock(static, Block(ExpressionStatement(CallExpression(VariableName,ArgList)))))))
197
198# Private properties
199
200class Foo {
201 #bar() { this.#a() + this?.#prop == #prop in this; }
202 #prop;
203 #etc = 20;
204}
205
206==>
207
208Script(ClassDeclaration(class,VariableDefinition,ClassBody(
209 MethodDeclaration(PrivatePropertyDefinition,ParamList,Block(
210 ExpressionStatement(BinaryExpression(
211 BinaryExpression(
212 CallExpression(MemberExpression(this,PrivatePropertyName),ArgList),
213 ArithOp,
214 MemberExpression(this,PrivatePropertyName)),
215 CompareOp,
216 BinaryExpression(PrivatePropertyName, in, this))))),
217 PropertyDeclaration(PrivatePropertyDefinition),
218 PropertyDeclaration(PrivatePropertyDefinition,Equals,Number))))
219
220# Computed properties
221
222class Foo {
223 [x] = 44;
224 [Symbol.iterator]() {}
225}
226
227==>
228
229Script(ClassDeclaration(class,VariableDefinition,ClassBody(
230 PropertyDeclaration(VariableName,Equals,Number),
231 MethodDeclaration(MemberExpression(VariableName,PropertyName),ParamList,Block))))
232
233# Imports
234
235import defaultMember from "module-name";
236import * as name from "module-name";
237import { member } from "module-name";
238import { member1, member2 as alias2 } from "module-name";
239import defaultMember, { member1, member2 as alias2, } from "module-name";
240import "module-name";
241import defer x from "y";
242import defer from "y";
243
244==>
245
246Script(
247 ImportDeclaration(import,VariableDefinition,from,String),
248 ImportDeclaration(import,Star,as,VariableDefinition,from,String),
249 ImportDeclaration(import,ImportGroup(VariableDefinition),from,String),
250 ImportDeclaration(import,ImportGroup(VariableDefinition,VariableName,as,VariableDefinition),from,String),
251 ImportDeclaration(import,VariableDefinition,ImportGroup(VariableDefinition,VariableName,as,VariableDefinition),from,String),
252 ImportDeclaration(import,String),
253 ImportDeclaration(import,defer,VariableDefinition,from,String),
254 ImportDeclaration(import,VariableDefinition,from,String))
255
256# Exports
257
258export { name1, name2, name3 as x, nameN };
259export let a, b = 2;
260export default 2 + 2;
261export default function() { }
262export default async function name1() { }
263export { name1 as default, } from "foo";
264export * from 'foo';
265
266==>
267
268Script(
269 ExportDeclaration(export,ExportGroup(VariableName,VariableName,VariableName,as,VariableName,VariableName)),
270 ExportDeclaration(export,VariableDeclaration(let,VariableDefinition,VariableDefinition,Equals,Number)),
271 ExportDeclaration(export,default,BinaryExpression(Number,ArithOp,Number)),
272 ExportDeclaration(export,default,FunctionDeclaration(function,ParamList,Block)),
273 ExportDeclaration(export,default,FunctionDeclaration(async,function,VariableDefinition,ParamList,Block)),
274 ExportDeclaration(export,ExportGroup(VariableName,as,VariableName),from,String),
275 ExportDeclaration(export,Star,from,String))
276
277# Empty statements
278
279if (true) { ; };;;
280
281==>
282
283Script(IfStatement(if,ParenthesizedExpression(BooleanLiteral),Block))
284
285# Comments
286
287/* a */
288one;
289
290/* b **/
291two;
292
293/* c ***/
294three;
295
296/* d
297
298***/
299four;
300
301y // comment
302 * z;
303
304==>
305
306Script(
307 BlockComment,
308 ExpressionStatement(VariableName),
309 BlockComment,
310 ExpressionStatement(VariableName),
311 BlockComment,
312 ExpressionStatement(VariableName),
313 BlockComment,
314 ExpressionStatement(VariableName),
315 ExpressionStatement(BinaryExpression(VariableName,LineComment,ArithOp,VariableName)))
316
317# Recover from invalid char
318
319const {foobar} = {};
320
321==>
322
323Script(VariableDeclaration(
324 const,
325 ObjectPattern("{",PatternProperty(PropertyName,⚠),"}"),
326 Equals,
327 ObjectExpression))
328
329# Sync back to statement
330
331function f() {
332 log(a b --c)
333}
334function g() {}
335
336==>
337
338Script(
339 FunctionDeclaration(function,VariableDefinition,ParamList,Block(ExpressionStatement(CallExpression(VariableName,ArgList(...))))),
340 FunctionDeclaration(function,VariableDefinition,ParamList,Block))
341
342# Destructuring
343
344({x} = y);
345[u, v] = w;
346let [a,, b = 0] = c;
347let {x, y: z = 1} = d;
348let {[f]: m} = e;
349
350==>
351
352Script(
353 ExpressionStatement(ParenthesizedExpression(AssignmentExpression(
354 ObjectPattern(PatternProperty(PropertyName)),Equals,VariableName))),
355 ExpressionStatement(AssignmentExpression(ArrayPattern(VariableDefinition,VariableDefinition),Equals,VariableName)),
356 VariableDeclaration(let,ArrayPattern(VariableDefinition,VariableDefinition,Equals,Number),Equals,VariableName),
357 VariableDeclaration(let,ObjectPattern(
358 PatternProperty(PropertyName),
359 PatternProperty(PropertyName,VariableDefinition,Equals,Number)
360 ),Equals,VariableName),
361 VariableDeclaration(let,ObjectPattern(PatternProperty(VariableName,VariableDefinition)),Equals,VariableName))
362
363# Generators
364
365function* foo() { yield 1 }
366
367class B {
368 *method() {}
369}
370
371({*x() {}})
372
373==>
374
375Script(
376 FunctionDeclaration(function,Star,VariableDefinition,ParamList,Block(
377 ExpressionStatement(YieldExpression(yield,Number)))),
378 ClassDeclaration(class,VariableDefinition,ClassBody(
379 MethodDeclaration(Star,PropertyDefinition,ParamList,Block))),
380 ExpressionStatement(ParenthesizedExpression(ObjectExpression(Property(Star,PropertyDefinition,ParamList,Block)))))
381
382# Hashbang
383
384#!/bin/env node
385foo()
386
387==>
388
389Script(Hashbang,ExpressionStatement(CallExpression(VariableName,ArgList)))
390
391# new.target
392
393function MyObj() {
394 if (!new.target) {
395 throw new Error('Must construct MyObj with new');
396 }
397}
398
399==>
400
401Script(
402 FunctionDeclaration(function,VariableDefinition,ParamList,Block(
403 IfStatement(if,ParenthesizedExpression(UnaryExpression(LogicOp,NewTarget(new,PropertyName))), Block(
404 ThrowStatement(throw,NewExpression(new,VariableName,ArgList(String))))))))