ga-lang 1.1.0

package/.github/workflows/test.yml

@@ -0,0 +1,35 @@
+name: Node.js Test CI
+
+on:
+  push:
+    branches: ['main']
+  pull_request:
+    branches: ['main']
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [22.x]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'pnpm'
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm build
+
+      - name: Run tests
+        run: pnpm test

package/.pnpmrc

@@ -0,0 +1 @@
+engine-strict=true

package/.prettierrc.json

@@ -0,0 +1,8 @@
+{
+  "printWidth": 80,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "semi": true,
+  "bracketSpacing": true,
+  "requirePragma": false
+}

package/bin/ga.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/src/main.js';

package/dist/src/ast.js

@@ -0,0 +1,38 @@
+export class VariableExpr {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    accept(visitor) {
+        return visitor.visitVariableExpr(this);
+    }
+}
+export class LiteralExpr {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitLiteralExpr(this);
+    }
+}
+export class PrintStmt {
+    expression;
+    constructor(expression) {
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitPrintStmt(this);
+    }
+}
+export class VarStmt {
+    name;
+    initializer;
+    constructor(name, initializer) {
+        this.name = name;
+        this.initializer = initializer;
+    }
+    accept(visitor) {
+        return visitor.visitVarStmt(this);
+    }
+}

package/dist/src/interpreter.js

@@ -0,0 +1,35 @@
+export class Interpreter {
+    interpret(statements) {
+        for (const statement of statements) {
+            this.execute(statement);
+        }
+    }
+    execute(stmt) {
+        stmt.accept(this);
+    }
+    /*
+     * Process print statement
+     */
+    visitPrintStmt(stmt) {
+        const value = this.evaluate(stmt.expression);
+        console.log(value);
+    }
+    visitVarStmt(stmt) {
+        // TODO: yet to implement
+    }
+    visitLiteralExpr(expr) {
+        if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
+            return expr.value.slice(1, -1);
+        }
+        return expr.value;
+    }
+    visitVariableExpr(expr) {
+        // TODO: yet to implement
+    }
+    /*
+     * Evaluate an expression
+     */
+    evaluate(expr) {
+        return expr.accept(this);
+    }
+}

package/dist/src/lexer.js

