@ugo-studio/jspp 0.3.0 → 0.3.2

package/src/prelude/library/error.hpp

@@ -3,111 +3,11 @@
 #include "types.hpp"
 #include "any_value.hpp"
 
-// Declare Error variable
-inline jspp::AnyValue Error;
-
-// Constructor logic
-inline auto errorConstructor = [](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-{
-    // Access global Error to get prototype
-    jspp::AnyValue proto = Error.get_own_property("prototype");
-
-    jspp::AnyValue target = thisVal;
-    bool is_construct_call = false;
-
-    if (target.is_object())
-    {
-        auto obj = target.as_object();
-        if (!obj->proto.is_null() && !obj->proto.is_undefined() && is_strictly_equal_to_primitive(obj->proto, proto))
-        {
-            is_construct_call = true;
-        }
-    }
-
-    if (!is_construct_call)
-    {
-        target = jspp::AnyValue::make_object_with_proto({}, proto);
-    }
-
-    std::string name = "Error";
-    std::string message = "";
-    if (!args.empty() && !args[0].is_undefined())
-    {
-        message = args[0].to_std_string();
-    }
-
-    target.define_data_property("message", jspp::AnyValue::make_string(message), true, false, true);
-    target.define_data_property("name", jspp::AnyValue::make_string(name), true, false, true);
-    target.define_data_property("stack", jspp::AnyValue::make_string(name + ": " + message + "\n    at <unknown>"), true, false, true);
-
-    if (args.size() > 1 && args[1].is_object())
-    {
-        jspp::AnyValue cause = args[1].get_own_property("cause");
-        if (!cause.is_undefined())
-        {
-            target.define_data_property("cause", cause, true, false, true);
-        }
-    }
-
-    return target;
-};
-
-// Static Error.isError(val) implementation
-inline auto isErrorFn = jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                      {
-    if (args.empty()) return jspp::Constants::FALSE;
-    
-    jspp::AnyValue val = args[0];
-    if (!val.is_object()) return jspp::Constants::FALSE;
-    
-    // Check if it inherits from Error.prototype
-    // This is essentially 'instanceof Error'
-    jspp::AnyValue proto = Error.get_own_property("prototype");
-    
-    // Walk prototype chain
-    if (val.is_object()) {
-        auto current = val.as_object()->proto;
-        while (!current.is_null()) {
-             if (is_strictly_equal_to_primitive(current, proto)) return jspp::Constants::TRUE;
-             if (current.is_object()) current = current.as_object()->proto;
-             else break;
-        }
-    }
-    
-    return jspp::Constants::FALSE; }, "isError");
-
-// toString method for Error.prototype
-inline auto errorToStringFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                            {
-    std::string name = "Error";
-    std::string msg = "";
-    
-    jspp::AnyValue n = thisVal.get_own_property("name");
-    if (!n.is_undefined()) name = n.to_std_string();
-    
-    jspp::AnyValue m = thisVal.get_own_property("message");
-    if (!m.is_undefined()) msg = m.to_std_string();
-    
-    if (name.empty() && msg.empty()) return jspp::AnyValue::make_string("Error");
-    if (name.empty()) return jspp::AnyValue::make_string(msg);
-    if (msg.empty()) return jspp::AnyValue::make_string(name);
-    
-    return jspp::AnyValue::make_string(name + ": " + msg); }, "toString");
-
-// Initialize Error class and its prototype
-struct ErrorInit
-{
-    ErrorInit()
-    {
-        // Initialize Error class
-        Error = jspp::AnyValue::make_class(errorConstructor, "Error");
-
-        // Define Error.prototype.toString
-        auto proto = Error.get_own_property("prototype");
-        proto.define_data_property("toString", errorToStringFn, true, false, true);
-        proto.define_data_property(jspp::WellKnownSymbols::toStringTag->key, errorToStringFn, true, false, true);
-
-        // Define static Error.isError
-        Error.define_data_property("isError", isErrorFn, true, false, true);
-    }
-} errorInit;
+namespace jspp {
+    extern AnyValue Error; 
+    void init_error();
+    extern AnyValue isErrorFn;
+    extern AnyValue errorToStringFn;
+}
+
+using jspp::Error;

package/src/prelude/library/function.cpp

