epoxylang 0.1.1

package/bin/epoxy.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import { run } from "../src/index.js";
+
+const file = process.argv[2];
+
+if (!file) {
+    console.error("Usage: epoxy <file.epx>");
+    process.exit(1);
+}
+
+if (!file.endsWith(".epx")) {
+    console.error("Only .epx files allowed");
+    process.exit(1);
+}
+
+const code = fs.readFileSync(path.resolve(file), "utf8");
+run(code);

package/examples/demo.epx

@@ -0,0 +1,9 @@
+make square[n] {
+  give n * n;
+}
+
+assign nums as array = {2, 4, 6};
+assign result as int = call square[nums{1}];
+
+store msg = `square of [nums{1}] is [result]`;
+show msg;

package/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "epoxylang",
+  "version": "0.1.1",
+  "type": "module",
+  "bin": {
+    "epoxy": "./bin/epoxy.js"
+  }
+}

package/src/generator/jsgenerator.js

@@ -0,0 +1,193 @@
+import { OP_MAP, TokenType } from "../lexer/tokens.js";
+import { Parser } from "../parser/parser.js";
+import { tokenizeAll } from "../runtime/runner.js";
+
+class JSCodeGenerator {
+    constructor() {
+        this.output = "";
+    }
+
+    generate(node) {
+        return this.visit(node);
+    }
+
+    visit(node) {
+        switch (node.type) {
+            case "Program":
+                return node.statements.map(s => this.visit(s)).join("\n");
+            case "AssignStatement":
+                return this.visitAssignStatement(node);
+            case "BinaryExpression": return this.visitBinaryExpression(node);
+            case "Literal": return this.visitLiteral(node);
+            case "Identifier": return this.visitIdentifier(node);
+            case "StoreStatement": return this.visitStoreStatement(node);
+            case "ShowStatement": return this.visitShowStatement(node);
+            case "FunctionDeclaration": return this.visitFunctionDeclaration(node);
+            case "ReturnStatement": return this.visitReturnStatement(node);
+            case "CallExpression": return this.visitCallExpression(node);
+            case "IfChain": return this.visitIfChain(node);
+            case "RepeatFor": return this.visitRepeatFor(node);
+            case "RepeatUntil": return this.visitRepeatUntil(node);
+            case "ArrayLiteral": return this.visitArrayLiteral(node);
+            case "ArrayAccess": return this.visitArrayAccess(node);
+            default:
+                throw new Error("Unknown AST node: " + node.type);
+        }
+    }
+
+
+    visitAssignStatement(node) {
+        const keyword = node.isGlobal ? "var" : "let";
+        const value = this.visit(node.value);
+        return `${keyword} ${node.name} = ${value};`;
+    }
+
+    visitBinaryExpression(node) {
+        const left = this.visit(node.left);
+        const right = this.visit(node.right);
+        const op = OP_MAP[node.operator];
+        return `(${left} ${op} ${right})`;
+    }
+
+
+    visitLiteral(node) {
+        if (typeof node.value === "string") {
+            return JSON.stringify(node.value);
+        }
+        return String(node.value);
+    }
+
+    visitIdentifier(node) {
+        return node.name;
+    }
+
+    convertInterpolation(text) {
+        let result = "";
+        let i = 0;
+
+        while (i < text.length) {
+            if (text[i] === "[") {
+                let depth = 1;
+                let expr = "";
+                i++; // skip '['
+
+                while (i < text.length && depth > 0) {
+                    if (text[i] === "[") depth++;
+                    else if (text[i] === "]") depth--;
+
+                    if (depth > 0) expr += text[i];
+                    i++;
+                }
+
+                if (depth !== 0) {
+                    throw new Error("Unmatched [ in store interpolation");
+                }
+
+                // 🔥 parse boxed expression safely
+                const jsExpr = this.convertInlineExpression(expr.trim());
+                result += "${" + jsExpr + "}";
+
+            } else {
+                result += text[i];
+                i++;
+            }
+        }
+
+        return result;
+    }
+
+
+    convertInlineExpression(expr) {
+        const tokens = tokenizeAll(expr);
+        const parser = new Parser(tokens);
+        const ast = parser.parseExpression();
+
+        if (parser.current().type !== TokenType.EOF) {
+            throw new Error("Invalid expression inside [ ]");
+        }
+
+        return this.visit(ast);
+    }
+
+
+    visitStoreStatement(node) {
+        const interpolated = this.convertInterpolation(node.value);
+        return `const ${node.name} = \`${interpolated}\`;`;
+    }
+
+    visitShowStatement(node) {
+        return `console.log(${this.visit(node.value)});`;
+    }
+
+    visitFunctionDeclaration(node) {
+        const params = node.params.join(", ");
+        const body = node.body.map(s => this.visit(s)).join("\n");
+        return `function ${node.name}(${params}) {\n${body}\n}`;
+    }
+
+    visitReturnStatement(node) {
+        return `return ${this.visit(node.value)};`;
+    }
+
+    visitArrayLiteral(node) {
+        const items = node.elements.map(e => this.visit(e)).join(", ");
+        return `[${items}]`;
+    }
+
+    visitArrayAccess(node) {
+        const arr = this.visit(node.array);
+        const idx = this.visit(node.index);
+        return `${arr}[${idx}]`;
+    }
+
+    visitCallExpression(node) {
+        const args = node.args.map(a => this.visit(a)).join(", ");
+        return `${node.name}(${args})`;
+    }
+
+    visitIfChain(node) {
+        let code = `if (${this.visit(node.condition)}) {\n`;
+        code += node.body.map(s => this.visit(s)).join("\n");
+        code += "\n}";
+
+        for (const oc of node.orChecks) {
+            code += ` else if (${this.visit(oc.condition)}) {\n`;
+            code += oc.body.map(s => this.visit(s)).join("\n");
+            code += "\n}";
+        }
+
+        if (node.altBody) {
+            code += ` else {\n`;
+            code += node.altBody.map(s => this.visit(s)).join("\n");
+            code += "\n}";
+        }
+
+        return code;
+    }
+
+    visitRepeatFor(node) {
+        const v = node.varName;
+        const start = this.visit(node.start);
+        const end = this.visit(node.end);
+        const step = this.visit(node.step);
+        const body = node.body.map(s => this.visit(s)).join("\n");
+
+        return `
+for (let ${v} = ${start}; ${v} <= ${end}; ${v} += ${step}) {
+${body}
+}`.trim();
+    }
+
+    visitRepeatUntil(node) {
+        const condition = this.visit(node.condition);
+        const body = node.body.map(s => this.visit(s)).join("\n");
+
+        return `
+do {
+${body}
+} while (!(${condition}));`.trim();
+    }
+
+}
+
+export { JSCodeGenerator };

