@ugo-studio/jspp 0.1.0

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

@@ -0,0 +1,485 @@
+import ts from "typescript";
+import { CodeGenerator } from "./";
+export function visitSourceFile(node, context) {
+    const sourceFile = node;
+    let code = "";
+    const varDecls = sourceFile.statements
+        .filter(ts.isVariableStatement)
+        .flatMap((stmt) => stmt.declarationList.declarations);
+    const funcDecls = sourceFile.statements.filter(ts.isFunctionDeclaration);
+    const hoistedSymbols = new Set();
+    // 1. Hoist function declarations
+    funcDecls.forEach((func) => {
+        const funcName = func.name?.getText();
+        if (funcName && !hoistedSymbols.has(funcName)) {
+            hoistedSymbols.add(funcName);
+            code +=
+                `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+        }
+    });
+    // Hoist variable declarations
+    varDecls.forEach((decl) => {
+        const name = decl.name.getText();
+        if (hoistedSymbols.has(name)) {
+            return;
+        }
+        hoistedSymbols.add(name);
+        const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+            0;
+        const initializer = isLetOrConst
+            ? "jspp::AnyValue::make_uninitialized()"
+            : "jspp::AnyValue::make_undefined()";
+        code +=
+            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+    });
+    // 2. Assign all hoisted functions first
+    funcDecls.forEach((stmt) => {
+        const funcName = stmt.name?.getText();
+        if (funcName) {
+            const lambda = this.generateLambda(stmt, true);
+            code += `${this.indent()}*${funcName} = ${lambda};\n`;
+        }
+    });
+    // 3. Process other statements
+    sourceFile.statements.forEach((stmt) => {
+        if (ts.isFunctionDeclaration(stmt)) {
+            // Already handled
+        }
+        else if (ts.isVariableStatement(stmt)) {
+            const isLetOrConst = (stmt.declarationList.flags &
+                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+                0;
+            const contextForVisit = {
+                ...context,
+                isAssignmentOnly: !isLetOrConst,
+            };
+            const assignments = this.visit(stmt.declarationList, contextForVisit);
+            if (assignments) {
+                code += `${this.indent()}${assignments};\n`;
+            }
+        }
+        else {
+            code += this.visit(stmt, context);
+        }
+    });
+    return code;
+}
+export function visitBlock(node, context) {
+    let code = "{\n";
+    this.indentationLevel++;
+    const block = node;
+    const varDecls = block.statements
+        .filter(ts.isVariableStatement)
+        .flatMap((stmt) => stmt.declarationList.declarations);
+    const funcDecls = block.statements.filter(ts.isFunctionDeclaration);
+    const hoistedSymbols = new Set();
+    // 1. Hoist all function declarations
+    funcDecls.forEach((func) => {
+        const funcName = func.name?.getText();
+        if (funcName && !hoistedSymbols.has(funcName)) {
+            hoistedSymbols.add(funcName);
+            code +=
+                `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+        }
+    });
+    // Hoist variable declarations
+    varDecls.forEach((decl) => {
+        const name = decl.name.getText();
+        if (hoistedSymbols.has(name)) {
+            return;
+        }
+        hoistedSymbols.add(name);
+        const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+            0;
+        const initializer = isLetOrConst
+            ? "jspp::AnyValue::make_uninitialized()"
+            : "jspp::AnyValue::make_undefined()";
+        code +=
+            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+    });
+    // 2. Assign all hoisted functions first
+    funcDecls.forEach((stmt) => {
+        const funcName = stmt.name?.getText();
+        if (funcName) {
+            const lambda = this.generateLambda(stmt, true);
+            code += `${this.indent()}*${funcName} = ${lambda};\n`;
+        }
+    });
+    // 3. Process other statements
+    block.statements.forEach((stmt) => {
+        if (ts.isFunctionDeclaration(stmt)) {
+            // Do nothing, already handled
+        }
+        else if (ts.isVariableStatement(stmt)) {
+            const isLetOrConst = (stmt.declarationList.flags &
+                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+                0;
+            const contextForVisit = {
+                ...context,
+                isAssignmentOnly: !isLetOrConst,
+            };
+            const assignments = this.visit(stmt.declarationList, contextForVisit);
+            if (assignments) {
+                code += `${this.indent()}${assignments};\n`;
+            }
+        }
+        else {
+            code += this.visit(stmt, context);
+        }
+    });
+    if (context.isFunctionBody) {
+        const lastStatement = block.statements[block.statements.length - 1];
+        if (!lastStatement || !ts.isReturnStatement(lastStatement)) {
+            code +=
+                `${this.indent()}return jspp::AnyValue::make_undefined();\n`;
+        }
+    }
+    this.indentationLevel--;
+    code += `${this.indent()}}\n`;
+    return code;
+}
+export function visitVariableStatement(node, context) {
+    return (this.indent() +
+        this.visit(node.declarationList, context) +
+        ";\n");
+}
+export function visitForStatement(node, context) {
+    const forStmt = node;
+    let code = "";
+    this.indentationLevel++; // Enter a new scope for the for loop
+    // Handle initializer
+    let initializerCode = "";
+    if (forStmt.initializer) {
+        if (ts.isVariableDeclarationList(forStmt.initializer)) {
+            const varDeclList = forStmt.initializer;
+            const isLetOrConst = (varDeclList.flags &
+                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+                0;
+            if (isLetOrConst) {
+                // For `let` or `const` in for loop, they are block-scoped to the loop.
+                // Declare the variable within the loop's scope.
+                // The C++ for loop initializer can contain a declaration.
+                const decl = varDeclList.declarations[0]; // Assuming single declaration for simplicity
+                if (decl) {
+                    const name = decl.name.getText();
+                    const initValue = decl.initializer
+                        ? this.visit(decl.initializer, context)
+                        : "jspp::AnyValue::make_undefined()";
+                    initializerCode =
+                        `auto ${name} = std::make_unique<jspp::AnyValue>(${initValue})`;
+                }
+            }
+            else {
+                // For 'var', it's already hoisted, so this is an assignment.
+                initializerCode = this.visit(forStmt.initializer, {
+                    ...context,
+                    isAssignmentOnly: true,
+                });
+            }
+        }
+        else {
+            // If it's an expression (e.g., `i = 0`)
+            initializerCode = this.visit(forStmt.initializer, context);
+        }
+    }
+    code += `${this.indent()}for (${initializerCode}; `;
+    if (forStmt.condition) {
+        code += `(${this.visit(forStmt.condition, context)}).is_truthy()`;
+    }
+    code += "; ";
+    if (forStmt.incrementor) {
+        code += this.visit(forStmt.incrementor, context);
+    }
+    code += ") ";
+    code += this.visit(forStmt.statement, {
+        ...context,
+        isFunctionBody: false,
+    });
+    this.indentationLevel--; // Exit the scope for the for loop
+    return code;
+}
+export function visitForInStatement(node, context) {
+    const forIn = node;
+    let code = `${this.indent()}{\n`;
+    this.indentationLevel++; // Enter a new scope for the for-in loop
+    let varName = "";
+    if (ts.isVariableDeclarationList(forIn.initializer)) {
+        const decl = forIn.initializer.declarations[0];
+        if (decl) {
+            varName = decl.name.getText();
+            // Declare the shared_ptr before the loop
+            code +=
+                `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+        }
+    }
+    else if (ts.isIdentifier(forIn.initializer)) {
+        varName = forIn.initializer.getText();
+        // Assume it's already declared in an outer scope, just assign to it.
+        // No explicit declaration here.
+    }
+    const expr = forIn.expression;
+    const exprText = this.visit(expr, context);
+    let derefExpr = exprText;
+    if (ts.isIdentifier(expr)) {
+        derefExpr = `jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)})`;
+    }
+    const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
+    code +=
+        `${this.indent()}std::vector<std::string> ${keysVar} = jspp::Access::get_object_keys(${derefExpr});\n`;
+    code += `${this.indent()}for (const auto& ${varName}_str : ${keysVar}) {\n`;
+    this.indentationLevel++;
+    code +=
+        `${this.indent()}*${varName} = jspp::AnyValue::make_string(${varName}_str);\n`;
+    code += this.visit(forIn.statement, {
+        ...context,
+        isFunctionBody: false,
+    });
+    this.indentationLevel--;
+    code += `${this.indent()}}}\n`;
+    this.indentationLevel--; // Exit the scope for the for-in loop
+    return code;
+}
+export function visitForOfStatement(node, context) {
+    const forOf = node;
+    let code = "";
+    this.indentationLevel++; // Enter a new scope for the for-of loop
+    let varName = "";
+    if (ts.isVariableDeclarationList(forOf.initializer)) {
+        const decl = forOf.initializer.declarations[0];
+        if (decl) {
+            varName = decl.name.getText();
+            // Declare the shared_ptr before the loop
+            code +=
+                `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+        }
+    }
+    else if (ts.isIdentifier(forOf.initializer)) {
+        varName = forOf.initializer.getText();
+        // Assume it's already declared in an outer scope, just assign to it.
+        // No explicit declaration here.
+    }
+    const iterableExpr = this.visit(forOf.expression, context);
+    const derefIterable = `jspp::Access::deref(${iterableExpr}, ${this.getJsVarName(forOf.expression)})`;
+    const arrayPtr = this.generateUniqueName("__array_ptr_", new Set());
+    code +=
+        `${this.indent()}{ auto ${arrayPtr} = std::any_cast<std::shared_ptr<jspp::JsArray>>(${derefIterable});\n`;
+    code +=
+        `${this.indent()}for (const auto& ${varName}_val : ${arrayPtr}->items) {\n`;
+    this.indentationLevel++;
+    code += `${this.indent()}*${varName} = ${varName}_val;\n`;
+    code += this.visit(forOf.statement, {
+        ...context,
+        isFunctionBody: false,
+    });
+    this.indentationLevel--;
+    code += `${this.indent()}}}\n`;
+    this.indentationLevel--; // Exit the scope for the for-of loop
+    return code;
+}
+export function visitIfStatement(node, context) {
+    const ifStmt = node;
+    const condition = this.visit(ifStmt.expression, context);
+    const thenStmt = this.visit(ifStmt.thenStatement, {
+        ...context,
+        isFunctionBody: false,
+    });
+    let elseStmt = "";
+    if (ifStmt.elseStatement) {
+        elseStmt = " else " +
+            this.visit(ifStmt.elseStatement, {
+                ...context,
+                isFunctionBody: false,
+            });
+    }
+    return `${this.indent()}if ((${condition}).is_truthy()) ${thenStmt}${elseStmt}`;
+}
+export function visitExpressionStatement(node, context) {
+    return (this.indent() +
+        this.visit(node.expression, context) +
+        ";\n");
+}
+export function visitThrowStatement(node, context) {
+    const throwStmt = node;
+    const expr = this.visit(throwStmt.expression, context);
+    return `${this.indent()}throw jspp::RuntimeError(${expr});
+`;
+}
+export function visitTryStatement(node, context) {
+    const tryStmt = node;
+    if (tryStmt.finallyBlock) {
+        const declaredSymbols = new Set();
+        this.getDeclaredSymbols(tryStmt.tryBlock).forEach((s) => declaredSymbols.add(s));
+        if (tryStmt.catchClause) {
+            this.getDeclaredSymbols(tryStmt.catchClause).forEach((s) => declaredSymbols.add(s));
+        }
+        this.getDeclaredSymbols(tryStmt.finallyBlock).forEach((s) => declaredSymbols.add(s));
+        const finallyLambdaName = this.generateUniqueName("__finally_", declaredSymbols);
+        const resultVarName = this.generateUniqueName("__try_result_", declaredSymbols);
+        const hasReturnedFlagName = this.generateUniqueName("__try_has_returned_", declaredSymbols);
+        let code = `${this.indent()}{\n`;
+        this.indentationLevel++;
+        code += `${this.indent()}jspp::AnyValue ${resultVarName};\n`;
+        code += `${this.indent()}bool ${hasReturnedFlagName} = false;\n`;
+        const finallyBlockCode = this.visit(tryStmt.finallyBlock, {
+            ...context,
+            isFunctionBody: false,
+        });
+        code +=
+            `${this.indent()}auto ${finallyLambdaName} = [=]() ${finallyBlockCode.trim()};\n`;
+        code += `${this.indent()}try {\n`;
+        this.indentationLevel++;
+        code +=
+            `${this.indent()}${resultVarName} = ([=, &${hasReturnedFlagName}]() -> jspp::AnyValue {\n`;
+        this.indentationLevel++;
+        const innerContext = {
+            ...context,
+            isFunctionBody: false,
+            isInsideTryCatchLambda: true,
+            hasReturnedFlag: hasReturnedFlagName,
+        };
+        code += `${this.indent()}try {\n`;
+        this.indentationLevel++;
+        code += this.visit(tryStmt.tryBlock, innerContext);
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        if (tryStmt.catchClause) {
+            const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause.variableDeclaration?.name.getText());
+            const catchContext = { ...innerContext, exceptionName };
+            code +=
+                `${this.indent()}catch (const std::exception& ${exceptionName}) {\n`;
+            this.indentationLevel++;
+            code += this.visit(tryStmt.catchClause.block, catchContext);
+            this.indentationLevel--;
+            code += `${this.indent()}}\n`;
+        }
+        else {
+            code += `${this.indent()}catch (...) { throw; }\n`;
+        }
+        code += `${this.indent()}return jspp::AnyValue::make_undefined();\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}})();\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}} catch (...) {\n`;
+        this.indentationLevel++;
+        code += `${this.indent()}${finallyLambdaName}();\n`;
+        code += `${this.indent()}throw;\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        code += `${this.indent()}${finallyLambdaName}();\n`;
+        code += `${this.indent()}if (${hasReturnedFlagName}) {\n`;
+        this.indentationLevel++;
+        code += `${this.indent()}return ${resultVarName};\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        return code;
+    }
+    else {
+        const exceptionName = this.generateUniqueExceptionName(tryStmt.catchClause?.variableDeclaration?.name.getText());
+        const newContext = {
+            ...context,
+            isFunctionBody: false,
+            exceptionName,
+        };
+        let code = `${this.indent()}try `;
+        code += this.visit(tryStmt.tryBlock, newContext);
+        if (tryStmt.catchClause) {
+            code += ` catch (const std::exception& ${exceptionName}) `;
+            code += this.visit(tryStmt.catchClause, newContext);
+        }
+        return code;
+    }
+}
+export function visitCatchClause(node, context) {
+    const catchClause = node;
+    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");
+    }
+    if (catchClause.variableDeclaration) {
+        const varName = catchClause.variableDeclaration.name.getText();
+        let code = `{\n`;
+        this.indentationLevel++;
+        code += `${this.indent()}{\n`;
+        this.indentationLevel++;
+        // Always create the JS exception variable.
+        code +=
+            `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::RuntimeError::error_to_value(${exceptionName}));\n`;
+        // Shadow the C++ exception variable *only if* the names don't clash.
+        if (varName !== exceptionName) {
+            code +=
+                `${this.indent()}auto ${exceptionName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+        }
+        code += this.visit(catchClause.block, context);
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        return code;
+    }
+    else {
+        // No variable in the catch clause, e.g., `catch { ... }`
+        let code = `{\n`; // Alway create block scope
+        code += this.visit(catchClause.block, context);
+        code += `${this.indent()}}\n`;
+        return code;
+    }
+}
+export function visitReturnStatement(node, context) {
+    if (context.isMainContext) {
+        return `${this.indent()}jspp::RuntimeError::throw_invalid_return_statement_error();\n`;
+    }
+    const returnStmt = node;
+    if (context.isInsideTryCatchLambda && context.hasReturnedFlag) {
+        let returnCode = `${this.indent()}${context.hasReturnedFlag} = true;\n`;
+        if (returnStmt.expression) {
+            const expr = returnStmt.expression;
+            const exprText = this.visit(expr, context);
+            if (ts.isIdentifier(expr)) {
+                const scope = this.getScopeForNode(expr);
+                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
+                if (!typeInfo) {
+                    returnCode +=
+                        `${this.indent()}jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)});\n`; // THROWS, not returns
+                }
+                if (typeInfo &&
+                    !typeInfo.isParameter &&
+                    !typeInfo.isBuiltin) {
+                    returnCode +=
+                        `${this.indent()}return jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
+                }
+                else {
+                    returnCode += `${this.indent()}return ${exprText};\n`;
+                }
+            }
+            else {
+                returnCode += `${this.indent()}return ${exprText};\n`;
+            }
+        }
+        else {
+            returnCode +=
+                `${this.indent()}return jspp::AnyValue::make_undefined();\n`;
+        }
+        return returnCode;
+    }
+    if (returnStmt.expression) {
+        const expr = returnStmt.expression;
+        const exprText = this.visit(expr, context);
+        if (ts.isIdentifier(expr)) {
+            const scope = this.getScopeForNode(expr);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
+            if (!typeInfo) {
+                return `${this.indent()}jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)});\n`; // THROWS, not returns
+            }
+            if (typeInfo &&
+                !typeInfo.isParameter &&
+                !typeInfo.isBuiltin) {
+                return `${this.indent()}return jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
+            }
+        }
+        return `${this.indent()}return ${exprText};\n`;
+    }
+    return `${this.indent()}return jspp::AnyValue::make_undefined();\n`;
+}

package/dist/core/codegen/visitor.js

@@ -0,0 +1,86 @@
+import ts from "typescript";
+import { CodeGenerator } from "./";
+import { visitVariableDeclaration, visitVariableDeclarationList, } from "./declaration-handlers";
+import { visitArrayLiteralExpression, visitBinaryExpression, visitCallExpression, visitElementAccessExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, visitVoidExpression, } from "./expression-handlers";
+import { visitArrowFunction, visitFunctionDeclaration, visitFunctionExpression, } from "./function-handlers";
+import { visitFalseKeyword, visitIdentifier, visitNoSubstitutionTemplateLiteral, visitNullKeyword, visitNumericLiteral, visitStringLiteral, visitTrueKeyword, visitUndefinedKeyword, } from "./literal-handlers";
+import { visitBlock, visitCatchClause, visitExpressionStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitIfStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, } from "./statement-handlers";
+export function visit(node, context) {
+    if (ts.isFunctionDeclaration(node)) {
+        return visitFunctionDeclaration.call(this, node, context);
+    }
+    switch (node.kind) {
+        case ts.SyntaxKind.ArrowFunction:
+            return visitArrowFunction.call(this, node, context);
+        case ts.SyntaxKind.FunctionExpression:
+            return visitFunctionExpression.call(this, node, context);
+        case ts.SyntaxKind.SourceFile:
+            return visitSourceFile.call(this, node, context);
+        case ts.SyntaxKind.Block:
+            return visitBlock.call(this, node, context);
+        case ts.SyntaxKind.VariableStatement:
+            return visitVariableStatement.call(this, node, context);
+        case ts.SyntaxKind.VariableDeclarationList:
+            return visitVariableDeclarationList.call(this, node, context);
+        case ts.SyntaxKind.VariableDeclaration:
+            return visitVariableDeclaration.call(this, node, context);
+        case ts.SyntaxKind.ObjectLiteralExpression:
+            return visitObjectLiteralExpression.call(this, node, context);
+        case ts.SyntaxKind.ArrayLiteralExpression:
+            return visitArrayLiteralExpression.call(this, node, context);
+        case ts.SyntaxKind.ForStatement:
+            return visitForStatement.call(this, node, context);
+        case ts.SyntaxKind.ForInStatement:
+            return visitForInStatement.call(this, node, context);
+        case ts.SyntaxKind.ForOfStatement:
+            return visitForOfStatement.call(this, node, context);
+        case ts.SyntaxKind.IfStatement:
+            return visitIfStatement.call(this, node, context);
+        case ts.SyntaxKind.PrefixUnaryExpression:
+            return visitPrefixUnaryExpression.call(this, node, context);
+        case ts.SyntaxKind.PostfixUnaryExpression:
+            return visitPostfixUnaryExpression.call(this, node, context);
+        case ts.SyntaxKind.ParenthesizedExpression:
+            return visitParenthesizedExpression.call(this, node, context);
+        case ts.SyntaxKind.PropertyAccessExpression:
+            return visitPropertyAccessExpression.call(this, node, context);
+        case ts.SyntaxKind.ElementAccessExpression:
+            return visitElementAccessExpression.call(this, node, context);
+        case ts.SyntaxKind.ExpressionStatement:
+            return visitExpressionStatement.call(this, node, context);
+        case ts.SyntaxKind.BinaryExpression:
+            return visitBinaryExpression.call(this, node, context);
+        case ts.SyntaxKind.ThrowStatement:
+            return visitThrowStatement.call(this, node, context);
+        case ts.SyntaxKind.TryStatement:
+            return visitTryStatement.call(this, node, context);
+        case ts.SyntaxKind.CatchClause:
+            return visitCatchClause.call(this, node, context);
+        case ts.SyntaxKind.CallExpression:
+            return visitCallExpression.call(this, node, context);
+        case ts.SyntaxKind.ReturnStatement:
+            return visitReturnStatement.call(this, node, context);
+        case ts.SyntaxKind.Identifier:
+            return visitIdentifier.call(this, node);
+        case ts.SyntaxKind.NumericLiteral:
+            return visitNumericLiteral.call(this, node);
+        case ts.SyntaxKind.StringLiteral:
+            return visitStringLiteral.call(this, node);
+        case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+            return visitNoSubstitutionTemplateLiteral.call(this, node);
+        case ts.SyntaxKind.TemplateExpression:
+            return visitTemplateExpression.call(this, node, context);
+        case ts.SyntaxKind.TrueKeyword:
+            return visitTrueKeyword.call(this);
+        case ts.SyntaxKind.FalseKeyword:
+            return visitFalseKeyword.call(this);
+        case ts.SyntaxKind.VoidExpression:
+            return visitVoidExpression.call(this, node, context);
+        case ts.SyntaxKind.UndefinedKeyword:
+            return visitUndefinedKeyword.call(this);
+        case ts.SyntaxKind.NullKeyword:
+            return visitNullKeyword.call(this);
+        default:
+            return `/* Unhandled node: ${ts.SyntaxKind[node.kind]} */`;
+    }
+}

package/dist/core/parser.js

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

package/dist/core/traverser.js

@@ -0,0 +1,19 @@
+import * as ts from "typescript";
+export class Traverser {
+    traverse(node, visitor) {
+        this.traverseNode(node, null, visitor);
+    }
+    traverseNode(node, parent, visitor) {
+        const nodeKind = ts.SyntaxKind[node.kind];
+        const visitorActions = visitor[nodeKind];
+        if (visitorActions && visitorActions.enter) {
+            visitorActions.enter(node, parent);
+        }
+        ts.forEachChild(node, (childNode) => {
+            this.traverseNode(childNode, node, visitor);
+        });
+        if (visitorActions && visitorActions.exit) {
+            visitorActions.exit(node, parent);
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,16 @@
+import path from "path";
+import { TypeAnalyzer } from "./analysis/typeAnalyzer";
+import { CodeGenerator } from "./core/codegen";
+import { Parser } from "./core/parser";
+export class Interpreter {
+    parser = new Parser();
+    analyzer = new TypeAnalyzer();
+    generator = new CodeGenerator();
+    interpret(jsCode) {
+        const ast = this.parser.parse(jsCode);
+        this.analyzer.analyze(ast);
+        const cppCode = this.generator.generate(ast, this.analyzer);
+        const preludePath = path.resolve(__dirname, "..", "src", "prelude");
+        return { cppCode, preludePath };
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ugo-studio/jspp",
+  "version": "0.1.0",
+  "description": "A modern, experimental 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"
+  },
+  "files": [
+    "dist",
+    "src/prelude",
+    "prelude-build"
+  ],
+  "scripts": {
+    "dev": "bun run src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "precompile": "bun run scripts/precompile-headers.ts",
+    "test": "bun run precompile && bun test",
+    "build": "tsc",
+    "prepack": "bun run build",
+    "publish-package": "npm publish --access=public"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "author": "Ugochukwu David",
+  "license": "MIT",
+  "homepage": "https://github.com/ugo-studio/jspp/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ugo-studio/jspp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ugo-studio/jspp/issues"
+  }
+}