@@ -0,0 +1,69 @@
+#include "jspp.hpp"
+#include "library/function.hpp"
+
+namespace jspp
+{
+
+    AnyValue Function = jspp::AnyValue::make_class([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                   { return jspp::Constants::UNDEFINED; }, "Function");
+
+    struct FunctionInit
+    {
+        FunctionInit()
+        {
+            auto proto = Function.get_own_property("prototype");
+
+            // Function.prototype.call
+            proto.define_data_property("call", jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                             {
+            if (!thisVal.is_function()) throw jspp::Exception::make_exception("Function.prototype.call called on non-function", "TypeError");
+            if (args.empty()) return thisVal.call(jspp::Constants::UNDEFINED, {});
+            auto receiver = args[0];
+            return thisVal.call(receiver, args.subspan(1)); }, "call"),
+                                       true, false, true);
+
+            // Function.prototype.apply
+            proto.define_data_property("apply", jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                              {
+            if (!thisVal.is_function()) throw jspp::Exception::make_exception("Function.prototype.apply called on non-function", "TypeError");
+            auto receiver = args.size() > 0 ? args[0] : jspp::Constants::UNDEFINED;
+            auto applyArgs = args.size() > 1 ? args[1] : jspp::Constants::UNDEFINED;
+            
+            if (applyArgs.is_null() || applyArgs.is_undefined()) return thisVal.call(receiver, {});
+            if (!applyArgs.is_array()) throw jspp::Exception::make_exception("CreateListFromArrayLike called on non-object", "TypeError");
+            
+            auto arr = applyArgs.as_array();
+            std::vector<jspp::AnyValue> vec;
+            for(uint64_t i = 0; i < arr->length; ++i) vec.push_back(arr->get_property(static_cast<uint32_t>(i)));
+            return thisVal.call(receiver, vec); }, "apply"),
+                                       true, false, true);
+
+            // Function.prototype.bind
+            proto.define_data_property("bind", jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                             {
+            if (!thisVal.is_function()) throw jspp::Exception::make_exception("Function.prototype.bind called on non-function", "TypeError");
+            auto receiver = args.size() > 0 ? args[0] : jspp::Constants::UNDEFINED;
+            std::vector<jspp::AnyValue> boundArgs(args.begin() + (args.empty() ? 0 : 1), args.end());
+            
+            return jspp::AnyValue::make_function([thisVal, receiver, boundArgs](jspp::AnyValue, std::span<const jspp::AnyValue> callArgs) -> jspp::AnyValue {
+                std::vector<jspp::AnyValue> combinedArgs = boundArgs;
+                combinedArgs.insert(combinedArgs.end(), callArgs.begin(), callArgs.end());
+                return thisVal.call(receiver, combinedArgs);
+            }, thisVal.as_function()->name); }, "bind"),
+                                       true, false, true);
+
+            // Function.prototype.toString
+            auto toStringFn = jspp::FunctionPrototypes::get("toString");
+            if (toStringFn.has_value())
+            {
+                proto.define_data_property("toString", toStringFn.value(), true, false, true);
+            }
+        }
+    };
+
+    void init_function_lib()
+    {
+        static FunctionInit functionInit;
+    }
+
+} // namespace jspp

package/src/prelude/library/function.hpp

@@ -3,8 +3,9 @@
 #include "types.hpp"
 #include "any_value.hpp"
 
-// Define Function constructor
-// In a full implementation, this would support 'new Function(args, body)'
-inline auto Function = jspp::AnyValue::make_class([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-    return jspp::Constants::UNDEFINED;
-}, "Function");
+namespace jspp {
+    extern AnyValue Function;
+    void init_function_lib();
+}
+
+using jspp::Function;

package/src/prelude/library/global.cpp