@@ -0,0 +1,187 @@
+import { keywords, Token, TokenKind } from './token.js';
+export class Lexer {
+    source;
+    tokens;
+    startPos;
+    currentPos;
+    line;
+    constructor(source) {
+        this.source = source;
+        this.tokens = [];
+        this.startPos = 0;
+        this.currentPos = 0;
+        this.line = 1;
+    }
+    /**
+     * Read tokens from source
+     */
+    readTokens() {
+        while (!this.isAtEnd()) {
+            this.startPos = this.currentPos;
+            this.readToken();
+        }
+        this.tokens.push(new Token(TokenKind.Eof, '', this.line));
+        return this.tokens;
+    }
+    /**
+     * Read individual lexeme
+     */
+    readToken() {
+        const char = this.readChar();
+        switch (char) {
+            case ',':
+                this.createToken(TokenKind.Comma);
+                break;
+            case ':':
+                this.createToken(TokenKind.Colon);
+                break;
+            case '.':
+                this.createToken(TokenKind.Period);
+                break;
+            case ';':
+                this.createToken(TokenKind.Semicolon);
+                break;
+            case '(':
+                this.createToken(TokenKind.OpenParen);
+                break;
+            case ')':
+                this.createToken(TokenKind.CloseParen);
+                break;
+            case '{':
+                this.createToken(TokenKind.OpenCurly);
+                break;
+            case '}':
+                this.createToken(TokenKind.CloseCurly);
+                break;
+            case '+':
+                this.createToken(TokenKind.Plus);
+                break;
+            case '-':
+                this.createToken(TokenKind.Minus);
+                break;
+            case '*':
+                this.createToken(TokenKind.Star);
+                break;
+            case '/':
+                this.createToken(TokenKind.Slash);
+                break;
+            case '%':
+                this.createToken(TokenKind.Mod);
+                break;
+            case '!':
+                this.createToken(TokenKind.Bang);
+                break;
+            case '=':
+                this.createToken(TokenKind.Equal);
+                break;
+            /* Handle whitespaces */
+            case ' ':
+            case '\r':
+            case '\t':
+                break;
+            case '\n':
+                this.line++;
+                break;
+            case '"':
+                this.readDevanagariString();
+                break;
+            default:
+                if (this.isDevnagariChar(char)) {
+                    if (this.isDevanagariDigit(char))
+                        this.readDevanagariDigit();
+                    else
+                        this.readDevanagariIdentifier();
+                }
+                break;
+        }
+    }
+    /**
+     * Read character
+     */
+    readChar() {
+        if (this.isAtEnd())
+            return '\0';
+        return this.source.charAt(this.currentPos++);
+    }
+    /**
+     * Create token out of individual lexeme
+     * @param {TokenKind} kind
+     * @param {any} literal
+     */
+    createToken(kind, literal) {
+        if (literal === undefined)
+            literal = null;
+        const text = this.source.substring(this.startPos, this.currentPos);
+        this.tokens.push(new Token(kind, text, this.line));
+    }
+    /**
+     * Check if we've reached the end of file
+     */
+    isAtEnd() {
+        return this.currentPos >= this.source.length;
+    }
+    /**
+     * Peek next character
+     */
+    peekNextChar() {
+        if (this.isAtEnd())
+            return '\0';
+        return this.source.charAt(this.currentPos);
+    }
+    /**
+     * Get next character
+     */
+    getNextChar() {
+        return this.source.charAt(this.currentPos++);
+    }
+    /**
+     * Check if the character is devanagari character
+     * @param {string} char
+     */
+    isDevnagariChar(char) {
+        return (('\u{0900}' <= char && char <= '\u{097F}') ||
+            ('\u{A8E0}' <= char && char <= '\u{A8FF}'));
+    }
+    /**
+     * Check if the character is devanagari digit
+     * @param {string} char
+     */
+    isDevanagariDigit(char) {
+        return '\u{0966}' <= char && char <= '\u{096F}';
+    }
+    /**
+     * Read devanagari character sequence as number
+     */
+    readDevanagariDigit() {
+        while (this.isDevanagariDigit(this.peekNextChar()))
+            this.getNextChar();
+        const literal = this.source.substring(this.startPos, this.currentPos);
+        this.createToken(TokenKind.Number, literal);
+    }
+    /**
+     * Read devanagari character sequence as identifier
+     */
+    readDevanagariIdentifier() {
+        while (this.isDevnagariChar(this.peekNextChar()))
+            this.getNextChar();
+        const literal = this.source.substring(this.startPos, this.currentPos);
+        const keywordKind = keywords[literal];
+        if (keywordKind)
+            this.createToken(keywordKind, literal);
+        else
+            this.createToken(TokenKind.Identifier, literal);
+    }
+    /**
+     * Read string literals
+     */
+    readDevanagariString() {
+        while (this.peekNextChar() != '"' && !this.isAtEnd()) {
+            if (this.peekNextChar() === '\n')
+                this.line++;
+            this.getNextChar();
+        }
+        this.getNextChar();
+        const content = this.source.substring(this.startPos + 1, this.currentPos - 1);
+        this.createToken(TokenKind.String, content);
+    }
+}

package/dist/src/main.js

@@ -0,0 +1,27 @@
+import { readFileSync } from 'node:fs';
+import { Lexer } from './lexer.js';
+import { Parser } from './parser.js';
+import { Interpreter } from './interpreter.js';
+function getFileNameFromArgs(args) {
+    if (args.length > 1) {
+        console.log('> Too many arguments.');
+    }
+    const fileName = args[0] || null;
+    return fileName;
+}
+function execFile(path) {
+    const source = readFileSync(path, 'utf-8');
+    const lexer = new Lexer(source);
+    const tokens = lexer.readTokens();
+    const parser = new Parser(tokens);
+    const stmts = parser.parse();
+    const interpreter = new Interpreter();
+    interpreter.interpret(stmts);
+}
+function main() {
+    const fileName = getFileNameFromArgs(process.argv.slice(2));
+    if (fileName !== null) {
+        execFile(fileName);
+    }
+}
+main();

