ga-lang 1.2.3 → 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/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/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/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/package.json

@@ -1,9 +1,10 @@
 {
   "name": "ga-lang",
-  "version": "1.2.3",
+  "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"
   },
@@ -12,12 +13,13 @@
     "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",
+    "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",
@@ -28,14 +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",

package/src/main.ts

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

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"]
+}