epoxylang 0.1.10 → 0.1.12

package/epoxy-vs-code/language-configuration.json

@@ -0,0 +1,86 @@
+{
+    "comments": {
+        "lineComment": "$"
+    },
+    "brackets": [
+        [
+            "{",
+            "}"
+        ],
+        [
+            "[",
+            "]"
+        ],
+        [
+            "(",
+            ")"
+        ]
+    ],
+    "autoClosingPairs": [
+        {
+            "open": "{",
+            "close": "}"
+        },
+        {
+            "open": "[",
+            "close": "]"
+        },
+        {
+            "open": "(",
+            "close": ")"
+        },
+        {
+            "open": "\"",
+            "close": "\""
+        },
+        {
+            "open": "'",
+            "close": "'"
+        },
+        {
+            "open": "`",
+            "close": "`"
+        },
+        {
+            "open": "@js :~",
+            "close": "~:"
+        }
+    ],
+    "surroundingPairs": [
+        [
+            "{",
+            "}"
+        ],
+        [
+            "[",
+            "]"
+        ],
+        [
+            "(",
+            ")"
+        ],
+        [
+            "\"",
+            "\""
+        ],
+        [
+            "'",
+            "'"
+        ],
+        [
+            "`",
+            "`"
+        ]
+    ],
+    "folding": {
+        "markers": {
+            "start": "^\\s*\\{",
+            "end": "^\\s*\\}"
+        }
+    },
+    "wordPattern": "(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)",
+    "indentationRules": {
+        "increaseIndentPattern": "^.*\\{[^}]*$",
+        "decreaseIndentPattern": "^\\s*\\}"
+    }
+}

package/epoxy-vs-code/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "epoxy-language",
+  "displayName": "Epoxy Language",
+  "description": "Syntax highlighting for the Epoxy programming language",
+  "version": "0.1.0",
+  "publisher": "iamsatyanchal",
+  "engines": {
+    "vscode": "^1.75.0"
+  },
+  "categories": ["Programming Languages"],
+  "contributes": {
+    "languages": [
+      {
+        "id": "epoxy",
+        "aliases": ["Epoxy", "epx"],
+        "extensions": [".epx"],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "epoxy",
+        "scopeName": "source.epoxy",
+        "path": "./syntaxes/epoxy.tmLanguage.json"
+      }
+    ]
+  }
+}

package/epoxy-vs-code/syntaxes/epoxy.tmLanguage.json