@@ -0,0 +1,98 @@
+#include "jspp.hpp"
+#include "library/global.hpp"
+
+namespace jspp {
+    jspp::AnyValue GeneratorFunction;
+    jspp::AnyValue AsyncFunction;
+    jspp::AnyValue AsyncGeneratorFunction;
+    jspp::AnyValue global;
+
+    void initialize_runtime() {
+        if (!global.is_undefined()) return;
+
+        // 1. Initialize core built-ins
+        init_symbol();
+        init_function_lib();
+        init_object();
+        init_array();
+        init_error();
+        init_promise();
+        init_math();
+        init_console();
+        init_boolean();
+
+        // 2. Initialize functions and linking
+        GeneratorFunction = jspp::AnyValue::make_generator([](jspp::AnyValue, std::vector<jspp::AnyValue>) -> jspp::JsIterator<jspp::AnyValue>
+                                                                    { co_return jspp::Constants::UNDEFINED; })
+                                        .get_own_property("prototype")
+                                        .get_own_property("constructor");
+        AsyncFunction = jspp::AnyValue::make_async_function([](jspp::AnyValue, std::vector<jspp::AnyValue>) -> jspp::JsPromise
+                                                                   { co_return jspp::Constants::UNDEFINED; })
+                                    .get_own_property("prototype")
+                                    .get_own_property("constructor");
+        AsyncGeneratorFunction = jspp::AnyValue::make_async_generator([](jspp::AnyValue, std::vector<jspp::AnyValue>) -> jspp::JsAsyncIterator<jspp::AnyValue>
+                                                                             { co_return jspp::Constants::UNDEFINED; })
+                                             .get_own_property("prototype")
+                                             .get_own_property("constructor");
+
+        global = jspp::AnyValue::make_object({
+            {"Symbol", Symbol},
+            {"process", process},
+            {"Function", Function},
+            {"GeneratorFunction", GeneratorFunction},
+            {"AsyncFunction", AsyncFunction},
+            {"AsyncGeneratorFunction", AsyncGeneratorFunction},
+            {"console", jspp::console},
+            {"performance", performance},
+            {"Error", Error},
+            {"Promise", Promise},
+            {"setTimeout", setTimeout},
+            {"clearTimeout", clearTimeout},
+            {"setInterval", setInterval},
+            {"clearInterval", clearInterval},
+            {"Math", jspp::Math},
+            {"Object", jspp::Object},
+            {"Array", jspp::Array},
+            {"Boolean", jspp::Boolean},
+        });
+
+        auto objectProto = ::Object.get_own_property("prototype");
+        auto functionProto = ::Function.get_own_property("prototype");
+        auto arrayProto = ::Array.get_own_property("prototype");
+
+        auto toStringTagSym = jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toStringTag);
+
+        objectProto.define_data_property(toStringTagSym, jspp::AnyValue::make_string("Object"), true, false, true);
+        functionProto.define_data_property(toStringTagSym, jspp::AnyValue::make_string("Function"), true, false, true);
+        arrayProto.define_data_property(toStringTagSym, jspp::AnyValue::make_string("Array"), true, false, true);
+
+        // Important: Link prototypes to Object.prototype
+        arrayProto.set_prototype(objectProto);
+        functionProto.set_prototype(objectProto);
+        ::Error.get_own_property("prototype").set_prototype(objectProto);
+        ::Promise.get_own_property("prototype").set_prototype(objectProto);
+        ::Symbol.get_own_property("prototype").set_prototype(objectProto);
+
+        auto generatorFunctionProto = GeneratorFunction.get_own_property("prototype");
+        generatorFunctionProto.set_prototype(functionProto);
+        generatorFunctionProto.define_data_property(toStringTagSym, jspp::AnyValue::make_string("GeneratorFunction"), true, false, true);
+
+        auto asyncFunctionProto = AsyncFunction.get_own_property("prototype");
+        asyncFunctionProto.set_prototype(functionProto);
+        asyncFunctionProto.define_data_property(toStringTagSym, jspp::AnyValue::make_string("AsyncFunction"), true, false, true);
+
+        auto asyncGeneratorFunctionProto = AsyncGeneratorFunction.get_own_property("prototype");
+        asyncGeneratorFunctionProto.set_prototype(functionProto);
+        asyncGeneratorFunctionProto.define_data_property(toStringTagSym, jspp::AnyValue::make_string("AsyncGeneratorFunction"), true, false, true);
+
+        ::Object.set_prototype(functionProto);
+        ::Array.set_prototype(functionProto);
+        ::Function.set_prototype(functionProto);
+        GeneratorFunction.set_prototype(functionProto);
+        AsyncFunction.set_prototype(functionProto);
+        AsyncGeneratorFunction.set_prototype(functionProto);
+        ::Error.set_prototype(functionProto);
+        ::Promise.set_prototype(functionProto);
+        ::Symbol.set_prototype(functionProto);
+    }
+}

package/src/prelude/library/global.hpp

@@ -10,32 +10,16 @@
 #include "library/timer.hpp"
 #include "library/math.hpp"
 
