@ugo-studio/jspp 0.1.0

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

@@ -0,0 +1,333 @@
+import ts from "typescript";
+import { CodeGenerator } from "./";
+function visitObjectPropertyName(node, context) {
+    if (ts.isStringLiteral(node)) {
+        return `"${node.getText().substring(1, node.getText().length - 1) // remove trailing "' from original name
+        }"`;
+    }
+    else if (ts.isComputedPropertyName(node)) {
+        let name = ts.isIdentifier(node.expression)
+            ? `jspp::Access::deref(${node.expression.getText()},${this.getJsVarName(node.expression)})`
+            : this.visit(node.expression, context);
+        name += ".to_std_string()";
+        return name;
+    }
+    return context.isPropertyNameAccess
+        ? node.getText()
+        : `"${node.getText()}"`;
+}
+export function visitObjectLiteralExpression(node, context) {
+    const obj = node;
+    let props = "";
+    for (const prop of obj.properties) {
+        // console.log("Property kind:", ts.SyntaxKind[prop.kind]);
+        if (ts.isPropertyAssignment(prop)) {
+            const key = visitObjectPropertyName.call(this, prop.name, context);
+            const value = ts.isIdentifier(prop.initializer)
+                ? `jspp::Access::deref(${this.visit(prop.initializer, context)}, ${this.getJsVarName(prop.initializer)})`
+                : this.visit(prop.initializer, context);
+            props += `{${key}, ${value}},`;
+        }
+        else if (ts.isShorthandPropertyAssignment(prop)) {
+            const key = visitObjectPropertyName.call(this, prop.name, context);
+            const value = `jspp::Access::deref(${this.visit(prop.name, context)}, ${this.getJsVarName(prop.name)})`;
+            props += `{${key}, ${value}},`;
+        }
+    }
+    return `jspp::AnyValue::make_object({${props}})`;
+}
+export function visitArrayLiteralExpression(node, context) {
+    const elements = node.elements
+        .map((elem) => ts.isIdentifier(elem)
+        ? `jspp::Access::deref(${this.visit(elem, context)}, ${this.getJsVarName(elem)})`
+        : this.visit(elem, context))
+        .join(", ");
+    return `jspp::AnyValue::make_array({${elements}})`;
+}
+export function visitPrefixUnaryExpression(node, context) {
+    const prefixUnaryExpr = node;
+    const operand = this.visit(prefixUnaryExpr.operand, context);
+    const operator = ts.tokenToString(prefixUnaryExpr.operator);
+    if (operator === "++" || operator === "--") {
+        return `${operator}(*${operand})`;
+    }
+    if (operator === "~") {
+        return `${operator}(*${operand})`;
+    }
+    return `${operator}${operand}`;
+}
+export function visitPostfixUnaryExpression(node, context) {
+    const postfixUnaryExpr = node;
+    const operand = this.visit(postfixUnaryExpr.operand, context);
+    const operator = ts.tokenToString(postfixUnaryExpr.operator);
+    return `(*${operand})${operator}`;
+}
+export function visitParenthesizedExpression(node, context) {
+    const parenExpr = node;
+    return `(${this.visit(parenExpr.expression, context)})`;
+}
+export function visitPropertyAccessExpression(node, context) {
+    const propAccess = node;
+    const exprText = this.visit(propAccess.expression, context);
+    const propName = propAccess.name.getText();
+    const scope = this.getScopeForNode(propAccess.expression);
+    const typeInfo = ts.isIdentifier(propAccess.expression)
+        ? this.typeAnalyzer.scopeManager.lookupFromScope(propAccess.expression.getText(), scope)
+        : null;
+    if (ts.isIdentifier(propAccess.expression) && !typeInfo &&
+        !this.isBuiltinObject(propAccess.expression)) {
+        return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(propAccess.expression)})`;
+    }
+    let finalExpr = "";
+    if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
+        finalExpr = `jspp::Access::deref(${exprText}, ${this.getJsVarName(propAccess.expression)})`;
+    }
+    else {
+        finalExpr = exprText;
+    }
+    return `${finalExpr}.get_own_property("${propName}")`;
+    // return `${finalExpr}["${propName}"]`;
+}
+export function visitElementAccessExpression(node, context) {
+    const elemAccess = node;
+    const exprText = this.visit(elemAccess.expression, context);
+    let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isPropertyNameAccess: true });
+    // Dereference the expression being accessed
+    const exprScope = this.getScopeForNode(elemAccess.expression);
+    const exprTypeInfo = ts.isIdentifier(elemAccess.expression)
+        ? this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.expression.getText(), exprScope)
+        : null;
+    if (ts.isIdentifier(elemAccess.expression) && !exprTypeInfo &&
+        !this.isBuiltinObject(elemAccess.expression)) {
+        return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(elemAccess.expression)})`;
+    }
+    const finalExpr = exprTypeInfo && !exprTypeInfo.isParameter && !exprTypeInfo.isBuiltin
+        ? `jspp::Access::deref(${exprText}, ${this.getJsVarName(elemAccess.expression)})`
+        : exprText;
+    // Dereference the argument expression if it's an identifier
+    if (ts.isIdentifier(elemAccess.argumentExpression)) {
+        const argScope = this.getScopeForNode(elemAccess.argumentExpression);
+        const argTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.argumentExpression.getText(), argScope);
+        if (!argTypeInfo && !this.isBuiltinObject(elemAccess.argumentExpression)) {
+            return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(elemAccess.argumentExpression)})`;
+        }
+        if (argTypeInfo && !argTypeInfo.isParameter && !argTypeInfo.isBuiltin) {
+            argText = `jspp::Access::deref(${argText}, ${this.getJsVarName(elemAccess.argumentExpression)})`;
+        }
+    }
+    return `${finalExpr}.get_own_property(${argText})`;
+    // return `${finalExpr}[${argText}]`;
+}
+export function visitBinaryExpression(node, context) {
+    const binExpr = node;
+    const opToken = binExpr.operatorToken;
+    let op = opToken.getText();
+    if (opToken.kind === ts.SyntaxKind.PlusEqualsToken ||
+        opToken.kind === ts.SyntaxKind.MinusEqualsToken ||
+        opToken.kind === ts.SyntaxKind.AsteriskEqualsToken ||
+        opToken.kind === ts.SyntaxKind.SlashEqualsToken ||
+        opToken.kind === ts.SyntaxKind.PercentEqualsToken) {
+        const leftText = this.visit(binExpr.left, context);
+        const rightText = this.visit(binExpr.right, context);
+        return `*${leftText} ${op} ${rightText}`;
+    }
+    if (opToken.kind === ts.SyntaxKind.EqualsToken) {
+        const rightText = this.visit(binExpr.right, context);
+        if (ts.isPropertyAccessExpression(binExpr.left)) {
+            const propAccess = binExpr.left;
+            const objExprText = this.visit(propAccess.expression, context);
+            const propName = propAccess.name.getText();
+            const scope = this.getScopeForNode(propAccess.expression);
+            const typeInfo = ts.isIdentifier(propAccess.expression)
+                ? this.typeAnalyzer.scopeManager.lookupFromScope(propAccess.expression.getText(), scope)
+                : null;
+            const finalObjExpr = typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin
+                ? `jspp::Access::deref(${objExprText}, ${this.getJsVarName(propAccess.expression)})`
+                : objExprText;
+            let finalRightText = rightText;
+            if (ts.isIdentifier(binExpr.right)) {
+                const rightScope = this.getScopeForNode(binExpr.right);
+                const rightTypeInfo = this.typeAnalyzer.scopeManager
+                    .lookupFromScope(binExpr.right.getText(), rightScope);
+                if (rightTypeInfo &&
+                    !rightTypeInfo.isParameter &&
+                    !rightTypeInfo.isBuiltin) {
+                    finalRightText = `jspp::Access::deref(${rightText}, ${this.getJsVarName(binExpr.right)})`;
+                }
+            }
+            return `${finalObjExpr}.set_own_property("${propName}", ${finalRightText})`;
+            // return `${finalObjExpr}["${propName}"] = ${finalRightText}`;
+        }
+        else if (ts.isElementAccessExpression(binExpr.left)) {
+            const elemAccess = binExpr.left;
+            const objExprText = this.visit(elemAccess.expression, context);
+            let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isPropertyNameAccess: true });
+            const scope = this.getScopeForNode(elemAccess.expression);
+            const typeInfo = ts.isIdentifier(elemAccess.expression)
+                ? this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.expression.getText(), scope)
+                : null;
+            const finalObjExpr = typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin
+                ? `jspp::Access::deref(${objExprText}, ${this.getJsVarName(elemAccess.expression)})`
+                : objExprText;
+            if (ts.isIdentifier(elemAccess.argumentExpression)) {
+                const argScope = this.getScopeForNode(elemAccess.argumentExpression);
+                const argTypeInfo = this.typeAnalyzer.scopeManager
+                    .lookupFromScope(elemAccess.argumentExpression.getText(), argScope);
+                if (argTypeInfo &&
+                    !argTypeInfo.isParameter &&
+                    !argTypeInfo.isBuiltin) {
+                    argText = `jspp::Access::deref(${argText}, ${this.getJsVarName(elemAccess.argumentExpression)})`;
+                }
+            }
+            let finalRightText = rightText;
+            if (ts.isIdentifier(binExpr.right)) {
+                const rightScope = this.getScopeForNode(binExpr.right);
+                const rightTypeInfo = this.typeAnalyzer.scopeManager
+                    .lookupFromScope(binExpr.right.getText(), rightScope);
+                if (rightTypeInfo &&
+                    !rightTypeInfo.isParameter &&
+                    !rightTypeInfo.isBuiltin) {
+                    finalRightText = `jspp::Access::deref(${rightText}, ${this.getJsVarName(binExpr.right)})`;
+                }
+            }
+            return `${finalObjExpr}.set_own_property(${argText}, ${finalRightText})`;
+            // return `${finalObjExpr}[${argText}] = ${finalRightText}`;
+        }
+        const leftText = this.visit(binExpr.left, context);
+        const scope = this.getScopeForNode(binExpr.left);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
+        if (!typeInfo && !this.isBuiltinObject(binExpr.left)) {
+            return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(binExpr.left)})`;
+        }
+        if (typeInfo?.isConst) {
+            return `jspp::RuntimeError::throw_immutable_assignment_error()`;
+        }
+        return `*${leftText} ${op} ${rightText}`;
+    }
+    const leftText = this.visit(binExpr.left, context);
+    const rightText = this.visit(binExpr.right, context);
+    const leftIsIdentifier = ts.isIdentifier(binExpr.left);
+    const rightIsIdentifier = ts.isIdentifier(binExpr.right);
+    const scope = this.getScopeForNode(node);
+    const leftTypeInfo = leftIsIdentifier
+        ? this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.getText(), scope)
+        : null;
+    const rightTypeInfo = rightIsIdentifier
+        ? this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope)
+        : null;
+    const finalLeft = leftIsIdentifier && leftTypeInfo && !leftTypeInfo.isParameter &&
+        !leftTypeInfo.isBuiltin
+        ? `jspp::Access::deref(${leftText}, ${this.getJsVarName(binExpr.left)})`
+        : leftText;
+    const finalRight = rightIsIdentifier && rightTypeInfo && !rightTypeInfo.isParameter &&
+        !rightTypeInfo.isBuiltin
+        ? `jspp::Access::deref(${rightText}, ${this.getJsVarName(binExpr.right)})`
+        : rightText;
+    if (leftIsIdentifier && !leftTypeInfo &&
+        !this.isBuiltinObject(binExpr.left)) {
+        return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(binExpr.left)})`;
+    }
+    if (rightIsIdentifier && !rightTypeInfo &&
+        !this.isBuiltinObject(binExpr.right)) {
+        return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(binExpr.right)})`;
+    }
+    if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
+        return `${finalLeft}.is_strictly_equal_to_primitive(${finalRight})`;
+    }
+    if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
+        return `${finalLeft}.is_equal_to_primitive(${finalRight})`;
+    }
+    if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
+        return `${finalLeft}.not_strictly_equal_to_primitive(${finalRight})`;
+    }
+    if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
+        return `${finalLeft}.not_equal_to_primitive(${finalRight})`;
+    }
+    if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskToken) {
+        return `jspp::pow(${finalLeft}, ${finalRight})`;
+    }
+    if (op === "+" ||
+        op === "-" ||
+        op === "*" ||
+        op === "/" ||
+        op === "%" ||
+        op === "^" ||
+        op === "&" ||
+        op === "|") {
+        return `(${finalLeft} ${op} ${finalRight})`;
+    }
+    return `${finalLeft} ${op} ${finalRight}`;
+}
+export function visitCallExpression(node, context) {
+    const callExpr = node;
+    const callee = callExpr.expression;
+    const calleeName = this.escapeString(callee.getText());
+    const args = callExpr.arguments
+        .map((arg) => {
+        const argText = this.visit(arg, context);
+        if (ts.isIdentifier(arg)) {
+            const scope = this.getScopeForNode(arg);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(arg.text, scope);
+            if (!typeInfo) {
+                return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(arg)})`;
+            }
+            if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
+                return `jspp::Access::deref(${argText}, ${this.getJsVarName(arg)})`;
+            }
+        }
+        return argText;
+    })
+        .join(", ");
+    const calleeCode = this.visit(callee, context);
+    let derefCallee;
+    if (ts.isIdentifier(callee)) {
+        const scope = this.getScopeForNode(callee);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(callee.text, scope);
+        if (!typeInfo && !this.isBuiltinObject(callee)) {
+            return `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(callee)})`;
+        }
+        if (typeInfo?.isBuiltin) {
+            derefCallee = calleeCode;
+        }
+        else {
+            derefCallee = `jspp::Access::deref(${calleeCode}, ${this.getJsVarName(callee)})`;
+        }
+    }
+    else {
+        derefCallee = calleeCode;
+    }
+    return `${derefCallee}.as_function()->call({${args}})`;
+    // return `${derefCallee}.as_function("${calleeName}")->call({${args}})`;
+}
+export function visitVoidExpression(node, context) {
+    const voidExpr = node;
+    const exprText = this.visit(voidExpr.expression, context);
+    return `(${exprText}, jspp::AnyValue::make_undefined())`;
+}
+export function visitTemplateExpression(node, context) {
+    const templateExpr = node;
+    let result = `jspp::AnyValue::make_string("${this.escapeString(templateExpr.head.text)}")`;
+    for (const span of templateExpr.templateSpans) {
+        const expr = span.expression;
+        const exprText = this.visit(expr, context);
+        let finalExpr = exprText;
+        if (ts.isIdentifier(expr)) {
+            const scope = this.getScopeForNode(expr);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
+            if (!typeInfo && !this.isBuiltinObject(expr)) {
+                finalExpr =
+                    `jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)})`;
+            }
+            else if (typeInfo &&
+                !typeInfo.isParameter &&
+                !typeInfo.isBuiltin) {
+                finalExpr = `jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)})`;
+            }
+        }
+        result += ` + (${finalExpr})`;
+        if (span.literal.text) {
+            result += ` + jspp::AnyValue::make_string("${this.escapeString(span.literal.text)}")`;
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,94 @@
+import ts from "typescript";
+import { CodeGenerator } from "./";
+export function generateLambda(node, isAssignment = false, capture = "[=]") {
+    const declaredSymbols = this.getDeclaredSymbols(node);
+    const argsName = this.generateUniqueName("__args_", declaredSymbols);
+    let lambda = `${capture}(const std::vector<jspp::AnyValue>& ${argsName}) mutable -> jspp::AnyValue `;
+    const visitContext = {
+        isMainContext: false,
+        isInsideFunction: true,
+        isFunctionBody: false,
+    };
+    if (node.body) {
+        if (ts.isBlock(node.body)) {
+            let paramExtraction = "";
+            this.indentationLevel++;
+            node.parameters.forEach((p, i) => {
+                const name = p.name.getText();
+                const defaultValue = p.initializer
+                    ? this.visit(p.initializer, visitContext)
+                    : "jspp::AnyValue::make_undefined()";
+                paramExtraction +=
+                    `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
+            });
+            this.indentationLevel--;
+            const blockContent = this.visit(node.body, {
+                isMainContext: false,
+                isInsideFunction: true,
+                isFunctionBody: true,
+            });
+            // The block visitor already adds braces, so we need to inject the param extraction.
+            lambda += "{\n" + paramExtraction + blockContent.substring(2);
+        }
+        else {
+            lambda += "{\n";
+            this.indentationLevel++;
+            node.parameters.forEach((p, i) => {
+                const name = p.name.getText();
+                const defaultValue = p.initializer
+                    ? this.visit(p.initializer, visitContext)
+                    : "jspp::AnyValue::make_undefined()";
+                lambda +=
+                    `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
+            });
+            lambda += `${this.indent()}return ${this.visit(node.body, {
+                isMainContext: false,
+                isInsideFunction: true,
+                isFunctionBody: false,
+            })};
+`;
+            this.indentationLevel--;
+            lambda += `${this.indent()}}`;
+        }
+    }
+    else {
+        lambda += "{ return jspp::AnyValue::make_undefined(); }\n";
+    }
+    const signature = `jspp::AnyValue(const std::vector<jspp::AnyValue>&)`;
+    const callable = `std::function<${signature}>(${lambda})`;
+    const funcName = node.name?.getText();
+    const fullExpression = `jspp::AnyValue::make_function(${callable}, "${funcName || ""}")`;
+    if (ts.isFunctionDeclaration(node) && !isAssignment && funcName) {
+        return `${this.indent()}auto ${funcName} = ${fullExpression};\n`;
+    }
+    return fullExpression;
+}
+export function visitFunctionDeclaration(node, context) {
+    if (context.isInsideFunction) {
+        // This will now be handled by the Block visitor for hoisting.
+        // However, we still need to generate the lambda for assignment.
+        // The block visitor will wrap this in an assignment.
+        return this.generateLambda(node);
+    }
+    return "";
+}
+export function visitArrowFunction(node, context) {
+    return this.generateLambda(node);
+}
+export function visitFunctionExpression(node, context) {
+    const funcExpr = node;
+    if (funcExpr.name) {
+        const funcName = funcExpr.name.getText();
+        let code = "([=]() -> jspp::AnyValue {\n";
+        this.indentationLevel++;
+        code +=
+            `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>();\n`;
+        const lambda = this.generateLambda(funcExpr, false, "[=]");
+        code += `${this.indent()}*${funcName} = ${lambda};\n`;
+        code += `${this.indent()}return *${funcName};\n`;
+        this.indentationLevel--;
+        code += `${this.indent()}})()`;
+        return code;
+    }
+    return this.generateLambda(node);
+}

package/dist/core/codegen/helpers.js

@@ -0,0 +1,83 @@
+import ts from "typescript";
+import { Scope } from "../../analysis/scope";
+import { CodeGenerator } from "./";
+const BUILTIN_OBJECTS = new Set([
+    "global",
+    "globalThis",
+    "console",
+    "Symbol",
+]);
+export function isBuiltinObject(node) {
+    return BUILTIN_OBJECTS.has(node.text);
+}
+export function getDeclaredSymbols(node) {
+    const symbols = new Set();
+    const visitor = (child) => {
+        if (ts.isVariableDeclaration(child)) {
+            // Handles let, const, var
+            symbols.add(child.name.getText());
+        }
+        else if (ts.isFunctionDeclaration(child) && child.name) {
+            // Handles function declarations
+            symbols.add(child.name.getText());
+        }
+        else if (ts.isParameter(child)) {
+            // Handles function parameters
+            symbols.add(child.name.getText());
+        }
+        else if (ts.isCatchClause(child) && child.variableDeclaration) {
+            // Handles catch clause variable
+            symbols.add(child.variableDeclaration.name.getText());
+        }
+        ts.forEachChild(child, visitor);
+    };
+    visitor(node);
+    return symbols;
+}
+export function generateUniqueName(prefix, namesToAvoid) {
+    let name = `${prefix}${this.exceptionCounter}`;
+    while (namesToAvoid.has(name)) {
+        this.exceptionCounter++;
+        name = `${prefix}${this.exceptionCounter}`;
+    }
+    this.exceptionCounter++;
+    return name;
+}
+export function generateUniqueExceptionName(nameToAvoid) {
+    let exceptionName = `__caught_exception_${this.exceptionCounter}`;
+    while (exceptionName === nameToAvoid) {
+        this.exceptionCounter++;
+        exceptionName = `__caught_exception_${this.exceptionCounter}`;
+    }
+    this.exceptionCounter++;
+    return exceptionName;
+}
+export function getScopeForNode(node) {
+    let current = node;
+    while (current) {
+        const scope = this.typeAnalyzer.nodeToScope.get(current);
+        if (scope) {
+            return scope;
+        }
+        current = current.parent;
+    }
+    const rootScope = this.typeAnalyzer.scopeManager.getAllScopes()[0];
+    if (!rootScope) {
+        throw new Error("Compiler bug: Could not find a root scope.");
+    }
+    return rootScope;
+}
+export function indent() {
+    return "  ".repeat(this.indentationLevel);
+}
+export function escapeString(str) {
+    return str
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t");
+}
+export function getJsVarName(node) {
+    return `"${node.text}"`;
+}

package/dist/core/codegen/index.js

@@ -0,0 +1,54 @@
+import { TypeAnalyzer } from "../../analysis/typeAnalyzer";
+import { generateLambda } from "./function-handlers";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getJsVarName, getScopeForNode, indent, isBuiltinObject, } from "./helpers";
+import { visit } from "./visitor";
+const CONTAINER_FUNCTION_NAME = "__container__";
+export class CodeGenerator {
+    indentationLevel = 0;
+    typeAnalyzer;
+    exceptionCounter = 0;
+    // visitor
+    visit = visit;
+    // helpers
+    getDeclaredSymbols = getDeclaredSymbols;
+    generateUniqueName = generateUniqueName;
+    generateUniqueExceptionName = generateUniqueExceptionName;
+    getScopeForNode = getScopeForNode;
+    indent = indent;
+    escapeString = escapeString;
+    getJsVarName = getJsVarName;
+    isBuiltinObject = isBuiltinObject;
+    // function handlers
+    generateLambda = generateLambda;
+    /**
+     * Main entry point for the code generation process.
+     */
+    generate(ast, analyzer) {
+        this.typeAnalyzer = analyzer;
+        const declarations = `#include "index.hpp"\n\n`;
+        let containerCode = `jspp::AnyValue ${CONTAINER_FUNCTION_NAME}() {\n`;
+        this.indentationLevel++;
+        containerCode += this.visit(ast, {
+            isMainContext: true,
+            isInsideFunction: true,
+            isFunctionBody: true,
+        });
+        this.indentationLevel--;
+        containerCode += "  return jspp::AnyValue::make_undefined();\n";
+        containerCode += "}\n\n";
+        let mainCode = "int main() {\n";
+        mainCode += `  std::ios::sync_with_stdio(false);\n`;
+        mainCode += `  std::cin.tie(nullptr);\n`;
+        mainCode += `  try {\n`;
+        mainCode += `    ${CONTAINER_FUNCTION_NAME}();\n`;
+        mainCode += `  } catch (const std::exception& ex) {\n`;
+        mainCode +=
+            "    auto error = std::make_shared<jspp::AnyValue>(jspp::RuntimeError::error_to_value(ex));\n{\n";
+        mainCode +=
+            `    console.get_own_property("error").as_function("console.error")->call({*error});\n`;
+        mainCode += `    return 1;\n}\n`;
+        mainCode += `  }\n`;
+        mainCode += "  return 0;\n}";
+        return declarations + containerCode + mainCode;
+    }
+}

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

@@ -0,0 +1,32 @@
+import ts from "typescript";
+import { CodeGenerator } from "./";
+export function visitIdentifier(node) {
+    if (node.text === "NaN") {
+        return "jspp::AnyValue::make_nan()";
+    }
+    if (node.text === "undefined") {
+        return "jspp::AnyValue::make_undefined()";
+    }
+    return node.text;
+}
+export function visitNumericLiteral(node) {
+    return `jspp::AnyValue::make_number(${this.escapeString(node.text)})`;
+}
+export function visitStringLiteral(node) {
+    return `jspp::AnyValue::make_string("${this.escapeString(node.text)}")`;
+}
+export function visitNoSubstitutionTemplateLiteral(node) {
+    return `jspp::AnyValue::make_string("${this.escapeString(node.text)}")`;
+}
+export function visitTrueKeyword() {
+    return "jspp::AnyValue::make_boolean(true)";
+}
+export function visitFalseKeyword() {
+    return "jspp::AnyValue::make_boolean(false)";
+}
+export function visitUndefinedKeyword() {
+    return "jspp::AnyValue::make_undefined()";
+}
+export function visitNullKeyword() {
+    return "jspp::AnyValue::make_null()";
+}