@@ -0,0 +1,280 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "Epoxy",
+  "scopeName": "source.epoxy",
+  "patterns": [
+    { "include": "#comments" },
+    { "include": "#raw-js-block" },
+    { "include": "#keywords" },
+    { "include": "#types" },
+    { "include": "#constants" },
+    { "include": "#strings" },
+    { "include": "#numbers" },
+    { "include": "#operators" },
+    { "include": "#punctuation" },
+    { "include": "#special-input" },
+    { "include": "#function-declaration" },
+    { "include": "#function-call" },
+    { "include": "#identifiers" }
+  ],
+  "repository": {
+    "comments": {
+      "patterns": [
+        {
+          "name": "comment.line.dollar.epoxy",
+          "match": "\\$.*$",
+          "captures": {
+            "0": { "name": "punctuation.definition.comment.epoxy" }
+          }
+        }
+      ]
+    },
+    "raw-js-block": {
+      "patterns": [
+        {
+          "name": "meta.embedded.block.javascript",
+          "begin": "(@js)\\s*(:~)",
+          "end": "(~:)",
+          "beginCaptures": {
+            "1": { "name": "keyword.control.js.epoxy" },
+            "2": { "name": "punctuation.definition.js-block.begin.epoxy" }
+          },
+          "endCaptures": {
+            "1": { "name": "punctuation.definition.js-block.end.epoxy" }
+          },
+          "patterns": [
+            { "include": "source.js" }
+          ]
+        }
+      ]
+    },
+    "keywords": {
+      "patterns": [
+        {
+          "name": "keyword.control.flow.epoxy",
+          "match": "\\b(check|alt|repeat|until|give)\\b"
+        },
+        {
+          "name": "keyword.control.loop.epoxy",
+          "match": "\\b(in|to)\\b"
+        },
+        {
+          "name": "keyword.declaration.epoxy",
+          "match": "\\b(assign|store|make|update)\\b"
+        },
+        {
+          "name": "keyword.modifier.epoxy",
+          "match": "\\b(all|fix)\\b"
+        },
+        {
+          "name": "keyword.other.epoxy",
+          "match": "\\b(call|show|as)\\b"
+        },
+        {
+          "name": "keyword.operator.logical.epoxy",
+          "match": "\\b(and|or)\\b"
+        }
+      ]
+    },
+    "types": {
+      "patterns": [
+        {
+          "name": "storage.type.epoxy",
+          "match": "\\b(int|double|string|bool|array|object)\\b"
+        }
+      ]
+    },
+    "constants": {
+      "patterns": [
+        {
+          "name": "constant.language.boolean.true.epoxy",
+          "match": "\\btrue\\b"
+        },
+        {
+          "name": "constant.language.boolean.false.epoxy",
+          "match": "\\bfalse\\b"
+        },
+        {
+          "name": "constant.language.null.epoxy",
+          "match": "\\bnull\\b"
+        },
+        {
+          "name": "constant.language.undefined.epoxy",
+          "match": "\\bundefined\\b"
+        }
+      ]
+    },
+    "strings": {
+      "patterns": [
+        {
+          "name": "string.quoted.backtick.epoxy",
+          "begin": "`",
+          "end": "`",
+          "patterns": [
+            {
+              "name": "meta.interpolation.epoxy",
+              "begin": "\\[",
+              "end": "\\]",
+              "beginCaptures": {
+                "0": { "name": "punctuation.definition.interpolation.begin.epoxy" }
+              },
+              "endCaptures": {
+                "0": { "name": "punctuation.definition.interpolation.end.epoxy" }
+              },
+              "patterns": [
+                { "include": "#identifiers" },
+                { "include": "#function-call" },
+                { "include": "#array-access" },
+                { "include": "#numbers" }
+              ]
+            },
+            {
+              "name": "constant.character.escape.epoxy",
+              "match": "\\\\."
+            }
+          ]
+        },
+        {
+          "name": "string.quoted.double.epoxy",
+          "begin": "\"",
+          "end": "\"",
+          "patterns": [
+            {
+              "name": "constant.character.escape.epoxy",
+              "match": "\\\\."
+            }
+          ]
+        },
+        {
+          "name": "string.quoted.single.epoxy",
+          "begin": "'",
+          "end": "'",
+          "patterns": [
+            {
+              "name": "constant.character.escape.epoxy",
+              "match": "\\\\."
+            }
+          ]
+        }
+      ]
+    },
+    "numbers": {
+      "patterns": [
+        {
+          "name": "constant.numeric.decimal.epoxy",
+          "match": "\\b\\d+\\.\\d+\\b"
+        },
+        {
+          "name": "constant.numeric.integer.epoxy",
+          "match": "\\b\\d+\\b"
+        }
+      ]
+    },
+    "operators": {
+      "patterns": [
+        {
+          "name": "keyword.operator.comparison.epoxy",
+          "match": "(===|!==|==|!=|>=|<=|>|<)"
+        },
+        {
+          "name": "keyword.operator.arithmetic.epoxy",
+          "match": "(\\+|\\-|\\*|\\/)"
+        },
+        {
+          "name": "keyword.operator.assignment.epoxy",
+          "match": "="
+        }
+      ]
+    },
+    "punctuation": {
+      "patterns": [
+        {
+          "name": "punctuation.terminator.statement.epoxy",
+          "match": ";"
+        },
+        {
+          "name": "punctuation.separator.comma.epoxy",
+          "match": ","
+        },
+        {
+          "name": "punctuation.section.block.begin.epoxy",
+          "match": "\\{"
+        },
+        {
+          "name": "punctuation.section.block.end.epoxy",
+          "match": "\\}"
+        },
+        {
+          "name": "punctuation.section.brackets.begin.epoxy",
+          "match": "\\["
+        },
+        {
+          "name": "punctuation.section.brackets.end.epoxy",
+          "match": "\\]"
+        },
+        {
+          "name": "punctuation.section.parens.begin.epoxy",
+          "match": "\\("
+        },
+        {
+          "name": "punctuation.section.parens.end.epoxy",
+          "match": "\\)"
+        }
+      ]
+    },
+    "special-input": {
+      "patterns": [
+        {
+          "name": "variable.language.input.epoxy",
+          "match": ":input\\b"
+        }
+      ]
+    },
+    "function-declaration": {
+      "patterns": [
+        {
+          "name": "meta.function.epoxy",
+          "match": "\\b(make)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(\\[)",
+          "captures": {
+            "1": { "name": "keyword.declaration.epoxy" },
+            "2": { "name": "entity.name.function.epoxy" },
+            "3": { "name": "punctuation.section.brackets.begin.epoxy" }
+          }
+        }
+      ]
+    },
+    "function-call": {
+      "patterns": [
+        {
+          "name": "meta.function-call.epoxy",
+          "match": "\\b(call)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(\\[)",
+          "captures": {
+            "1": { "name": "keyword.other.epoxy" },
+            "2": { "name": "entity.name.function.epoxy" },
+            "3": { "name": "punctuation.section.brackets.begin.epoxy" }
+          }
+        }
+      ]
+    },
+    "array-access": {
+      "patterns": [
+        {
+          "name": "meta.array-access.epoxy",
+          "match": "([a-zA-Z_][a-zA-Z0-9_]*)\\s*(\\{)",
+          "captures": {
+            "1": { "name": "variable.other.epoxy" },
+            "2": { "name": "punctuation.section.braces.begin.epoxy" }
+          }
+        }
+      ]
+    },
+    "identifiers": {
+      "patterns": [
+        {
+          "name": "variable.other.epoxy",
+          "match": "\\b[a-zA-Z_][a-zA-Z0-9_]*\\b"
+        }
+      ]
+    }
+  }
+}

