jpsx 0.1.16 → 0.1.19

package/dist/parser/grammar.js

@@ -55,12 +55,9 @@ const AUG_ASSIGN = { test: (t) => t.type === "OP" && ["+=", "-=", "*=", "/="].in
 const grammar = {
     Lexer: undefined,
     ParserRules: [
-        { "name": "program", "symbols": ["statements"], "postprocess": (d) => ({ type: "Program", body: d[0] }) },
-        { "name": "lambda_expr", "symbols": [LAMBDA, "_", "func_params", "_", COLON, "_", "expression"], "postprocess": (d) => ({
-                type: "LambdaExpression",
-                params: d[2],
-                body: d[6]
-            }) },
+        { "name": "program", "symbols": ["statements_opt"], "postprocess": (d) => ({ type: "Program", body: (d[0] || []).filter((s) => s !== null) }) },
+        { "name": "statements_opt", "symbols": ["statements"], "postprocess": id },
+        { "name": "statements_opt", "symbols": [], "postprocess": () => [] },
         { "name": "statements", "symbols": ["statement"], "postprocess": (d) => [d[0]] },
         { "name": "statements", "symbols": ["statement", "_", "statements"], "postprocess": (d) => [d[0], ...d[2]] },
         { "name": "statement", "symbols": ["function_def"], "postprocess": id },
@@ -73,62 +70,83 @@ const grammar = {
         { "name": "statement", "symbols": ["import_stmt"], "postprocess": id },
         { "name": "statement", "symbols": ["export_stmt"], "postprocess": id },
         { "name": "statement", "symbols": ["expr_stmt"], "postprocess": id },
-        { "name": "import_stmt", "symbols": [IMPORT, "_", IDENT, "_", NEWLINE], "postprocess": (d) => ({
+        { "name": "statement", "symbols": [NEWLINE], "postprocess": () => null }, // Skip blank lines
+        {
+            "name": "import_stmt", "symbols": [IMPORT, "_", IDENT, "_", NEWLINE], "postprocess": (d) => ({
                 type: "ImportDeclaration",
                 source: d[2].value,
                 specifiers: [{ local: d[2].value, imported: d[2].value }]
-            }) },
-        { "name": "import_stmt", "symbols": [FROM, "_", IDENT, "_", IMPORT, "_", IDENT, "_", NEWLINE], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "import_stmt", "symbols": [FROM, "_", IDENT, "_", IMPORT, "_", IDENT, "_", NEWLINE], "postprocess": (d) => ({
                 type: "ImportDeclaration",
                 source: d[2].value,
                 specifiers: [{ local: d[6].value, imported: d[6].value }]
-            }) },
-        { "name": "import_stmt", "symbols": [FROM, "_", IDENT, "_", IMPORT, "_", IDENT, "_", AS, "_", IDENT, "_", NEWLINE], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "import_stmt", "symbols": [FROM, "_", IDENT, "_", IMPORT, "_", IDENT, "_", AS, "_", IDENT, "_", NEWLINE], "postprocess": (d) => ({
                 type: "ImportDeclaration",
                 source: d[2].value,
                 specifiers: [{ local: d[10].value, imported: d[6].value }]
-            }) },
-        { "name": "export_stmt", "symbols": [EXPORT, "_", "statement"], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "export_stmt", "symbols": [EXPORT, "_", "statement"], "postprocess": (d) => ({
                 type: "ExportDeclaration",
                 declaration: d[2]
-            }) },
-        { "name": "return_stmt", "symbols": [RETURN, "_", "expression_list", "_", NEWLINE], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "return_stmt", "symbols": [RETURN, "_", "expression_list", "_", "newline_opt"], "postprocess": (d) => ({
                 type: "ReturnStatement",
                 argument: d[2].length > 1 ? { type: "ArrayLiteral", elements: d[2] } : d[2][0]
-            }) },
+            })
+        },
         { "name": "return_stmt", "symbols": [RETURN, "_", NEWLINE], "postprocess": () => ({ type: "ReturnStatement", argument: null }) },
+        { "name": "newline_opt", "symbols": [NEWLINE] },
+        { "name": "newline_opt", "symbols": [] },
         { "name": "expression_list", "symbols": ["expression"], "postprocess": (d) => [d[0]] },
         { "name": "expression_list", "symbols": ["expression", "_", COMMA, "_", "expression_list"], "postprocess": (d) => [d[0], ...d[4]] },
-        { "name": "expr_stmt", "symbols": ["expression", "_", NEWLINE], "postprocess": (d) => ({ type: "ExpressionStatement", expression: d[0] }) },
+        { "name": "expr_stmt", "symbols": ["expression", "_", "newline_opt"], "postprocess": (d) => ({ type: "ExpressionStatement", expression: d[0] }) },
         { "name": "expression", "symbols": ["assignment_expr"], "postprocess": id },
         { "name": "expression", "symbols": ["conditional_expr"], "postprocess": id },
         { "name": "expression", "symbols": ["binary_expr"], "postprocess": id },
-        { "name": "assignment_expr", "symbols": ["target_expr", "_", ASSIGN, "_", "expression"], "postprocess": (d) => ({
+        {
+            "name": "assignment_expr", "symbols": ["target_expr", "_", ASSIGN, "_", "expression"], "postprocess": (d) => ({
                 type: "BinaryExpression",
                 operator: d[2].value,
                 left: d[0],
                 right: d[4]
-            }) },
-        { "name": "assignment_expr", "symbols": ["target_expr", "_", AUG_ASSIGN, "_", "expression"], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "assignment_expr", "symbols": ["target_expr", "_", AUG_ASSIGN, "_", "expression"], "postprocess": (d) => ({
                 type: "BinaryExpression",
                 operator: d[2].value,
                 left: d[0],
                 right: d[4]
-            }) },
+            })
+        },
         { "name": "target_expr", "symbols": [IDENT], "postprocess": (d) => ({ type: "Identifier", name: d[0].value }) },
         { "name": "target_expr", "symbols": ["member_expr"], "postprocess": id },
-        { "name": "target_expr", "symbols": [IDENT, "_", COMMA, "_", "target_expr_list"], "postprocess": (d) => ({
+        {
+            "name": "target_expr", "symbols": [IDENT, "_", COMMA, "_", "target_expr_list"], "postprocess": (d) => ({
                 type: "ArrayLiteral",
                 elements: [{ type: "Identifier", name: d[0].value }, ...d[4]]
-            }) },
+            })
+        },
         { "name": "target_expr_list", "symbols": [IDENT], "postprocess": (d) => [{ type: "Identifier", name: d[0].value }] },
         { "name": "target_expr_list", "symbols": [IDENT, "_", COMMA, "_", "target_expr_list"], "postprocess": (d) => [{ type: "Identifier", name: d[0].value }, ...d[4]] },
-        { "name": "function_def", "symbols": [DEF, "_", IDENT, "_", LPAREN, "_", "func_params", "_", RPAREN, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+        {
+            "name": "function_def", "symbols": [DEF, "_", IDENT, "_", LPAREN, "_", "func_params", "_", RPAREN, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "FunctionDeclaration",
                 name: d[2].value,
                 params: d[6],
                 body: d[16].filter((s) => s !== null)
-            }) },
+            })
+        },
         { "name": "func_params", "symbols": [IDENT], "postprocess": (d) => [d[0].value] },
         { "name": "func_params", "symbols": [IDENT, "_", COMMA, "_", "func_params"], "postprocess": (d) => [d[0].value, ...d[4]] },
         { "name": "func_params", "symbols": [IDENT, "_", ASSIGN, "_", "param_value"], "postprocess": (d) => [d[0].value + "=" + d[4].value] },
@@ -137,82 +155,116 @@ const grammar = {
         { "name": "param_value", "symbols": ["number_literal"], "postprocess": id },
         { "name": "param_value", "symbols": ["string_literal"], "postprocess": id },
         { "name": "param_value", "symbols": ["boolean_literal"], "postprocess": id },
-        { "name": "if_stmt", "symbols": [IF, "_", "expression", "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+        {
+            "name": "if_stmt", "symbols": [IF, "_", "expression", "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "IfStatement",
                 test: d[2],
                 consequent: d[10].filter((s) => s !== null),
                 alternate: null
-            }) },
-        { "name": "if_stmt", "symbols": [IF, "_", "expression", "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT, "_", ELSE, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "if_stmt", "symbols": [IF, "_", "expression", "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT, "_", ELSE, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "IfStatement",
                 test: d[2],
                 consequent: d[10].filter((s) => s !== null),
                 alternate: d[22].filter((s) => s !== null)
-            }) },
-        { "name": "for_stmt", "symbols": [FOR, "_", "loop_vars", "_", IN, "_", RANGE, "_", LPAREN, "_", "expression", "_", COMMA, "_", "expression", "_", RPAREN, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "for_stmt", "symbols": [FOR, "_", "loop_vars", "_", IN, "_", RANGE, "_", LPAREN, "_", "expression", "_", COMMA, "_", "expression", "_", RPAREN, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "ForStatement",
                 iterator: d[2],
                 start: d[10],
                 end: d[14],
                 body: d[24].filter((s) => s !== null)
-            }) },
-        { "name": "for_stmt", "symbols": [FOR, "_", "loop_vars", "_", IN, "_", "expression", "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "for_stmt", "symbols": [FOR, "_", "loop_vars", "_", IN, "_", RANGE, "_", LPAREN, "_", "expression", "_", RPAREN, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+                type: "ForStatement",
+                iterator: d[2],
+                start: { type: "NumberLiteral", value: 0 },
+                end: d[10],
+                body: d[20].filter((s) => s !== null)
+            })
+        },
+        {
+            "name": "for_stmt", "symbols": [FOR, "_", "loop_vars", "_", IN, "_", "expression", "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "ForStatement",
                 iterator: d[2],
                 collection: d[6],
                 body: d[14].filter((s) => s !== null)
-            }) },
+            })
+        },
         { "name": "loop_vars", "symbols": [IDENT], "postprocess": (d) => d[0].value },
         { "name": "loop_vars", "symbols": [IDENT, "_", COMMA, "_", "loop_vars"], "postprocess": (d) => "[" + d[0].value + ", " + d[4].replace(/^\[|\]$/g, "") + "]" },