-inline auto global = jspp::AnyValue::make_object({
-    {"Symbol", Symbol},
-    {"process", process},
-    {"Function", Function},
-    {"console", console},
-    {"performance", performance},
-    {"Error", Error},
-    {"Promise", Promise},
-    {"setTimeout", setTimeout},
-    {"clearTimeout", clearTimeout},
-    {"setInterval", setInterval},
-    {"clearInterval", clearInterval},
-    {"Math", Math},
-    {"Object", Object},
-    {"Array", Array},
-});
+namespace jspp {
+    extern AnyValue GeneratorFunction;
+    extern AnyValue AsyncFunction;
+    extern AnyValue AsyncGeneratorFunction;
+    extern AnyValue global;
 
-struct GlobalInit {
-    GlobalInit() {
-        auto objectProto = ::Object.get_own_property("prototype");
-        
-        // Tie built-in prototypes to Object.prototype
-        ::Array.get_own_property("prototype").set_prototype(objectProto);
-        ::Function.get_own_property("prototype").set_prototype(objectProto);
-        ::Error.get_own_property("prototype").set_prototype(objectProto);
-        ::Promise.get_own_property("prototype").set_prototype(objectProto);
-        ::Symbol.get_own_property("prototype").set_prototype(objectProto);
-    }
-} globalInit;
+    void initialize_runtime();
+}
+
+using jspp::global;
+using jspp::GeneratorFunction;
+using jspp::AsyncFunction;
+using jspp::AsyncGeneratorFunction;

package/src/prelude/library/global_usings.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "library/console.hpp"
+#include "library/math.hpp"
+#include "library/object.hpp"
+#include "library/array.hpp"
+#include "library/error.hpp"
+#include "library/promise.hpp"
+
+// Global usings for the transpiled code
+using jspp::console;
+using jspp::Math;
+using jspp::Object;
+using jspp::Array;
+using jspp::Error;
+using jspp::Promise;

package/src/prelude/library/math.cpp