package/examples/hybrid.epx

@@ -3,16 +3,24 @@ assign numbers as array = {};
 repeat[x in 0 to 4, 1]{
   show "Enter a number: ";
   assign num_insert = :input;
-  @js :~ 
-    numbers.push(num_insert);
-  ~:
+  method:array numbers.append[num_insert];
 }
 show "The numbers you entered are: " + numbers;
-repeat[i in numbers]{
-  assign n as int = numbers{i};
-  @js :~
-    if(n % 2 == 0){
-      console.log(n);
-    }
-  ~:
-}
+
+
+
+
+$ make test[name]{
+$ all assign ok as string = :input;
+$ fix assign tes as int = 3.14159;
+$ store bubu = `[ok] and tes is [tes]`;
+$ give bubu;
+$ }
+$ repeat[i in numbers]{
+$   assign n as int = numbers{i};
+$   @js :~
+$     if(n % 2 == 0){
+$       console.log(n);
+$     }
+$   ~:
+$ }

package/examples/method_test.epx

@@ -0,0 +1,48 @@
+$ Test array methods
+assign numbers as array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+show "Original array:";
+show numbers;
+
+$ Test filter with lambda and modulo
+assign evens as array = method:array numbers.filter[call [x] -> x % 2 == 0];
+show "Even numbers (filter):";
+show evens;
+
+$ Test map with lambda
+assign doubled as array = method:array numbers.map[call [x] -> x * 2];
+show "Doubled numbers (map):";
+show doubled;
+
+$ Test slice - reverse array (note: slice takes string literal)
+assign reversed as array = method:array numbers.slice["::-1"];
+show "Reversed array:";
+show reversed;
+
+$ Test slice - every 2nd element
+assign everynd as array = method:array numbers.slice["::2"];
+show "Every 2nd element:";
+show everynd;
+
+$ Test slice - range
+assign range as array = method:array numbers.slice["2:5"];
+show "Elements 2-4:";
+show range;
+
+$ Test string methods
+assign message as string = "Hello World";
+assign upper as string = method:string message.upper[];
+show "Uppercase:";
+show upper;
+
+assign lower as string = method:string message.lower[];
+show "Lowercase:";
+show lower;
+show method:string lower.size[];
+show method:string lower.replace["world", "epoxy"];
+
+$ Test modulo operator
+assign remainder as int = 17 % 5;
+assign okko as double = 3.14;
+show okko;
+show "17 % 5 =";
+show remainder;

package/examples/square.epx

@@ -2,8 +2,12 @@ make square[n] {
   give n * n;
 }
 assign nums as array = {2, 4, 6};
+assign ok as string;
 repeat[x in nums]{
   assign result as int = call square[nums{x}]; $ yaha pe comment dal rhe hai bhaii..
+  $ assign add as int = call [x,y] -> give x +y
   store msg = `square of [nums{x}] is [result]`;
   show msg;
 }
