ga-lang 1.2.1 → 1.2.4

package/dist/src/ast.d.ts

@@ -0,0 +1,77 @@
+import type { Token } from './token.js';
+export interface Expr {
+    accept<T>(visitor: ExprVisitor<T>): T;
+}
+export interface ExprVisitor<T> {
+    visitVariableExpr(expr: VariableExpr): T;
+    visitLiteralExpr(expr: LiteralExpr): T;
+    visitCallExpr(expr: CallExpr): T;
+    visitBinaryExpr(expr: BinaryExpr): T;
+}
+export interface Stmt {
+    accept<T>(visitor: StmtVisitor<T>): T;
+}
+export interface StmtVisitor<T> {
+    visitPrintStmt(stmt: PrintStmt): T;
+    visitVarStmt(stmt: VarStmt): T;
+    visitFunctionStmt(stmt: FunctionStmt): T;
+    visitBlockStmt(stmt: BlockStmt): T;
+    visitExpressionStmt(stmt: ExpressionStmt): T;
+    visitReturnStmt(stmt: ReturnStmt): T;
+}
+export declare class VariableExpr implements Expr {
+    name: Token;
+    constructor(name: Token);
+    accept<T>(visitor: ExprVisitor<T>): T;
+}
+export declare class LiteralExpr implements Expr {
+    value: any;
+    constructor(value: any);
+    accept<T>(visitor: ExprVisitor<T>): T;
+}
+export declare class CallExpr implements Expr {
+    callee: VariableExpr;
+    args: Expr[];
+    constructor(callee: VariableExpr, args: Expr[]);
+    accept<T>(visitor: ExprVisitor<T>): T;
+}
+export declare class BinaryExpr implements Expr {
+    left: Expr;
+    operator: Token;
+    right: Expr;
+    constructor(left: Expr, operator: Token, right: Expr);
+    accept<T>(visitor: ExprVisitor<T>): T;
+}
+export declare class PrintStmt implements Stmt {
+    expression: Expr;
+    constructor(expression: Expr);
+    accept<T>(visitor: StmtVisitor<T>): T;
+}
+export declare class VarStmt implements Stmt {
+    name: Token;
+    initializer: Expr | null;
+    constructor(name: Token, initializer: Expr | null);
+    accept<T>(visitor: StmtVisitor<T>): T;
+}
+export declare class FunctionStmt implements Stmt {
+    name: Token;
+    params: Token[];
+    body: Stmt[];
+    constructor(name: Token, params: Token[], body: Stmt[]);
+    accept<T>(visitor: StmtVisitor<T>): T;
+}
+export declare class BlockStmt implements Stmt {
+    statements: Stmt[];
+    constructor(statements: Stmt[]);
+    accept<T>(visitor: StmtVisitor<T>): T;
+}
+export declare class ExpressionStmt implements Stmt {
+    expression: Expr;
+    constructor(expression: Expr);
+    accept<T>(visitor: StmtVisitor<T>): T;
+}
+export declare class ReturnStmt implements Stmt {
+    value: Expr | null;
+    constructor(value: Expr | null);
+    accept<T>(visitor: StmtVisitor<T>): T;
+}

package/dist/src/ast.js

@@ -27,6 +27,19 @@ export class CallExpr {
         return visitor.visitCallExpr(this);
     }
 }
+export class BinaryExpr {
+    left;
+    operator;
+    right;
+    constructor(left, operator, right) {
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitBinaryExpr(this);
+    }
+}
 export class PrintStmt {
     expression;
     constructor(expression) {
@@ -78,3 +91,12 @@ export class ExpressionStmt {
         return visitor.visitExpressionStmt(this);
     }
 }
+export class ReturnStmt {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitReturnStmt(this);
+    }
+}

package/dist/src/interpreter.d.ts

