@ugo-studio/jspp 0.2.4 → 0.2.6

package/dist/core/codegen/statement-handlers.js

@@ -1,6 +1,8 @@
 import ts from "typescript";
 import { DeclaredSymbols } from "../../ast/symbols.js";
-import { collectBlockScopedDeclarations, collectFunctionScopedDeclarations, } from "./helpers.js";
+import { constants } from "../constants.js";
+import { CompilerError } from "../error.js";
+import { collectBlockScopedDeclarations, collectFunctionScopedDeclarations, shouldIgnoreStatement, } from "./helpers.js";
 import { CodeGenerator } from "./index.js";
 export function visitSourceFile(node, context) {
     const sourceFile = node;
@@ -8,27 +10,32 @@ export function visitSourceFile(node, context) {
     // 1. Collect all var declarations (recursively) + top-level let/const
     const varDecls = collectFunctionScopedDeclarations(sourceFile);
     const topLevelLetConst = collectBlockScopedDeclarations(sourceFile.statements);
-    const funcDecls = sourceFile.statements.filter(ts.isFunctionDeclaration);
+    const funcDecls = sourceFile.statements.filter((s) => ts.isFunctionDeclaration(s) && !!s.body);
     const classDecls = sourceFile.statements.filter(ts.isClassDeclaration);
+    const enumDecls = sourceFile.statements.filter(ts.isEnumDeclaration);
     const hoistedSymbols = new DeclaredSymbols();
     // Hoist function declarations
     funcDecls.forEach((func) => {
-        code += this.hoistDeclaration(func, hoistedSymbols);
+        code += this.hoistDeclaration(func, hoistedSymbols, node);
     });
     // Hoist class declarations
     classDecls.forEach((cls) => {
-        code += this.hoistDeclaration(cls, hoistedSymbols);
+        code += this.hoistDeclaration(cls, hoistedSymbols, node);
+    });
+    // Hoist enum declarations
+    enumDecls.forEach((enm) => {
+        code += this.hoistDeclaration(enm, hoistedSymbols, node);
     });
     // Hoist variable declarations (var)
     varDecls.forEach((decl) => {
-        code += this.hoistDeclaration(decl, hoistedSymbols);
+        code += this.hoistDeclaration(decl, hoistedSymbols, node);
     });
     // Hoist top-level let/const
     topLevelLetConst.forEach((decl) => {
-        code += this.hoistDeclaration(decl, hoistedSymbols);
+        code += this.hoistDeclaration(decl, hoistedSymbols, node);
     });
     // Compile symbols for other statements (excluding function)
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
     const localScopeSymbols = new DeclaredSymbols(hoistedSymbols); // hoistedSymbols becomes new local
     // 2. Assign all hoisted functions first
     const contextForFunctions = {
@@ -37,13 +44,29 @@ export function visitSourceFile(node, context) {
     };
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
-        if (funcName) {
-            this.markSymbolAsChecked(funcName, contextForFunctions.topLevelScopeSymbols, contextForFunctions.localScopeSymbols);
-            this.markSymbolAsChecked(funcName, topLevelScopeSymbols, localScopeSymbols);
-            const lambda = this.generateLambda(stmt, contextForFunctions, {
-                isAssignment: true,
-            });
-            code += `${this.indent()}*${funcName} = ${lambda};\n`;
+        if (!funcName)
+            return;
+        const symbol = hoistedSymbols.get(funcName);
+        if (!symbol)
+            return;
+        // Mark before further visits
+        this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
+        this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Generate and update self name
+        const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        hoistedSymbols.update(funcName, { func: { nativeName } });
+        // Generate lambda
+        const lambda = this.generateLambda(stmt, contextForFunctions, {
+            isAssignment: true,
+            generateOnlyLambda: true,
+            nativeName,
+        });
+        code += `${this.indent()}auto ${nativeName} = ${lambda};\n`;
+        // Generate AnyValue wrapper
+        if (this.isFunctionUsedAsValue(stmt, node) ||
+            this.isFunctionUsedBeforeDeclaration(funcName, node)) {
+            const fullExpression = this.generateFullLambdaExpression(stmt, contextForFunctions, nativeName, { isAssignment: true, noTypeSignature: true });
+            code += `${this.indent()}*${funcName} = ${fullExpression};\n`;
         }
     });
     // 3. Process other statements
@@ -52,25 +75,17 @@ export function visitSourceFile(node, context) {
             // Already handled
         }
         else if (ts.isVariableStatement(stmt)) {
-            const isLetOrConst = (stmt.declarationList.flags &
-                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-                0;
-            const contextForVisit = {
+            code += this.visit(stmt, {
                 ...context,
-                topLevelScopeSymbols,
+                globalScopeSymbols,
                 localScopeSymbols,
-                isAssignmentOnly: !isLetOrConst,
-            };
-            const assignments = this.visit(stmt.declarationList, contextForVisit);
-            if (assignments) {
-                code += `${this.indent()}${assignments};\n`;
-            }
+            });
         }
         else {
             code += this.visit(stmt, {
                 ...context,
                 isFunctionBody: false,
-                topLevelScopeSymbols,
+                globalScopeSymbols,
                 localScopeSymbols,
             });
         }
@@ -78,28 +93,34 @@ export function visitSourceFile(node, context) {
     return code;
 }
 export function visitBlock(node, context) {
+    context.currentScopeNode = node; // Update scope node
     let code = `${this.indent()}{\n`;
     this.indentationLevel++;
     const block = node;
     // Collect ONLY block-scoped declarations (let/const)
     const blockScopedDecls = collectBlockScopedDeclarations(block.statements);
-    const funcDecls = block.statements.filter(ts.isFunctionDeclaration);
+    const funcDecls = block.statements.filter((s) => ts.isFunctionDeclaration(s) && !!s.body);
     const classDecls = block.statements.filter(ts.isClassDeclaration);
+    const enumDecls = block.statements.filter(ts.isEnumDeclaration);
     const hoistedSymbols = new DeclaredSymbols();
     // 1. Hoist all function declarations
     funcDecls.forEach((func) => {
-        code += this.hoistDeclaration(func, hoistedSymbols);
+        code += this.hoistDeclaration(func, hoistedSymbols, node);
     });
     // Hoist class declarations
     classDecls.forEach((cls) => {
-        code += this.hoistDeclaration(cls, hoistedSymbols);
+        code += this.hoistDeclaration(cls, hoistedSymbols, node);
+    });
+    // Hoist enum declarations
+    enumDecls.forEach((enm) => {
+        code += this.hoistDeclaration(enm, hoistedSymbols, node);
     });
     // Hoist variable declarations (let/const only)
     blockScopedDecls.forEach((decl) => {
-        code += this.hoistDeclaration(decl, hoistedSymbols);
+        code += this.hoistDeclaration(decl, hoistedSymbols, node);
     });
     // Compile symbols for other statements (excluding function)
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
     const localScopeSymbols = new DeclaredSymbols(hoistedSymbols); // hoistedSymbols becomes new local
     // 2. Assign all hoisted functions first
     const contextForFunctions = {
@@ -108,13 +129,29 @@ export function visitBlock(node, context) {
     };
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
-        if (funcName) {
-            this.markSymbolAsChecked(funcName, contextForFunctions.topLevelScopeSymbols, contextForFunctions.localScopeSymbols);
-            this.markSymbolAsChecked(funcName, topLevelScopeSymbols, localScopeSymbols);
-            const lambda = this.generateLambda(stmt, contextForFunctions, {
-                isAssignment: true,
-            });
-            code += `${this.indent()}*${funcName} = ${lambda};\n`;
+        if (!funcName)
+            return;
+        const symbol = hoistedSymbols.get(funcName);
+        if (!symbol)
+            return;
+        // Mark before further visits
+        this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
+        this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Generate and update self name
+        const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        hoistedSymbols.update(funcName, { func: { nativeName } });
+        // Generate lambda
+        const lambda = this.generateLambda(stmt, contextForFunctions, {
+            isAssignment: true,
+            generateOnlyLambda: true,
+            nativeName,
+        });
+        code += `${this.indent()}auto ${nativeName} = ${lambda};\n`;
+        // Generate AnyValue wrapper
+        if (this.isFunctionUsedAsValue(stmt, node) ||
+            this.isFunctionUsedBeforeDeclaration(funcName, node)) {
+            const fullExpression = this.generateFullLambdaExpression(stmt, contextForFunctions, nativeName, { isAssignment: true, noTypeSignature: true });
+            code += `${this.indent()}*${funcName} = ${fullExpression};\n`;
         }
     });
     // 3. Process other statements
@@ -123,25 +160,17 @@ export function visitBlock(node, context) {
             // Do nothing, already handled
         }
         else if (ts.isVariableStatement(stmt)) {
-            const isLetOrConst = (stmt.declarationList.flags &
-                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-                0;
-            const contextForVisit = {
+            code += this.visit(stmt, {
                 ...context,
-                topLevelScopeSymbols,
+                globalScopeSymbols,
                 localScopeSymbols,
-                isAssignmentOnly: !isLetOrConst,
-            };
-            const assignments = this.visit(stmt.declarationList, contextForVisit);
-            if (assignments) {
-                code += `${this.indent()}${assignments};\n`;
-            }
+            });
         }
         else {
             code += this.visit(stmt, {
                 ...context,
                 isFunctionBody: false,
-                topLevelScopeSymbols,
+                globalScopeSymbols,
                 localScopeSymbols,
             });
         }
@@ -157,9 +186,87 @@ export function visitBlock(node, context) {
     return code;
 }
 export function visitVariableStatement(node, context) {
-    return (this.indent() +
-        this.visit(node.declarationList, context) +
-        ";\n");
+    if (shouldIgnoreStatement(node)) {
+        return "";
+    }
+    const isLetOrConst = (node.declarationList.flags &
+        (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+        0;
+    const visitContext = {
+        ...context,
+        isAssignmentOnly: !isLetOrConst,
+    };
+    const assignments = this.visit(node.declarationList, visitContext);
+    if (assignments) {
+        return `${this.indent()}${assignments};\n`;
+    }
+    return "";
+}
+export function visitTypeAliasDeclaration(node, context) {
+    return "";
+}
+export function visitInterfaceDeclaration(node, context) {
+    return "";
+}
+export function visitEnumDeclaration(node, context) {
+    const name = node.name.getText();
+    const scope = this.getScopeForNode(node);
+    const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+    // Mark as initialized
+    this.markSymbolAsInitialized(name, context.globalScopeSymbols, context.localScopeSymbols);
+    const enumVar = typeInfo.needsHeapAllocation ? `(*${name})` : name;
+    let code = `${this.indent()}${enumVar} = jspp::AnyValue::make_object({});\n`;
+    code += `${this.indent()}{\n`;
+    this.indentationLevel++;
+    code +=
+        `${this.indent()}jspp::AnyValue lastVal = jspp::AnyValue::make_number(-1);\n`; // Previous value tracker
+    for (const member of node.members) {
+        const memberName = member.name.getText();
+        let valueCode = "";
+        // Handle member name (it could be a string literal or identifier)
+        let key = "";
+        if (ts.isIdentifier(member.name)) {
+            key = `"${memberName}"`;
+        }
+        else if (ts.isStringLiteral(member.name)) {
+            key = member.name.getText(); // Includes quotes
+        }
+        else {
+            // Computed property names or numeric literals in enums are rarer but possible
+            // For now assume simple enum
+            key = `"${memberName}"`;
+        }
+        if (member.initializer) {
+            // Visit initializer
+            valueCode = this.visit(member.initializer, context);
+        }
+        else {
+            // Auto-increment
+            valueCode = `lastVal + 1`;
+        }
+        code += `${this.indent()}lastVal = ${valueCode};\n`;
+        code +=
+            `${this.indent()}${enumVar}.set_own_property(${key}, lastVal);\n`;
+        // Reverse mapping for numeric enums
+        code += `${this.indent()}if (lastVal.is_number()) {\n`;
+        this.indentationLevel++;
+        code +=
+            `${this.indent()}${enumVar}.set_own_property(lastVal, jspp::AnyValue::make_string(${key}));\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+    }
+    this.indentationLevel--;
+    code += `${this.indent()}}\n`;
+    return code;
+}
+export function visitModuleDeclaration(node, context) {
+    return "";
+}
+export function visitImportDeclaration(node, context) {
+    return "";
+}
+export function visitImportEqualsDeclaration(node, context) {
+    return "";
 }
 export function visitBreakStatement(node, context) {
     if (node.label) {
@@ -204,7 +311,12 @@ export function visitLabeledStatement(node, context) {
 }
 export function visitIfStatement(node, context) {
     const ifStmt = node;
-    const condition = this.visit(ifStmt.expression, context);
+    const isBinaryExpression = ts.isBinaryExpression(ifStmt.expression) &&
+        constants.booleanOperators.includes(ifStmt.expression.operatorToken.kind);
+    const condition = this.visit(ifStmt.expression, {
+        ...context,
+        supportedNativeLiterals: isBinaryExpression ? ["boolean"] : undefined,
+    });
     const thenStmt = this.visit(ifStmt.thenStatement, {
         ...context,
         isFunctionBody: false,
@@ -217,7 +329,10 @@ export function visitIfStatement(node, context) {
                 isFunctionBody: false,
             });
     }
-    return `${this.indent()}if (is_truthy(${condition})) ${thenStmt}${elseStmt}`;
+    if (isBinaryExpression) {
+        return `${this.indent()}if (${condition}) ${thenStmt}${elseStmt}`;
+    }
+    return `${this.indent()}if (jspp::is_truthy(${condition})) ${thenStmt}${elseStmt}`;
 }
 export function visitExpressionStatement(node, context) {
     return (this.indent() +
@@ -234,7 +349,7 @@ export function visitTryStatement(node, context) {
     const tryStmt = node;
     if (context.isInsideAsyncFunction) {
         if (tryStmt.finallyBlock) {
-            const declaredSymbols = new Set(context.topLevelScopeSymbols.toSet());
+            const declaredSymbols = new Set(context.globalScopeSymbols.names);
             this.getDeclaredSymbols(tryStmt.tryBlock).forEach((s) => declaredSymbols.add(s));
             if (tryStmt.catchClause) {
                 this.getDeclaredSymbols(tryStmt.catchClause).forEach((s) => declaredSymbols.add(s));
@@ -339,7 +454,7 @@ export function visitTryStatement(node, context) {
             return code;
         }
         else {
-            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
+            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.globalScopeSymbols, context.localScopeSymbols);
             const newContext = {
                 ...context,
                 isFunctionBody: false,
@@ -405,7 +520,7 @@ export function visitTryStatement(node, context) {
         }
     }
     if (tryStmt.finallyBlock) {
-        const declaredSymbols = new Set(context.topLevelScopeSymbols.toSet());
+        const declaredSymbols = new Set(context.globalScopeSymbols.names);
         this.getDeclaredSymbols(tryStmt.tryBlock).forEach((s) => declaredSymbols.add(s));
         if (tryStmt.catchClause) {
             this.getDeclaredSymbols(tryStmt.catchClause).forEach((s) => declaredSymbols.add(s));
@@ -440,7 +555,7 @@ export function visitTryStatement(node, context) {
         this.indentationLevel--;
         code += `${this.indent()}}\n`;
         if (tryStmt.catchClause) {
-            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
+            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText(), context.globalScopeSymbols, context.localScopeSymbols);
             const catchContext = { ...innerContext, exceptionName };
             code +=
                 `${this.indent()}catch (const std::exception& ${exceptionName}) {\n`;
@@ -476,7 +591,7 @@ export function visitTryStatement(node, context) {
         return code;
     }
     else {
-        const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.topLevelScopeSymbols, context.localScopeSymbols);
+        const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText(), context.globalScopeSymbols, context.localScopeSymbols);
         const newContext = {
             ...context,
             isFunctionBody: false,
@@ -497,7 +612,7 @@ export function visitCatchClause(node, context) {
     const exceptionName = context.exceptionName;
     if (!exceptionName) {
         // This should not happen if it's coming from a TryStatement
-        throw new Error("Compiler bug: exceptionName not found in context for CatchClause");
+        throw new CompilerError("exceptionName not found in context for CatchClause", node, "CompilerBug");
     }
     if (catchClause.variableDeclaration) {
         const varName = catchClause.variableDeclaration.name.getText();
@@ -540,7 +655,7 @@ export function visitYieldExpression(node, context) {
             let code = `${this.indent()}{\n`;
             this.indentationLevel++;
             const declaredSymbols = this.getDeclaredSymbols(expr);
-            context.topLevelScopeSymbols.toSet().forEach((s) => declaredSymbols.add(s));
+            context.globalScopeSymbols.names.forEach((s) => declaredSymbols.add(s));
             const iterableRef = this.generateUniqueName("__iter_ref", declaredSymbols);
             const iterator = this.generateUniqueName("__iter", declaredSymbols);
             const nextFunc = this.generateUniqueName("__next_func", declaredSymbols);
@@ -566,7 +681,7 @@ export function visitYieldExpression(node, context) {
                     `${this.indent()}auto ${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
             }
             code +=
-                `${this.indent()}while (!is_truthy(${nextRes}.get_own_property("done"))) {\n`;
+                `${this.indent()}while (!jspp::is_truthy(${nextRes}.get_own_property("done"))) {\n`;
             this.indentationLevel++;
             if (context.isInsideAsyncFunction) {
                 code +=

package/dist/core/codegen/visitor.js

@@ -2,11 +2,11 @@ import ts from "typescript";
 import { visitClassDeclaration } from "./class-handlers.js";
 import { visitCaseClause, visitDefaultClause, visitDoStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitSwitchStatement, visitWhileStatement, } from "./control-flow-handlers.js";
 import { visitVariableDeclaration, visitVariableDeclarationList, } from "./declaration-handlers.js";
-import { visitArrayLiteralExpression, visitAwaitExpression, visitBinaryExpression, visitCallExpression, visitConditionalExpression, visitDeleteExpression, visitElementAccessExpression, visitNewExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, visitTypeOfExpression, visitVoidExpression, } from "./expression-handlers.js";
+import { visitArrayLiteralExpression, visitAsExpression, visitAwaitExpression, visitBinaryExpression, visitCallExpression, visitConditionalExpression, visitDeleteExpression, visitElementAccessExpression, visitNewExpression, visitNonNullExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitSatisfiesExpression, visitTemplateExpression, visitTypeAssertionExpression, visitTypeOfExpression, visitVoidExpression, } from "./expression-handlers.js";
 import { visitArrowFunction, visitFunctionDeclaration, visitFunctionExpression, } from "./function-handlers.js";
 import { CodeGenerator } from "./index.js";
 import { visitFalseKeyword, visitIdentifier, visitNoSubstitutionTemplateLiteral, visitNullKeyword, visitNumericLiteral, visitStringLiteral, visitThisKeyword, visitTrueKeyword, visitUndefinedKeyword, } from "./literal-handlers.js";
-import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitExpressionStatement, visitIfStatement, visitLabeledStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, visitYieldExpression, } from "./statement-handlers.js";
+import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitEnumDeclaration, visitExpressionStatement, visitIfStatement, visitImportDeclaration, visitImportEqualsDeclaration, visitInterfaceDeclaration, visitLabeledStatement, visitModuleDeclaration, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitTypeAliasDeclaration, visitVariableStatement, visitYieldExpression, } from "./statement-handlers.js";
 export function visit(node, context) {
     if (ts.isFunctionDeclaration(node)) {
         return visitFunctionDeclaration.call(this, node, context);
@@ -114,6 +114,26 @@ export function visit(node, context) {
             return visitNullKeyword.call(this);
         case ts.SyntaxKind.ThisKeyword:
             return visitThisKeyword.call(this);
+        case ts.SyntaxKind.AsExpression:
+            return visitAsExpression.call(this, node, context);
+        case ts.SyntaxKind.TypeAssertionExpression:
+            return visitTypeAssertionExpression.call(this, node, context);
+        case ts.SyntaxKind.NonNullExpression:
+            return visitNonNullExpression.call(this, node, context);
+        case ts.SyntaxKind.SatisfiesExpression:
+            return visitSatisfiesExpression.call(this, node, context);
+        case ts.SyntaxKind.TypeAliasDeclaration:
+            return visitTypeAliasDeclaration.call(this, node, context);
+        case ts.SyntaxKind.InterfaceDeclaration:
+            return visitInterfaceDeclaration.call(this, node, context);
+        case ts.SyntaxKind.EnumDeclaration:
+            return visitEnumDeclaration.call(this, node, context);
+        case ts.SyntaxKind.ModuleDeclaration:
+            return visitModuleDeclaration.call(this, node, context);
+        case ts.SyntaxKind.ImportDeclaration:
+            return visitImportDeclaration.call(this, node, context);
+        case ts.SyntaxKind.ImportEqualsDeclaration:
+            return visitImportEqualsDeclaration.call(this, node, context);
         default:
             return `/* Unhandled node: ${ts.SyntaxKind[node.kind]} */`;
     }

package/dist/core/constants.js

@@ -0,0 +1,16 @@
+import ts from "typescript";
+const booleanOperators = [
+    ts.SyntaxKind.EqualsEqualsEqualsToken,
+    ts.SyntaxKind.EqualsEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsToken,
+    ts.SyntaxKind.InstanceOfKeyword,
+    ts.SyntaxKind.InKeyword,
+    ts.SyntaxKind.LessThanToken,
+    ts.SyntaxKind.LessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanToken,
+    ts.SyntaxKind.GreaterThanEqualsToken,
+];
+export const constants = Object.freeze({
+    booleanOperators,
+});

package/dist/core/error.js

@@ -0,0 +1,58 @@
+import ts from "typescript";
+const COLORS = {
+    reset: "\x1b[0m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    cyan: "\x1b[36m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+};
+export class CompilerError extends Error {
+    node;
+    type;
+    constructor(message, node, type = "SyntaxError") {
+        super(message);
+        this.node = node;
+        this.type = type;
+        Object.setPrototypeOf(this, CompilerError.prototype);
+    }
+    getFormattedError() {
+        const sourceFile = this.node.getSourceFile();
+        if (!sourceFile) {
+            return `${COLORS.red}${this.type}: ${this.message}${COLORS.reset}`;
+        }
+        const start = this.node.getStart();
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+        // Get the full line content safely
+        const lineStartPos = sourceFile.getPositionOfLineAndCharacter(line, 0);
+        let lineEndPos;
+        try {
+            lineEndPos = sourceFile.getLineEndOfPosition(start);
+        }
+        catch {
+            lineEndPos = sourceFile.text.length;
+        }
+        const lineContent = sourceFile.text.substring(lineStartPos, lineEndPos).replace(/\r/g, ''); // Remove CR
+        const fileName = sourceFile.fileName;
+        const lineNum = line + 1;
+        const charNum = character + 1;
+        let output = `\n${COLORS.red}${COLORS.bold}${this.type}:${COLORS.reset} ${this.message}\n`;
+        output += `   ${COLORS.dim}at ${fileName}:${lineNum}:${charNum}${COLORS.reset}\n\n`;
+        // Code frame
+        const lineNumStr = `${lineNum} | `;
+        output += `${COLORS.dim}${lineNumStr}${COLORS.reset}${lineContent}\n`;
+        // Adjust pointer position if there are tabs
+        let pointerPadding = "";
+        for (let i = 0; i < character; i++) {
+            if (lineContent[i] === '\t') {
+                pointerPadding += "\t";
+            }
+            else {
+                pointerPadding += " ";
+            }
+        }
+        const padding = " ".repeat(lineNumStr.length) + pointerPadding;
+        output += `${padding}${COLORS.red}^${COLORS.reset}\n`;
+        return output;
+    }
+}

package/dist/core/parser.js

@@ -1,6 +1,6 @@
 import * as ts from "typescript";
 export class Parser {
-    parse(sourceCode) {
-        return ts.createSourceFile("temp.js", sourceCode, ts.ScriptTarget.Latest, true);
+    parse(sourceCode, fileName) {
+        return ts.createSourceFile(fileName || "temp.js", sourceCode, ts.ScriptTarget.Latest, true);
     }
 }

package/dist/index.js

@@ -6,10 +6,13 @@ export class Interpreter {
     parser = new Parser();
     analyzer = new TypeAnalyzer();
     generator = new CodeGenerator();
-    interpret(jsCode) {
-        const ast = this.parser.parse(jsCode);
+    interpret(code, fileName) {
+        const ast = this.parser.parse(code, fileName);
         this.analyzer.analyze(ast);
-        const cppCode = this.generator.generate(ast, this.analyzer);
+        const isTypescript = fileName
+            ? path.extname(fileName) === ".ts"
+            : false;
+        const cppCode = this.generator.generate(ast, this.analyzer, isTypescript);
         const preludePath = path.resolve(import.meta.dirname, "..", "src", "prelude");
         return { cppCode, preludePath };
     }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
   "type": "module",
   "bin": {
-    "jspp": "dist/cli.js"
+    "jspp": "dist/cli/index.js"
   },
   "files": [
     "dist",
@@ -15,7 +15,7 @@
   ],
   "scripts": {
     "postinstall": "bun run scripts/setup-compiler.ts",
-    "dev": "bun run src/cli.ts",
+    "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
     "precompile": "bun run scripts/precompile-headers.ts",
     "test": "bun test",