@@ -0,0 +1,261 @@
+#include "jspp.hpp"
+#include "library/math.hpp"
+#include <numbers>
+#include <random>
+
+namespace jspp {
+    namespace Library {
+        static std::random_device rd;
+        static std::mt19937 gen(rd());
+        static std::uniform_real_distribution<> dis(0.0, 1.0);
+
+        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]);
+        }
+
+        jspp::AnyValue MathFunc1(std::span<const jspp::AnyValue> args, double (*func)(double)) {
+            return jspp::AnyValue::make_number(func(GetArgAsDouble(args, 0)));
+        }
+
+        jspp::AnyValue MathFunc2(std::span<const jspp::AnyValue> args, double (*func)(double, double)) {
+            return jspp::AnyValue::make_number(func(GetArgAsDouble(args, 0), GetArgAsDouble(args, 1)));
+        }
+    }
+
+    jspp::AnyValue Math = jspp::AnyValue::make_object({});
+
+    struct MathInit {
+        MathInit() {
+            using namespace jspp::Library;
+
+            auto defConst = [](const std::string& key, double val) {
+                jspp::Math.define_data_property(key, AnyValue::make_number(val), false, false, false);
+            };
+            auto defMutable = [](const std::string& key, AnyValue val) {
+                jspp::Math.define_data_property(key, val, true, false, true);
+            };
+
+            defConst("E", std::numbers::e);
+            defConst("LN10", std::numbers::ln10);
+            defConst("LN2", std::numbers::ln2);
+            defConst("LOG10E", std::numbers::log10e);
+            defConst("LOG2E", std::numbers::log2e);
+            defConst("PI", std::numbers::pi);
+            defConst("SQRT1_2", std::numbers::sqrt2 / 2.0);
+            defConst("SQRT2", std::numbers::sqrt2);
+
+            defMutable("abs", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return AnyValue::make_number(std::abs(GetArgAsDouble(args, 0)));
+            }, "abs"));
+
+            defMutable("acos", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::acos);
+            }, "acos"));
+
+            defMutable("acosh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::acosh);
+            }, "acosh"));
+
+            defMutable("asin", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::asin);
+            }, "asin"));
+
+            defMutable("asinh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::asinh);
+            }, "asinh"));
+
+            defMutable("atan", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::atan);
+            }, "atan"));
+
+            defMutable("atan2", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc2(args, std::atan2);
+            }, "atan2"));
+
+            defMutable("atanh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::atanh);
+            }, "atanh"));
+
+            defMutable("cbrt", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::cbrt);
+            }, "cbrt"));
+
+            defMutable("ceil", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::ceil);
+            }, "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]);
+                if (val == 0) return AnyValue::make_number(32);
+                return AnyValue::make_number(std::countl_zero(val));
+            }, "clz32"));
+
+            defMutable("cos", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::cos);
+            }, "cos"));
+
+            defMutable("cosh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::cosh);
+            }, "cosh"));
+
+            defMutable("exp", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::exp);
+            }, "exp"));
+
+            defMutable("expm1", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::expm1);
+            }, "expm1"));
+
+            defMutable("floor", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::floor);
+            }, "floor"));
+
+            defMutable("fround", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                double d = GetArgAsDouble(args, 0);
+                return AnyValue::make_number(static_cast<double>(static_cast<float>(d)));
+            }, "fround"));
+
+            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);
+                    if (std::isinf(val)) return AnyValue::make_number(std::numeric_limits<double>::infinity());
+                    result = std::hypot(result, val);
+                }
+                return AnyValue::make_number(result);
+            }, "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]);
+                return AnyValue::make_number(a * b);
+            }, "imul"));
+
+            defMutable("log", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::log);
+            }, "log"));
+
+            defMutable("log10", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::log10);
+            }, "log10"));
+
+            defMutable("log1p", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::log1p);
+            }, "log1p"));
+
+            defMutable("log2", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::log2);
+            }, "log2"));
+
+            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);
+                    if (std::isnan(val)) return AnyValue::make_nan();
+                    if (val > maxVal) maxVal = val;
+                }
+                return AnyValue::make_number(maxVal);
+            }, "max"));
+
+            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);
+                    if (std::isnan(val)) return AnyValue::make_nan();
+                    if (val < minVal) minVal = val;
+                }
+                return AnyValue::make_number(minVal);
+            }, "min"));
+
+            defMutable("pow", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc2(args, std::pow);
+            }, "pow"));
+
+            defMutable("random", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return AnyValue::make_number(dis(gen));
+            }, "random"));
+
+            defMutable("round", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                double d = GetArgAsDouble(args, 0);
+                if (std::isnan(d)) return AnyValue::make_nan();
+                return AnyValue::make_number(std::floor(d + 0.5)); 
+            }, "round"));
+
+            defMutable("sign", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                double d = GetArgAsDouble(args, 0);
+                if (std::isnan(d)) return AnyValue::make_nan();
+                if (d == 0) return AnyValue::make_number(d);
+                return AnyValue::make_number(d > 0 ? 1.0 : -1.0);
+            }, "sign"));
+
+            defMutable("sin", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::sin);
+            }, "sin"));
+
+            defMutable("sinh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::sinh);
+            }, "sinh"));
+
+            defMutable("sqrt", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::sqrt);
+            }, "sqrt"));
+
+            defMutable("tan", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::tan);
+            }, "tan"));
+
+            defMutable("tanh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::tanh);
+            }, "tanh"));
+
+            defMutable("trunc", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                return MathFunc1(args, std::trunc);
+            }, "trunc"));
+
+            // Math.f16round(x)
+            defMutable("f16round", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+                double d = GetArgAsDouble(args, 0);
+                #if defined(__STDCPP_FLOAT16_T__)
+                                return AnyValue::make_number(static_cast<double>(static_cast<std::float16_t>(d)));
+                #else
+                                float f = static_cast<float>(d);
+                                return AnyValue::make_number(static_cast<double>(f));
+                #endif
+            }, "f16round"));
+            // Math.sumPrecise(iterable)
+            defMutable("sumPrecise", AnyValue::make_function([](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue {
+                if (args.empty()) throw Exception::make_exception("Math.sumPrecise requires an iterable", "TypeError");
+                
+                auto iterObj = jspp::Access::get_object_iterator(args[0], "iterable");
+                auto nextFunc = iterObj.get_own_property("next");
+                
+                double sum = 0;
+                // Kahan summation algorithm for better precision
+                double c = 0; 
+                
+                while (true) {
+                    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"));
+                    if (std::isnan(val)) {
+                        sum = std::numeric_limits<double>::quiet_NaN();
+                        break;
+                    }
+                    
+                    double y = val - c;
+                    double t = sum + y;
+                    c = (t - sum) - y;
+                    sum = t;
+                }
+                
+                return AnyValue::make_number(sum);
+            }, "sumPrecise"));
+        }
+    };
+    void init_math()
+    {
+        static MathInit mathInit;
+    }
+}