package/dist/src/parser.js

@@ -0,0 +1,77 @@
+import { LiteralExpr, PrintStmt, VariableExpr } from './ast.js';
+import { TokenKind } from './token.js';
+export class Parser {
+    tokens;
+    currentPos;
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.currentPos = 0;
+    }
+    parse() {
+        const stmts = [];
+        while (!this.isAtEnd()) {
+            stmts.push(this.parseStmt());
+        }
+        return stmts;
+    }
+    parseStmt() {
+        if (this.match(TokenKind.Print)) {
+            return this.parsePrintStmt();
+        }
+        throw this.error(this.peek(), 'Expression expected.');
+    }
+    parsePrintStmt() {
+        this.consume(TokenKind.OpenParen, "Expect '(' after 'छाप'");
+        const expr = this.parseExpression();
+        this.consume(TokenKind.CloseParen, "Expect ')' after expression");
+        return new PrintStmt(expr);
+    }
+    parseExpression() {
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        if (this.match(TokenKind.String, TokenKind.Number)) {
+            return new LiteralExpr(this.previous().lexeme);
+        }
+        if (this.match(TokenKind.Identifier)) {
+            return new VariableExpr(this.previous());
+        }
+        throw this.error(this.peek(), 'Expression expected.');
+    }
+    match(...kinds) {
+        for (const kind of kinds) {
+            if (this.check(kind)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+    consume(kind, message) {
+        if (this.check(kind))
+            return this.advance();
+        throw this.error(this.peek(), message);
+    }
+    check(kind) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().kind === kind;
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.currentPos++;
+        return this.previous();
+    }
+    peek() {
+        return this.tokens[this.currentPos];
+    }
+    previous() {
+        return this.tokens[this.currentPos - 1];
+    }
+    isAtEnd() {
+        return this.peek().kind === TokenKind.Eof;
+    }
+    error(token, message) {
+        return new Error(`> [line ${token.line}] Error: ${message}`);
+    }
+}

package/dist/src/token.js

@@ -0,0 +1,56 @@
+export var TokenKind;
+(function (TokenKind) {
+    TokenKind["Eof"] = "Eof";
+    TokenKind["Illegal"] = "Illegal";
+    /* -- Punctuation/Delimiters -- */
+    TokenKind["Comma"] = "Comma";
+    TokenKind["Colon"] = "Colon";
+    TokenKind["Period"] = "Period";
+    TokenKind["Semicolon"] = "Semicolon";
+    TokenKind["OpenParen"] = "OpenParen";
+    TokenKind["CloseParen"] = "CloseParen";
+    TokenKind["OpenCurly"] = "OpenCurly";
+    TokenKind["CloseCurly"] = "CloseCurly";
+    /* -- Operators -- */
+    TokenKind["Plus"] = "Plus";
+    TokenKind["Minus"] = "Minus";
+    TokenKind["Star"] = "Star";
+    TokenKind["Slash"] = "Slash";
+    TokenKind["Mod"] = "Mod";
+    TokenKind["Bang"] = "Bang";
+    TokenKind["Equal"] = "Equal";
+    /* -- Literals -- */
+    TokenKind["Number"] = "Number";
+    TokenKind["Character"] = "Character";
+    TokenKind["String"] = "String";
+    TokenKind["Identifier"] = "Identifier";
+    /* -- Keywords -- */
+    TokenKind["Let"] = "Let";
+    TokenKind["Function"] = "Function";
+    TokenKind["Print"] = "Print";
+    TokenKind["Return"] = "Return";
+    TokenKind["If"] = "If";
+    TokenKind["Else"] = "Else";
+    TokenKind["True"] = "True";
+    TokenKind["False"] = "False";
+})(TokenKind || (TokenKind = {}));
+export const keywords = {
+    मानौ: TokenKind.Let,
+    कार्य: TokenKind.Function,
+    छाप: TokenKind.Print,
+    यदि: TokenKind.If,
+    नभए: TokenKind.Else,
+    फिर्ता: TokenKind.Return,
+    सत्य: TokenKind.True,
+    असत्य: TokenKind.False
+};
+export class Token {
+    kind;
+    lexeme;
+    line;
+    constructor(kind, lexeme, line) {
+        this.kind = kind;
+        this.lexeme = lexeme;
+        this.line = line;
+    }
+}

package/examples/init.ga

@@ -0,0 +1,2 @@
+छाप("सोच्छौ के मेरो बारे?")
+छाप(१२३)

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "ga-lang",
+  "version": "1.1.0",
+  "description": "An interpreted toy programming language",
+  "type": "module",
+  "main": "dist/main.js",
+  "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",
+    "test": "pnpm run build && node --test ./dist/tests/**/*.js",
+    "ga": "pnpm run build && node dist/src/main.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/x-incubator/ga.git"
+  },
+  "keywords": [
+    "devanagari",
+    "nepali",
+    "nepali-programming-language",
+    "programming-language"
+  ],
+  "author": "Basanta Rai",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/x-incubator/ga/issues"
+  },
+  "homepage": "https://github.com/x-incubator/ga#readme",
+  "packageManager": "pnpm@10.25.0",
+  "engines": {
+    "node": ">=22.x.x",
+    "pnpm": ">=10.x.x"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "error"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3"
+  }
+}

