@ugo-studio/jspp 0.3.1 → 0.3.3

package/dist/{core → interpreter/core}/codegen/function-handlers.js

@@ -5,8 +5,18 @@ import { CodeGenerator } from "./index.js";
 export function generateLambdaComponents(node, context, options) {
     const declaredSymbols = this.getDeclaredSymbols(node);
     const argsName = this.generateUniqueName("__args_", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
-    const nativeExcessArgsName = this.generateUniqueName("__excess_args", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
-    const nativeTotalArgsSizeName = this.generateUniqueName("__total_args_size", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
+    // const nativeExcessArgsName = this.generateUniqueName(
+    //     "__excess_args",
+    //     declaredSymbols,
+    //     context.globalScopeSymbols,
+    //     context.localScopeSymbols,
+    // );
+    // const nativeTotalArgsSizeName = this.generateUniqueName(
+    //     "__total_args_size",
+    //     declaredSymbols,
+    //     context.globalScopeSymbols,
+    //     context.localScopeSymbols,
+    // );
     const isInsideGeneratorFunction = this.isGeneratorFunction(node);
     const isInsideAsyncFunction = this.isAsyncFunction(node);
     const isArrow = ts.isArrowFunction(node);
@@ -14,15 +24,27 @@ export function generateLambdaComponents(node, context, options) {
         isInsideGeneratorFunction: isInsideGeneratorFunction,
         isInsideAsyncFunction: isInsideAsyncFunction,
     });
-    const funcReturnType = (isInsideGeneratorFunction && isInsideAsyncFunction)
-        ? "jspp::JsAsyncIterator<jspp::AnyValue>"
-        : (isInsideGeneratorFunction
-            ? "jspp::JsIterator<jspp::AnyValue>"
-            : (isInsideAsyncFunction ? "jspp::JsPromise" : "jspp::AnyValue"));
+    const getFuncReturnType = (isInsideNativeLambda) => {
+        if (isInsideGeneratorFunction && isInsideAsyncFunction) {
+            return "jspp::JsAsyncIterator<jspp::AnyValue>";
+        }
+        else if (isInsideGeneratorFunction) {
+            return "jspp::JsIterator<jspp::AnyValue>";
+        }
+        else if (isInsideAsyncFunction)
+            return "jspp::JsPromise";
+        else {
+            const inferedReturnType = this.typeAnalyzer.inferFunctionReturnType(node);
+            if (isInsideNativeLambda && inferedReturnType === "number") {
+                return "double";
+            }
+            return "jspp::AnyValue";
+        }
+    };
     // Lambda arguments: regular functions use std::span for performance.
     // Generators and async functions use std::vector to ensure they are safely copied into the coroutine frame.
     const paramThisType = "jspp::AnyValue";
-    const paramArgsType = (isInsideGeneratorFunction || isInsideAsyncFunction)
+    const paramArgsType = isInsideGeneratorFunction || isInsideAsyncFunction
         ? "std::vector<jspp::AnyValue>"
         : "std::span<const jspp::AnyValue>";
     const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
@@ -31,7 +53,7 @@ export function generateLambdaComponents(node, context, options) {
         isMainContext: false,
         isInsideFunction: true,
         isFunctionBody: false,
-        lambdaName: undefined,
+        functionName: undefined,
         globalScopeSymbols,
         localScopeSymbols: new DeclaredSymbols(),
         superClassVar: context.superClassVar,
@@ -95,7 +117,8 @@ export function generateLambdaComponents(node, context, options) {
                     `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${signatureName});\n`;
             }
             else {
-                nativeParamsContent += this.generateDestructuring(p.name, signatureName, visitContext) + ";\n";
+                nativeParamsContent += this.generateDestructuring(p.name, signatureName, visitContext) +
+                    ";\n";
             }
         }
     });
@@ -114,8 +137,7 @@ export function generateLambdaComponents(node, context, options) {
                     checks: { initialized: true },
                 });
                 const scope = this.getScopeForNode(p);