package/src/index.js

@@ -0,0 +1 @@
+export { compile, run } from "./runtime/runner.js";

package/src/lexer/lexer.js

@@ -0,0 +1,141 @@
+import { TokenType, Token, KEYWORDS, TYPES } from "./tokens.js";
+
+class Lexer {
+    constructor(input) {
+        this.input = input;
+        this.pos = 0;
+        this.current = input[0];
+    }
+
+    advance() {
+        this.pos++;
+        this.current = this.pos < this.input.length ? this.input[this.pos] : null;
+    }
+
+    peek() {
+        return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
+    }
+
+    skipWhitespace() {
+        while (this.current && /\s/.test(this.current)) {
+            this.advance();
+        }
+    }
+
+    readNumber() {
+        let num = "";
+        while (this.current && /[0-9]/.test(this.current)) {
+            num += this.current;
+            this.advance();
+        }
+        return new Token(TokenType.NUMBER, Number(num));
+    }
+
+    readWord() {
+        let word = "";
+        while (this.current && /[a-zA-Z_]/.test(this.current)) {
+            word += this.current;
+            this.advance();
+        }
+
+        if (KEYWORDS[word]) {
+            return new Token(KEYWORDS[word], word);
+        }
+
+        if (TYPES.includes(word)) {
+            return new Token(TokenType.TYPE, word);
+        }
+
+        if (word === "true" || word === "false") {
+            return new Token(TokenType.BOOLEAN, word === "true");
+        }
+
+        if (word === "null") {
+            return new Token(TokenType.NULL, null);
+        }
+
+        if (word === "undefined") {
+            return new Token(TokenType.UNDEFINED, undefined);
+        }
+
+        return new Token(TokenType.IDENTIFIER, word);
+    }
+
+    readString() {
+        const quote = this.current;
+        let value = "";
+        this.advance();
+
+        while (this.current && this.current !== quote) {
+            value += this.current;
+            this.advance();
+        }
+
+        if (this.current !== quote) {
+            throw new Error("Unterminated string");
+        }
+
+        this.advance();
+
+        return new Token(TokenType.STRING, value, {
+            quoteType: quote
+        });
+    }
+
+    getNextToken() {
+        while (this.current) {
+            if (/\s/.test(this.current)) {
+                this.skipWhitespace();
+                continue;
+            }
+
+            // comment
+            if (this.current === "$") {
+                while (this.current && this.current !== "\n") {
+                    this.advance();
+                }
+                continue;
+            }
+
+            if (/[0-9]/.test(this.current)) return this.readNumber();
+            if (/[a-zA-Z_]/.test(this.current)) return this.readWord();
+            if (`'"\``.includes(this.current)) return this.readString();
+
+            // double-char operators
+            const twoChar = this.current + this.peek();
+            if (twoChar === "==") { this.advance(); this.advance(); return new Token(TokenType.EQEQ); }
+            if (twoChar === "!=") { this.advance(); this.advance(); return new Token(TokenType.NOTEQ); }
+            if (twoChar === ">=") { this.advance(); this.advance(); return new Token(TokenType.GTE); }
+            if (twoChar === "<=") { this.advance(); this.advance(); return new Token(TokenType.LTE); }
+
+            // single-char
+            const single = {
+                "=": TokenType.EQUAL,
+                "+": TokenType.PLUS,
+                "-": TokenType.MINUS,
+                "*": TokenType.STAR,
+                "/": TokenType.SLASH,
+                ">": TokenType.GT,
+                "<": TokenType.LT,
+                "{": TokenType.LBRACE,
+                "}": TokenType.RBRACE,
+                "[": TokenType.LBRACKET,
+                "]": TokenType.RBRACKET,
+                ";": TokenType.SEMICOLON,
+                ",": TokenType.COMMA
+            };
+
+            if (single[this.current]) {
+                const t = single[this.current];
+                this.advance();
+                return new Token(t);
+            }
+
+            throw new Error("Unknown character: " + this.current);
+        }
+
+        return new Token(TokenType.EOF);
+    }
+}
+
+export { Lexer };