package/src/ast.ts

@@ -0,0 +1,69 @@
+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;
+}
+
+export interface Stmt {
+  accept<T>(visitor: StmtVisitor<T>): T;
+}
+
+export interface StmtVisitor<T> {
+  visitPrintStmt(stmt: PrintStmt): T;
+  visitVarStmt(stmt: VarStmt): T;
+}
+
+export class VariableExpr implements Expr {
+  name: Token;
+
+  constructor(name: Token) {
+    this.name = name;
+  }
+
+  accept<T>(visitor: ExprVisitor<T>): T {
+    return visitor.visitVariableExpr(this);
+  }
+}
+
+export class LiteralExpr implements Expr {
+  value: any;
+
+  constructor(value: any) {
+    this.value = value;
+  }
+
+  accept<T>(visitor: ExprVisitor<T>): T {
+    return visitor.visitLiteralExpr(this);
+  }
+}
+
+export class PrintStmt implements Stmt {
+  expression: Expr;
+
+  constructor(expression: Expr) {
+    this.expression = expression;
+  }
+
+  accept<T>(visitor: StmtVisitor<T>): T {
+    return visitor.visitPrintStmt(this);
+  }
+}
+
+export class VarStmt implements Stmt {
+  name: Token;
+  initializer: Expr | null;
+
+  constructor(name: Token, initializer: Expr | null) {
+    this.name = name;
+    this.initializer = initializer;
+  }
+
+  accept<T>(visitor: StmtVisitor<T>): T {
+    return visitor.visitVarStmt(this);
+  }
+}

package/src/interpreter.ts