-        { "name": "try_stmt", "symbols": [TRY, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT, "_", EXCEPT, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+        {
+            "name": "try_stmt", "symbols": [TRY, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT, "_", EXCEPT, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "TryStatement",
                 block: d[8].filter((s) => s !== null),
                 handler: d[20].filter((s) => s !== null)
-            }) },
-        { "name": "class_def", "symbols": [CLASS, "_", IDENT, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "class_def", "symbols": [CLASS, "_", IDENT, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "ClassDeclaration",
                 name: d[2].value,
                 superClass: null,
                 body: d[10].filter((s) => s !== null)
-            }) },
-        { "name": "class_def", "symbols": [CLASS, "_", IDENT, "_", LPAREN, "_", IDENT, "_", RPAREN, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "class_def", "symbols": [CLASS, "_", IDENT, "_", LPAREN, "_", IDENT, "_", RPAREN, "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "ClassDeclaration",
                 name: d[2].value,
                 superClass: d[6].value,
                 body: d[16].filter((s) => s !== null)
-            }) },
-        { "name": "conditional_expr", "symbols": ["binary_expr", "_", IF, "_", "expression", "_", ELSE, "_", "expression"], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "conditional_expr", "symbols": ["binary_expr", "_", IF, "_", "expression", "_", ELSE, "_", "expression"], "postprocess": (d) => ({
                 type: "ConditionalExpression",
                 test: d[4],
                 consequent: d[0],
                 alternate: d[8]
-            }) },
-        { "name": "binary_expr", "symbols": ["binary_expr", "_", OP, "_", "unary_expr"], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "binary_expr", "symbols": ["binary_expr", "_", OP, "_", "unary_expr"], "postprocess": (d) => ({
                 type: "BinaryExpression",
                 operator: d[2].value,
                 left: d[0],
                 right: d[4]
-            }) },
-        { "name": "binary_expr", "symbols": ["binary_expr", "_", AND, "_", "unary_expr"], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "binary_expr", "symbols": ["binary_expr", "_", AND, "_", "unary_expr"], "postprocess": (d) => ({
                 type: "BinaryExpression",
                 operator: "and",
                 left: d[0],
                 right: d[4]
-            }) },
-        { "name": "binary_expr", "symbols": ["binary_expr", "_", OR, "_", "unary_expr"], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "binary_expr", "symbols": ["binary_expr", "_", OR, "_", "unary_expr"], "postprocess": (d) => ({
                 type: "BinaryExpression",
                 operator: "or",
                 left: d[0],
                 right: d[4]
-            }) },
-        { "name": "binary_expr", "symbols": ["binary_expr", "_", IN, "_", "unary_expr"], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "binary_expr", "symbols": ["binary_expr", "_", IN, "_", "unary_expr"], "postprocess": (d) => ({
                 type: "BinaryExpression",
-                operator: "in", // We might want a runtime helper for this
+                operator: "in",
                 left: d[0],
                 right: d[4]
-            }) },
-        { "name": "binary_expr", "symbols": ["binary_expr", "_", NOT, "_", IN, "_", "unary_expr"], "postprocess": (d) => ({
-                type: "UnaryExpression", // Treat not in as !(in)
+            })
+        },
+        {
+            "name": "binary_expr", "symbols": ["binary_expr", "_", NOT, "_", IN, "_", "unary_expr"], "postprocess": (d) => ({
+                type: "UnaryExpression",
                 operator: "!",
                 argument: {
                     type: "BinaryExpression",
@@ -220,9 +272,11 @@ const grammar = {
                     left: d[0],
                     right: d[6]
                 }
-            }) },
+            })
+        },
         { "name": "binary_expr", "symbols": ["unary_expr"], "postprocess": id },
