jpsx 0.1.16

package/dist/parser/grammar.d.ts

@@ -0,0 +1,29 @@
+interface NearleyToken {
+    value: any;
+    [key: string]: any;
+}
+interface NearleyLexer {
+    reset: (chunk: string, info: any) => void;
+    next: () => NearleyToken | undefined;
+    save: () => any;
+    formatError: (token: never) => string;
+    has: (tokenType: string) => boolean;
+}
+interface NearleyRule {
+    name: string;
+    symbols: NearleySymbol[];
+    postprocess?: (d: any[], loc?: number, reject?: {}) => any;
+}
+type NearleySymbol = string | {
+    literal: any;
+} | {
+    test: (token: any) => boolean;
+};
+interface Grammar {
+    Lexer: NearleyLexer | undefined;
+    ParserRules: NearleyRule[];
+    ParserStart: string;
+}
+declare const grammar: Grammar;
+export default grammar;
+//# sourceMappingURL=grammar.d.ts.map

package/dist/parser/grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../src/parser/grammar.ts"],"names":[],"mappings":"AAwDA,UAAU,YAAY;IACpB,KAAK,EAAE,GAAG,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;IAC1C,IAAI,EAAE,MAAM,YAAY,GAAG,SAAS,CAAC;IACrC,IAAI,EAAE,MAAM,GAAG,CAAC;IAChB,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC;IACtC,GAAG,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CACrC;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,KAAK,GAAG,CAAC;CAC5D;AAED,KAAK,aAAa,GAAG,MAAM,GAAG;IAAE,OAAO,EAAE,GAAG,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAA;CAAE,CAAC;AAEnF,UAAU,OAAO;IACf,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;IAChC,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,QAAA,MAAM,OAAO,EAAE,OAgQd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/parser/grammar.js

