@ugo-studio/jspp 0.3.3 → 0.3.4

package/README.md

@@ -61,7 +61,7 @@ Using these keywords as variable names will result in a `SyntaxError`.
 To use JSPP as a command-line tool, install it globally via npm:
 
 ```sh
-npm i @ugo-studio/jspp -g
+npm i @ugo-studio/jspp@latest -g
 ```
 
 ## For Developers
@@ -86,7 +86,7 @@ To contribute to JSPP or run its test suite, follow these steps:
     ```sh
     bun install
     ```
-    *Note: The `postinstall` script will automatically check for your C++ compiler and precompile the runtime headers and library.*
+    *Note: The `postinstall` script will automatically check for your C++ compiler and setup emsdk for wasm support.*
 
 ## Usage
 
@@ -106,10 +106,6 @@ jspp my-code/test.ts
 
 The transpiled C++ file and executable will be generated in the same directory as the input file and cleaned up after execution (unless `--keep-cpp` is used).
 
-### Timing and Reports
-
-In debug mode (default), JSPP provides a compilation time report using GCC's `-ftime-report`. This helps track the performance of the transpilation and compilation phases.
-
 ## Roadmap
 
 This project is ambitious, and there is a long and exciting road ahead. Here is a high-level overview of the planned features and the project's current standing.

package/dist/cli/args.js