package/src/lexer/tokens.js

@@ -0,0 +1,114 @@
+const TokenType = {
+    // keywords
+    ASSIGN: "ASSIGN",
+    ALL: "ALL",
+    STORE: "STORE",
+    MAKE: "MAKE",
+    CALL: "CALL",
+    GIVE: "GIVE",
+    CHECK: "CHECK",
+    ALT: "ALT",
+    REPEAT: "REPEAT",
+    UNTIL: "UNTIL",
+    IN: "IN",
+    TO: "TO",
+    OR: "OR",
+    AND: "AND",
+    AS: "AS",
+    SHOW: "SHOW",
+
+    // datatypes
+    TYPE: "TYPE",
+
+    // literals
+    NUMBER: "NUMBER",
+    STRING: "STRING",
+    BOOLEAN: "BOOLEAN",
+    NULL: "NULL",
+    UNDEFINED: "UNDEFINED",
+
+    IDENTIFIER: "IDENTIFIER",
+
+    // operators
+    EQUAL: "EQUAL",
+    PLUS: "PLUS",
+    MINUS: "MINUS",
+    STAR: "STAR",
+    SLASH: "SLASH",
+    GT: "GT",
+    LT: "LT",
+    GTE: "GTE",
+    LTE: "LTE",
+    EQEQ: "EQEQ",
+    NOTEQ: "NOTEQ",
+
+    // symbols
+    LBRACE: "LBRACE",
+    RBRACE: "RBRACE",
+    LBRACKET: "LBRACKET",
+    RBRACKET: "RBRACKET",
+    SEMICOLON: "SEMICOLON",
+    COMMA: "COMMA",
+
+    EOF: "EOF"
+};
+
+class Token {
+    constructor(type, value = null, meta = {}) {
+        this.type = type;
+        this.value = value;
+        this.meta = meta;
+    }
+}
+
+const KEYWORDS = {
+    assign: TokenType.ASSIGN,
+    all: TokenType.ALL,
+    store: TokenType.STORE,
+    make: TokenType.MAKE,
+    call: TokenType.CALL,
+    give: TokenType.GIVE,
+    check: TokenType.CHECK,
+    alt: TokenType.ALT,
+    repeat: TokenType.REPEAT,
+    until: TokenType.UNTIL,
+    in: TokenType.IN,
+    to: TokenType.TO,
+    or: TokenType.OR,
+    and: TokenType.AND,
+    as: TokenType.AS,
+    show: TokenType.SHOW,
+};
+
+const TYPES = [
+    "string",
+    "int",
+    "bool",
+    "array",
+    "null",
+    "undefined",
+    "object"
+];
+
+const OP_MAP = {
+    PLUS: "+",
+    MINUS: "-",
+    STAR: "*",
+    SLASH: "/",
+    GT: ">",
+    LT: "<",
+    GTE: ">=",
+    LTE: "<=",
+    EQEQ: "===",
+    NOTEQ: "!==",
+    AND: "&&",
+    OR: "||"
+};
+
+export {
+    TokenType,
+    Token,
+    KEYWORDS,
+    TYPES,
+    OP_MAP
+};

