Adding support for Binary expression via Acorn Parser

src/components/Editor/Editor.data.tsx

@@ -30,8 +30,12 @@ foo1();`,
 	{
 		title: 'microtasks',
 		code: `console.log(1);  
-setTimeout(() => console.log(2), 0);  
-queueMicrotask(() => console.log(3));  
+console.log(2-1);
+console.log(4*8);
+console.log(9/3);
+console.log(10%5);
+setTimeout(() => console.log(2+4), 0);  
+queueMicrotask(() => console.log(3+9));  
 Promise.resolve().then(() => {
     console.log(4);
 });   

src/utils/nodes/BinaryExpression.ts

@@ -0,0 +1,29 @@
+import { NodeClass, NodeClassConstructor } from './Node.abstract';
+
+export class BinaryExpressionClass extends NodeClass {
+	constructor(params: NodeClassConstructor) {
+		super(params);
+	}
+
+	serialize = () => {
+		const left = this.node.left.value;
+		const operator = this.node.operator;
+		const right = this.node.right.value;
+		switch (operator) {
+			case '+':
+				return left + right;
+			case '-':
+				return left - right;
+			case '/':
+				return left / right;
+			case '*':
+				return left * right;
+			case '%':
+				return left % right;
+			default:
+				return 'operator not supported';
+		}
+	};
+
+	traverse = () => {};
+}

src/utils/nodes/factory.ts

@@ -1,16 +1,17 @@
-import { ExpressionStatementClass } from './ExpressionStatement.ts';
+import { ArrowFunctionExpressionClass } from './ArrowFunctionExpression.ts';
+import { AssignmentExpressionClass } from './AssignmentExpression.ts';
+import { BinaryExpressionClass } from './BinaryExpression.ts';
+import { BlockStatementClass } from './BlockStatement.ts';
 import { CallExpressionClass } from './CallExpression.ts';
+import { ExpressionStatementClass } from './ExpressionStatement.ts';
 import { FunctionDeclarationClass } from './FunctionDeclaration.ts';
 import { IdentifierClass } from './Identifier.ts';
-import { NotImplementedNodeClass } from './NotImplemented.ts';
-import { MemberExpressionClass } from './MemberExpression.ts';
 import { LiteralClass } from './Literal.ts';
-import { ArrowFunctionExpressionClass } from './ArrowFunctionExpression.ts';
+import { MemberExpressionClass } from './MemberExpression.ts';
 import { NodeClass, NodeClassConstructor } from './Node.abstract.ts';
-import { BlockStatementClass } from './BlockStatement.ts';
+import { NotImplementedNodeClass } from './NotImplemented.ts';
 import { ProgramClass } from './Program.ts';
 import { VariableDeclarationClass } from './VariableDeclaration.ts';
-import { AssignmentExpressionClass } from './AssignmentExpression.ts';
 
 export const nodeFactory = (params: NodeClassConstructor): NodeClass => {
 	switch (params.node.type) {
@@ -36,6 +37,8 @@ export const nodeFactory = (params: NodeClassConstructor): NodeClass => {
 			return new VariableDeclarationClass(params);
 		case 'AssignmentExpression':
 			return new AssignmentExpressionClass(params);
+		case 'BinaryExpression':
+			return new BinaryExpressionClass(params);
 		default:
 			return new NotImplementedNodeClass(params);
 	}