+update ok = :input;
+show ok;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "epoxylang",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "bin": {
     "epoxy": "./bin/epoxy.js"

package/src/generator/jsgenerator.js

@@ -35,6 +35,8 @@ class JSCodeGenerator {
             case "RepeatUntil": return this.visitRepeatUntil(node);
             case "ArrayLiteral": return this.visitArrayLiteral(node);
             case "ArrayAccess": return this.visitArrayAccess(node);
+            case "MethodCall": return this.visitMethodCall(node);
+            case "LambdaExpression": return this.visitLambdaExpression(node);
             default:
                 throw new Error("Unknown AST node: " + node.type);
         }
@@ -91,7 +93,7 @@ class JSCodeGenerator {
     }
 
     visitInputExpression(node) {
-        return "await input_of_epoxy_lang_dont_use_this_name()";
+        return "input_of_epoxy_lang_dont_use_this_name()";
     }
 
     convertInterpolation(text) {
@@ -243,6 +245,140 @@ ${body}
 } while (!(${condition}));`.trim();
     }
 
+    visitMethodCall(node) {
+        const target = node.target;
+        const methodName = node.methodName;
+        const args = node.args;
+
+        // Array methods
+        if (node.targetType === "array") {
+            switch (methodName) {
+                case "append":
+                    // .append[value] -> .push(value)
+                    if (args.length !== 1) {
+                        throw new Error("append requires exactly 1 argument");
+                    }
+                    return `${target}.push(${this.visit(args[0])})`;
+
+                case "pop":
+                    // .pop[] -> .pop()
+                    return `${target}.pop()`;
+
+                case "includes":
+                    // .includes[value] -> .includes(value)
+                    if (args.length !== 1) {
+                        throw new Error("includes requires exactly 1 argument");
+                    }
+                    return `${target}.includes(${this.visit(args[0])})`;
+
+                case "filter":
+                    // .filter[call [x] -> x % 2 == 0] -> .filter((x) => x % 2 === 0)
+                    if (args.length !== 1) {
+                        throw new Error("filter requires exactly 1 argument (lambda function)");
+                    }
+                    return `${target}.filter(${this.visit(args[0])})`;
+
+                case "map":
+                    // .map[call [x] -> x * 2] -> .map((x) => x * 2)
+                    if (args.length !== 1) {
+                        throw new Error("map requires exactly 1 argument (lambda function)");
+                    }
+                    return `${target}.map(${this.visit(args[0])})`;
+
+                case "join":
+                    // .join[separator] -> .join(separator) or .join() for default
+                    if (args.length === 0) {
+                        return `${target}.join()`;
+                    } else if (args.length === 1) {
+                        return `${target}.join(${this.visit(args[0])})`;
+                    } else {
+                        throw new Error("join requires 0 or 1 argument");
+                    }
+
+                case "slice":
+                    // .slice[pythonSlice] -> .slice(start, end)
+                    if (args.length !== 1) {
+                        throw new Error("slice requires exactly 1 argument (slice notation)");
+                    }
+                    return this.convertPythonSlice(target, args[0]);
+
+                default:
+                    throw new Error(`Unknown array method: ${methodName}`);
+            }
+        }
+
+        // String methods
+        if (node.targetType === "string") {
+            switch (methodName) {
+                case "upper":
+                    // .upper[] -> .toUpperCase()
+                    return `${target}.toUpperCase()`;
+
+                case "lower":
+                    // .lower[] -> .toLowerCase()
+                    return `${target}.toLowerCase()`;
+
+                case "size":
+                    // .size[] -> .length
+                    return `${target}.length`;
+
+                case "includes":
+                    // .includes[value] -> .includes(value)
+                    if (args.length !== 1) {
+                        throw new Error("includes requires exactly 1 argument");
+                    }
+                    return `${target}.includes(${this.visit(args[0])})`;
+
+                case "replace":
+                    // .replace["old" with "new"] -> .replace("old", "new")
+                    if (args.length !== 2) {
+                        throw new Error("replace requires exactly 2 arguments (old, new)");
+                    }
+                    return `${target}.replace(${this.visit(args[0])}, ${this.visit(args[1])})`;
+
+                default:
+                    throw new Error(`Unknown string method: ${methodName}`);
+            }
+        }
+
+        throw new Error(`Unknown target type: ${node.targetType}`);
+    }
+
+    visitLambdaExpression(node) {
+        // Convert lambda to arrow function: call [x] -> x % 2 == 0 => (x) => x % 2 === 0
+        const params = node.params.join(", ");
+        const body = this.visit(node.body);
+        return `(${params}) => ${body}`;
+    }
+
+    convertPythonSlice(target, sliceExpr) {
+        // Handle Python-style slicing: ::2, 2:5, ::-1
+        // This is a simplified version - you'd need to parse the slice notation
+        // For now, let's assume sliceExpr is a string literal
+
+        if (sliceExpr.type === "Literal" && typeof sliceExpr.value === "string") {
+            const slice = sliceExpr.value;
+
+            // Parse slice notation
+            if (slice === "::-1") {
+                // Reverse array
+                return `${target}.slice().reverse();`;
+            } else if (slice.startsWith("::")) {
+                // Every nth element
+                const step = parseInt(slice.substring(2));
+                return `${target}.filter((_, i) => i % ${step} === 0);`;
+            } else if (slice.includes(":")) {
+                // Range slice
+                const parts = slice.split(":");
+                const start = parts[0] || "0";
+                const end = parts[1] || `${target}.length`;
+                return `${target}.slice(${start}, ${end});`;
+            }
+        }
+
+        throw new Error("Invalid slice notation");
+    }
+
 }
 
 export { JSCodeGenerator };

package/src/lexer/lexer.js

@@ -170,6 +170,7 @@ class Lexer {
                 // Not :input, restore position
                 this.pos = saved;
                 this.current = this.input[this.pos];
+                // If not :input, fall through to handle : as COLON token
             }
 
             // double-char operators
@@ -178,6 +179,7 @@ class Lexer {
             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); }
+            if (twoChar === "->") { this.advance(); this.advance(); return new Token(TokenType.ARROW); }
 
             // single-char
             const single = {
@@ -186,6 +188,7 @@ class Lexer {
                 "-": TokenType.MINUS,
                 "*": TokenType.STAR,
                 "/": TokenType.SLASH,
+                "%": TokenType.MODULO,
                 ">": TokenType.GT,
                 "<": TokenType.LT,
                 "{": TokenType.LBRACE,
@@ -195,7 +198,9 @@ class Lexer {
                 "(": TokenType.LPAREN,
                 ")": TokenType.RPAREN,
                 ";": TokenType.SEMICOLON,
-                ",": TokenType.COMMA
+                ",": TokenType.COMMA,
+                ".": TokenType.DOT,
+                ":": TokenType.COLON
             };
 
             if (single[this.current]) {

package/src/lexer/tokens.js

@@ -18,6 +18,7 @@ const TokenType = {
     AND: "AND",
     AS: "AS",
     SHOW: "SHOW",
+    METHOD: "METHOD",
 
     // datatypes
     TYPE: "TYPE",
@@ -41,12 +42,14 @@ const TokenType = {
     MINUS: "MINUS",
     STAR: "STAR",
     SLASH: "SLASH",
+    MODULO: "MODULO",
     GT: "GT",
     LT: "LT",
     GTE: "GTE",
     LTE: "LTE",
     EQEQ: "EQEQ",
     NOTEQ: "NOTEQ",
+    ARROW: "ARROW",
 
     // symbols
     LBRACE: "LBRACE",
@@ -57,6 +60,8 @@ const TokenType = {
     RPAREN: "RPAREN",
     SEMICOLON: "SEMICOLON",
     COMMA: "COMMA",
+    DOT: "DOT",
+    COLON: "COLON",
 
     EOF: "EOF"
 };
@@ -88,6 +93,7 @@ const KEYWORDS = {
     and: TokenType.AND,
     as: TokenType.AS,
     show: TokenType.SHOW,
+    method: TokenType.METHOD,
 };
 
 const TYPES = [
@@ -106,6 +112,7 @@ const OP_MAP = {
     MINUS: "-",
     STAR: "*",
     SLASH: "/",
+    MODULO: "%",
     GT: ">",
     LT: "<",
     GTE: ">=",

package/src/parser/ast.js

@@ -145,6 +145,24 @@ class InputExpression {
     }
 }
 
+class MethodCall {
+    constructor(targetType, target, methodName, args) {
+        this.type = "MethodCall";
+        this.targetType = targetType; // "array" or "string"
+        this.target = target; // variable name (Identifier or expression)
+        this.methodName = methodName; // method name like "append", "upper"
+        this.args = args; // array of argument expressions
+    }
+}
+
+class LambdaExpression {
+    constructor(params, body) {
+        this.type = "LambdaExpression";
+        this.params = params; // array of parameter names
+        this.body = body; // expression
+    }
+}
+
 export {
     Program,
     AssignStatement,
@@ -163,5 +181,7 @@ export {
     ShowStatement,
     RepeatFor,
     RawJSBlock,
-    InputExpression
+    InputExpression,
+    MethodCall,
+    LambdaExpression
 };

package/src/parser/parser.js

@@ -16,7 +16,9 @@ import {
     ShowStatement,
     RepeatFor,
     RawJSBlock,
-    InputExpression
+    InputExpression,
+    MethodCall,
+    LambdaExpression
 } from "./ast.js";
 
 class Parser {
@@ -94,6 +96,7 @@ class Parser {
         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();
+        if (t === TokenType.METHOD) return this.parseMethodCall();
 
         throw new Error("Unknown statement: " + t);
     }
@@ -279,10 +282,38 @@ class Parser {
             return new InputExpression();
         }
 
-        // call expression
+        // call expression or lambda
         if (tok.type === TokenType.CALL) {
             this.eat(TokenType.CALL);
 
+            // Check if this is a lambda: call [param] -> body
+            if (this.current().type === TokenType.LBRACKET) {
+                this.eat(TokenType.LBRACKET);
+
+                // Parse parameters
+                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);
+
+                // Check for arrow
+                if (this.current().type === TokenType.ARROW) {
+                    this.eat(TokenType.ARROW);
+                    const body = this.parseExpression();
+                    return new LambdaExpression(params, body);
+                }
+            }
+
+            // Regular function call: call functionName[args]
             const name = this.current().value;
             this.eat(TokenType.IDENTIFIER);
 
@@ -337,6 +368,41 @@ class Parser {
             return node;
         }
 
+        // method call as expression
+        if (tok.type === TokenType.METHOD) {
+            this.eat(TokenType.METHOD);
+            this.eat(TokenType.COLON);
+
+            // Get the target type (array or string)
+            const targetType = this.current().value;
+            this.eat(TokenType.TYPE);
+
+            // Get the target variable
+            const target = this.current().value;
+            this.eat(TokenType.IDENTIFIER);
+
+            this.eat(TokenType.DOT);
+
+            // Get the method name
+            const methodName = this.current().value;
+            this.eat(TokenType.IDENTIFIER);
+
+            // Parse arguments in brackets
+            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 MethodCall(targetType, target, methodName, args);
+        }
 
         throw new Error("Invalid primary expression: " + tok.type);
     }
@@ -346,7 +412,8 @@ class Parser {
 
         while (
             this.current().type === TokenType.STAR ||
-            this.current().type === TokenType.SLASH
+            this.current().type === TokenType.SLASH ||
+            this.current().type === TokenType.MODULO
         ) {
             const op = this.current().type;
             this.pos++;
@@ -601,6 +668,42 @@ class Parser {
         return new ShowStatement(value);
     }
 
+    parseMethodCall() {
+        this.eat(TokenType.METHOD);
+        this.eat(TokenType.COLON);
+
+        // Get the target type (array or string)
+        const targetType = this.current().value;
+        this.eat(TokenType.TYPE);
+
+        // Get the target variable
+        const target = this.current().value;
+        this.eat(TokenType.IDENTIFIER);
+
+        this.eat(TokenType.DOT);
+
+        // Get the method name
+        const methodName = this.current().value;
+        this.eat(TokenType.IDENTIFIER);
+
+        // Parse arguments in brackets
+        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 MethodCall(targetType, target, methodName, args);
+    }
+
 }
 
 export { Parser };

package/src/runtime/runner.js

@@ -2,6 +2,9 @@ import { Lexer } from "../lexer/lexer.js";
 import { TokenType } from "../lexer/tokens.js";
 import { Parser } from "../parser/parser.js";
 import { JSCodeGenerator } from "../generator/jsgenerator.js";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
 
 function tokenizeAll(code) {
     const lexer = new Lexer(code);
@@ -10,7 +13,6 @@ function tokenizeAll(code) {
     do {
         t = lexer.getNextToken();
         tokens.push(t);
-        //console.log(t);
     } while (t.type !== TokenType.EOF);
     return tokens;
 }
@@ -23,30 +25,18 @@ function compile(code) {
 
 function run(code) {
     const js = compile(code);
+
     const finalcode_input = `
-let buffer_of_epoxy_lang_dont_use_this_name = "";
-let resolvers_of_epoxy_lang_dont_use_this_name = [];
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", chunk => {
-    buffer_of_epoxy_lang_dont_use_this_name += chunk;
-    while (buffer_of_epoxy_lang_dont_use_this_name.includes("\\n") && resolvers_of_epoxy_lang_dont_use_this_name.length > 0) {
-        const line = buffer_of_epoxy_lang_dont_use_this_name.slice(0, buffer_of_epoxy_lang_dont_use_this_name.indexOf("\\n")).trim();
-        buffer_of_epoxy_lang_dont_use_this_name = buffer_of_epoxy_lang_dont_use_this_name.slice(buffer_of_epoxy_lang_dont_use_this_name.indexOf("\\n") + 1);
-        const resolve_of_epoxy_lang_dont_use_this_name = resolvers_of_epoxy_lang_dont_use_this_name.shift();
-        resolve_of_epoxy_lang_dont_use_this_name(line);
-    }
-});
-function input_of_epoxy_lang_dont_use_this_name() {
-    return new Promise(resolve => {
-        resolvers_of_epoxy_lang_dont_use_this_name.push(resolve);
-})}
-async function main_of_epoxy_lang_dont_use_this_name() {
+const promptSync_of_epoxy_lang_dont_use_this_name = require("prompt-sync");
+const input_of_epoxy_lang_dont_use_this_name = promptSync_of_epoxy_lang_dont_use_this_name();
 ${js}
-process.stdin.pause();
-}
-main_of_epoxy_lang_dont_use_this_name();`;
-    const thisisthecode = js.includes("input_of_epoxy_lang_dont_use_this_name()") ? finalcode_input : js;
+`;
+
+    const thisisthecode = js.includes("input_of_epoxy_lang_dont_use_this_name()")
+        ? finalcode_input
+        : js;
+
     return eval(thisisthecode);
 }
 