-                const typeInfo = this.typeAnalyzer.scopeManager
-                    .lookupFromScope(name, scope);
+                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
                 // Handle rest parameters
                 if (!!p.dotDotDotToken) {
                     const initValue = `jspp::AnyValue::make_array(${argsName}.subspan(${i}))`;
@@ -148,39 +170,43 @@ export function generateLambdaComponents(node, context, options) {
                 const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
                 paramsCode +=
                     `${this.indent()}auto ${tempName} = ${initValue};\n`;
-                paramsCode += this.generateDestructuring(p.name, tempName, visitContext) + ";\n";
+                paramsCode +=
+                    this.generateDestructuring(p.name, tempName, visitContext) +
+                        ";\n";
             }
         });
         return paramsCode;
     };
     // Generate params and function body
     let paramsContent = "";
-    let blockContentWithoutOpeningBrace = "";
+    let getBlockContentWithoutOpeningBrace = () => "";
     // Generate `arguments` variable if it used in the function body
-    if (this.isVariableUsedWithoutDeclaration("arguments", node.body)) {
-        // Add span parameter for holding the excess arguments from the caller of the native lambda
-        nativeFuncArgs +=
-            `, const std::size_t ${nativeTotalArgsSizeName}, std::span<const jspp::AnyValue> ${nativeExcessArgsName} = {}`;
-        // TODO: compile arguments array from parameters
-        // this.indentationLevel++;
-        // nativeParamsContent +=
-        //     `${this.indent()}jspp::AnyValue arguments = jspp::Constants::UNDEFINED;\n`;
-        // nativeParamsContent += `${this.indent()}{\n`;
-        // this.indentationLevel++;
-        // nativeParamsContent +=
-        //     `${this.indent()}std::vector<jspp::AnyValue> ${argsName};\n`;
-        // this.validateFunctionParams(node.parameters).forEach(
-        //     (p, i) => {
-        //     },
-        // );
-        // this.indentationLevel--;
-        // nativeParamsContent += `${this.indent()}}\n`;
-        // this.indentationLevel--;
-        // this.indentationLevel++;
-        // paramsContent =
-        //     `${this.indent()}jspp::AnyValue arguments = jspp::AnyValue::make_array(${argsName});\n`;
-        // this.indentationLevel--;
-    }
+    // TODO: compile arguments array from parameters
+    // if (
+    //     this.isVariableUsedWithoutDeclaration("arguments", node.body as ts.Node)
+    // ) {
+    //     // Add span parameter for holding the excess arguments from the caller of the native lambda
+    //     nativeFuncArgs +=
+    //         `, const std::size_t ${nativeTotalArgsSizeName}, std::span<const jspp::AnyValue> ${nativeExcessArgsName} = {}`;
+    //     // this.indentationLevel++;
+    //     // nativeParamsContent +=
+    //     //     `${this.indent()}jspp::AnyValue arguments = jspp::Constants::UNDEFINED;\n`;
+    //     // nativeParamsContent += `${this.indent()}{\n`;
+    //     // this.indentationLevel++;
+    //     // nativeParamsContent +=
+    //     //     `${this.indent()}std::vector<jspp::AnyValue> ${argsName};\n`;
+    //     // this.validateFunctionParams(node.parameters).forEach(
+    //     //     (p, i) => {
+    //     //     },
+    //     // );
+    //     // this.indentationLevel--;
+    //     // nativeParamsContent += `${this.indent()}}\n`;
+    //     // this.indentationLevel--;
+    //     // this.indentationLevel++;
+    //     // paramsContent =
+    //     //     `${this.indent()}jspp::AnyValue arguments = jspp::AnyValue::make_array(${argsName});\n`;
+    //     // this.indentationLevel--;
+    // }
     if (node.body) {
         if (ts.isBlock(node.body)) {
             // Hoist var declarations in the function body
@@ -202,34 +228,53 @@ export function generateLambdaComponents(node, context, options) {
             paramsContent += generateParamsBuilder();
             this.indentationLevel--;
             // The block visitor already adds braces, so we need to remove the opening brace to inject the preamble and param extraction.
-            blockContentWithoutOpeningBrace = this.visit(node.body, {
-                ...visitContext,
-                isMainContext: false,
-                isInsideFunction: true,
-                isFunctionBody: true,
-                isInsideGeneratorFunction: isInsideGeneratorFunction,
-                isInsideAsyncFunction: isInsideAsyncFunction,
-            }).trimStart().substring(2);
+            const properIndentationLevel = this.indentationLevel;
+            const nodeBody = node.body;
+            getBlockContentWithoutOpeningBrace = (isInsideNativeLambda) => {
+                const currentIndentationLevel = this.indentationLevel;
+                this.indentationLevel = properIndentationLevel;
+                const code = this.visit(nodeBody, {
+                    ...visitContext,
+                    isMainContext: false,
+                    isInsideFunction: true,
+                    isFunctionBody: true,
+                    isInsideGeneratorFunction,
+                    isInsideAsyncFunction,
+                    isInsideNativeLambda,
+                })
+                    .trim()
+                    .substring(2);
+                this.indentationLevel = currentIndentationLevel;
+                return code;
+            };
         }
         else {
             this.indentationLevel++;
             paramsContent += generateParamsBuilder();
-            blockContentWithoutOpeningBrace =
-                `${this.indent()}${returnCommand} ${this.visit(node.body, {
+            const properIndentationLevel = this.indentationLevel;
+            const nodeBody = node.body;
+            getBlockContentWithoutOpeningBrace = (isInsideNativeLambda) => {
+                const currentIndentationLevel = this.indentationLevel;
+                this.indentationLevel = properIndentationLevel;
+                let code = `${this.indent()}${returnCommand} ${this.visit(nodeBody, {
                     ...visitContext,
                     isMainContext: false,
                     isInsideFunction: true,
                     isFunctionBody: false,
-                    isInsideGeneratorFunction: isInsideGeneratorFunction,
-                    isInsideAsyncFunction: isInsideAsyncFunction,
+                    isInsideGeneratorFunction,
+                    isInsideAsyncFunction,
+                    isInsideNativeLambda,
                 })};\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}`;
+                this.indentationLevel = currentIndentationLevel;
+                return code;
+            };
             this.indentationLevel--;
-            blockContentWithoutOpeningBrace += `${this.indent()}}`;
         }
     }
     else {
-        blockContentWithoutOpeningBrace =
-            `${returnCommand} jspp::Constants::UNDEFINED; }\n`;
+        getBlockContentWithoutOpeningBrace = () => `${returnCommand} jspp::Constants::UNDEFINED; }`;
     }
     return {
         node,
@@ -239,37 +284,39 @@ export function generateLambdaComponents(node, context, options) {
         thisArgParam,
         funcArgs,
         nativeFuncArgs,
-        funcReturnType,
+        getFuncReturnType,
         preamble,
         nativePreamble,
         paramsContent,
         nativeParamsContent,
-        blockContentWithoutOpeningBrace,
+        getBlockContentWithoutOpeningBrace,
         isInsideGeneratorFunction,
         isInsideAsyncFunction,
     };
 }
 export function generateNativeLambda(comps) {
-    const { options, thisArgParam, nativeFuncArgs, funcReturnType, nativePreamble, nativeParamsContent, blockContentWithoutOpeningBrace, } = comps;
+    const { options, thisArgParam, nativeFuncArgs, getFuncReturnType, nativePreamble, nativeParamsContent, getBlockContentWithoutOpeningBrace, } = comps;
     const capture = options?.capture || "[=]";
     const nativeName = options?.nativeName;
     const selfParam = nativeName ? `this auto&& ${nativeName}, ` : "";
     const mutableLabel = nativeName ? "" : "mutable ";
+    const funcReturnType = getFuncReturnType(true);
     let lambda = `${capture}(${selfParam}${thisArgParam}${nativeFuncArgs}) ${mutableLabel}-> ${funcReturnType} {\n`;
     lambda += nativePreamble;
     lambda += nativeParamsContent;
-    lambda += blockContentWithoutOpeningBrace;
+    lambda += getBlockContentWithoutOpeningBrace(true);
     return lambda;
 }
 export function generateWrappedLambda(comps) {
-    const { node, context, options, thisArgParam, funcArgs, funcReturnType, preamble, paramsContent, blockContentWithoutOpeningBrace, isInsideGeneratorFunction, isInsideAsyncFunction, } = comps;
+    const { node, context, options, thisArgParam, funcArgs, getFuncReturnType, preamble, paramsContent, getBlockContentWithoutOpeningBrace, isInsideGeneratorFunction, isInsideAsyncFunction, } = comps;
     const capture = options?.capture || "[=]";
     const isAssignment = options?.isAssignment || false;
+    const funcReturnType = getFuncReturnType(false);
     const noTypeSignature = options?.noTypeSignature || false;
     let lambda = `${capture}(${thisArgParam}, ${funcArgs}) mutable -> ${funcReturnType} {\n`;
     lambda += preamble;
     lambda += paramsContent;
-    lambda += blockContentWithoutOpeningBrace;
+    lambda += getBlockContentWithoutOpeningBrace(false);
     let callable = lambda;
     let method = "";
     // Handle generator function
@@ -308,7 +355,7 @@ export function generateWrappedLambda(comps) {
             method = `jspp::AnyValue::make_function`;
         }
     }
-    const funcName = context?.lambdaName || node.name?.getText();
+    const funcName = context?.functionName || node.name?.getText();
     const hasName = !!funcName && funcName.length > 0;
     let args = callable;
     const isArrow = ts.isArrowFunction(node);
@@ -378,7 +425,7 @@ export function visitFunctionExpression(node, context) {
             `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>();\n`;
         const lambda = this.generateWrappedLambda(this.generateLambdaComponents(funcExpr, {
             ...context,
-            lambdaName: funcName,
+            functionName: funcName,
         }, {
             isAssignment: true,
             capture: "[=]",

package/dist/{core → interpreter/core}/codegen/helpers.js

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope.js";
-import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
+import { DeclarationType, DeclaredSymbols, } from "../../ast/symbols.js";
 import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 /**
@@ -250,7 +250,7 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                         : ts.isEnumDeclaration(decl)
                             ? DeclarationType.enum
                             : DeclarationType.var;
-    const hoistName = (nameNode) => {
+    const hoistName = (nameNode, isFromDestructuring = false) => {
         if (ts.isIdentifier(nameNode)) {
             const name = nameNode.text;
             if (hoistedSymbols.has(name)) {
@@ -269,6 +269,10 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
             }
             else {
                 // Add the symbol to the hoisted symbols
+                hoistedSymbols.add(name, {
+                    type: declType,
+                });
+                // Get and update symbol features
                 if (ts.isFunctionDeclaration(decl) ||
                     (ts.isVariableDeclaration(decl) && decl.initializer &&
                         nameNode === decl.name &&
@@ -278,22 +282,23 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                     const funcExpr = ts.isVariableDeclaration(decl)
                         ? decl.initializer
                         : decl;
-                    const isAsync = this.isAsyncFunction(funcExpr);
-                    const isGenerator = this.isGeneratorFunction(funcExpr);
-                    hoistedSymbols.add(name, {
-                        type: declType,
-                        features: { isAsync, isGenerator },
+                    // Update features
+                    hoistedSymbols.update(name, {
+                        features: {
+                            isAsync: this.isAsyncFunction(funcExpr),
+                            isGenerator: this.isGeneratorFunction(funcExpr),
+                        },
                     });
                     // Don't hoist declarations not used as a variable
                     // They will be called with their native lambda/value
                     if (!this.isDeclarationUsedAsValue(decl, scopeNode) &&
                         !this.isDeclarationUsedBeforeInitialization(name, scopeNode)) {
+                        hoistedSymbols.update(name, {
+                            checks: { skippedHoisting: true },
+                        });
                         return "";
                     }
                 }
-                else {
-                    hoistedSymbols.add(name, { type: declType });
-                }
             }
             const scope = this.getScopeForNode(decl);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
@@ -304,6 +309,13 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                 return `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
             }
             else {
+                if ((isLet || isConst) &&
+                    !this.isDeclarationUsedBeforeInitialization(name, scopeNode) && !isFromDestructuring) {
+                    hoistedSymbols.update(name, {
+                        checks: { skippedHoisting: true },
+                    });
+                    return "";
+                }
                 return `${this.indent()}jspp::AnyValue ${name} = ${initializer};\n`;
             }
         }