-        { "name": "unary_expr", "symbols": [OP, "_", "unary_expr"], "postprocess": (d) => {
+        {
+            "name": "unary_expr", "symbols": [OP, "_", "unary_expr"], "postprocess": (d) => {
                 if (d[0].value === "-") {
                     return {
                         type: "BinaryExpression",
@@ -232,17 +286,27 @@ const grammar = {
                     };
                 }
                 return d[2];
-            } },
-        { "name": "unary_expr", "symbols": [NOT, "_", "unary_expr"], "postprocess": (d) => ({
+            }
+        },
+        {
+            "name": "unary_expr", "symbols": [NOT, "_", "unary_expr"], "postprocess": (d) => ({
                 type: "UnaryExpression",
                 operator: "!",
                 argument: d[2]
-            }) },
+            })
+        },
         { "name": "unary_expr", "symbols": ["operand"], "postprocess": id },
         { "name": "operand", "symbols": ["call_expr"], "postprocess": id },
         { "name": "operand", "symbols": ["list_comp"], "postprocess": id },
         { "name": "operand", "symbols": ["lambda_expr"], "postprocess": id },
-        { "name": "operand", "symbols": ["identifier"], "postprocess": id },
+        {
+            "name": "lambda_expr", "symbols": [LAMBDA, "_", "func_params", "_", COLON, "_", "expression"], "postprocess": (d) => ({
+                type: "LambdaExpression",
+                params: d[2],
+                body: d[6]
+            })
+        },
+        { "name": "operand", "symbols": ["identifier_expr"], "postprocess": id },
         { "name": "operand", "symbols": ["number_literal"], "postprocess": id },
         { "name": "operand", "symbols": ["string_literal"], "postprocess": id },
         { "name": "operand", "symbols": ["boolean_literal"], "postprocess": id },
@@ -250,47 +314,57 @@ const grammar = {
         { "name": "operand", "symbols": ["object_literal"], "postprocess": id },
         { "name": "operand", "symbols": ["member_expr"], "postprocess": id },
         { "name": "operand", "symbols": [LPAREN, "_", "expression", "_", RPAREN], "postprocess": (d) => d[2] },
-        { "name": "member_expr", "symbols": ["operand", "_", DOT, "_", IDENT], "postprocess": (d) => ({
+        {
+            "name": "member_expr", "symbols": ["operand", "_", DOT, "_", "identifier"], "postprocess": (d) => ({
                 type: "MemberExpression",
                 object: d[0],
-                property: { type: "Identifier", name: d[4].value },
+                property: { type: "Identifier", name: d[4] },
                 computed: false
-            }) },
-        { "name": "member_expr", "symbols": ["operand", "_", LBRACKET, "_", "expression", "_", RBRACKET], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "member_expr", "symbols": ["operand", "_", LBRACKET, "_", "expression", "_", RBRACKET], "postprocess": (d) => ({
                 type: "MemberExpression",
                 object: d[0],
-                property: d[4], // For computed access, we likely need to handle this in generator if we treat property as expression directly? 
-                // Wait, my MemberExpression type in AST might expect Identifier for property but for computed it is Expression.
-                // Let's check AST type.
+                property: d[4],
                 computed: true
-            }) },
-        { "name": "call_expr", "symbols": ["operand", "_", LPAREN, "_", "args", "_", RPAREN], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "call_expr", "symbols": ["operand", "_", LPAREN, "_", "args", "_", RPAREN], "postprocess": (d) => ({
                 type: "CallExpression",
                 callee: d[0],
                 args: d[4]
-            }) },
-        { "name": "list_comp", "symbols": [LBRACKET, "_", "expression", "_", FOR, "_", IDENT, "_", IN, "_", "expression", "_", "opt_if_clause", "_", RBRACKET], "postprocess": (d) => ({
+            })
+        },
+        {
+            "name": "list_comp", "symbols": [LBRACKET, "_", "expression", "_", FOR, "_", IDENT, "_", IN, "_", "expression", "_", "opt_if_clause", "_", RBRACKET], "postprocess": (d) => ({
                 type: "ListComprehension",
                 expression: d[2],
                 iterator: d[6].value,
                 collection: d[10],
                 test: d[12]
-            }) },
+            })
+        },
         { "name": "opt_if_clause", "symbols": [IF, "_", "expression"], "postprocess": (d) => d[2] },
         { "name": "opt_if_clause", "symbols": [], "postprocess": () => null },
         { "name": "args", "symbols": ["expression"], "postprocess": (d) => [d[0]] },
         { "name": "args", "symbols": ["args", "_", COMMA, "_", "expression"], "postprocess": (d) => [...d[0], d[4]] },
         { "name": "args", "symbols": [], "postprocess": () => [] },
-        { "name": "identifier", "symbols": [IDENT], "postprocess": (d) => ({ type: "Identifier", name: d[0].value }) },
+        { "name": "identifier_expr", "symbols": ["identifier"], "postprocess": (d) => ({ type: "Identifier", name: d[0] }) },
+        { "name": "identifier", "symbols": [IDENT], "postprocess": (d) => d[0].value },
+        { "name": "identifier", "symbols": [RANGE], "postprocess": (d) => d[0].value },
         { "name": "string_literal", "symbols": [STRING], "postprocess": (d) => ({ type: "StringLiteral", value: d[0].value }) },
         { "name": "string_literal", "symbols": [FSTRING], "postprocess": (d) => ({ type: "FStringLiteral", value: d[0].value }) },
         { "name": "number_literal", "symbols": [NUMBER], "postprocess": (d) => ({ type: "NumberLiteral", value: Number(d[0].value) }) },
         { "name": "_", "symbols": [] },
-        { "name": "while_stmt", "symbols": [WHILE, "_", "expression", "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
+        {
+            "name": "while_stmt", "symbols": [WHILE, "_", "expression", "_", COLON, "_", NEWLINE, "_", INDENT, "_", "statements", "_", DEDENT], "postprocess": (d) => ({
                 type: "WhileStatement",
                 test: d[2],
                 body: d[10].filter((s) => s !== null)
-            }) },
+            })
+        },
         { "name": "sws", "symbols": [NEWLINE, "sws"] },
         { "name": "sws", "symbols": [INDENT, "sws"] },
         { "name": "sws", "symbols": [DEDENT, "sws"] },
@@ -305,7 +379,7 @@ const grammar = {
         { "name": "object_literal", "symbols": [LBRACE, "sws", RBRACE], "postprocess": () => ({ type: "ObjectLiteral", properties: [] }) },
         { "name": "properties", "symbols": ["property"], "postprocess": (d) => [d[0]] },
         { "name": "properties", "symbols": ["properties", "sws", COMMA, "sws", "property"], "postprocess": (d) => [...d[0], d[4]] },
-        { "name": "property", "symbols": [STRING, "sws", COLON, "sws", "expression"], "postprocess": (d) => ({ key: d[0].value, value: d[4] }) }
+        { "name": "property", "symbols": ["string_literal", "sws", COLON, "sws", "expression"], "postprocess": (d) => ({ key: d[0].value, value: d[4] }) }
     ],
     ParserStart: "program",
 };