package/src/parser/ast.js

@@ -0,0 +1,139 @@
+class Program {
+    constructor(statements) {
+        this.type = "Program";
+        this.statements = statements;
+    }
+}
+
+class AssignStatement {
+    constructor({ isGlobal, name, dataType, value }) {
+        this.type = "AssignStatement";
+        this.isGlobal = isGlobal;
+        this.name = name;
+        this.dataType = dataType; //null allowed
+        this.value = value;
+    }
+}
+
+class StoreStatement {
+    constructor({ name, value }) {
+        this.type = "StoreStatement";
+        this.name = name;
+        this.value = value;
+    }
+}
+
+class BinaryExpression {
+    constructor(left, operator, right) {
+        this.type = "BinaryExpression";
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+}
+
+class Identifier {
+    constructor(name) {
+        this.type = "Identifier";
+        this.name = name;
+    }
+}
+
+class Literal {
+    constructor(value) {
+        this.type = "Literal";
+        this.value = value;
+    }
+}
+
+class IfStatement {
+    constructor(condition, body, altBody) {
+        this.type = "IfStatement";
+        this.condition = condition;
+        this.body = body;
+        this.altBody = altBody;
+    }
+}
+
+class FunctionDeclaration {
+    constructor(name, params, body) {
+        this.type = "FunctionDeclaration";
+        this.name = name;
+        this.params = params;
+        this.body = body;
+    }
+}
+
+class ReturnStatement {
+    constructor(value) {
+        this.type = "ReturnStatement";
+        this.value = value;
+    }
+}
+
+class ArrayLiteral {
+    constructor(elements) {
+        this.type = "ArrayLiteral";
+        this.elements = elements;
+    }
+}
+
+class ArrayAccess {
+    constructor(array, index) {
+        this.type = "ArrayAccess";
+        this.array = array;
+        this.index = index;
+    }
+}
+
+class CallExpression {
+    constructor(name, args) {
+        this.type = "CallExpression";
+        this.name = name;
+        this.args = args;
+    }
+}
+
+class RepeatUntil {
+    constructor(condition, body) {
+        this.type = "RepeatUntil";
+        this.condition = condition;
+        this.body = body;
+    }
+}
+
+class ShowStatement {
+    constructor(value) {
+        this.type = "ShowStatement";
+        this.value = value;
+    }
+}
+
+class RepeatFor {
+    constructor(varName, start, end, step, body) {
+        this.type = "RepeatFor";
+        this.varName = varName;
+        this.start = start;
+        this.end = end;
+        this.step = step;
+        this.body = body;
+    }
+}
+
+export {
+    Program,
+    AssignStatement,
+    StoreStatement,
+    BinaryExpression,
+    Identifier,
+    Literal,
+    IfStatement,
+    FunctionDeclaration,
+    ReturnStatement,
+    ArrayLiteral,
+    ArrayAccess,
+    CallExpression,
+    RepeatUntil,
+    ShowStatement,
+    RepeatFor
+};

package/src/parser/parser.js

@@ -0,0 +1,484 @@
+import { TokenType } from "../lexer/tokens.js";
+import {
+    Program,
+    AssignStatement,
+    StoreStatement,
+    BinaryExpression,
+    Identifier,
+    Literal,
+    FunctionDeclaration,
+    ReturnStatement,
+    ArrayLiteral,
+    ArrayAccess,
+    CallExpression,
+    RepeatUntil,
+    ShowStatement,
+    RepeatFor
+} from "./ast.js";
+
+class Parser {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.pos = 0;
+    }
+
+    current() {
+        return this.tokens[this.pos];
+    }
+
+    eat(type) {
+        if (this.current().type === type) {
+            this.pos++;
+        }
+        else {
+            throw new Error(
+                `Expected ${type} but got ${this.current().type}`
+            );
+        }
+    }
+
+    peekType(offset = 1) {
+        const token = this.tokens[this.pos + offset];
+        return token ? token.type : null;
+    }
+
+    validateStoreString(token) {
+        const text = token.value;
+
+        // if contains 'call' outside [ ]
+        const illegalCallOutsideBox = /(^|[^\[])\bcall\b/.test(text);
+        const boxedCall = /\[.*\bcall\b.*\]/.test(text);
+
+        if (illegalCallOutsideBox && !boxedCall) {
+            throw new Error(
+                "store: function calls must be inside [ ] interpolation"
+            );
+        }
+    }
+
+    parseProgram() {
+        const statements = [];
+        while (this.current().type !== TokenType.EOF) {
+            statements.push(this.parseStatement());
+        }
+        return new Program(statements);
+    }
+
+    parseStatement() {
+        const t = this.current().type;
+
+        if (t === TokenType.ALL || t === TokenType.ASSIGN) return this.parseAssign();
+        if (t === TokenType.STORE) return this.parseStore();
+        if (t === TokenType.CHECK) return this.parseCheck();
+        if (t === TokenType.MAKE) return this.parseMake();
+        if (t === TokenType.CALL) return this.parseCall();
+        if (t === TokenType.GIVE) return this.parseGive();
+        if (t === TokenType.REPEAT && this.peekType() === TokenType.LBRACKET) return this.parseRepeatFor();
+        if (t === TokenType.REPEAT) return this.parseRepeatUntil();
+
+        if (t === TokenType.SHOW) return this.parseShow(); // 🔥 ADD THIS
+
+        throw new Error("Unknown statement: " + t);
+    }
+
+    parseAssign() {
+        let isGlobal = false;
+
+        if (this.current().type === TokenType.ALL) {
+            isGlobal = true;
+            this.eat(TokenType.ALL);
+        }
+
+        this.eat(TokenType.ASSIGN);
+
+        const name = this.current().value;
+        this.eat(TokenType.IDENTIFIER);
+
+        let dataType = null;
+        if (this.current().type === TokenType.AS) {
+            this.eat(TokenType.AS);
+            dataType = this.current().value;
+            this.eat(TokenType.TYPE);
+        }
+
+        this.eat(TokenType.EQUAL);
+
+        // 🔥 FIX IS HERE
+        const value = this.parseExpression();
+
+        // enforce rule
+        if (value.type === "CallExpression" && !dataType) {
+            throw new Error(
+                "assign: datatype required when assigning function call result"
+            );
+        }
+        if (value.type === "ArrayLiteral" && dataType !== "array") {
+            throw new Error("assign: array literal requires 'as array'");
+        }
+
+
+        this.eat(TokenType.SEMICOLON);
+
+        return new AssignStatement({
+            isGlobal,
+            name,
+            dataType,
+            value
+        });
+    }
+
+    parseStore() {
+        this.eat(TokenType.STORE);
+        const name = this.current().value;
+        this.eat(TokenType.IDENTIFIER);
+        this.eat(TokenType.EQUAL);
+
+        const str = this.current();
+        if (str.type !== TokenType.STRING || str.meta.quoteType !== "`") {
+            throw new Error("store requires backtick string only");
+        }
+
+        this.validateStoreString(str);
+
+        this.eat(TokenType.STRING);
+        this.eat(TokenType.SEMICOLON);
+
+        return new StoreStatement({ name, value: str.value });
+    }
+
+    parseValue() {
+        const token = this.current();
+
+        if (
+            token.type === TokenType.NUMBER ||
+            token.type === TokenType.STRING ||
+            token.type === TokenType.BOOLEAN ||
+            token.type === TokenType.NULL ||
+            token.type === TokenType.UNDEFINED ||
+            token.type === TokenType.IDENTIFIER
+        ) {
+            this.pos++;
+            return token;
+        }
+
+        throw new Error(`Invalid value: ${token.type}`);
+    }
+
+    parsePrimary() {
+        const tok = this.current();
+
+        // literals
+        if (
+            tok.type === TokenType.NUMBER ||
+            tok.type === TokenType.STRING ||
+            tok.type === TokenType.BOOLEAN ||
+            tok.type === TokenType.NULL ||
+            tok.type === TokenType.UNDEFINED
+        ) {
+            this.pos++;
+            return new Literal(tok.value);
+        }
+
+        // call expression
+        if (tok.type === TokenType.CALL) {
+            this.eat(TokenType.CALL);
+
+            const name = this.current().value;
+            this.eat(TokenType.IDENTIFIER);
+
+            this.eat(TokenType.LBRACKET);
+            const args = [];
+
+            if (this.current().type !== TokenType.RBRACKET) {
+                args.push(this.parseExpression());
+                while (this.current().type === TokenType.COMMA) {
+                    this.eat(TokenType.COMMA);
+                    args.push(this.parseExpression());
+                }
+            }
+
+            this.eat(TokenType.RBRACKET);
+
+            return new CallExpression(name, args);
+        }
+
+        // array literal
+        if (this.current().type === TokenType.LBRACE) {
+            this.eat(TokenType.LBRACE);
+
+            const elements = [];
+            if (this.current().type !== TokenType.RBRACE) {
+                elements.push(this.parseExpression());
+
+                while (this.current().type === TokenType.COMMA) {
+                    this.eat(TokenType.COMMA);
+                    elements.push(this.parseExpression());
+                }
+            }
+
+            this.eat(TokenType.RBRACE);
+            return new ArrayLiteral(elements);
+        }
+
+
+        // identifier
+        if (tok.type === TokenType.IDENTIFIER) {
+            this.pos++;
+            let node = new Identifier(tok.value);
+
+            // array access: test{index}
+            if (this.current().type === TokenType.LBRACE) {
+                this.eat(TokenType.LBRACE);
+                const index = this.parseExpression();
+                this.eat(TokenType.RBRACE);
+                node = new ArrayAccess(node, index);
+            }
+
+            return node;
+        }
+
+
+        throw new Error("Invalid primary expression: " + tok.type);
+    }
+
+    parseFactor() {
+        let node = this.parsePrimary();
+
+        while (
+            this.current().type === TokenType.STAR ||
+            this.current().type === TokenType.SLASH
+        ) {
+            const op = this.current().type;
+            this.pos++;
+            const right = this.parsePrimary();
+            node = new BinaryExpression(node, op, right);
+        }
+
+        return node;
+    }
+
+    parseTerm() {
+        let node = this.parseFactor();
+
+        while (
+            this.current().type === TokenType.PLUS ||
+            this.current().type === TokenType.MINUS
+        ) {
+            const op = this.current().type;
+            this.pos++;
+            const right = this.parseFactor();
+            node = new BinaryExpression(node, op, right);
+        }
+
+        return node;
+    }
+
+    parseComparison() {
+        let node = this.parseTerm();
+
+        while (
+            [
+                TokenType.GT, TokenType.LT,
+                TokenType.GTE, TokenType.LTE,
+                TokenType.EQEQ, TokenType.NOTEQ
+            ].includes(this.current().type)
+        ) {
+            const op = this.current().type;
+            this.pos++;
+            const right = this.parseTerm();
+            node = new BinaryExpression(node, op, right);
+        }
+
+        return node;
+    }
+
+    parseCheck() {
+        this.eat(TokenType.CHECK);
+        this.eat(TokenType.LBRACKET);
+        const condition = this.parseExpression();
+        this.eat(TokenType.RBRACKET);
+
+        this.eat(TokenType.LBRACE);
+        const body = [];
+        while (this.current().type !== TokenType.RBRACE) {
+            body.push(this.parseStatement());
+        }
+        this.eat(TokenType.RBRACE);
+
+        const orChecks = [];
+        while (this.current().type === TokenType.OR) {
+            this.eat(TokenType.OR);
+            this.eat(TokenType.CHECK);
+            this.eat(TokenType.LBRACKET);
+            const c = this.parseExpression();
+            this.eat(TokenType.RBRACKET);
+
+            this.eat(TokenType.LBRACE);
+            const b = [];
+            while (this.current().type !== TokenType.RBRACE) {
+                b.push(this.parseStatement());
+            }
+            this.eat(TokenType.RBRACE);
+
+            orChecks.push({ condition: c, body: b });
+        }
+
+        let altBody = null;
+        if (this.current().type === TokenType.ALT) {
+            this.eat(TokenType.ALT);
+            this.eat(TokenType.LBRACE);
+            altBody = [];
+            while (this.current().type !== TokenType.RBRACE) {
+                altBody.push(this.parseStatement());
+            }
+            this.eat(TokenType.RBRACE);
+        }
+
+        return { type: "IfChain", condition, body, orChecks, altBody };
+    }
+
+    parseMake() {
+        this.eat(TokenType.MAKE);
+        const name = this.current().value;
+        this.eat(TokenType.IDENTIFIER);
+
+        this.eat(TokenType.LBRACKET);
+        const params = [];
+        if (this.current().type !== TokenType.RBRACKET) {
+            params.push(this.current().value);
+            this.eat(TokenType.IDENTIFIER);
+
+            while (this.current().type === TokenType.COMMA) {
+                this.eat(TokenType.COMMA);
+                params.push(this.current().value);
+                this.eat(TokenType.IDENTIFIER);
+            }
+        }
+        this.eat(TokenType.RBRACKET);
+
+        this.eat(TokenType.LBRACE);
+
+        const body = [];
+        while (this.current().type !== TokenType.RBRACE) {
+            body.push(this.parseStatement());
+        }
+        this.eat(TokenType.RBRACE);
+
+        return new FunctionDeclaration(name, params, body);
+    }
+
+    parseGive() {
+        this.eat(TokenType.GIVE);
+        const value = this.parseExpression();
+        this.eat(TokenType.SEMICOLON);
+        return new ReturnStatement(value);
+    }
+
+    parseCall() {
+        this.eat(TokenType.CALL);
+        const name = this.current().value;
+        this.eat(TokenType.IDENTIFIER);
+
+        this.eat(TokenType.LBRACKET);
+        const args = [];
+        if (this.current().type !== TokenType.RBRACKET) {
+            args.push(this.parseExpression());
+            while (this.current().type === TokenType.COMMA) {
+                this.eat(TokenType.COMMA);
+                args.push(this.parseExpression());
+            }
+        }
+        this.eat(TokenType.RBRACKET);
+        this.eat(TokenType.SEMICOLON);
+
+        return new CallExpression(name, args);
+    }
+
+    parseRepeatUntil() {
+        this.eat(TokenType.REPEAT);
+        this.eat(TokenType.UNTIL);
+        this.eat(TokenType.LBRACKET);
+
+        const condition = this.parseExpression();
+
+        this.eat(TokenType.RBRACKET);
+        this.eat(TokenType.LBRACE);
+
+        const body = [];
+        while (this.current().type !== TokenType.RBRACE) {
+            body.push(this.parseStatement());
+        }
+        this.eat(TokenType.RBRACE);
+
+        return new RepeatUntil(condition, body);
+    }
+
+    parseExpression() {
+        return this.parseLogicalOr();
+    }
+
+    parseLogicalOr() {
+        let node = this.parseLogicalAnd();
+
+        while (this.current().type === TokenType.OR) {
+            this.eat(TokenType.OR);
+            const right = this.parseLogicalAnd();
+            node = new BinaryExpression(node, "OR", right);
+        }
+
+        return node;
+    }
+
+    parseLogicalAnd() {
+        let node = this.parseComparison();
+
+        while (this.current().type === TokenType.AND) {
+            this.eat(TokenType.AND);
+            const right = this.parseComparison();
+            node = new BinaryExpression(node, "AND", right);
+        }
+
+        return node;
+    }
+
+    parseRepeatFor() {
+        this.eat(TokenType.REPEAT);
+        this.eat(TokenType.LBRACKET);
+
+        const varName = this.current().value;
+        this.eat(TokenType.IDENTIFIER);
+
+        this.eat(TokenType.IN);
+        const start = this.parseExpression();
+        this.eat(TokenType.TO);
+        const end = this.parseExpression();
+
+        this.eat(TokenType.COMMA);
+        const step = this.parseExpression();
+
+        this.eat(TokenType.RBRACKET);
+        this.eat(TokenType.LBRACE);
+
+        const body = [];
+        while (this.current().type !== TokenType.RBRACE) {
+            body.push(this.parseStatement());
+        }
+        this.eat(TokenType.RBRACE);
+
+        return new RepeatFor(varName, start, end, step, body);
+    }
+
+    parseShow() {
+        this.eat(TokenType.SHOW);
+
+        // allow full expressions
+        const value = this.parseExpression();
+
+        this.eat(TokenType.SEMICOLON);
+
+        return new ShowStatement(value);
+    }
+
+}
+
+export { Parser };

package/src/runtime/runner.js

@@ -0,0 +1,29 @@
+import { Lexer } from "../lexer/lexer.js";
+import { TokenType } from "../lexer/tokens.js";
+import { Parser } from "../parser/parser.js";
+import { JSCodeGenerator } from "../generator/jsGenerator.js";
+
+function tokenizeAll(code) {
+    const lexer = new Lexer(code);
+    const tokens = [];
+    let t;
+    do {
+        t = lexer.getNextToken();
+        tokens.push(t);
+        //console.log(t);
+    } while (t.type !== TokenType.EOF);
+    return tokens;
+}
+
+function compile(code) {
+    const tokens = tokenizeAll(code);
+    const ast = new Parser(tokens).parseProgram();
+    return new JSCodeGenerator().generate(ast);
+}
+
+function run(code) {
+    const js = compile(code);
+    return eval(js);
+}
+
+export { tokenizeAll, compile, run };