@@ -0,0 +1,53 @@
+import type {
+  Expr,
+  ExprVisitor,
+  LiteralExpr,
+  PrintStmt,
+  Stmt,
+  StmtVisitor,
+  VariableExpr,
+  VarStmt
+} from './ast.js';
+
+export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
+  interpret(statements: Stmt[]): void {
+    for (const statement of statements) {
+      this.execute(statement);
+    }
+  }
+
+  private execute(stmt: Stmt): void {
+    stmt.accept(this);
+  }
+
+  /*
+   * Process print statement
+   */
+  visitPrintStmt(stmt: PrintStmt): void {
+    const value = this.evaluate(stmt.expression);
+    console.log(value);
+  }
+
+  visitVarStmt(stmt: VarStmt): void {
+    // TODO: yet to implement
+  }
+
+  visitLiteralExpr(expr: LiteralExpr): any {
+    if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
+      return expr.value.slice(1, -1);
+    }
+
+    return expr.value;
+  }
+
+  visitVariableExpr(expr: VariableExpr): any {
+    // TODO: yet to implement
+  }
+
+  /*
+   * Evaluate an expression
+   */
+  private evaluate(expr: Expr): any {
+    return expr.accept(this);
+  }
+}

package/src/lexer.ts

@@ -0,0 +1,202 @@
+import { keywords, Token, TokenKind } from './token.js';
+
+export class Lexer {
+  private source: string;
+  private tokens: Token[];
+  private startPos: number;
+  private currentPos: number;
+  private line: number;
+
+  constructor(source: string) {
+    this.source = source;
+    this.tokens = [];
+    this.startPos = 0;
+    this.currentPos = 0;
+    this.line = 1;
+  }
+
+  /**
+   * Read tokens from source
+   */
+  readTokens(): Token[] {
+    while (!this.isAtEnd()) {
+      this.startPos = this.currentPos;
+      this.readToken();
+    }
+
+    this.tokens.push(new Token(TokenKind.Eof, '', this.line));
+    return this.tokens;
+  }
+
+  /**
+   * Read individual lexeme
+   */
+  readToken(): void {
+    const char = this.readChar();
+
+    switch (char) {
+      case ',':
+        this.createToken(TokenKind.Comma);
+        break;
+      case ':':
+        this.createToken(TokenKind.Colon);
+        break;
+      case '.':
+        this.createToken(TokenKind.Period);
+        break;
+      case ';':
+        this.createToken(TokenKind.Semicolon);
+        break;
+      case '(':
+        this.createToken(TokenKind.OpenParen);
+        break;
+      case ')':
+        this.createToken(TokenKind.CloseParen);
+        break;
+      case '{':
+        this.createToken(TokenKind.OpenCurly);
+        break;
+      case '}':
+        this.createToken(TokenKind.CloseCurly);
+        break;
+      case '+':
+        this.createToken(TokenKind.Plus);
+        break;
+      case '-':
+        this.createToken(TokenKind.Minus);
+        break;
+      case '*':
+        this.createToken(TokenKind.Star);
+        break;
+      case '/':
+        this.createToken(TokenKind.Slash);
+        break;
+      case '%':
+        this.createToken(TokenKind.Mod);
+        break;
+      case '!':
+        this.createToken(TokenKind.Bang);
+        break;
+      case '=':
+        this.createToken(TokenKind.Equal);
+        break;
+
+      /* Handle whitespaces */
+      case ' ':
+      case '\r':
+      case '\t':
+        break;
+      case '\n':
+        this.line++;
+        break;
+      case '"':
+        this.readDevanagariString();
+        break;
+      default:
+        if (this.isDevnagariChar(char)) {
+          if (this.isDevanagariDigit(char)) this.readDevanagariDigit();
+          else this.readDevanagariIdentifier();
+        }
+        break;
+    }
+  }
+
+  /**
+   * Read character
+   */
+  readChar(): string {
+    if (this.isAtEnd()) return '\0';
+    return this.source.charAt(this.currentPos++);
+  }
+
+  /**
+   * Create token out of individual lexeme
+   * @param {TokenKind} kind
+   * @param {any} literal
+   */
+  createToken(kind: TokenKind, literal?: any): void {
+    if (literal === undefined) literal = null;
+    const text = this.source.substring(this.startPos, this.currentPos);
+    this.tokens.push(new Token(kind, text, this.line));
+  }
+
+  /**
+   * Check if we've reached the end of file
+   */
+  private isAtEnd(): boolean {
+    return this.currentPos >= this.source.length;
+  }
+
+  /**
+   * Peek next character
+   */
+  private peekNextChar(): string {
+    if (this.isAtEnd()) return '\0';
+    return this.source.charAt(this.currentPos);
+  }
+
+  /**
+   * Get next character
+   */
+  private getNextChar(): string {
+    return this.source.charAt(this.currentPos++);
+  }
+
+  /**
+   * Check if the character is devanagari character
+   * @param {string} char
+   */
+  private isDevnagariChar(char: string): boolean {
+    return (
+      ('\u{0900}' <= char && char <= '\u{097F}') ||
+      ('\u{A8E0}' <= char && char <= '\u{A8FF}')
+    );
+  }
+
+  /**
+   * Check if the character is devanagari digit
+   * @param {string} char
+   */
+  private isDevanagariDigit(char: string): boolean {
+    return '\u{0966}' <= char && char <= '\u{096F}';
+  }
+
+  /**
+   * Read devanagari character sequence as number
+   */
+  private readDevanagariDigit(): void {
+    while (this.isDevanagariDigit(this.peekNextChar())) this.getNextChar();
+    const literal = this.source.substring(this.startPos, this.currentPos);
+
+    this.createToken(TokenKind.Number, literal);
+  }
+
+  /**
+   * Read devanagari character sequence as identifier
+   */
+  private readDevanagariIdentifier(): void {
+    while (this.isDevnagariChar(this.peekNextChar())) this.getNextChar();
+    const literal = this.source.substring(this.startPos, this.currentPos);
+
+    const keywordKind = keywords[literal];
+    if (keywordKind) this.createToken(keywordKind, literal);
+    else this.createToken(TokenKind.Identifier, literal);
+  }
+
+  /**
+   * Read string literals
+   */
+  private readDevanagariString(): void {
+    while (this.peekNextChar() != '"' && !this.isAtEnd()) {
+      if (this.peekNextChar() === '\n') this.line++;
+      this.getNextChar();
+    }
+
+    this.getNextChar();
+    const content = this.source.substring(
+      this.startPos + 1,
+      this.currentPos - 1
+    );
+    this.createToken(TokenKind.String, content);
+  }
+}