@@ -5,6 +5,7 @@ export function parseArgs(rawArgs) {
     let jsFilePathArg = null;
     let isRelease = false;
     let keepCpp = false;
+    let shouldRunOutput = false;
     let outputExePath = null;
     let scriptArgs = [];
     let target = "native";
@@ -22,6 +23,9 @@ export function parseArgs(rawArgs) {
         else if (arg === "--keep-cpp") {
             keepCpp = true;
         }
+        else if (arg === "--run-output") {
+            shouldRunOutput = true;
+        }
         else if (arg === "-t" || arg === "--target") {
             if (i + 1 < rawArgs.length) {
                 const targetValue = rawArgs[i + 1]?.toLowerCase();
@@ -72,6 +76,7 @@ export function parseArgs(rawArgs) {
         jsFilePath: path.resolve(process.cwd(), jsFilePathArg),
         isRelease,
         keepCpp,
+        shouldRunOutput,
         outputExePath: outputExePath
             ? path.resolve(process.cwd(), outputExePath)
             : null,

package/dist/cli/compiler.js

@@ -49,5 +49,5 @@ export async function compileCpp(cppFilePath, exeFilePath, pchDir, preludePath,
     }
     const compileEndTime = performance.now();
     const compileTime = msToHumanReadable(compileEndTime - compileStartTime);
-    spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset} ${COLORS.dim}[${compileTime}]${COLORS.reset}`);
+    spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${exeFilePath}${COLORS.reset} ${COLORS.dim}[${compileTime}]${COLORS.reset}`);
 }

package/dist/cli/index.js

@@ -17,7 +17,7 @@ const emsdkEnv = {
     PATH: `${path.join(pkgDir, ".emsdk")}${path.delimiter}${path.join(pkgDir, ".emsdk", "upstream", "emscripten")}${path.delimiter}${process.env.PATH}`,
 };
 async function main() {
-    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs, target, } = parseArgs(process.argv.slice(2));
+    const { jsFilePath, isRelease, keepCpp, shouldRunOutput, outputExePath, scriptArgs, target, } = parseArgs(process.argv.slice(2));
     const isWasm = target === "wasm";
     const ext = path.extname(jsFilePath);
     const jsFileName = path.basename(jsFilePath, ext);
@@ -80,7 +80,9 @@ async function main() {
             }
         }
         // 4. Execution Phase
-        await runOutput(exeFilePath, scriptArgs, isWasm);
+        if (shouldRunOutput) {
+            await runOutput(exeFilePath, scriptArgs, isWasm);
+        }
     }
     catch (error) {
         if (error instanceof CompilerError) {

package/dist/interpreter/analysis/typeAnalyzer.js

@@ -568,7 +568,7 @@ export class TypeAnalyzer {
         };
         const visitor = {
             // Enter new scope for any block-like structure
-            Block: {
+            [ts.SyntaxKind.Block]: {
                 enter: (node, parent) => {
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
                         null;
@@ -591,7 +591,7 @@ export class TypeAnalyzer {
                 },
                 exit: () => this.scopeManager.exitScope(),
             },
-            ForStatement: {
+            [ts.SyntaxKind.ForStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -604,7 +604,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            ForOfStatement: {
+            [ts.SyntaxKind.ForOfStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -617,7 +617,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            ForInStatement: {
+            [ts.SyntaxKind.ForInStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -649,7 +649,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            WhileStatement: {
+            [ts.SyntaxKind.WhileStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -662,7 +662,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            DoStatement: {
+            [ts.SyntaxKind.DoStatement]: {
                 enter: (node) => {
                     this.loopDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -675,7 +675,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            SwitchStatement: {
+            [ts.SyntaxKind.SwitchStatement]: {
                 enter: (node) => {
                     this.switchDepth++;
                     const currentFuncNode = this.functionStack[this.functionStack.length - 1] ??
@@ -688,7 +688,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            LabeledStatement: {
+            [ts.SyntaxKind.LabeledStatement]: {
                 enter: (node) => {
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                     this.labelStack.push(node.label.text);
@@ -697,7 +697,7 @@ export class TypeAnalyzer {
                     this.labelStack.pop();
                 },
             },
-            BreakStatement: {
+            [ts.SyntaxKind.BreakStatement]: {
                 enter: (node) => {
                     const breakNode = node;
                     if (breakNode.label) {
@@ -712,7 +712,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            ContinueStatement: {
+            [ts.SyntaxKind.ContinueStatement]: {
                 enter: (node) => {
                     const continueNode = node;
                     if (continueNode.label) {
@@ -729,7 +729,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            ArrowFunction: {
+            [ts.SyntaxKind.ArrowFunction]: {
                 enter: (node) => {
                     if (ts.isArrowFunction(node)) {
                         const funcType = {
@@ -760,7 +760,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            FunctionExpression: {
+            [ts.SyntaxKind.FunctionExpression]: {
                 enter: (node) => {
                     if (ts.isFunctionExpression(node)) {
                         const funcType = {
@@ -795,7 +795,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            FunctionDeclaration: {
+            [ts.SyntaxKind.FunctionDeclaration]: {
                 enter: (node) => {
                     if (ts.isFunctionDeclaration(node)) {
                         // Define the function in the current scope.
@@ -831,7 +831,44 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            ClassDeclaration: {
+            [ts.SyntaxKind.GetAccessor]: {
+                enter: (node) => {
+                    if (ts.isGetAccessorDeclaration(node)) {
+                        this.scopeManager.enterScope(node);
+                        this.nodeToScope.set(node, this.scopeManager.currentScope);
+                        this.functionStack.push(node);
+                    }
+                },
+                exit: (node) => {
+                    if (ts.isGetAccessorDeclaration(node)) {
+                        this.functionStack.pop();
+                    }
+                    this.scopeManager.exitScope();
+                },
+            },
+            [ts.SyntaxKind.SetAccessor]: {
+                enter: (node) => {
+                    if (ts.isSetAccessorDeclaration(node)) {
+                        this.scopeManager.enterScope(node);
+                        this.nodeToScope.set(node, this.scopeManager.currentScope);
+                        // Define parameters in the new scope
+                        node.parameters.forEach((p) => {
+                            if (p.getText() == "this") { // Catch invalid parameters
+                                throw new CompilerError("Cannot use 'this' as a parameter name.", p, "SyntaxError");
+                            }
+                            this.defineParameter(p.name, p);
+                        });
+                        this.functionStack.push(node);
+                    }
+                },
+                exit: (node) => {
+                    if (ts.isSetAccessorDeclaration(node)) {
+                        this.functionStack.pop();
+                    }
+                    this.scopeManager.exitScope();
+                },
+            },
+            [ts.SyntaxKind.ClassDeclaration]: {
                 enter: (node) => {
                     const classNode = node;
                     if (classNode.name) {
@@ -853,7 +890,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            EnumDeclaration: {
+            [ts.SyntaxKind.EnumDeclaration]: {
                 enter: (node) => {
                     const enumNode = node;
                     if (enumNode.name) {
@@ -872,7 +909,7 @@ export class TypeAnalyzer {
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
             },
-            MethodDeclaration: {
+            [ts.SyntaxKind.MethodDeclaration]: {
                 enter: (node) => {
                     if (ts.isMethodDeclaration(node)) {
                         const funcType = {
@@ -898,7 +935,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            Constructor: {
+            [ts.SyntaxKind.Constructor]: {
                 enter: (node) => {
                     if (ts.isConstructorDeclaration(node)) {
                         const funcType = {
@@ -923,7 +960,7 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
-            VariableDeclaration: {
+            [ts.SyntaxKind.VariableDeclaration]: {
                 enter: (node) => {
                     if (ts.isVariableDeclaration(node)) {
                         // Check if it is an ambient declaration (declare var/let/const ...)
@@ -990,8 +1027,8 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            Identifier: {
-                enter: (node, parent) => {
+            [ts.SyntaxKind.Identifier]: {
+                enter: (node) => {
                     if (ts.isIdentifier(node)) {
                         if (isBuiltinObject.call(this, node))
                             return;
@@ -1027,7 +1064,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            BinaryExpression: {
+            [ts.SyntaxKind.BinaryExpression]: {
                 enter: (node) => {
                     if (ts.isBinaryExpression(node)) {
                         const isAssignment = node.operatorToken.kind >=
@@ -1050,7 +1087,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            CallExpression: {
+            [ts.SyntaxKind.CallExpression]: {
                 enter: (node) => {
                     if (ts.isCallExpression(node)) {
                         const callee = node.expression;
@@ -1070,7 +1107,7 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            ReturnStatement: {
+            [ts.SyntaxKind.ReturnStatement]: {
                 enter: (node) => {
                     if (ts.isReturnStatement(node) && node.expression) {
                         const currentFuncNode = this.functionStack[this.functionStack.length - 1];
@@ -1086,14 +1123,14 @@ export class TypeAnalyzer {
                     }
                 },
             },
-            PostfixUnaryExpression: {
+            [ts.SyntaxKind.PostfixUnaryExpression]: {
                 enter: (node) => {
                     if (ts.isPostfixUnaryExpression(node)) {
                         crossScopeModificationVisitor(node.operand);
                     }
                 },
             },
-            PrefixUnaryExpression: {
+            [ts.SyntaxKind.PrefixUnaryExpression]: {
                 enter: (node) => {
                     if (ts.isPrefixUnaryExpression(node)) {
                         const op = node.operator;

package/dist/interpreter/core/codegen/control-flow-handlers.js

@@ -153,16 +153,19 @@ export function visitForInStatement(node, context) {
         derefExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
     }
     const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
+    const visitContext = {
+        ...context,
+        globalScopeSymbols: this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols),
+        localScopeSymbols: new DeclaredSymbols(),
+        currentLabel: undefined,
+        isFunctionBody: false,
+    };
     code +=
         `${this.indent()}std::vector<jspp::AnyValue> ${keysVar} = jspp::Access::get_object_keys(${derefExpr});\n`;
     code += `${this.indent()}for (const auto& ${varName}_val : ${keysVar}) {\n`;
     this.indentationLevel++;
     code += `${this.indent()}${assignmentTarget} = ${varName}_val;\n`;
-    code += this.visit(forIn.statement, {
-        ...context,
-        currentLabel: undefined,
-        isFunctionBody: false,
-    });
+    code += this.visit(forIn.statement, visitContext);
     this.indentationLevel--;
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}_continue:;\n`;
@@ -188,6 +191,7 @@ export function visitForOfStatement(node, context) {
     this.indentationLevel++; // Enter a new scope for the for-of loop
     let elemName = "";
     let assignmentTarget = "";
+    let declarationType = DeclarationType.const;
     code += `${this.indent()}{\n`;
     if (ts.isVariableDeclarationList(forOf.initializer)) {
         const decl = forOf.initializer.declarations[0];
@@ -205,6 +209,11 @@ export function visitForOfStatement(node, context) {
                     `${this.indent()}jspp::AnyValue ${elemName} = jspp::Constants::UNDEFINED;\n`;
                 assignmentTarget = elemName;
             }
+            declarationType = (decl.parent.flags & (ts.NodeFlags.Let)) !== 0
+                ? DeclarationType.let
+                : (decl.parent.flags & (ts.NodeFlags.Const)) !== 0
+                    ? DeclarationType.const
+                    : DeclarationType.var;
         }
     }
     else if (ts.isIdentifier(forOf.initializer)) {
@@ -214,6 +223,12 @@ export function visitForOfStatement(node, context) {
         assignmentTarget = typeInfo?.needsHeapAllocation
             ? `*${elemName}`
             : elemName;
+        declarationType =
+            (forOf.initializer.parent.flags & (ts.NodeFlags.Let)) !== 0
+                ? DeclarationType.let
+                : (forOf.initializer.parent.flags & (ts.NodeFlags.Const)) !== 0
+                    ? DeclarationType.const
+                    : DeclarationType.var;
     }
     const iterableExpr = this.visit(forOf.expression, context);
     let derefIterable = iterableExpr;
@@ -230,6 +245,19 @@ export function visitForOfStatement(node, context) {
     const nextRes = this.generateUniqueName("__next_res", declaredSymbols);
     const isAwait = forOf.awaitModifier !== undefined;
     const varName = this.getJsVarName(forOf.expression);
+    const visitContext = {
+        ...context,
+        globalScopeSymbols: this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols),
+        localScopeSymbols: new DeclaredSymbols(),
+        currentLabel: undefined,
+        isFunctionBody: false,
+    };
+    if (elemName) {
+        visitContext.localScopeSymbols.add(elemName, {
+            type: declarationType,
+            checks: { initialized: true },
+        });
+    }
     code += `${this.indent()}auto ${iterableRef} = ${derefIterable};\n`;
     if (isAwait) {
         code +=
@@ -254,11 +282,7 @@ export function visitForOfStatement(node, context) {
     this.indentationLevel++;
     code +=
         `${this.indent()}${assignmentTarget} = ${nextRes}.get_own_property("value");\n`;
-    code += this.visit(forOf.statement, {
-        ...context,
-        currentLabel: undefined,
-        isFunctionBody: false,
-    });
+    code += this.visit(forOf.statement, visitContext);
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}_continue:;\n`;
     }

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

@@ -123,7 +123,7 @@ export function generateLambdaComponents(node, context, options) {
         }
     });
     // Extract lambda parameters from arguments span/vector
-    const generateParamsBuilder = () => {
+    const wrappedFuncParamsBuilder = () => {
         let paramsCode = "";
         this.validateFunctionParams(node.parameters).forEach((p, i) => {
             if (ts.isIdentifier(p.name)) {
@@ -152,14 +152,19 @@ export function generateLambdaComponents(node, context, options) {
                     return;
                 }
                 // Normal parameter
-                const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
-                if (typeInfo?.needsHeapAllocation) {
-                    paramsCode +=
-                        `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
-                }
-                else {
-                    paramsCode +=
-                        `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
+                const isUsedInFuncBody = !!p.initializer ||
+                    this.isDeclarationUsedAsValue(p, node) ||
+                    this.isDeclarationCalledAsFunction(p, node);
+                if (isUsedInFuncBody) {
+                    const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
+                    if (typeInfo?.needsHeapAllocation) {
+                        paramsCode +=
+                            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
+                    }
+                    else {
+                        paramsCode +=
+                            `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
+                    }
                 }
             }
             else {
@@ -225,7 +230,7 @@ export function generateLambdaComponents(node, context, options) {
                 }
             });
             this.indentationLevel++;
-            paramsContent += generateParamsBuilder();
+            paramsContent += wrappedFuncParamsBuilder();
             this.indentationLevel--;
             // The block visitor already adds braces, so we need to remove the opening brace to inject the preamble and param extraction.
             const properIndentationLevel = this.indentationLevel;
@@ -250,7 +255,7 @@ export function generateLambdaComponents(node, context, options) {
         }
         else {
             this.indentationLevel++;
-            paramsContent += generateParamsBuilder();
+            paramsContent += wrappedFuncParamsBuilder();
             const properIndentationLevel = this.indentationLevel;
             const nodeBody = node.body;
             getBlockContentWithoutOpeningBrace = (isInsideNativeLambda) => {

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

@@ -799,7 +799,11 @@ export function findEnclosingFunctionDeclarationFromReturnStatement(node) {
     let current = node;
     let foundReturn = false;
     while (current) {
-        if (ts.isFunctionDeclaration(current)) {
+        if (ts.isFunctionDeclaration(current) ||
+            ts.isFunctionExpression(current) ||
+            ts.isArrowFunction(current) ||
+            ts.isMethodDeclaration(current) ||
+            ts.isConstructorDeclaration(current)) {
             if (foundReturn) {
                 return current;
             }

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

@@ -106,7 +106,7 @@ export class CodeGenerator {
                 wasmWrappers +=
                     `    auto res = ${pointerName}(global${callArgs});\n`;
                 wasmWrappers +=
-                    `    return jspp::Operators_Private::ToNumber(res);\n`;
+                    `    return jspp::NumberOperators::ToDouble(res);\n`;
                 wasmWrappers += `}\n\n`;
             }
         }

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

@@ -819,22 +819,26 @@ export function visitReturnStatement(node, context) {
                 return `${this.indent()}jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)});\n`; // THROWS, not returns
             }
             if (typeInfo &&
-                !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
                 finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
-            const exprReturnType = this.typeAnalyzer.inferNodeReturnType(expr);
-            if (exprReturnType === "number" &&
-                context.isInsideNativeLambda &&
-                context.isInsideFunction) {
-                const funcDecl = this
-                    .findEnclosingFunctionDeclarationFromReturnStatement(expr);
-                if (funcDecl) {
-                    const funcReturnType = this.typeAnalyzer
-                        .inferFunctionReturnType(funcDecl);
-                    if (funcReturnType === "number") {
+            const funcDecl = this
+                .findEnclosingFunctionDeclarationFromReturnStatement(expr);
+            if (funcDecl) {
+                const funcReturnType = this.typeAnalyzer
+                    .inferFunctionReturnType(funcDecl);
+                if (funcReturnType === "number" &&
+                    context.isInsideNativeLambda &&
+                    context.isInsideFunction) {
+                    const exprReturnType = this.typeAnalyzer
+                        .inferNodeReturnType(expr);
+                    if (exprReturnType === "number") {
                         finalExpr = `${finalExpr}.as_double()`;
                     }
+                    else {
+                        finalExpr =
+                            `jspp::NumberOperators::ToDouble(${finalExpr})`;
+                    }
                 }
             }
         }

package/dist/interpreter/core/traverser.js

@@ -4,8 +4,7 @@ export class Traverser {
         this.traverseNode(node, null, visitor);
     }
     traverseNode(node, parent, visitor) {
-        const nodeKind = ts.SyntaxKind[node.kind];
-        const visitorActions = visitor[nodeKind];
+        const visitorActions = visitor[node.kind];
         if (visitorActions && visitorActions.enter) {
             visitorActions.enter(node, parent);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -14,7 +14,7 @@
     "scripts"
   ],
   "scripts": {
-    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts && bun run scripts/precompile-headers.ts --mode debug",
+    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts",
     "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",

package/src/prelude/library/array.cpp

@@ -78,7 +78,7 @@ namespace jspp {
                     }
                 } else {
                     auto lenVal = items.get_property_with_receiver("length", items);
-                    size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                    size_t len = static_cast<size_t>(jspp::NumberOperators::ToUint32(lenVal));
                     
                     for (size_t k = 0; k < len; ++k) {
                         auto kVal = items.get_property_with_receiver(std::to_string(k), items);
@@ -149,7 +149,7 @@ namespace jspp {
                     }
                 } else {
                     auto lenVal = items.get_property_with_receiver("length", items);
-                    size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                    size_t len = static_cast<size_t>(jspp::NumberOperators::ToUint32(lenVal));
                     for (size_t k = 0; k < len; ++k) {
                         auto kVal = items.get_property_with_receiver(std::to_string(k), items);
                         if (kVal.is_promise()) kVal = co_await kVal;

package/src/prelude/library/math.cpp

@@ -11,7 +11,7 @@ namespace jspp {
 
         double GetArgAsDouble(std::span<const jspp::AnyValue> args, size_t index) {
             if (index >= args.size()) return std::numeric_limits<double>::quiet_NaN();
-            return Operators_Private::ToNumber(args[index]);
+            return NumberOperators::ToDouble(args[index]);
         }
 
         jspp::AnyValue MathFunc1(std::span<const jspp::AnyValue> args, double (*func)(double)) {
@@ -86,7 +86,7 @@ namespace jspp {
             }, "ceil"));
 
             defMutable("clz32", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
-                uint32_t val = Operators_Private::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
+                uint32_t val = NumberOperators::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
                 if (val == 0) return AnyValue::make_number(32);
                 return AnyValue::make_number(std::countl_zero(val));
             }, "clz32"));
@@ -119,7 +119,7 @@ namespace jspp {
             defMutable("hypot", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 double result = 0;
                 for (const auto& arg : args) {
-                    double val = Operators_Private::ToNumber(arg);
+                    double val = NumberOperators::ToDouble(arg);
                     if (std::isinf(val)) return AnyValue::make_number(std::numeric_limits<double>::infinity());
                     result = std::hypot(result, val);
                 }
@@ -127,8 +127,8 @@ namespace jspp {
             }, "hypot"));
 
             defMutable("imul", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
-                int32_t a = Operators_Private::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
-                int32_t b = Operators_Private::ToInt32(args.size() < 2 ? Constants::UNDEFINED : args[1]);
+                int32_t a = NumberOperators::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
+                int32_t b = NumberOperators::ToInt32(args.size() < 2 ? Constants::UNDEFINED : args[1]);
                 return AnyValue::make_number(a * b);
             }, "imul"));
 
@@ -151,7 +151,7 @@ namespace jspp {
             defMutable("max", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 double maxVal = -std::numeric_limits<double>::infinity();
                 for (const auto& arg : args) {
-                    double val = Operators_Private::ToNumber(arg);
+                    double val = NumberOperators::ToDouble(arg);
                     if (std::isnan(val)) return AnyValue::make_nan();
                     if (val > maxVal) maxVal = val;
                 }
@@ -161,7 +161,7 @@ namespace jspp {
             defMutable("min", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 double minVal = std::numeric_limits<double>::infinity();
                 for (const auto& arg : args) {
-                    double val = Operators_Private::ToNumber(arg);
+                    double val = NumberOperators::ToDouble(arg);
                     if (std::isnan(val)) return AnyValue::make_nan();
                     if (val < minVal) minVal = val;
                 }
@@ -238,7 +238,7 @@ namespace jspp {
                     auto nextRes = nextFunc.call(iterObj, std::span<const jspp::AnyValue>{}, "next");
                     if (is_truthy(nextRes.get_own_property("done"))) break;
                     
-                    double val = Operators_Private::ToNumber(nextRes.get_own_property("value"));
+                    double val = NumberOperators::ToDouble(nextRes.get_own_property("value"));
                     if (std::isnan(val)) {
                         sum = std::numeric_limits<double>::quiet_NaN();
                         break;

package/src/prelude/utils/operators.hpp

@@ -192,15 +192,15 @@ namespace jspp
     // --- UNARY OPERATORS ---
     inline AnyValue plus(const AnyValue &val)
     {
-        return AnyValue::make_number(Operators_Private::ToNumber(val));
+        return AnyValue::make_number(NumberOperators::ToDouble(val));
     }
     inline AnyValue negate(const AnyValue &val)
     {
-        return AnyValue::make_number(-Operators_Private::ToNumber(val));
+        return AnyValue::make_number(-NumberOperators::ToDouble(val));
     }
     inline AnyValue bitwise_not(const AnyValue &val)
     {
-        return AnyValue::make_number(~Operators_Private::ToInt32(val));
+        return AnyValue::make_number(~NumberOperators::ToInt32(val));
     }
     inline AnyValue logical_not(const AnyValue &val)
     {

package/src/prelude/utils/operators_native.hpp

@@ -12,10 +12,10 @@
 namespace jspp
 {
     // Private namespace for helper functions that implement JS type conversions.
-    namespace Operators_Private
+    namespace NumberOperators
     {
-        // Implements the ToNumber abstract operation from ECMA-262.
-        inline double ToNumber(const AnyValue &val)
+        // Implements the ToDouble abstract operation from ECMA-262.
+        inline double ToDouble(const AnyValue &val)
         {
             if (val.is_number())
                 return val.as_double();
@@ -57,7 +57,7 @@ namespace jspp
         // Implements the ToInt32 abstract operation from ECMA-262.
         inline int32_t ToInt32(const AnyValue &val)
         {
-            double num = ToNumber(val);
+            double num = ToDouble(val);
 
             if (std::isnan(num) || std::isinf(num) || num == 0)
                 return 0;
@@ -73,7 +73,7 @@ namespace jspp
         // Implements the ToUint32 abstract operation from ECMA-262.
         inline uint32_t ToUint32(const AnyValue &val)
         {
-            double num = ToNumber(val);
+            double num = ToDouble(val);
             if (std::isnan(num) || std::isinf(num) || num == 0)
                 return 0;
             double posInt = std::signbit(num) ? -std::floor(std::abs(num)) : std::floor(std::abs(num));
@@ -111,11 +111,11 @@ namespace jspp
     }
 
     // --- UNARY NATIVE ---
-    inline double plus_native(const AnyValue &val) { return Operators_Private::ToNumber(val); }
+    inline double plus_native(const AnyValue &val) { return NumberOperators::ToDouble(val); }
     inline double plus_native(double val) { return val; }
-    inline double negate_native(const AnyValue &val) { return -Operators_Private::ToNumber(val); }
+    inline double negate_native(const AnyValue &val) { return -NumberOperators::ToDouble(val); }
     inline double negate_native(double val) { return -val; }
-    inline double bitwise_not_native(const AnyValue &val) { return static_cast<double>(~Operators_Private::ToInt32(val)); }
+    inline double bitwise_not_native(const AnyValue &val) { return static_cast<double>(~NumberOperators::ToInt32(val)); }
     inline double bitwise_not_native(double val) { return static_cast<double>(~static_cast<int32_t>(val)); }
     inline bool logical_not_native(const AnyValue &val) { return !is_truthy(val); }
     inline bool logical_not_native(double val) { return !is_truthy(val); }
@@ -202,11 +202,11 @@ namespace jspp
         }
         if (lhs_type == JsType::Number && rhs_type == JsType::String)
         {
-            return lhs.as_double() == Operators_Private::ToNumber(rhs);
+            return lhs.as_double() == NumberOperators::ToDouble(rhs);
         }
         if (lhs_type == JsType::String && rhs_type == JsType::Number)
         {
-            return Operators_Private::ToNumber(lhs) == rhs.as_double();
+            return NumberOperators::ToDouble(lhs) == rhs.as_double();
         }
         if (lhs_type == JsType::Boolean)
         {
@@ -247,114 +247,114 @@ namespace jspp
 
     // --- PRIMITIVE ARITHMETIC OPERATORS ---
     inline double add_native(const double &lhs, const double &rhs) { return lhs + rhs; }
-    inline double add_native(const AnyValue &lhs, const AnyValue &rhs) { return Operators_Private::ToNumber(lhs) + Operators_Private::ToNumber(rhs); }
-    inline double add_native(const AnyValue &lhs, const double &rhs) { return Operators_Private::ToNumber(lhs) + rhs; }
-    inline double add_native(const double &lhs, const AnyValue &rhs) { return lhs + Operators_Private::ToNumber(rhs); }
+    inline double add_native(const AnyValue &lhs, const AnyValue &rhs) { return NumberOperators::ToDouble(lhs) + NumberOperators::ToDouble(rhs); }
+    inline double add_native(const AnyValue &lhs, const double &rhs) { return NumberOperators::ToDouble(lhs) + rhs; }
+    inline double add_native(const double &lhs, const AnyValue &rhs) { return lhs + NumberOperators::ToDouble(rhs); }
 
     inline double sub_native(const double &lhs, const double &rhs) { return lhs - rhs; }
-    inline double sub_native(const AnyValue &lhs, const AnyValue &rhs) { return Operators_Private::ToNumber(lhs) - Operators_Private::ToNumber(rhs); }
-    inline double sub_native(const AnyValue &lhs, const double &rhs) { return Operators_Private::ToNumber(lhs) - rhs; }
-    inline double sub_native(const double &lhs, const AnyValue &rhs) { return lhs - Operators_Private::ToNumber(rhs); }
+    inline double sub_native(const AnyValue &lhs, const AnyValue &rhs) { return NumberOperators::ToDouble(lhs) - NumberOperators::ToDouble(rhs); }
+    inline double sub_native(const AnyValue &lhs, const double &rhs) { return NumberOperators::ToDouble(lhs) - rhs; }
+    inline double sub_native(const double &lhs, const AnyValue &rhs) { return lhs - NumberOperators::ToDouble(rhs); }
 
     inline double mul_native(const double &lhs, const double &rhs) { return lhs * rhs; }
-    inline double mul_native(const AnyValue &lhs, const AnyValue &rhs) { return Operators_Private::ToNumber(lhs) * Operators_Private::ToNumber(rhs); }
-    inline double mul_native(const AnyValue &lhs, const double &rhs) { return Operators_Private::ToNumber(lhs) * rhs; }
-    inline double mul_native(const double &lhs, const AnyValue &rhs) { return lhs * Operators_Private::ToNumber(rhs); }
+    inline double mul_native(const AnyValue &lhs, const AnyValue &rhs) { return NumberOperators::ToDouble(lhs) * NumberOperators::ToDouble(rhs); }
+    inline double mul_native(const AnyValue &lhs, const double &rhs) { return NumberOperators::ToDouble(lhs) * rhs; }
+    inline double mul_native(const double &lhs, const AnyValue &rhs) { return lhs * NumberOperators::ToDouble(rhs); }
 
     inline double div_native(const double &lhs, const double &rhs) { return lhs / rhs; }
-    inline double div_native(const AnyValue &lhs, const AnyValue &rhs) { return Operators_Private::ToNumber(lhs) / Operators_Private::ToNumber(rhs); }
-    inline double div_native(const AnyValue &lhs, const double &rhs) { return Operators_Private::ToNumber(lhs) / rhs; }
-    inline double div_native(const double &lhs, const AnyValue &rhs) { return lhs / Operators_Private::ToNumber(rhs); }
+    inline double div_native(const AnyValue &lhs, const AnyValue &rhs) { return NumberOperators::ToDouble(lhs) / NumberOperators::ToDouble(rhs); }
+    inline double div_native(const AnyValue &lhs, const double &rhs) { return NumberOperators::ToDouble(lhs) / rhs; }
+    inline double div_native(const double &lhs, const AnyValue &rhs) { return lhs / NumberOperators::ToDouble(rhs); }
 
     inline double mod_native(const double &lhs, const double &rhs) { return std::fmod(lhs, rhs); }
-    inline double mod_native(const AnyValue &lhs, const AnyValue &rhs) { return std::fmod(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)); }
-    inline double mod_native(const AnyValue &lhs, const double &rhs) { return std::fmod(Operators_Private::ToNumber(lhs), rhs); }
-    inline double mod_native(const double &lhs, const AnyValue &rhs) { return std::fmod(lhs, Operators_Private::ToNumber(rhs)); }
+    inline double mod_native(const AnyValue &lhs, const AnyValue &rhs) { return std::fmod(NumberOperators::ToDouble(lhs), NumberOperators::ToDouble(rhs)); }
+    inline double mod_native(const AnyValue &lhs, const double &rhs) { return std::fmod(NumberOperators::ToDouble(lhs), rhs); }
+    inline double mod_native(const double &lhs, const AnyValue &rhs) { return std::fmod(lhs, NumberOperators::ToDouble(rhs)); }
 
     inline double pow_native(const double &lhs, const double &rhs) { return std::pow(lhs, rhs); }
-    inline double pow_native(const AnyValue &lhs, const AnyValue &rhs) { return std::pow(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)); }
-    inline double pow_native(const AnyValue &lhs, const double &rhs) { return std::pow(Operators_Private::ToNumber(lhs), rhs); }
-    inline double pow_native(const double &lhs, const AnyValue &rhs) { return std::pow(lhs, Operators_Private::ToNumber(rhs)); }
+    inline double pow_native(const AnyValue &lhs, const AnyValue &rhs) { return std::pow(NumberOperators::ToDouble(lhs), NumberOperators::ToDouble(rhs)); }
+    inline double pow_native(const AnyValue &lhs, const double &rhs) { return std::pow(NumberOperators::ToDouble(lhs), rhs); }
+    inline double pow_native(const double &lhs, const AnyValue &rhs) { return std::pow(lhs, NumberOperators::ToDouble(rhs)); }
 
     // --- PRIMITIVE COMPARISON OPERATORS ---
     inline bool less_than_native(const double &lhs, const double &rhs) { return lhs < rhs; }
-    inline bool less_than_native(const AnyValue &lhs, const AnyValue &rhs) { return less_than_native(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)); }
-    inline bool less_than_native(const AnyValue &lhs, const double &rhs) { return less_than_native(Operators_Private::ToNumber(lhs), rhs); }
-    inline bool less_than_native(const double &lhs, const AnyValue &rhs) { return less_than_native(lhs, Operators_Private::ToNumber(rhs)); }
+    inline bool less_than_native(const AnyValue &lhs, const AnyValue &rhs) { return less_than_native(NumberOperators::ToDouble(lhs), NumberOperators::ToDouble(rhs)); }
+    inline bool less_than_native(const AnyValue &lhs, const double &rhs) { return less_than_native(NumberOperators::ToDouble(lhs), rhs); }
+    inline bool less_than_native(const double &lhs, const AnyValue &rhs) { return less_than_native(lhs, NumberOperators::ToDouble(rhs)); }
 
     inline bool greater_than_native(const double &lhs, const double &rhs) { return lhs > rhs; }
-    inline bool greater_than_native(const AnyValue &lhs, const AnyValue &rhs) { return greater_than_native(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)); }
-    inline bool greater_than_native(const AnyValue &lhs, const double &rhs) { return greater_than_native(Operators_Private::ToNumber(lhs), rhs); }
-    inline bool greater_than_native(const double &lhs, const AnyValue &rhs) { return greater_than_native(lhs, Operators_Private::ToNumber(rhs)); }
+    inline bool greater_than_native(const AnyValue &lhs, const AnyValue &rhs) { return greater_than_native(NumberOperators::ToDouble(lhs), NumberOperators::ToDouble(rhs)); }
+    inline bool greater_than_native(const AnyValue &lhs, const double &rhs) { return greater_than_native(NumberOperators::ToDouble(lhs), rhs); }
+    inline bool greater_than_native(const double &lhs, const AnyValue &rhs) { return greater_than_native(lhs, NumberOperators::ToDouble(rhs)); }
 
     inline bool less_than_or_equal_native(const double &lhs, const double &rhs) { return lhs <= rhs; }
-    inline bool less_than_or_equal_native(const AnyValue &lhs, const AnyValue &rhs) { return less_than_or_equal_native(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)); }
-    inline bool less_than_or_equal_native(const AnyValue &lhs, const double &rhs) { return less_than_or_equal_native(Operators_Private::ToNumber(lhs), rhs); }
-    inline bool less_than_or_equal_native(const double &lhs, const AnyValue &rhs) { return less_than_or_equal_native(lhs, Operators_Private::ToNumber(rhs)); }
+    inline bool less_than_or_equal_native(const AnyValue &lhs, const AnyValue &rhs) { return less_than_or_equal_native(NumberOperators::ToDouble(lhs), NumberOperators::ToDouble(rhs)); }
+    inline bool less_than_or_equal_native(const AnyValue &lhs, const double &rhs) { return less_than_or_equal_native(NumberOperators::ToDouble(lhs), rhs); }
+    inline bool less_than_or_equal_native(const double &lhs, const AnyValue &rhs) { return less_than_or_equal_native(lhs, NumberOperators::ToDouble(rhs)); }
 
     inline bool greater_than_or_equal_native(const double &lhs, const double &rhs) { return lhs >= rhs; }
-    inline bool greater_than_or_equal_native(const AnyValue &lhs, const AnyValue &rhs) { return greater_than_or_equal_native(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)); }
-    inline bool greater_than_or_equal_native(const AnyValue &lhs, const double &rhs) { return greater_than_or_equal_native(Operators_Private::ToNumber(lhs), rhs); }
-    inline bool greater_than_or_equal_native(const double &lhs, const AnyValue &rhs) { return greater_than_or_equal_native(lhs, Operators_Private::ToNumber(rhs)); }
+    inline bool greater_than_or_equal_native(const AnyValue &lhs, const AnyValue &rhs) { return greater_than_or_equal_native(NumberOperators::ToDouble(lhs), NumberOperators::ToDouble(rhs)); }
+    inline bool greater_than_or_equal_native(const AnyValue &lhs, const double &rhs) { return greater_than_or_equal_native(NumberOperators::ToDouble(lhs), rhs); }
+    inline bool greater_than_or_equal_native(const double &lhs, const AnyValue &rhs) { return greater_than_or_equal_native(lhs, NumberOperators::ToDouble(rhs)); }
 
     inline bool equal_native(const double &lhs, const double &rhs) { return lhs == rhs; }
-    inline bool equal_native(const AnyValue &lhs, const AnyValue &rhs) { return equal_native(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)); }
-    inline bool equal_native(const AnyValue &lhs, const double &rhs) { return equal_native(Operators_Private::ToNumber(lhs), rhs); }
-    inline bool equal_native(const double &lhs, const AnyValue &rhs) { return equal_native(lhs, Operators_Private::ToNumber(rhs)); }
+    inline bool equal_native(const AnyValue &lhs, const AnyValue &rhs) { return equal_native(NumberOperators::ToDouble(lhs), NumberOperators::ToDouble(rhs)); }
+    inline bool equal_native(const AnyValue &lhs, const double &rhs) { return equal_native(NumberOperators::ToDouble(lhs), rhs); }
+    inline bool equal_native(const double &lhs, const AnyValue &rhs) { return equal_native(lhs, NumberOperators::ToDouble(rhs)); }
 
     inline bool not_equal_native(const double &lhs, const double &rhs) { return lhs != rhs; }
-    inline bool not_equal_native(const AnyValue &lhs, const AnyValue &rhs) { return not_equal_native(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)); }
-    inline bool not_equal_native(const AnyValue &lhs, const double &rhs) { return not_equal_native(Operators_Private::ToNumber(lhs), rhs); }
-    inline bool not_equal_native(const double &lhs, const AnyValue &rhs) { return not_equal_native(lhs, Operators_Private::ToNumber(rhs)); }
+    inline bool not_equal_native(const AnyValue &lhs, const AnyValue &rhs) { return not_equal_native(NumberOperators::ToDouble(lhs), NumberOperators::ToDouble(rhs)); }
+    inline bool not_equal_native(const AnyValue &lhs, const double &rhs) { return not_equal_native(NumberOperators::ToDouble(lhs), rhs); }
+    inline bool not_equal_native(const double &lhs, const AnyValue &rhs) { return not_equal_native(lhs, NumberOperators::ToDouble(rhs)); }
 
     // --- PRIMITIVE BITWISE OPERATORS ---
     inline double bitwise_and_native(const double &lhs, const double &rhs)
     {
         return static_cast<double>(static_cast<int32_t>(lhs) & static_cast<int32_t>(rhs));
     }
-    inline double bitwise_and_native(const AnyValue &lhs, const AnyValue &rhs) { return bitwise_and_native(Operators_Private::ToInt32(lhs), Operators_Private::ToInt32(rhs)); }
-    inline double bitwise_and_native(const AnyValue &lhs, const double &rhs) { return bitwise_and_native(Operators_Private::ToInt32(lhs), rhs); }
-    inline double bitwise_and_native(const double &lhs, const AnyValue &rhs) { return bitwise_and_native(lhs, Operators_Private::ToInt32(rhs)); }
+    inline double bitwise_and_native(const AnyValue &lhs, const AnyValue &rhs) { return bitwise_and_native(NumberOperators::ToInt32(lhs), NumberOperators::ToInt32(rhs)); }
+    inline double bitwise_and_native(const AnyValue &lhs, const double &rhs) { return bitwise_and_native(NumberOperators::ToInt32(lhs), rhs); }
+    inline double bitwise_and_native(const double &lhs, const AnyValue &rhs) { return bitwise_and_native(lhs, NumberOperators::ToInt32(rhs)); }
 
     inline double bitwise_or_native(const double &lhs, const double &rhs)
     {
         return static_cast<double>(static_cast<int32_t>(lhs) | static_cast<int32_t>(rhs));
     }
-    inline double bitwise_or_native(const AnyValue &lhs, const AnyValue &rhs) { return bitwise_or_native(Operators_Private::ToInt32(lhs), Operators_Private::ToInt32(rhs)); }
-    inline double bitwise_or_native(const AnyValue &lhs, const double &rhs) { return bitwise_or_native(Operators_Private::ToInt32(lhs), rhs); }
-    inline double bitwise_or_native(const double &lhs, const AnyValue &rhs) { return bitwise_or_native(lhs, Operators_Private::ToInt32(rhs)); }
+    inline double bitwise_or_native(const AnyValue &lhs, const AnyValue &rhs) { return bitwise_or_native(NumberOperators::ToInt32(lhs), NumberOperators::ToInt32(rhs)); }
+    inline double bitwise_or_native(const AnyValue &lhs, const double &rhs) { return bitwise_or_native(NumberOperators::ToInt32(lhs), rhs); }
+    inline double bitwise_or_native(const double &lhs, const AnyValue &rhs) { return bitwise_or_native(lhs, NumberOperators::ToInt32(rhs)); }
 
     inline double bitwise_xor_native(const double &lhs, const double &rhs)
     {
         return static_cast<double>(static_cast<int32_t>(lhs) ^ static_cast<int32_t>(rhs));
     }
-    inline double bitwise_xor_native(const AnyValue &lhs, const AnyValue &rhs) { return bitwise_xor_native(Operators_Private::ToInt32(lhs), Operators_Private::ToInt32(rhs)); }
-    inline double bitwise_xor_native(const AnyValue &lhs, const double &rhs) { return bitwise_xor_native(Operators_Private::ToInt32(lhs), rhs); }
-    inline double bitwise_xor_native(const double &lhs, const AnyValue &rhs) { return bitwise_xor_native(lhs, Operators_Private::ToInt32(rhs)); }
+    inline double bitwise_xor_native(const AnyValue &lhs, const AnyValue &rhs) { return bitwise_xor_native(NumberOperators::ToInt32(lhs), NumberOperators::ToInt32(rhs)); }
+    inline double bitwise_xor_native(const AnyValue &lhs, const double &rhs) { return bitwise_xor_native(NumberOperators::ToInt32(lhs), rhs); }
+    inline double bitwise_xor_native(const double &lhs, const AnyValue &rhs) { return bitwise_xor_native(lhs, NumberOperators::ToInt32(rhs)); }
 
     inline double left_shift_native(const double &lhs, const double &rhs)
     {
         return static_cast<double>(static_cast<int32_t>(lhs) << (static_cast<int32_t>(rhs) & 0x1F));
     }
-    inline double left_shift_native(const AnyValue &lhs, const AnyValue &rhs) { return left_shift_native(Operators_Private::ToInt32(lhs), Operators_Private::ToInt32(rhs)); }
-    inline double left_shift_native(const AnyValue &lhs, const double &rhs) { return left_shift_native(Operators_Private::ToInt32(lhs), rhs); }
-    inline double left_shift_native(const double &lhs, const AnyValue &rhs) { return left_shift_native(lhs, Operators_Private::ToInt32(rhs)); }
+    inline double left_shift_native(const AnyValue &lhs, const AnyValue &rhs) { return left_shift_native(NumberOperators::ToInt32(lhs), NumberOperators::ToInt32(rhs)); }
+    inline double left_shift_native(const AnyValue &lhs, const double &rhs) { return left_shift_native(NumberOperators::ToInt32(lhs), rhs); }
+    inline double left_shift_native(const double &lhs, const AnyValue &rhs) { return left_shift_native(lhs, NumberOperators::ToInt32(rhs)); }
 
     inline double right_shift_native(const double &lhs, const double &rhs)
     {
         return static_cast<double>(static_cast<int32_t>(lhs) >> (static_cast<int32_t>(rhs) & 0x1F));
     }
-    inline double right_shift_native(const AnyValue &lhs, const AnyValue &rhs) { return right_shift_native(Operators_Private::ToInt32(lhs), Operators_Private::ToInt32(rhs)); }
-    inline double right_shift_native(const AnyValue &lhs, const double &rhs) { return right_shift_native(Operators_Private::ToInt32(lhs), rhs); }
-    inline double right_shift_native(const double &lhs, const AnyValue &rhs) { return right_shift_native(lhs, Operators_Private::ToInt32(rhs)); }
+    inline double right_shift_native(const AnyValue &lhs, const AnyValue &rhs) { return right_shift_native(NumberOperators::ToInt32(lhs), NumberOperators::ToInt32(rhs)); }
+    inline double right_shift_native(const AnyValue &lhs, const double &rhs) { return right_shift_native(NumberOperators::ToInt32(lhs), rhs); }
+    inline double right_shift_native(const double &lhs, const AnyValue &rhs) { return right_shift_native(lhs, NumberOperators::ToInt32(rhs)); }
 
     inline double unsigned_right_shift_native(const double &lhs, const double &rhs)
     {
         uint32_t l = static_cast<uint32_t>(fmod(lhs, 4294967296.0));
         return static_cast<double>(l >> (static_cast<int32_t>(rhs) & 0x1F));
     }
-    inline double unsigned_right_shift_native(const AnyValue &lhs, const AnyValue &rhs) { return unsigned_right_shift_native(Operators_Private::ToUint32(lhs), Operators_Private::ToInt32(rhs)); }
-    inline double unsigned_right_shift_native(const AnyValue &lhs, const double &rhs) { return unsigned_right_shift_native(Operators_Private::ToUint32(lhs), rhs); }
-    inline double unsigned_right_shift_native(const double &lhs, const AnyValue &rhs) { return unsigned_right_shift_native(lhs, Operators_Private::ToInt32(rhs)); }
+    inline double unsigned_right_shift_native(const AnyValue &lhs, const AnyValue &rhs) { return unsigned_right_shift_native(NumberOperators::ToUint32(lhs), NumberOperators::ToInt32(rhs)); }
+    inline double unsigned_right_shift_native(const AnyValue &lhs, const double &rhs) { return unsigned_right_shift_native(NumberOperators::ToUint32(lhs), rhs); }
+    inline double unsigned_right_shift_native(const double &lhs, const AnyValue &rhs) { return unsigned_right_shift_native(lhs, NumberOperators::ToInt32(rhs)); }
 
 }

package/src/prelude/values/array.cpp

@@ -286,7 +286,7 @@ AnyValue &get_length_desc()
 
         auto self = thisVal.as_array();
         const auto &new_len_val = args[0];
-        double new_len_double = Operators_Private::ToNumber(new_len_val);
+        double new_len_double = NumberOperators::ToDouble(new_len_val);
 
         if (new_len_double < 0 || std::isnan(new_len_double) || std::isinf(new_len_double) || new_len_double != static_cast<uint64_t>(new_len_double))
         {
@@ -484,7 +484,7 @@ AnyValue &get_at_fn()
                                                  {
                                                      auto self = thisVal.as_array();
                                                      double len = static_cast<double>(self->length);
-                                                     double relativeIndex = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
+                                                     double relativeIndex = args.empty() ? 0 : NumberOperators::ToDouble(args[0]);
                                                      double k;
                                                      if (relativeIndex >= 0) k = relativeIndex;
                                                      else k = len + relativeIndex;
@@ -502,7 +502,7 @@ AnyValue &get_includes_fn()
                                                      AnyValue searchElement = args.empty() ? Constants::UNDEFINED : args[0];
                                                      double len = static_cast<double>(self->length);
                                                      if (len == 0) return Constants::FALSE;
-                                                     double n = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : 0;
+                                                     double n = (args.size() > 1) ? NumberOperators::ToDouble(args[1]) : 0;
                                                      double k;
                                                      if (n >= 0) k = n;
                                                      else k = len + n;
@@ -528,7 +528,7 @@ AnyValue &get_indexOf_fn()
                                                      AnyValue searchElement = args.empty() ? Constants::UNDEFINED : args[0];
                                                      double len = static_cast<double>(self->length);
                                                      if (len == 0) return AnyValue::make_number(-1);
-                                                     double n = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : 0;
+                                                     double n = (args.size() > 1) ? NumberOperators::ToDouble(args[1]) : 0;
                                                      double k;
                                                      if (n >= 0) k = n;
                                                      else k = len + n;
@@ -554,7 +554,7 @@ AnyValue &get_lastIndexOf_fn()
                                                      AnyValue searchElement = args.empty() ? Constants::UNDEFINED : args[0];
                                                      double len = static_cast<double>(self->length);
                                                      if (len == 0) return AnyValue::make_number(-1);
-                                                     double n = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : len - 1;
+                                                     double n = (args.size() > 1) ? NumberOperators::ToDouble(args[1]) : len - 1;
                                                      double k;
                                                      if (n >= 0) k = std::min(n, len - 1);
                                                      else k = len + n;
@@ -897,7 +897,7 @@ AnyValue &get_flat_fn()
     static AnyValue fn = AnyValue::make_function([](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
                                                  {
                                                      auto self = thisVal.as_array();
-                                                     double depthVal = (args.size() > 0 && !args[0].is_undefined()) ? Operators_Private::ToNumber(args[0]) : 1;
+                                                     double depthVal = (args.size() > 0 && !args[0].is_undefined()) ? NumberOperators::ToDouble(args[0]) : 1;
                                                      int depth = static_cast<int>(depthVal);
                                                      if (depth < 0) depth = 0;
                                                      
@@ -968,8 +968,8 @@ AnyValue &get_fill_fn()
                                                      auto self = thisVal.as_array();
                                                      AnyValue value = args.empty() ? Constants::UNDEFINED : args[0];
                                                      double len = static_cast<double>(self->length);
-                                                     double start = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : 0;
-                                                     double end = (args.size() > 2 && !args[2].is_undefined()) ? Operators_Private::ToNumber(args[2]) : len;
+                                                     double start = (args.size() > 1) ? NumberOperators::ToDouble(args[1]) : 0;
+                                                     double end = (args.size() > 2 && !args[2].is_undefined()) ? NumberOperators::ToDouble(args[2]) : len;
                                                      
                                                      double k;
                                                      if (start >= 0) k = start; else k = len + start;
@@ -1041,7 +1041,7 @@ AnyValue &get_sort_fn()
                                                          
                                                          if (compareFn.is_function()) {
                                                              const AnyValue cmpArgs[] = {a, b};
-                                                             double res = Operators_Private::ToNumber(compareFn.call(Constants::UNDEFINED, std::span<const AnyValue>(cmpArgs, 2)));
+                                                             double res = NumberOperators::ToDouble(compareFn.call(Constants::UNDEFINED, std::span<const AnyValue>(cmpArgs, 2)));
                                                              return res < 0;
                                                          } else {
                                                              std::string sA = a.to_std_string();
@@ -1069,13 +1069,13 @@ AnyValue &get_splice_fn()
                                                  {
                                                      auto self = thisVal.as_array();
                                                      double len = static_cast<double>(self->length);
-                                                     double start = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
+                                                     double start = args.empty() ? 0 : NumberOperators::ToDouble(args[0]);
                                                      double actualStart = (start < 0) ? std::max(len + start, 0.0) : std::min(start, len);
                                                      
                                                      uint64_t startIdx = static_cast<uint64_t>(actualStart);
                                                      uint64_t deleteCount = 0;
                                                      if (args.size() >= 2) {
-                                                         double dc = Operators_Private::ToNumber(args[1]);
+                                                         double dc = NumberOperators::ToDouble(args[1]);
                                                          deleteCount = static_cast<uint64_t>(std::max(0.0, std::min(dc, len - startIdx)));
                                                      } else if (args.size() == 1) {
                                                          deleteCount = len - startIdx;
@@ -1141,9 +1141,9 @@ AnyValue &get_copyWithin_fn()
                                                  {
                                                      auto self = thisVal.as_array();
                                                      double len = static_cast<double>(self->length);
-                                                     double target = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
-                                                     double start = (args.size() > 1) ? Operators_Private::ToNumber(args[1]) : 0;
-                                                     double end = (args.size() > 2 && !args[2].is_undefined()) ? Operators_Private::ToNumber(args[2]) : len;
+                                                     double target = args.empty() ? 0 : NumberOperators::ToDouble(args[0]);
+                                                     double start = (args.size() > 1) ? NumberOperators::ToDouble(args[1]) : 0;
+                                                     double end = (args.size() > 2 && !args[2].is_undefined()) ? NumberOperators::ToDouble(args[2]) : len;
                                                      
                                                      double to;
                                                      if (target >= 0) to = target; else to = len + target;
@@ -1239,9 +1239,9 @@ AnyValue &get_slice_fn()
                                                  {
                                                      auto self = thisVal.as_array();
                                                      double len = static_cast<double>(self->length);
-                                                     double start = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
+                                                     double start = args.empty() ? 0 : NumberOperators::ToDouble(args[0]);
                                                      double actualStart = (start < 0) ? std::max(len + start, 0.0) : std::min(start, len);
-                                                     double end = (args.size() < 2 || args[1].is_undefined()) ? len : Operators_Private::ToNumber(args[1]);
+                                                     double end = (args.size() < 2 || args[1].is_undefined()) ? len : NumberOperators::ToDouble(args[1]);
                                                      double actualEnd = (end < 0) ? std::max(len + end, 0.0) : std::min(end, len);
                                                      
                                                      std::vector<AnyValue> result;
@@ -1298,7 +1298,7 @@ AnyValue &get_with_fn()
                                                      auto copy = thisVal.get_property_with_receiver("slice", thisVal).call(thisVal, {});
                                                      
                                                      double len = static_cast<double>(self->length);
-                                                     double idx = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
+                                                     double idx = args.empty() ? 0 : NumberOperators::ToDouble(args[0]);
                                                      double k;
                                                      if (idx >= 0) k = idx; else k = len + idx;
                                                      

package/src/prelude/values/number.cpp

@@ -87,7 +87,7 @@ namespace jspp
                                                      int digits = -1;
                                                      if (!args.empty() && !args[0].is_undefined())
                                                      {
-                                                         digits = Operators_Private::ToInt32(args[0]);
+                                                         digits = NumberOperators::ToInt32(args[0]);
                                                          if (digits < 0 || digits > 100)
                                                          {
                                                              throw Exception::make_exception("toExponential() digits argument must be between 0 and 100", "RangeError");
@@ -118,7 +118,7 @@ namespace jspp
                                                      int digits = 0;
                                                      if (!args.empty() && !args[0].is_undefined())
                                                      {
-                                                         digits = Operators_Private::ToInt32(args[0]);
+                                                         digits = NumberOperators::ToInt32(args[0]);
                                                      }
                                                      if (digits < 0 || digits > 100)
                                                      {
@@ -141,7 +141,7 @@ namespace jspp
                                                      {
                                                          return AnyValue::make_number(self).get_own_property("toString").call(AnyValue::make_number(self), {}, "toString");
                                                      }
-                                                     int precision = Operators_Private::ToInt32(args[0]);
+                                                     int precision = NumberOperators::ToInt32(args[0]);
                                                      if (precision < 1 || precision > 100)
                                                      {
                                                          throw Exception::make_exception("toPrecision() precision argument must be between 1 and 100", "RangeError");
@@ -162,7 +162,7 @@ namespace jspp
                                                      int radix = 10;
                                                      if (!args.empty() && !args[0].is_undefined())
                                                      {
-                                                         radix = Operators_Private::ToInt32(args[0]);
+                                                         radix = NumberOperators::ToInt32(args[0]);
                                                      }
                                                      if (radix < 2 || radix > 36)
                                                      {

package/src/prelude/values/string.cpp

@@ -92,7 +92,7 @@ AnyValue &get_charAt_fn()
     static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                  {
                                                      auto self = thisVal.as_string();
-                                                     double pos = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
+                                                     double pos = args.empty() ? 0 : NumberOperators::ToDouble(args[0]);
                                                      int index = static_cast<int>(pos);
                                                      if (index < 0 || index >= self->value.length())
                                                      {
@@ -125,7 +125,7 @@ AnyValue &get_endsWith_fn()
                                                      if (args.empty())
                                                          return Constants::FALSE;
                                                      std::string search = args[0].to_std_string();
-                                                     size_t end_pos = (args.size() > 1 && !args[1].is_undefined()) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : self->value.length();
+                                                     size_t end_pos = (args.size() > 1 && !args[1].is_undefined()) ? static_cast<size_t>(NumberOperators::ToDouble(args[1])) : self->value.length();
 
                                                      if (end_pos > self->value.length())
                                                          end_pos = self->value.length();
@@ -145,7 +145,7 @@ AnyValue &get_includes_fn()
                                                      if (args.empty())
                                                          return Constants::FALSE;
                                                      std::string search = args[0].to_std_string();
-                                                     size_t pos = (args.size() > 1) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : 0;
+                                                     size_t pos = (args.size() > 1) ? static_cast<size_t>(NumberOperators::ToDouble(args[1])) : 0;
 
                                                      return AnyValue::make_boolean(self->value.find(search, pos) != std::string::npos); },
                                                  "includes");
@@ -160,7 +160,7 @@ AnyValue &get_indexOf_fn()
                                                      if (args.empty())
                                                          return AnyValue::make_number(-1);
                                                      std::string search = args[0].to_std_string();
-                                                     size_t pos = (args.size() > 1) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : 0;
+                                                     size_t pos = (args.size() > 1) ? static_cast<size_t>(NumberOperators::ToDouble(args[1])) : 0;
                                                      size_t result = self->value.find(search, pos);
                                                      return result == std::string::npos ? AnyValue::make_number(-1) : AnyValue::make_number(result); },
                                                  "indexOf");
@@ -175,7 +175,7 @@ AnyValue &get_lastIndexOf_fn()
                                                      if (args.empty())
                                                          return AnyValue::make_number(-1);
                                                      std::string search = args[0].to_std_string();
-                                                     size_t pos = (args.size() > 1 && !args[1].is_undefined()) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : std::string::npos;
+                                                     size_t pos = (args.size() > 1 && !args[1].is_undefined()) ? static_cast<size_t>(NumberOperators::ToDouble(args[1])) : std::string::npos;
                                                      size_t result = self->value.rfind(search, pos);
                                                      return result == std::string::npos ? AnyValue::make_number(-1) : AnyValue::make_number(result); },
                                                  "lastIndexOf");
@@ -187,7 +187,7 @@ AnyValue &get_padEnd_fn()
     static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                  {
                                                      auto self = thisVal.as_string();
-                                                     size_t target_length = args.empty() ? 0 : static_cast<size_t>(Operators_Private::ToNumber(args[0]));
+                                                     size_t target_length = args.empty() ? 0 : static_cast<size_t>(NumberOperators::ToDouble(args[0]));
                                                      if (self->value.length() >= target_length)
                                                          return AnyValue::make_string(self->value);
                                                      std::string pad_string = (args.size() > 1 && !args[1].is_undefined() && !args[1].to_std_string().empty()) ? args[1].to_std_string() : " ";
@@ -206,7 +206,7 @@ AnyValue &get_padStart_fn()
     static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                  {
                                                      auto self = thisVal.as_string();
-                                                     size_t target_length = args.empty() ? 0 : static_cast<size_t>(Operators_Private::ToNumber(args[0]));
+                                                     size_t target_length = args.empty() ? 0 : static_cast<size_t>(NumberOperators::ToDouble(args[0]));
                                                      if (self->value.length() >= target_length)
                                                          return AnyValue::make_string(self->value);
                                                      std::string pad_string = (args.size() > 1 && !args[1].is_undefined() && !args[1].to_std_string().empty()) ? args[1].to_std_string() : " ";
@@ -225,7 +225,7 @@ AnyValue &get_repeat_fn()
     static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                  {
                                                      auto self = thisVal.as_string();
-                                                     double count = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
+                                                     double count = args.empty() ? 0 : NumberOperators::ToDouble(args[0]);
                                                      if (count < 0)
                                                      {
                                                          // In a real implementation, this should throw a RangeError.
@@ -290,8 +290,8 @@ AnyValue &get_slice_fn()
                                                  {
                                                      auto self = thisVal.as_string();
                                                      int len = self->value.length();
-                                                     int start = args.empty() ? 0 : Operators_Private::ToInt32(args[0]);
-                                                     int end = (args.size() < 2 || args[1].is_undefined()) ? len : Operators_Private::ToInt32(args[1]);
+                                                     int start = args.empty() ? 0 : NumberOperators::ToInt32(args[0]);
+                                                     int end = (args.size() < 2 || args[1].is_undefined()) ? len : NumberOperators::ToInt32(args[1]);
 
                                                      if (start < 0)
                                                          start += len;
@@ -347,7 +347,7 @@ AnyValue &get_startsWith_fn()
                                                      if (args.empty())
                                                          return Constants::FALSE;
                                                      std::string search = args[0].to_std_string();
-                                                     size_t pos = (args.size() > 1) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : 0;
+                                                     size_t pos = (args.size() > 1) ? static_cast<size_t>(NumberOperators::ToDouble(args[1])) : 0;
                                                      if (pos > self->value.length())
                                                          pos = self->value.length();
 
@@ -362,8 +362,8 @@ AnyValue &get_substring_fn()
                                                  {
                                                      auto self = thisVal.as_string();
                                                      int len = self->value.length();
-                                                     int start = args.empty() ? 0 : Operators_Private::ToInt32(args[0]);
-                                                     int end = (args.size() < 2 || args[1].is_undefined()) ? len : Operators_Private::ToInt32(args[1]);
+                                                     int start = args.empty() ? 0 : NumberOperators::ToInt32(args[0]);
+                                                     int end = (args.size() < 2 || args[1].is_undefined()) ? len : NumberOperators::ToInt32(args[1]);
 
                                                      start = std::max(0, start);
                                                      end = std::max(0, end);