package/dist/parser/parser.js

@@ -41,7 +41,7 @@ export function parse(tokens) {
         throw new Error("Parser produced no results.");
     }
     if (parser.results.length > 1) {
-        console.warn("Parser produced ambiguous results. Using the first one.");
+        // Ambiguous results, but we take the first one. Silent now.
     }
     return parser.results[0];
 }

package/package.json

@@ -1,54 +1,86 @@
-{
-  "name": "jpsx",
-  "version": "0.1.16",
-  "description": "Just Python Script (JPS) - A Python-like language that compiles to JavaScript",
-  "keywords": [
-    "compiler",
-    "python",
-    "javascript",
-    "jps"
-  ],
-  "author": "Loaii abdalslam",
-  "license": "ISC",
-  "files": [
-    "dist"
-  ],
-  "bin": {
-    "jps": "./dist/cli/index.js"
-  },
-  "main": "./dist/api/index.js",
-  "types": "./dist/api/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/api/index.d.ts",
-      "import": "./dist/api/index.js",
-      "require": "./dist/api/index.cjs"
-    },
-    "./cli": "./dist/cli/index.js",
-    "./runtime": "./dist/runtime/index.js",
-    "./package.json": "./package.json"
-  },
-  "private": false,
-  "type": "module",
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "start": "node dist/cli/index.js",
-    "test": "jest"
-  },
-  "dependencies": {
-    "chalk": "^5.6.2",
-    "commander": "^14.0.2",
-    "moo": "^0.5.2",
-    "nearley": "^2.20.1"
-  },
-  "devDependencies": {
-    "@types/jest": "^29.5.12",
-    "@types/moo": "^0.5.10",
-    "@types/nearley": "^2.11.5",
-    "@types/node": "^22.19.7",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
-  }
+{
+  "name": "jpsx",
+  "version": "0.1.19",
+  "description": "Just Python Script (JPS) - A Python-like language that compiles to JavaScript",
+  "keywords": [
+    "compiler",
+    "python",
+    "javascript",
+    "jps",
+    "jpsx",
+    "react",
+    "vue",
+    "svelte",
+    "angular",
+    "nextjs",
+    "nuxtjs",
+    "sveltekit",
+    "remix",
+    "astro",
+    "solidjs",
+    "qwik",
+    "bun",
+    "deno",
+    "node",
+    "react",
+    "vue",
+    "svelte",
+    "angular",
+    "nextjs",
+    "nuxtjs",
+    "sveltekit",
+    "remix",
+    "astro",
+    "solidjs",
+    "qwik",
+    "bun",
+    "deno",
+    "node"
+  ],
+  "author": "Loaii abdalslam",
+  "license": "ISC",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "jps": "./dist/cli/index.js"
+  },
+  "main": "./dist/api/index.js",
+  "types": "./dist/api/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/api/index.d.ts",
+      "import": "./dist/api/index.js",
+      "require": "./dist/api/index.cjs"
+    },
+    "./cli": "./dist/cli/index.js",
+    "./runtime": "./dist/runtime/index.js",
+    "./package.json": "./package.json"
+  },
+  "private": false,
+  "workspaces": [
+    "packages/*"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/cli/index.js",
+    "test": "jest"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "moo": "^0.5.2",
+    "nearley": "^2.20.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/moo": "^0.5.10",
+    "@types/nearley": "^2.11.5",
+    "@types/node": "^22.19.7",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
 }