package/src/main.ts

@@ -0,0 +1,34 @@
+import { readFileSync } from 'node:fs';
+import { Lexer } from './lexer.js';
+import { Parser } from './parser.js';
+import { Interpreter } from './interpreter.js';
+
+function getFileNameFromArgs(args: string[]): string | null {
+  if (args.length > 1) {
+    console.log('> Too many arguments.');
+  }
+
+  const fileName = args[0] || null;
+  return fileName;
+}
+
+function execFile(path: string): void {
+  const source = readFileSync(path, 'utf-8');
+  const lexer = new Lexer(source);
+  const tokens = lexer.readTokens();
+
+  const parser = new Parser(tokens);
+  const stmts = parser.parse();
+
+  const interpreter = new Interpreter();
+  interpreter.interpret(stmts);
+}
+
+function main(): void {
+  const fileName = getFileNameFromArgs(process.argv.slice(2));
+  if (fileName !== null) {
+    execFile(fileName);
+  }
+}
+
+main();

package/src/parser.ts

@@ -0,0 +1,99 @@
+import {
+  LiteralExpr,
+  PrintStmt,
+  VariableExpr,
+  type Expr,
+  type Stmt
+} from './ast.js';
+import { TokenKind, type Token } from './token.js';
+
+export class Parser {
+  private tokens: Token[];
+  private currentPos: number;
+
+  constructor(tokens: Token[]) {
+    this.tokens = tokens;
+    this.currentPos = 0;
+  }
+
+  parse(): Stmt[] {
+    const stmts: Stmt[] = [];
+    while (!this.isAtEnd()) {
+      stmts.push(this.parseStmt());
+    }
+
+    return stmts;
+  }
+
+  private parseStmt(): Stmt {
+    if (this.match(TokenKind.Print)) {
+      return this.parsePrintStmt();
+    }
+
+    throw this.error(this.peek(), 'Expression expected.');
+  }
+
+  private parsePrintStmt(): Stmt {
+    this.consume(TokenKind.OpenParen, "Expect '(' after 'छाप'");
+    const expr = this.parseExpression();
+    this.consume(TokenKind.CloseParen, "Expect ')' after expression");
+    return new PrintStmt(expr);
+  }
+
+  private parseExpression(): Expr {
+    return this.parsePrimary();
+  }
+
+  private parsePrimary(): Expr {
+    if (this.match(TokenKind.String, TokenKind.Number)) {
+      return new LiteralExpr(this.previous().lexeme);
+    }
+
+    if (this.match(TokenKind.Identifier)) {
+      return new VariableExpr(this.previous());
+    }
+
+    throw this.error(this.peek(), 'Expression expected.');
+  }
+
+  private match(...kinds: TokenKind[]): boolean {
+    for (const kind of kinds) {
+      if (this.check(kind)) {
+        this.advance();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private consume(kind: TokenKind, message: string): Token {
+    if (this.check(kind)) return this.advance();
+    throw this.error(this.peek(), message);
+  }
+
+  private check(kind: TokenKind): boolean {
+    if (this.isAtEnd()) return false;
+    return this.peek().kind === kind;
+  }
+
+  private advance(): Token {
+    if (!this.isAtEnd()) this.currentPos++;
+    return this.previous();
+  }
+
+  private peek(): Token {
+    return this.tokens[this.currentPos]!;
+  }
+
+  private previous(): Token {
+    return this.tokens[this.currentPos - 1]!;
+  }
+
+  private isAtEnd(): boolean {
+    return this.peek().kind === TokenKind.Eof;
+  }
+
+  private error(token: Token, message: string): Error {
+    return new Error(`> [line ${token.line}] Error: ${message}`);
+  }
+}

package/src/token.ts

@@ -0,0 +1,62 @@
+export enum TokenKind {
+  Eof = 'Eof',
+  Illegal = 'Illegal',
+
+  /* -- Punctuation/Delimiters -- */
+  Comma = 'Comma',
+  Colon = 'Colon',
+  Period = 'Period',
+  Semicolon = 'Semicolon',
+  OpenParen = 'OpenParen',
+  CloseParen = 'CloseParen',
+  OpenCurly = 'OpenCurly',
+  CloseCurly = 'CloseCurly',
+
+  /* -- Operators -- */
+  Plus = 'Plus',
+  Minus = 'Minus',
+  Star = 'Star',
+  Slash = 'Slash',
+  Mod = 'Mod',
+  Bang = 'Bang',
+  Equal = 'Equal',
+
+  /* -- Literals -- */
+  Number = 'Number',
+  Character = 'Character',
+  String = 'String',
+  Identifier = 'Identifier',
+
+  /* -- Keywords -- */
+  Let = 'Let',
+  Function = 'Function',
+  Print = 'Print',
+  Return = 'Return',
+  If = 'If',
+  Else = 'Else',
+  True = 'True',
+  False = 'False'
+}
+
+export const keywords: Record<string, TokenKind> = {
+  मानौ: TokenKind.Let,
+  कार्य: TokenKind.Function,
+  छाप: TokenKind.Print,
+  यदि: TokenKind.If,
+  नभए: TokenKind.Else,
+  फिर्ता: TokenKind.Return,
+  सत्य: TokenKind.True,
+  असत्य: TokenKind.False
+};
+
+export class Token {
+  kind: TokenKind;
+  lexeme: string;
+  line: number;
+
+  constructor(kind: TokenKind, lexeme: string, line: number) {
+    this.kind = kind;
+    this.lexeme = lexeme;
+    this.line = line;
+  }
+}

package/tests/lexer.test.ts

@@ -0,0 +1,88 @@
+import test, { describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { Lexer } from '../src/lexer.js';
+import { Token, TokenKind } from '../src/token.js';
+
+describe('Lexer', () => {
+  test('scan punctuations & delimeters', () => {
+    const source: string = `,:.;(){}`;
+
+    const lexer: Lexer = new Lexer(source.trim());
+    const actual = lexer.readTokens();
+
+    const expected: Token[] = [
+      new Token(TokenKind.Comma, ',', 1),
+      new Token(TokenKind.Colon, ':', 1),
+      new Token(TokenKind.Period, '.', 1),
+      new Token(TokenKind.Semicolon, ';', 1),
+      new Token(TokenKind.OpenParen, '(', 1),
+      new Token(TokenKind.CloseParen, ')', 1),
+      new Token(TokenKind.OpenCurly, '{', 1),
+      new Token(TokenKind.CloseCurly, '}', 1),
+      new Token(TokenKind.Eof, '', 1)
+    ];
+
+    assert.equal(actual.length, expected.length);
+    assert.deepEqual(actual, expected);
+  });
+
+  test('scan operators', () => {
+    const source: string = `+-*/%!=`;
+
+    const lexer: Lexer = new Lexer(source.trim());
+    const actual = lexer.readTokens();
+
+    const expected: Token[] = [
+      new Token(TokenKind.Plus, '+', 1),
+      new Token(TokenKind.Minus, '-', 1),
+      new Token(TokenKind.Star, '*', 1),
+      new Token(TokenKind.Slash, '/', 1),
+      new Token(TokenKind.Mod, '%', 1),
+      new Token(TokenKind.Bang, '!', 1),
+      new Token(TokenKind.Equal, '=', 1),
+      new Token(TokenKind.Eof, '', 1)
+    ];
+
+    assert.equal(actual.length, expected.length);
+    assert.deepEqual(actual, expected);
+  });
+
+  test('scan literals & keywords', () => {
+    const source: string = `कार्य काम() {
+    सन्देश = "सोच्छौ के मेरो बारे?"
+    छाप(सन्देश)
+    छाप(१२३)
+    }
+    काम() `;
+
+    const lexer: Lexer = new Lexer(source.trim());
+    const actual = lexer.readTokens();
+
+    const expected: Token[] = [
+      new Token(TokenKind.Function, 'कार्य', 1),
+      new Token(TokenKind.Identifier, 'काम', 1),
+      new Token(TokenKind.OpenParen, '(', 1),
+      new Token(TokenKind.CloseParen, ')', 1),
+      new Token(TokenKind.OpenCurly, '{', 1),
+      new Token(TokenKind.Identifier, 'सन्देश', 2),
+      new Token(TokenKind.Equal, '=', 2),
+      new Token(TokenKind.String, '"सोच्छौ के मेरो बारे?"', 2),
+      new Token(TokenKind.Print, 'छाप', 3),
+      new Token(TokenKind.OpenParen, '(', 3),
+      new Token(TokenKind.Identifier, 'सन्देश', 3),
+      new Token(TokenKind.CloseParen, ')', 3),
+      new Token(TokenKind.Print, 'छाप', 4),
+      new Token(TokenKind.OpenParen, '(', 4),
+      new Token(TokenKind.Number, '१२३', 4),
+      new Token(TokenKind.CloseParen, ')', 4),
+      new Token(TokenKind.CloseCurly, '}', 5),
+      new Token(TokenKind.Identifier, 'काम', 6),
+      new Token(TokenKind.OpenParen, '(', 6),
+      new Token(TokenKind.CloseParen, ')', 6),
+      new Token(TokenKind.Eof, '', 6)
+    ];
+
+    assert.equal(actual.length, expected.length);
+    assert.deepEqual(actual, expected);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    /* Base Options: */
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "target": "es2022",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+
+    /* Strictness */
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    /* Transpiling */
+    "module": "NodeNext",
+    "rootDir": ".",
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*.ts", "tests/**/*.test.ts"],
+  "exclude": ["node_modules", "dist"]
+}