@@ -0,0 +1,312 @@
+// Generated automatically by nearley, version 2.20.1
+// http://github.com/Hardmath123/nearley
+// Bypasses TS6133. Allow declared but unused functions.
+// @ts-ignore
+function id(d) { return d[0]; }
+// Helper to extract value from token
+const val = (d) => d[0].value;
+// Define tokens as predicates for robust matching
+const tokenCheck = (type) => ({ test: (t) => t.type === type });
+const NEWLINE = tokenCheck("NEWLINE");
+const DEF = tokenCheck("DEF");
+const INDENT = tokenCheck("INDENT");
+const DEDENT = tokenCheck("DEDENT");
+const IDENT = tokenCheck("IDENT");
+const LPAREN = tokenCheck("LPAREN");
+const RPAREN = tokenCheck("RPAREN");
+const COLON = tokenCheck("COLON");
+const COMMA = tokenCheck("COMMA");
+const IF = tokenCheck("IF");
+const ELSE = tokenCheck("ELSE");
+const FOR = tokenCheck("FOR");
+const IN = tokenCheck("IN");
+const RANGE = tokenCheck("RANGE");
+const RETURN = tokenCheck("RETURN");
+const CLASS = tokenCheck("CLASS");
+const TRY = tokenCheck("TRY");
+const EXCEPT = tokenCheck("EXCEPT");
+const LAMBDA = tokenCheck("LAMBDA");
+const LBRACKET = tokenCheck("LBRACKET");
+const RBRACKET = tokenCheck("RBRACKET");
+const STRING = tokenCheck("STRING");
+const FSTRING = tokenCheck("FSTRING");
+const NUMBER = tokenCheck("NUMBER");
+const TRUE = tokenCheck("TRUE");
+const FALSE = tokenCheck("FALSE");
+const WHILE = tokenCheck("WHILE");
+const LBRACE = tokenCheck("LBRACE");
+const RBRACE = tokenCheck("RBRACE");
+const DOT = tokenCheck("DOT");
+const IMPORT = tokenCheck("IMPORT");
+const FROM = tokenCheck("FROM");
+const NOT = tokenCheck("NOT");
+const AND = tokenCheck("AND");
+const OR = tokenCheck("OR");
+const EXPORT = tokenCheck("EXPORT");
+const AS = tokenCheck("AS");
+// Custom token checks for operators
+const OP = { test: (t) => t.type === "OP" && t.value !== "=" && !["+=", "-=", "*=", "/="].includes(t.value) };
+const ASSIGN = { test: (t) => t.type === "OP" && t.value === "=" };
+const AUG_ASSIGN = { test: (t) => t.type === "OP" && ["+=", "-=", "*=", "/="].includes(t.value) };
+;
+;
+;
+;
+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": "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 },
+        { "name": "statement", "symbols": ["class_def"], "postprocess": id },
+        { "name": "statement", "symbols": ["if_stmt"], "postprocess": id },
+        { "name": "statement", "symbols": ["while_stmt"], "postprocess": id },
+        { "name": "statement", "symbols": ["for_stmt"], "postprocess": id },
+        { "name": "statement", "symbols": ["try_stmt"], "postprocess": id },
+        { "name": "statement", "symbols": ["return_stmt"], "postprocess": id },
+        { "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) => ({
+                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) => ({
+                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) => ({
+                type: "ImportDeclaration",
+                source: d[2].value,
+                specifiers: [{ local: d[10].value, imported: d[6].value }]
+            }) },
+        { "name": "export_stmt", "symbols": [EXPORT, "_", "statement"], "postprocess": (d) => ({
+                type: "ExportDeclaration",
+                declaration: d[2]
+            }) },
+        { "name": "return_stmt", "symbols": [RETURN, "_", "expression_list", "_", NEWLINE], "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": "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": "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) => ({
+                type: "BinaryExpression",
+                operator: d[2].value,
+                left: d[0],
+                right: d[4]
+            }) },
+        { "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) => ({
+                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) => ({
+                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] },
+        { "name": "func_params", "symbols": [IDENT, "_", ASSIGN, "_", "param_value", "_", COMMA, "_", "func_params"], "postprocess": (d) => [d[0].value + "=" + d[4].value, ...d[8]] },
+        { "name": "func_params", "symbols": [], "postprocess": () => [] },
+        { "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) => ({
+                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) => ({
+                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) => ({
+                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) => ({
+                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) => ({
+                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) => ({
+                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) => ({
+                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) => ({
+                type: "ConditionalExpression",
+                test: d[4],
+                consequent: d[0],
+                alternate: d[8]
+            }) },
+        { "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) => ({
+                type: "BinaryExpression",
+                operator: "and",
+                left: d[0],
+                right: d[4]
+            }) },
+        { "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) => ({
+                type: "BinaryExpression",
+                operator: "in", // We might want a runtime helper for this
+                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)
+                operator: "!",
+                argument: {
+                    type: "BinaryExpression",
+                    operator: "in",
+                    left: d[0],
+                    right: d[6]
+                }
+            }) },
+        { "name": "binary_expr", "symbols": ["unary_expr"], "postprocess": id },
+        { "name": "unary_expr", "symbols": [OP, "_", "unary_expr"], "postprocess": (d) => {
+                if (d[0].value === "-") {
+                    return {
+                        type: "BinaryExpression",
+                        operator: "-",
+                        left: { type: "NumberLiteral", value: 0 },
+                        right: d[2]
+                    };
+                }
+                return d[2];
+            } },
+        { "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": "operand", "symbols": ["number_literal"], "postprocess": id },
+        { "name": "operand", "symbols": ["string_literal"], "postprocess": id },
+        { "name": "operand", "symbols": ["boolean_literal"], "postprocess": id },
+        { "name": "operand", "symbols": ["array_literal"], "postprocess": id },
+        { "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) => ({
+                type: "MemberExpression",
+                object: d[0],
+                property: { type: "Identifier", name: d[4].value },
+                computed: false
+            }) },
+        { "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.
+                computed: true
+            }) },
+        { "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) => ({
+                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": "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) => ({
+                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"] },
+        { "name": "sws", "symbols": [] },
+        { "name": "boolean_literal", "symbols": [TRUE], "postprocess": () => ({ type: "BooleanLiteral", value: true }) },
+        { "name": "boolean_literal", "symbols": [FALSE], "postprocess": () => ({ type: "BooleanLiteral", value: false }) },
+        { "name": "array_literal", "symbols": [LBRACKET, "sws", "elements", "sws", RBRACKET], "postprocess": (d) => ({ type: "ArrayLiteral", elements: d[2] }) },
+        { "name": "array_literal", "symbols": [LBRACKET, "sws", RBRACKET], "postprocess": () => ({ type: "ArrayLiteral", elements: [] }) },
+        { "name": "elements", "symbols": ["expression"], "postprocess": (d) => [d[0]] },
+        { "name": "elements", "symbols": ["elements", "sws", COMMA, "sws", "expression"], "postprocess": (d) => [...d[0], d[4]] },
+        { "name": "object_literal", "symbols": [LBRACE, "sws", "properties", "sws", RBRACE], "postprocess": (d) => ({ type: "ObjectLiteral", properties: d[2] }) },
+        { "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] }) }
+    ],
+    ParserStart: "program",
+};
+export default grammar;

package/dist/parser/parser.d.ts

@@ -0,0 +1,4 @@
+import { Token } from "../lexer/tokenizer.js";
+import { Program } from "../ast/types.js";
+export declare function parse(tokens: Token[]): Program;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/parser/parser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EACL,OAAO,EAYR,MAAM,iBAAiB,CAAC;AA4CzB,wBAAgB,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAa9C"}

package/dist/parser/parser.js

@@ -0,0 +1,47 @@
+import nearley from "nearley";
+import grammar from "./grammar.js";
+// Adapt our token array to Nearley's lexer interface.
+function createTokenLexer(tokens) {
+    let state = { index: 0, tokens };
+    return {
+        reset: (_data, savedState) => {
+            if (savedState) {
+                state = savedState;
+            }
+            else {
+                state = { index: 0, tokens };
+            }
+        },
+        next: () => {
+            if (state.index >= state.tokens.length) {
+                return undefined;
+            }
+            const token = state.tokens[state.index];
+            state.index += 1;
+            return token;
+        },
+        save: () => ({ ...state }),
+        formatError: (_token) => "Unexpected token",
+        has: (name) => {
+            if (state.index >= state.tokens.length)
+                return false;
+            const token = state.tokens[state.index];
+            const match = token.type === name;
+            return match;
+        }
+    };
+}
+// Parse tokens into a Program AST using nearley.
+export function parse(tokens) {
+    const lexer = createTokenLexer(tokens);
+    const grammarWithLexer = { ...grammar, Lexer: lexer };
+    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammarWithLexer));
+    parser.feed("");
+    if (parser.results.length === 0) {
+        throw new Error("Parser produced no results.");
+    }
+    if (parser.results.length > 1) {
+        console.warn("Parser produced ambiguous results. Using the first one.");
+    }
+    return parser.results[0];
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * JPS Standard Runtime Library
+ * This file provides the implementations for JPS builtin functions.
+ */
+export declare function print(...args: any[]): void;
+export declare function len(obj: any): number;
+export declare function range(start: number, end?: number, step?: number): number[];
+export declare function sum(iterable: number[], start?: number): number;
+export declare function map(fn: (x: any) => any, iterable: any[]): any[];
+export declare function filter(fn: (x: any) => boolean, iterable: any[]): any[];
+export declare function sorted(iterable: any[], key?: (x: any) => any, reverse?: boolean): any[];
+export declare function min(iterable: any[] | any, ...args: any[]): any;
+export declare function max(iterable: any[] | any, ...args: any[]): any;
+export declare function str(obj: any): string;
+export declare function int(obj: any): number;
+export declare function float(obj: any): number;
+export declare function list(iterable: any): any[];
+export declare function __in__(item: any, container: any): boolean;
+declare global {
+    interface String {
+        join(arr: any[]): string;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,wBAAgB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAE1C;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAWpC;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU,GAAG,MAAM,EAAE,CAgB7E;AAED,wBAAgB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,CAEjE;AAED,wBAAgB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,CAE/D;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,CAEtE;AAED,wBAAgB,MAAM,CAAC,QAAQ,EAAE,GAAG,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,OAAO,GAAE,OAAe,GAAG,GAAG,EAAE,CAU9F;AAED,wBAAgB,GAAG,CAAC,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAU9D;AAED,wBAAgB,GAAG,CAAC,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAQ9D;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAEpC;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAEpC;AAED,wBAAgB,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAEtC;AAED,wBAAgB,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,GAAG,EAAE,CAEzC;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,OAAO,CAWzD;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QACZ,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,MAAM,CAAC;KAC5B;CACJ"}

package/dist/runtime/index.js

@@ -0,0 +1,108 @@
+/**
+ * JPS Standard Runtime Library
+ * This file provides the implementations for JPS builtin functions.
+ */
+export function print(...args) {
+    console.log(...args);
+}
+export function len(obj) {
+    if (Array.isArray(obj) || typeof obj === "string") {
+        return obj.length;
+    }
+    if (obj instanceof Set || obj instanceof Map) {
+        return obj.size;
+    }
+    if (obj && typeof obj === "object") {
+        return Object.keys(obj).length;
+    }
+    throw new Error(`TypeError: object of type '${typeof obj}' has no len()`);
+}
+export function range(start, end, step = 1) {
+    if (end === undefined) {
+        end = start;
+        start = 0;
+    }
+    const result = [];
+    if (step > 0) {
+        for (let i = start; i < end; i += step) {
+            result.push(i);
+        }
+    }
+    else {
+        for (let i = start; i > end; i += step) {
+            result.push(i);
+        }
+    }
+    return result;
+}
+export function sum(iterable, start = 0) {
+    return iterable.reduce((a, b) => a + b, start);
+}
+export function map(fn, iterable) {
+    return iterable.map(fn);
+}
+export function filter(fn, iterable) {
+    return iterable.filter(fn);
+}
+export function sorted(iterable, key, reverse = false) {
+    const result = [...iterable];
+    result.sort((a, b) => {
+        const valA = key ? key(a) : a;
+        const valB = key ? key(b) : b;
+        if (valA < valB)
+            return reverse ? 1 : -1;
+        if (valA > valB)
+            return reverse ? -1 : 1;
+        return 0;
+    });
+    return result;
+}
+export function min(iterable, ...args) {
+    if (Array.isArray(iterable)) {
+        return Math.min(...iterable);
+    }
+    // Handle varargs logic if needed, but JPS usually calls min([list]) or min(1,2)
+    // If min(1, 2, 3) -> iterable=1, args=[2,3]
+    if (args.length > 0) {
+        return Math.min(iterable, ...args);
+    }
+    return Math.min(iterable);
+}
+export function max(iterable, ...args) {
+    if (Array.isArray(iterable)) {
+        return Math.max(...iterable);
+    }
+    if (args.length > 0) {
+        return Math.max(iterable, ...args);
+    }
+    return Math.max(iterable);
+}
+export function str(obj) {
+    return String(obj);
+}
+export function int(obj) {
+    return parseInt(obj, 10);
+}
+export function float(obj) {
+    return parseFloat(obj);
+}
+export function list(iterable) {
+    return Array.from(iterable);
+}
+export function __in__(item, container) {
+    if (Array.isArray(container) || typeof container === "string") {
+        return container.includes(item);
+    }
+    if (container instanceof Set) {
+        return container.has(item);
+    }
+    if (container && typeof container === "object") {
+        return item in container;
+    }
+    return false;
+}
+if (!String.prototype.join) {
+    String.prototype.join = function (arr) {
+        return arr.join(this);
+    };
+}

package/dist/transformer/transformer.d.ts

@@ -0,0 +1,3 @@
+import { Program } from "../ast/types.js";
+export declare function transform(program: Program): Program;
+//# sourceMappingURL=transformer.d.ts.map

package/dist/transformer/transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../src/transformer/transformer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAqD,MAAM,iBAAiB,CAAC;AAE7F,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAGnD"}