-export { tokenizeAll, compile, run };
+export { tokenizeAll, compile, run };

package/src/test.js

@@ -1,33 +1,18 @@
 import { compile } from './index.js';
 import { readFileSync } from 'fs';
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
 console.log("=== Testing test.epx ===");
-const inputfile = readFileSync('./examples/square.epx', 'utf-8');
+const inputfile = readFileSync('./examples/hybrid.epx', 'utf-8');
 console.log("Epoxy code:");
 console.log(inputfile);
 console.log("\nCompiled JavaScript:");
 const epx_to_js_raw = compile(inputfile);
 const finalcode_input = `
-let buffer_of_epoxy_lang_dont_use_this_name = "";
-let resolvers_of_epoxy_lang_dont_use_this_name = [];
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", chunk => {
-    buffer_of_epoxy_lang_dont_use_this_name += chunk;
-    while (buffer_of_epoxy_lang_dont_use_this_name.includes("\\n") && resolvers_of_epoxy_lang_dont_use_this_name.length > 0) {
-        const line = buffer_of_epoxy_lang_dont_use_this_name.slice(0, buffer_of_epoxy_lang_dont_use_this_name.indexOf("\\n")).trim();
-        buffer_of_epoxy_lang_dont_use_this_name = buffer_of_epoxy_lang_dont_use_this_name.slice(buffer_of_epoxy_lang_dont_use_this_name.indexOf("\\n") + 1);
-        const resolve_of_epoxy_lang_dont_use_this_name = resolvers_of_epoxy_lang_dont_use_this_name.shift();
-        resolve_of_epoxy_lang_dont_use_this_name(line);
-    }
-});
-function input_of_epoxy_lang_dont_use_this_name() {
-    return new Promise(resolve => {
-        resolvers_of_epoxy_lang_dont_use_this_name.push(resolve);
-})}
-async function main_of_epoxy_lang_dont_use_this_name() {
+const promptSync_of_epoxy_lang_dont_use_this_name = require("prompt-sync");
+const input_of_epoxy_lang_dont_use_this_name = promptSync_of_epoxy_lang_dont_use_this_name();
 ${epx_to_js_raw}
-process.stdin.pause();
-}
-main_of_epoxy_lang_dont_use_this_name();`;
+`;
 const thisisthecode = epx_to_js_raw.includes("input_of_epoxy_lang_dont_use_this_name()") ? finalcode_input : epx_to_js_raw;
 console.log(thisisthecode);
 console.log("\nRunning JavaScript:");