@@ -0,0 +1,22 @@
+import { BinaryExpr, FunctionStmt, ReturnStmt, type BlockStmt, type CallExpr, type ExpressionStmt, type ExprVisitor, type LiteralExpr, type PrintStmt, type Stmt, type StmtVisitor, type VariableExpr, type VarStmt } from './ast.js';
+export declare class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
+    private environment;
+    interpret(statements: Stmt[]): void;
+    private execute;
+    visitPrintStmt(stmt: PrintStmt): void;
+    private toDevanagariString;
+    private numberToDevanagari;
+    visitVarStmt(stmt: VarStmt): void;
+    visitFunctionStmt(stmt: FunctionStmt): void;
+    visitBlockStmt(stmt: BlockStmt): void;
+    visitExpressionStmt(stmt: ExpressionStmt): void;
+    visitReturnStmt(stmt: ReturnStmt): void;
+    visitLiteralExpr(expr: LiteralExpr): any;
+    private isDevanagariNumber;
+    private devanagariToNumber;
+    visitVariableExpr(expr: VariableExpr): any;
+    visitCallExpr(expr: CallExpr): any;
+    visitBinaryExpr(expr: BinaryExpr): any;
+    private toNumber;
+    private evaluate;
+}

package/dist/src/interpreter.js

@@ -1,4 +1,12 @@
-import { FunctionStmt } from './ast.js';
+import { BinaryExpr, FunctionStmt, ReturnStmt } from './ast.js';
+import { TokenKind } from './token.js';
+class ReturnValue extends Error {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+}
 export class Interpreter {
     environment = new Map();
     interpret(statements) {
@@ -14,7 +22,26 @@ export class Interpreter {
      */
     visitPrintStmt(stmt) {
         const value = this.evaluate(stmt.expression);
-        console.log(value);
+        console.log(this.toDevanagariString(value));
+    }
+    toDevanagariString(value) {
+        if (typeof value === 'number') {
+            return this.numberToDevanagari(value);
+        }
+        return String(value);
+    }
+    numberToDevanagari(num) {
+        const devanagariZero = 0x0966;
+        return num
+            .toString()
+            .split('')
+            .map((char) => {
+            if (char >= '0' && char <= '9') {
+                return String.fromCharCode(devanagariZero + parseInt(char));
+            }
+            return char;
+        })
+            .join('');
     }
     visitVarStmt(stmt) {
         const value = stmt.initializer !== null ? this.evaluate(stmt.initializer) : null;
@@ -31,12 +58,40 @@ export class Interpreter {
     visitExpressionStmt(stmt) {
         this.evaluate(stmt.expression);
     }
+    visitReturnStmt(stmt) {
+        const value = stmt.value !== null ? this.evaluate(stmt.value) : null;
+        throw new ReturnValue(value);
+    }
     visitLiteralExpr(expr) {
         if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
             return expr.value.slice(1, -1);
         }
+        // Check if it's a Devanagari number and convert it
+        if (typeof expr.value === 'string' && this.isDevanagariNumber(expr.value)) {
+            return this.devanagariToNumber(expr.value);
+        }
         return expr.value;
     }
+    isDevanagariNumber(value) {
+        if (value.length === 0)
+            return false;
+        for (const char of value) {
+            const code = char.charCodeAt(0);
+            if (code < 0x0966 || code > 0x096f) {
+                return false;
+            }
+        }
+        return true;
+    }
+    devanagariToNumber(value) {
+        const devanagariZero = 0x0966;
+        let num = 0;
+        for (const char of value) {
+            const code = char.charCodeAt(0);
+            num = num * 10 + (code - devanagariZero);
+        }
+        return num;
+    }
     visitVariableExpr(expr) {
         const value = this.environment.get(expr.name.lexeme);
         if (value === undefined) {
@@ -64,13 +119,85 @@ export class Interpreter {
             this.environment.set(func.params[i].lexeme, value);
         }
         // Execute function body
-        for (const stmt of func.body) {
-            this.execute(stmt);
+        try {
+            for (const stmt of func.body) {
+                this.execute(stmt);
+            }
+        }
+        catch (returnValue) {
+            if (returnValue instanceof ReturnValue) {
+                // Restore previous environment before returning
+                this.environment = prevEnvironment;
+                return returnValue.value;
+            }
+            throw returnValue;
         }
         // Restore previous environment
         this.environment = prevEnvironment;
         return null;
     }
+    visitBinaryExpr(expr) {
+        const left = this.evaluate(expr.left);
+        const right = this.evaluate(expr.right);
+        // Convert Devanagari digits to regular numbers for arithmetic
+        const leftNum = this.toNumber(left);
+        const rightNum = this.toNumber(right);
+        switch (expr.operator.kind) {
+            case TokenKind.Plus:
+                // Handle string concatenation or numeric addition
+                if (typeof left === 'string' && typeof right === 'string') {
+                    return left + right;
+                }
+                return leftNum + rightNum;
+            case TokenKind.Minus:
+                return leftNum - rightNum;
+            case TokenKind.Star:
+                return leftNum * rightNum;
+            case TokenKind.Slash:
+                if (rightNum === 0) {
+                    throw new Error('Division by zero');
+                }
+                return leftNum / rightNum;
+            case TokenKind.Mod:
+                if (rightNum === 0) {
+                    throw new Error('Modulo by zero');
+                }
+                return leftNum % rightNum;
+            default:
+                throw new Error(`Unknown operator: ${expr.operator.kind}`);
+        }
+    }
+    toNumber(value) {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string') {
+            // Check if it's a Devanagari number
+            const devanagariZero = '\u{0966}'.charCodeAt(0); // ०
+            let isDevanagari = true;
+            let num = 0;
+            for (const char of value) {
+                const code = char.charCodeAt(0);
+                if (code >= devanagariZero && code <= devanagariZero + 9) {
+                    num = num * 10 + (code - devanagariZero);
+                }
+                else if (char >= '0' && char <= '9') {
+                    isDevanagari = false;
+                }
+                else {
+                    throw new Error(`Cannot convert '${value}' to number`);
+                }
+            }
+            if (isDevanagari && value.length > 0)
+                return num;
+            // Otherwise try regular parsing
+            const parsed = parseFloat(value);
+            if (isNaN(parsed)) {
+                throw new Error(`Cannot convert '${value}' to number`);
+            }
+            return parsed;
+        }
+        throw new Error(`Cannot convert '${value}' to number`);
+    }
     /*
      * Evaluate an expression
      */

package/dist/src/lexer.d.ts

@@ -0,0 +1,66 @@
+import { Token, TokenKind } from './token.js';
+export declare class Lexer {
+    private source;
+    private tokens;
+    private startPos;
+    private currentPos;
+    private line;
+    constructor(source: string);
+    /**
+     * Read tokens from source
+     */
+    readTokens(): Token[];
+    /**
+     * Read individual lexeme
+     */
+    readToken(): void;
+    /**
+     * Read character
+     */
+    readChar(): string;
+    /**
+     * Create token out of individual lexeme
+     * @param {TokenKind} kind
+     * @param {any} literal
+     */
+    createToken(kind: TokenKind, literal?: any): void;
+    /**
+     * Check if we've reached the end of file
+     */
+    private isAtEnd;
+    /**
+     * Peek next character
+     */
+    private peekNextChar;
+    /**
+     * Get next character
+     */
+    private getNextChar;
+    /**
+     * Check if the character is devanagari character
+     * @param {string} char
+     */
+    private isDevnagariChar;
+    /**
+     * Check if the character is devanagari digit
+     * @param {string} char
+     */
+    private isDevanagariDigit;
+    /**
+     * Check if the character is whitespace
+     * @param {string} char
+     */
+    private isWhitespace;
+    /**
+     * Read devanagari character sequence as number
+     */
+    private readDevanagariDigit;
+    /**
+     * Read devanagari character sequence as identifier
+     */
+    private readDevanagariIdentifier;
+    /**
+     * Read string literals
+     */
+    private readDevanagariString;
+}

package/dist/src/main.d.ts

@@ -0,0 +1,4 @@
+import { Lexer } from './lexer.js';
+import { Parser } from './parser.js';
+import { Interpreter } from './interpreter.js';
+export { Lexer, Parser, Interpreter };

package/dist/src/main.js

@@ -28,3 +28,5 @@ function main() {
     }
 }
 main();
+// Export Lexer, Parser, and Interpreter
+export { Lexer, Parser, Interpreter };

package/dist/src/parser.d.ts

@@ -0,0 +1,28 @@
+import { type Stmt } from './ast.js';
+import { type Token } from './token.js';
+export declare class Parser {
+    private tokens;
+    private currentPos;
+    constructor(tokens: Token[]);
+    parse(): Stmt[];
+    private parseStmt;
+    private parseReturnStmt;
+    private parseExpressionStmt;
+    private parsePrintStmt;
+    private parseVarStmt;
+    private parseFunctionStmt;
+    private parseBlock;
+    private parseExpression;
+    private parseAddition;
+    private parseMultiplication;
+    private parseCall;
+    private parsePrimary;
+    private match;
+    private consume;
+    private check;
+    private advance;
+    private peek;
+    private previous;
+    private isAtEnd;
+    private error;
+}

package/dist/src/parser.js

@@ -1,4 +1,4 @@
-import { CallExpr, ExpressionStmt, FunctionStmt, LiteralExpr, PrintStmt, VarStmt, VariableExpr } from './ast.js';
+import { BinaryExpr, CallExpr, ExpressionStmt, FunctionStmt, LiteralExpr, PrintStmt, ReturnStmt, VarStmt, VariableExpr } from './ast.js';
 import { TokenKind } from './token.js';
 export class Parser {
     tokens;
@@ -28,8 +28,19 @@ export class Parser {
         if (this.match(TokenKind.Function)) {
             return this.parseFunctionStmt();
         }
+        if (this.match(TokenKind.Return)) {
+            return this.parseReturnStmt();
+        }
         return this.parseExpressionStmt();
     }
+    parseReturnStmt() {
+        let value = null;
+        // Check if there's a value to return (not just "फिर्ता" alone)
+        if (!this.check(TokenKind.CloseCurly) && !this.isAtEnd()) {
+            value = this.parseExpression();
+        }
+        return new ReturnStmt(value);
+    }
     parseExpressionStmt() {
         const expr = this.parseExpression();
         return new ExpressionStmt(expr);
@@ -71,7 +82,25 @@ export class Parser {
         return statements;
     }
     parseExpression() {
-        return this.parseCall();
+        return this.parseAddition();
+    }
+    parseAddition() {
+        let expr = this.parseMultiplication();
+        while (this.match(TokenKind.Plus, TokenKind.Minus)) {
+            const operator = this.previous();
+            const right = this.parseMultiplication();
+            expr = new BinaryExpr(expr, operator, right);
+        }
+        return expr;
+    }
+    parseMultiplication() {
+        let expr = this.parseCall();
+        while (this.match(TokenKind.Star, TokenKind.Slash, TokenKind.Mod)) {
+            const operator = this.previous();
+            const right = this.parseCall();
+            expr = new BinaryExpr(expr, operator, right);
+        }
+        return expr;
     }
     parseCall() {
         let expr = this.parsePrimary();
@@ -99,6 +128,11 @@ export class Parser {
         if (this.match(TokenKind.Identifier)) {
             return new VariableExpr(this.previous());
         }
+        if (this.match(TokenKind.OpenParen)) {
+            const expr = this.parseExpression();
+            this.consume(TokenKind.CloseParen, "Expect ')' after expression");
+            return expr;
+        }
         throw this.error(this.peek(), 'Expression expected.');
     }
     match(...kinds) {

package/dist/src/token.d.ts

@@ -0,0 +1,38 @@
+export declare enum TokenKind {
+    Eof = "Eof",
+    Illegal = "Illegal",
+    Comma = "Comma",
+    Colon = "Colon",
+    Period = "Period",
+    Semicolon = "Semicolon",
+    OpenParen = "OpenParen",
+    CloseParen = "CloseParen",
+    OpenCurly = "OpenCurly",
+    CloseCurly = "CloseCurly",
+    Plus = "Plus",
+    Minus = "Minus",
+    Star = "Star",
+    Slash = "Slash",
+    Mod = "Mod",
+    Bang = "Bang",
+    Equal = "Equal",
+    Number = "Number",
+    Character = "Character",
+    String = "String",
+    Identifier = "Identifier",
+    Let = "Let",
+    Function = "Function",
+    Print = "Print",
+    Return = "Return",
+    If = "If",
+    Else = "Else",
+    True = "True",
+    False = "False"
+}
+export declare const keywords: Record<string, TokenKind>;
+export declare class Token {
+    kind: TokenKind;
+    lexeme: string;
+    line: number;
+    constructor(kind: TokenKind, lexeme: string, line: number);
+}

package/examples/init.ga

@@ -1,14 +1,6 @@
-कार्य सुरु () {
-    मानौ सन्देश = "सोच्छौ के मेरो बारे?"
-    मानौ एकदुइतिन = १२३
-    छाप(सन्देश)
-    छाप(एकदुइतिन)
+कार्य जोड (अ , आ) {
+  फिर्ता अ + आ 
 }
 
-कार्य जोड( अ, आ) {
- छाप(अ)
- छाप(आ)
-}
-
-सुरु()
-जोड(१,२)
+मानौ जम्मा = जोड(१, २)
+छाप(जम्मा)

package/package.json

@@ -1,15 +1,25 @@
 {
   "name": "ga-lang",
-  "version": "1.2.1",
+  "version": "1.2.4",
   "description": "An interpreted toy programming language",
   "type": "module",
-  "main": "dist/main.js",
+  "main": "dist/src/main.js",
+  "types": "dist/src/main.d.ts",
   "bin": {
     "ga": "./bin/ga.js"
   },
+  "scripts": {
+    "prettier:check": "prettier --check \"./**/*.{js,ts,json}\"",
+    "prettier:fix": "prettier --write \"./**/*.{js,ts,json}\"",
+    "clean": "rm -rf dist",
+    "build": "pnpm run clean && tsc",
+    "build:tests": "tsc -p tsconfig.test.json",
+    "test": "pnpm run build && pnpm run build:tests && node --test ./dist/tests/**/*.js",
+    "ga": "pnpm run build && node dist/src/main.js"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bvsvntv/ga.git"
+    "url": "git+https://github.com/bvsvntv/ga-lang.git"
   },
   "keywords": [
     "devanagari",
@@ -20,13 +30,17 @@
   "author": "Basanta Rai",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/bvsvntv/ga/issues"
+    "url": "https://github.com/bvsvntv/ga-lang/issues"
   },
-  "homepage": "https://github.com/bvsvntv/ga#readme",
+  "homepage": "https://github.com/bvsvntv/ga-lang#readme",
+  "packageManager": "pnpm@10.25.0",
   "engines": {
     "node": ">=22.x.x",
     "pnpm": ">=10.x.x"
   },
+  "exports": {
+    ".": "./dist/src/main.js"
+  },
   "devEngines": {
     "runtime": {
       "name": "node",
@@ -37,13 +51,5 @@
     "@types/node": "^25.0.3",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3"
-  },
-  "scripts": {
-    "prettier:check": "prettier --check \"./**/*.{js,ts,json}\"",
-    "prettier:fix": "prettier --write \"./**/*.{js,ts,json}\"",
-    "clean": "rm -rf dist",
-    "build": "pnpm run clean && tsc",
-    "test": "pnpm run build && node --test ./dist/tests/**/*.js",
-    "ga": "pnpm run build && node dist/src/main.js"
   }
-}
+}

package/src/ast.ts

@@ -8,6 +8,7 @@ export interface ExprVisitor<T> {
   visitVariableExpr(expr: VariableExpr): T;
   visitLiteralExpr(expr: LiteralExpr): T;
   visitCallExpr(expr: CallExpr): T;
+  visitBinaryExpr(expr: BinaryExpr): T;
 }
 
 export interface Stmt {
@@ -20,6 +21,7 @@ export interface StmtVisitor<T> {
   visitFunctionStmt(stmt: FunctionStmt): T;
   visitBlockStmt(stmt: BlockStmt): T;
   visitExpressionStmt(stmt: ExpressionStmt): T;
+  visitReturnStmt(stmt: ReturnStmt): T;
 }
 
 export class VariableExpr implements Expr {
@@ -60,6 +62,22 @@ export class CallExpr implements Expr {
   }
 }
 
+export class BinaryExpr implements Expr {
+  left: Expr;
+  operator: Token;
+  right: Expr;
+
+  constructor(left: Expr, operator: Token, right: Expr) {
+    this.left = left;
+    this.operator = operator;
+    this.right = right;
+  }
+
+  accept<T>(visitor: ExprVisitor<T>): T {
+    return visitor.visitBinaryExpr(this);
+  }
+}
+
 export class PrintStmt implements Stmt {
   expression: Expr;
 
@@ -125,3 +143,15 @@ export class ExpressionStmt implements Stmt {
     return visitor.visitExpressionStmt(this);
   }
 }
+
+export class ReturnStmt implements Stmt {
+  value: Expr | null;
+
+  constructor(value: Expr | null) {
+    this.value = value;
+  }
+
+  accept<T>(visitor: StmtVisitor<T>): T {
+    return visitor.visitReturnStmt(this);
+  }
+}

package/src/interpreter.ts

@@ -1,5 +1,7 @@
 import {
+  BinaryExpr,
   FunctionStmt,
+  ReturnStmt,
   type BlockStmt,
   type CallExpr,
   type ExpressionStmt,
@@ -12,6 +14,15 @@ import {
   type VariableExpr,
   type VarStmt
 } from './ast.js';
+import { TokenKind } from './token.js';
+
+class ReturnValue extends Error {
+  value: any;
+  constructor(value: any) {
+    super();
+    this.value = value;
+  }
+}
 
 export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
   private environment: Map<string, any> = new Map();
@@ -31,7 +42,28 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
    */
   visitPrintStmt(stmt: PrintStmt): void {
     const value = this.evaluate(stmt.expression);
-    console.log(value);
+    console.log(this.toDevanagariString(value));
+  }
+
+  private toDevanagariString(value: any): string {
+    if (typeof value === 'number') {
+      return this.numberToDevanagari(value);
+    }
+    return String(value);
+  }
+
+  private numberToDevanagari(num: number): string {
+    const devanagariZero = 0x0966;
+    return num
+      .toString()
+      .split('')
+      .map((char) => {
+        if (char >= '0' && char <= '9') {
+          return String.fromCharCode(devanagariZero + parseInt(char));
+        }
+        return char;
+      })
+      .join('');
   }
 
   visitVarStmt(stmt: VarStmt): void {
@@ -54,14 +86,45 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
     this.evaluate(stmt.expression);
   }
 
+  visitReturnStmt(stmt: ReturnStmt): void {
+    const value = stmt.value !== null ? this.evaluate(stmt.value) : null;
+    throw new ReturnValue(value);
+  }
+
   visitLiteralExpr(expr: LiteralExpr): any {
     if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
       return expr.value.slice(1, -1);
     }
 
+    // Check if it's a Devanagari number and convert it
+    if (typeof expr.value === 'string' && this.isDevanagariNumber(expr.value)) {
+      return this.devanagariToNumber(expr.value);
+    }
+
     return expr.value;
   }
 
+  private isDevanagariNumber(value: string): boolean {
+    if (value.length === 0) return false;
+    for (const char of value) {
+      const code = char.charCodeAt(0);
+      if (code < 0x0966 || code > 0x096f) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private devanagariToNumber(value: string): number {
+    const devanagariZero = 0x0966;
+    let num = 0;
+    for (const char of value) {
+      const code = char.charCodeAt(0);
+      num = num * 10 + (code - devanagariZero);
+    }
+    return num;
+  }
+
   visitVariableExpr(expr: VariableExpr): any {
     const value = this.environment.get(expr.name.lexeme);
     if (value === undefined) {
@@ -96,8 +159,17 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
     }
 
     // Execute function body
-    for (const stmt of func.body) {
-      this.execute(stmt);
+    try {
+      for (const stmt of func.body) {
+        this.execute(stmt);
+      }
+    } catch (returnValue) {
+      if (returnValue instanceof ReturnValue) {
+        // Restore previous environment before returning
+        this.environment = prevEnvironment;
+        return returnValue.value;
+      }
+      throw returnValue;
     }
 
     // Restore previous environment
@@ -106,6 +178,68 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
     return null;
   }
 
+  visitBinaryExpr(expr: BinaryExpr): any {
+    const left = this.evaluate(expr.left);
+    const right = this.evaluate(expr.right);
+
+    // Convert Devanagari digits to regular numbers for arithmetic
+    const leftNum = this.toNumber(left);
+    const rightNum = this.toNumber(right);
+
+    switch (expr.operator.kind) {
+      case TokenKind.Plus:
+        // Handle string concatenation or numeric addition
+        if (typeof left === 'string' && typeof right === 'string') {
+          return left + right;
+        }
+        return leftNum + rightNum;
+      case TokenKind.Minus:
+        return leftNum - rightNum;
+      case TokenKind.Star:
+        return leftNum * rightNum;
+      case TokenKind.Slash:
+        if (rightNum === 0) {
+          throw new Error('Division by zero');
+        }
+        return leftNum / rightNum;
+      case TokenKind.Mod:
+        if (rightNum === 0) {
+          throw new Error('Modulo by zero');
+        }
+        return leftNum % rightNum;
+      default:
+        throw new Error(`Unknown operator: ${expr.operator.kind}`);
+    }
+  }
+
+  private toNumber(value: any): number {
+    if (typeof value === 'number') return value;
+    if (typeof value === 'string') {
+      // Check if it's a Devanagari number
+      const devanagariZero = '\u{0966}'.charCodeAt(0); // ०
+      let isDevanagari = true;
+      let num = 0;
+      for (const char of value) {
+        const code = char.charCodeAt(0);
+        if (code >= devanagariZero && code <= devanagariZero + 9) {
+          num = num * 10 + (code - devanagariZero);
+        } else if (char >= '0' && char <= '9') {
+          isDevanagari = false;
+        } else {
+          throw new Error(`Cannot convert '${value}' to number`);
+        }
+      }
+      if (isDevanagari && value.length > 0) return num;
+      // Otherwise try regular parsing
+      const parsed = parseFloat(value);
+      if (isNaN(parsed)) {
+        throw new Error(`Cannot convert '${value}' to number`);
+      }
+      return parsed;
+    }
+    throw new Error(`Cannot convert '${value}' to number`);
+  }
+
   /*
    * Evaluate an expression
    */

package/src/main.ts

@@ -36,3 +36,6 @@ function main(): void {
 }
 
 main();
+
+// Export Lexer, Parser, and Interpreter
+export { Lexer, Parser, Interpreter };

package/src/parser.ts

@@ -1,9 +1,11 @@
 import {
+  BinaryExpr,
   CallExpr,
   ExpressionStmt,
   FunctionStmt,
   LiteralExpr,
   PrintStmt,
+  ReturnStmt,
   VarStmt,
   VariableExpr,
   type Expr,
@@ -46,9 +48,22 @@ export class Parser {
       return this.parseFunctionStmt();
     }
 
+    if (this.match(TokenKind.Return)) {
+      return this.parseReturnStmt();
+    }
+
     return this.parseExpressionStmt();
   }
 
+  private parseReturnStmt(): ReturnStmt {
+    let value: Expr | null = null;
+    // Check if there's a value to return (not just "फिर्ता" alone)
+    if (!this.check(TokenKind.CloseCurly) && !this.isAtEnd()) {
+      value = this.parseExpression();
+    }
+    return new ReturnStmt(value);
+  }
+
   private parseExpressionStmt(): ExpressionStmt {
     const expr = this.parseExpression();
     return new ExpressionStmt(expr);
@@ -111,7 +126,31 @@ export class Parser {
   }
 
   private parseExpression(): Expr {
-    return this.parseCall();
+    return this.parseAddition();
+  }
+
+  private parseAddition(): Expr {
+    let expr = this.parseMultiplication();
+
+    while (this.match(TokenKind.Plus, TokenKind.Minus)) {
+      const operator = this.previous();
+      const right = this.parseMultiplication();
+      expr = new BinaryExpr(expr, operator, right);
+    }
+
+    return expr;
+  }
+
+  private parseMultiplication(): Expr {
+    let expr = this.parseCall();
+
+    while (this.match(TokenKind.Star, TokenKind.Slash, TokenKind.Mod)) {
+      const operator = this.previous();
+      const right = this.parseCall();
+      expr = new BinaryExpr(expr, operator, right);
+    }
+
+    return expr;
   }
 
   private parseCall(): Expr {
@@ -145,6 +184,12 @@ export class Parser {
       return new VariableExpr(this.previous());
     }
 
+    if (this.match(TokenKind.OpenParen)) {
+      const expr = this.parseExpression();
+      this.consume(TokenKind.CloseParen, "Expect ')' after expression");
+      return expr;
+    }
+
     throw this.error(this.peek(), 'Expression expected.');
   }
 

package/tests/interpreter.test.ts

@@ -0,0 +1,176 @@
+import test, { describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { Lexer } from '../src/lexer.js';
+import { Parser } from '../src/parser.js';
+import { Interpreter } from '../src/interpreter.js';
+
+describe('Interpreter', () => {
+  function runSource(source: string): string[] {
+    const lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser = new Parser(tokens);
+    const stmts = parser.parse();
+    const interpreter = new Interpreter();
+
+    const outputs: string[] = [];
+    const originalLog = console.log;
+    console.log = (...args: any[]) => {
+      outputs.push(args.join(' '));
+    };
+
+    try {
+      interpreter.interpret(stmts);
+    } finally {
+      console.log = originalLog;
+    }
+
+    return outputs;
+  }
+
+  test('evaluate addition with Devanagari numbers', () => {
+    const source = `मानौ क = ५ + ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate subtraction', () => {
+    const source = `मानौ क = १० - २
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate multiplication', () => {
+    const source = `मानौ क = ४ * २
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate division', () => {
+    const source = `मानौ क = १५ / ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '५');
+  });
+
+  test('evaluate modulo', () => {
+    const source = `मानौ क = १७ % ५
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२');
+  });
+
+  test('evaluate operator precedence', () => {
+    const source = `मानौ क = २ + ३ * ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '१४');
+  });
+
+  test('evaluate parentheses grouping', () => {
+    const source = `मानौ क = (२ + ३) * ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२०');
+  });
+
+  test('evaluate chained addition', () => {
+    const source = `मानौ क = १ + २ + ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '६');
+  });
+
+  test('evaluate mixed operations', () => {
+    const source = `मानौ क = १० - ३ * २ + ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate division by zero throws error', () => {
+    const source = `मानौ क = १० / ०
+छाप(क)`;
+    assert.throws(() => {
+      runSource(source);
+    }, /Division by zero/);
+  });
+
+  test('evaluate modulo by zero throws error', () => {
+    const source = `मानौ क = १० % ०
+छाप(क)`;
+    assert.throws(() => {
+      runSource(source);
+    }, /Modulo by zero/);
+  });
+
+  test('evaluate complex expression', () => {
+    const source = `मानौ क = (५ + ५) * (३ - १)
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२०');
+  });
+
+  test('evaluate multiple print statements', () => {
+    const source = `मानौ क = ५ + ५
+छाप(क)
+मानौ ख = क + ५
+छाप(ख)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 2);
+    assert.equal(outputs[0], '१०');
+    assert.equal(outputs[1], '१५');
+  });
+
+  test('print string literal', () => {
+    const source = `छाप("नमस्ते")`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], 'नमस्ते');
+  });
+
+  test('function returns value', () => {
+    const source = `कार्य जोड(क, ख) {
+  फिर्ता क + ख
+}
+मानौ परिणाम = जोड(२, ३)
+छाप(परिणाम)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '५');
+  });
+
+  test('function returns expression result', () => {
+    const source = `कार्य गुणा(क, ख) {
+  फिर्ता क * ख + १०
+}
+मानौ परिणाम = गुणा(३, ४)
+छाप(परिणाम)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२२');
+  });
+
+  test('function returns string', () => {
+    const source = `कार्य नमस्कार() {
+  फिर्ता "नमस्ते संसार"
+}
+मानौ सन्देश = नमस्कार()
+छाप(सन्देश)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], 'नमस्ते संसार');
+  });
+});

package/tests/parser.test.ts

@@ -7,7 +7,8 @@ import {
   VarStmt,
   FunctionStmt,
   LiteralExpr,
-  VariableExpr
+  VariableExpr,
+  BinaryExpr
 } from '../src/ast.js';
 
 describe('Parser', () => {
@@ -128,4 +129,91 @@ describe('Parser', () => {
     assert.equal(funcStmt.params[1]!.lexeme, 'ब');
     assert.equal(funcStmt.body.length, 2);
   });
+
+  test('parse binary expression with addition', () => {
+    const source: string = `मानौ क = ५ + ३`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof LiteralExpr);
+    assert.ok(binaryExpr.right instanceof LiteralExpr);
+  });
+
+  test('parse binary expression with operator precedence', () => {
+    const source: string = `मानौ क = २ + ३ * ४`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof LiteralExpr);
+    assert.ok(binaryExpr.right instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with parentheses', () => {
+    const source: string = `मानौ क = (२ + ३) * ४`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof BinaryExpr);
+    assert.ok(binaryExpr.right instanceof LiteralExpr);
+  });
+
+  test('parse binary expression with subtraction', () => {
+    const source: string = `मानौ क = १० - ५`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with division', () => {
+    const source: string = `मानौ क = १५ / ३`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with modulo', () => {
+    const source: string = `मानौ क = १७ % ५`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
 });

package/tsconfig.json

@@ -9,6 +9,7 @@
     "moduleDetection": "force",
     "isolatedModules": true,
     "verbatimModuleSyntax": true,
+    "declaration": true,
 
     /* Strictness */
     "strict": true,
@@ -20,6 +21,6 @@
     "rootDir": ".",
     "outDir": "./dist"
   },
-  "include": ["src/**/*.ts", "tests/**/*.test.ts"],
+  "include": ["src/**/*.ts"],
   "exclude": ["node_modules", "dist"]
 }

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": false,
+    "noEmit": false,
+    "outDir": "./dist"
+  },
+  "include": ["tests/**/*.ts", "src/**/*.ts"]
+}