@@ -311,7 +323,7 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
             let code = "";
             nameNode.elements.forEach((element) => {
                 if (ts.isBindingElement(element)) {
-                    code += hoistName(element.name);
+                    code += hoistName(element.name, true);
                 }
             });
             return code;
@@ -715,6 +727,33 @@ export function isVariableUsedWithoutDeclaration(name, root) {
     visit(root);
     return isUsedIllegally;
 }
+/**
+ * Checks if a node (usually a SourceFile) contains any top-level await expressions.
+ * This determines if the module function should be a coroutine.
+ */
+export function needsTopLevelAwait(node) {
+    let found = false;
+    const visitor = (n) => {
+        if (found)
+            return;
+        if (ts.isAwaitExpression(n)) {
+            found = true;
+            return;
+        }
+        if (ts.isForOfStatement(n) && n.awaitModifier) {
+            found = true;
+            return;
+        }
+        // Nested functions/classes have their own context
+        if (ts.isFunctionLike(n) || ts.isClassLike(n) ||
+            ts.isModuleDeclaration(n)) {
+            return;
+        }
+        ts.forEachChild(n, visitor);
+    };
+    ts.forEachChild(node, visitor);
+    return found;
+}
 /**
  * Validates and filters function parameters, checking for illegal "this"
  * and correctly positioned rest parameters.
@@ -744,3 +783,32 @@ export function validateFunctionParams(parameters) {
         return p;
     }) || [];
 }
+/**
+ * Traverses the AST upwards from the given node to find the nearest enclosing
+ * `FunctionDeclaration` node that contains a `ReturnStatement` ancestor.
+ *
+ * This function is useful for determining the function context in which a return
+ * statement appears. It starts from the provided node and walks up the parent
+ * chain, tracking whether a return statement has been encountered. Once a
+ * function declaration is found after encountering a return statement, it is returned.
+ *
+ * @param node - The starting TypeScript AST node.
+ * @returns The enclosing `ts.FunctionDeclaration` node if found, otherwise `undefined`.
+ */
+export function findEnclosingFunctionDeclarationFromReturnStatement(node) {
+    let current = node;
+    let foundReturn = false;
+    while (current) {
+        if (ts.isFunctionDeclaration(current)) {
+            if (foundReturn) {
+                return current;
+            }
+            break;
+        }
+        if (ts.isReturnStatement(current)) {
+            foundReturn = true;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}

package/dist/interpreter/core/codegen/index.js

@@ -0,0 +1,156 @@
+import ts from "typescript";
+import { DeclaredSymbols } from "../../ast/symbols.js";
+import { generateDestructuring } from "./destructuring-handlers.js";
+import { generateLambdaComponents, generateNativeLambda, generateWrappedLambda, } from "./function-handlers.js";
+import { escapeString, findEnclosingFunctionDeclarationFromReturnStatement, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isDeclarationCalledAsFunction, isDeclarationUsedAsValue, isDeclarationUsedBeforeInitialization, isGeneratorFunction, isVariableUsedWithoutDeclaration, markSymbolAsInitialized, needsTopLevelAwait, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
+import { visit } from "./visitor.js";
+export class CodeGenerator {
+    indentationLevel = 0;
+    typeAnalyzer;
+    isTypescript = false;
+    moduleFunctionName;
+    globalThisVar;
+    uniqueNameCounter = 0;
+    isWasm = false;
+    wasmExports = [];
+    // visitor
+    visit = visit;
+    // helpers
+    getDeclaredSymbols = getDeclaredSymbols;
+    generateUniqueName = generateUniqueName;
+    generateUniqueExceptionName = generateUniqueExceptionName;
+    hoistDeclaration = hoistDeclaration;
+    getScopeForNode = getScopeForNode;
+    indent = indent;
+    escapeString = escapeString;
+    getJsVarName = getJsVarName;
+    getDerefCode = getDerefCode;
+    getReturnCommand = getReturnCommand;
+    isBuiltinObject = isBuiltinObject;
+    isGeneratorFunction = isGeneratorFunction;
+    isAsyncFunction = isAsyncFunction;
+    prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
+    markSymbolAsInitialized = markSymbolAsInitialized;
+    isDeclarationCalledAsFunction = isDeclarationCalledAsFunction;
+    isDeclarationUsedAsValue = isDeclarationUsedAsValue;
+    isDeclarationUsedBeforeInitialization = isDeclarationUsedBeforeInitialization;
+    isVariableUsedWithoutDeclaration = isVariableUsedWithoutDeclaration;
+    validateFunctionParams = validateFunctionParams;
+    generateDestructuring = generateDestructuring;
+    findEnclosingFunctionDeclarationFromReturnStatement = findEnclosingFunctionDeclarationFromReturnStatement;
+    // function handlers
+    generateLambdaComponents = generateLambdaComponents;
+    generateNativeLambda = generateNativeLambda;
+    generateWrappedLambda = generateWrappedLambda;
+    /**
+     * Main entry point for the code generation process.
+     */
+    generate(ast, analyzer, isTypescript, isWasm = false) {
+        this.typeAnalyzer = analyzer;
+        this.isTypescript = isTypescript;
+        this.isWasm = isWasm;
+        this.wasmExports = [];
+        this.moduleFunctionName = this.generateUniqueName("__module_entry_point_", this.getDeclaredSymbols(ast));
+        this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
+        const isAsyncModule = needsTopLevelAwait(ast);
+        const moduleReturnType = isAsyncModule
+            ? "jspp::JsPromise"
+            : "jspp::AnyValue";
+        const moduleReturnCommand = isAsyncModule ? "co_return" : "return";
+        let declarations = `#include "jspp.hpp"\n#include "library/global_usings.hpp"\n`;
+        if (isWasm) {
+            declarations += `#include <emscripten.h>\n`;
+        }
+        declarations += `\n`;
+        // module function code
+        let moduleCode = `${moduleReturnType} ${this.moduleFunctionName}() {\n`;
+        this.indentationLevel++;
+        moduleCode +=
+            `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
+        const context = {
+            currentScopeNode: ast,
+            isMainContext: true,
+            isInsideFunction: true,
+            isFunctionBody: true,
+            isInsideAsyncFunction: isAsyncModule,
+            globalScopeSymbols: new DeclaredSymbols(),
+            localScopeSymbols: new DeclaredSymbols(),
+        };
+        const generatedBody = this.visit(ast, context);
+        moduleCode += generatedBody;
+        moduleCode +=
+            `${this.indent()}${moduleReturnCommand} jspp::Constants::UNDEFINED;\n`;
+        this.indentationLevel--;
+        moduleCode += "}\n\n";
+        // Wasm Exports
+        let wasmGlobalPointers = "";
+        let wasmWrappers = "";
+        if (isWasm) {
+            for (const exp of this.wasmExports) {
+                const paramTypes = exp.params.map((_, i) => `jspp::AnyValue`);
+                const paramList = paramTypes.length > 0
+                    ? `, ${paramTypes.join(", ")}`
+                    : "";
+                const pointerName = `__wasm_export_ptr_${exp.jsName}`;
+                wasmGlobalPointers +=
+                    `std::function<jspp::AnyValue(jspp::AnyValue${paramList})> ${pointerName} = nullptr;\n`;
+                const wrapperParamList = exp.params.map((_, i) => `double p${i}`).join(", ");
+                const callArgsList = exp.params.map((_, i) => `jspp::AnyValue::make_number(p${i})`);
+                const callArgs = callArgsList.length > 0
+                    ? `, ${callArgsList.join(", ")}`
+                    : "";
+                wasmWrappers += `extern "C" EMSCRIPTEN_KEEPALIVE\n`;
+                wasmWrappers +=
+                    `double wasm_export_${exp.jsName}(${wrapperParamList}) {\n`;
+                wasmWrappers += `    if (!${pointerName}) return 0;\n`;
+                wasmWrappers +=
+                    `    auto res = ${pointerName}(global${callArgs});\n`;
+                wasmWrappers +=
+                    `    return jspp::Operators_Private::ToNumber(res);\n`;
+                wasmWrappers += `}\n\n`;
+            }
+        }
+        // main function code
+        let mainCode = "int main(int argc, char** argv) {\n";
+        this.indentationLevel++;
+        mainCode += `${this.indent()}try {\n`;
+        this.indentationLevel++;
+        mainCode += `${this.indent()}jspp::initialize_runtime();\n`;
+        mainCode += `${this.indent()}jspp::setup_process_argv(argc, argv);\n`;
+        if (isAsyncModule) {
+            mainCode +=
+                `${this.indent()}auto p = ${this.moduleFunctionName}();\n`;
+            mainCode +=
+                `${this.indent()}p.then(nullptr, [](jspp::AnyValue err) {\n`;
+            this.indentationLevel++;
+            mainCode +=
+                `${this.indent()}auto error = std::make_shared<jspp::AnyValue>(err);\n`;
+            this.indentationLevel++;
+            mainCode +=
+                `${this.indent()}console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+            mainCode += `${this.indent()}std::exit(1);\n`;
+            this.indentationLevel--;
+            mainCode += `${this.indent()}});\n`;
+        }
+        else {
+            mainCode += `${this.indent()}${this.moduleFunctionName}();\n`;
+        }
+        mainCode += `${this.indent()}jspp::Scheduler::instance().run();\n`;
+        this.indentationLevel--;
+        mainCode += `${this.indent()}} catch (const std::exception& ex) {\n`;
+        this.indentationLevel++;
+        mainCode +=
+            `${this.indent()}auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n`;
+        this.indentationLevel++;
+        mainCode +=
+            `${this.indent()}console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+        mainCode += `${this.indent()}return 1;\n`;
+        this.indentationLevel--;
+        mainCode += `${this.indent()}}\n`;
+        mainCode += `${this.indent()}return 0;\n`;
+        this.indentationLevel--;
+        mainCode += `}`;
+        return declarations + wasmGlobalPointers + wasmWrappers + moduleCode +
+            mainCode;
+    }
+}

package/dist/{core → interpreter/core}/codegen/literal-handlers.js

@@ -11,6 +11,15 @@ export function visitIdentifier(node) {
     return node.text;
 }
 export function visitNumericLiteral(node) {
+    const getOuterExpr = (n) => !ts.isParenthesizedExpression(n) &&
+        n.kind !== ts.SyntaxKind.FirstLiteralToken
+        ? n
+        : getOuterExpr(n.parent);
+    const outerExpr = getOuterExpr(node);
+    if (!ts.isPropertyAccessExpression(outerExpr) &&
+        !ts.isElementAccessExpression(outerExpr)) {
+        return this.escapeString(node.text);
+    }
     if (node.text === "0" || (node.text.startsWith("0.") &&
         !node.text.substring(2).split("").some((c) => c !== "0")))
         return "jspp::Constants::ZERO";