@ugo-studio/jspp 0.1.4 → 0.1.5

package/src/prelude/library/math.hpp

@@ -0,0 +1,308 @@
+#pragma once
+
+#include <cmath>
+#include <limits>
+#include <random>
+#include <algorithm>
+#include <bit>
+#include <numbers>
+#include <stdfloat>
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+
+namespace jspp {
+    namespace Library {
+        // --- Random Number Generator ---
+        static std::random_device rd;
+        static std::mt19937 gen(rd());
+        static std::uniform_real_distribution<> dis(0.0, 1.0);
+
+        // --- Helpers ---
+        inline 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]);
+        }
+
+        inline jspp::AnyValue MathFunc1(std::span<const jspp::AnyValue> args, double (*func)(double)) {
+            return jspp::AnyValue::make_number(func(GetArgAsDouble(args, 0)));
+        }
+
+        inline 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)));
+        }
+    }
+}
+
+inline auto Math = jspp::AnyValue::make_object({});
+
+struct MathInit {
+    MathInit() {
+        using namespace jspp;
+        using namespace jspp::Library;
+
+        // --- Constants ---
+        auto defConst = [](const std::string& key, double val) {
+            Math.define_data_property(key, AnyValue::make_number(val), false, false, false);
+        };
+
+        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);
+
+        // --- Methods ---
+        
+        // Math.abs(x)
+        Math.define_data_property("abs", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return AnyValue::make_number(std::abs(GetArgAsDouble(args, 0)));
+        }, "abs"));
+
+        // Math.acos(x)
+        Math.define_data_property("acos", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::acos);
+        }, "acos"));
+
+        // Math.acosh(x)
+        Math.define_data_property("acosh", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::acosh);
+        }, "acosh"));
+
+        // Math.asin(x)
+        Math.define_data_property("asin", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::asin);
+        }, "asin"));
+
+        // Math.asinh(x)
+        Math.define_data_property("asinh", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::asinh);
+        }, "asinh"));
+
+        // Math.atan(x)
+        Math.define_data_property("atan", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::atan);
+        }, "atan"));
+
+        // Math.atan2(y, x)
+        Math.define_data_property("atan2", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc2(args, std::atan2);
+        }, "atan2"));
+
+        // Math.atanh(x)
+        Math.define_data_property("atanh", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::atanh);
+        }, "atanh"));
+
+        // Math.cbrt(x)
+        Math.define_data_property("cbrt", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::cbrt);
+        }, "cbrt"));
+
+        // Math.ceil(x)
+        Math.define_data_property("ceil", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::ceil);
+        }, "ceil"));
+
+        // Math.clz32(x)
+        Math.define_data_property("clz32", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            uint32_t val = Operators_Private::ToInt32(args.empty() ? AnyValue::make_undefined() : args[0]);
+            if (val == 0) return AnyValue::make_number(32);
+            return AnyValue::make_number(std::countl_zero(val));
+        }, "clz32"));
+
+        // Math.cos(x)
+        Math.define_data_property("cos", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::cos);
+        }, "cos"));
+
+        // Math.cosh(x)
+        Math.define_data_property("cosh", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::cosh);
+        }, "cosh"));
+
+        // Math.exp(x)
+        Math.define_data_property("exp", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::exp);
+        }, "exp"));
+
+        // Math.expm1(x)
+        Math.define_data_property("expm1", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::expm1);
+        }, "expm1"));
+
+        // Math.f16round(x)
+        Math.define_data_property("f16round", AnyValue::make_function([](const 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
+            // Manual fallback if float16_t is not available
+            // This is a very rough approximation, actual f16round is more complex
+            float f = static_cast<float>(d);
+            return AnyValue::make_number(static_cast<double>(f));
+#endif
+        }, "f16round"));
+
+        // Math.floor(x)
+        Math.define_data_property("floor", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::floor);
+        }, "floor"));
+
+        // Math.fround(x)
+        Math.define_data_property("fround", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            double d = GetArgAsDouble(args, 0);
+            return AnyValue::make_number(static_cast<double>(static_cast<float>(d)));
+        }, "fround"));
+
+        // Math.hypot(...args)
+        Math.define_data_property("hypot", AnyValue::make_function([](const 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"));
+
+        // Math.imul(x, y)
+        Math.define_data_property("imul", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            int32_t a = Operators_Private::ToInt32(args.empty() ? AnyValue::make_undefined() : args[0]);
+            int32_t b = Operators_Private::ToInt32(args.size() < 2 ? AnyValue::make_undefined() : args[1]);
+            return AnyValue::make_number(a * b);
+        }, "imul"));
+
+        // Math.log(x)
+        Math.define_data_property("log", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::log);
+        }, "log"));
+
+        // Math.log10(x)
+        Math.define_data_property("log10", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::log10);
+        }, "log10"));
+
+        // Math.log1p(x)
+        Math.define_data_property("log1p", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::log1p);
+        }, "log1p"));
+
+        // Math.log2(x)
+        Math.define_data_property("log2", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::log2);
+        }, "log2"));
+
+        // Math.max(...args)
+        Math.define_data_property("max", AnyValue::make_function([](const 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"));
+
+        // Math.min(...args)
+        Math.define_data_property("min", AnyValue::make_function([](const 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"));
+
+        // Math.pow(base, exponent)
+        Math.define_data_property("pow", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc2(args, std::pow);
+        }, "pow"));
+
+        // Math.random()
+        Math.define_data_property("random", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return AnyValue::make_number(dis(gen));
+        }, "random"));
+
+        // Math.round(x)
+        Math.define_data_property("round", AnyValue::make_function([](const 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"));
+
+        // Math.sign(x)
+        Math.define_data_property("sign", AnyValue::make_function([](const 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"));
+
+        // Math.sin(x)
+        Math.define_data_property("sin", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::sin);
+        }, "sin"));
+
+        // Math.sinh(x)
+        Math.define_data_property("sinh", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::sinh);
+        }, "sinh"));
+
+        // Math.sqrt(x)
+        Math.define_data_property("sqrt", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::sqrt);
+        }, "sqrt"));
+
+        // Math.sumPrecise(iterable)
+        Math.define_data_property("sumPrecise", AnyValue::make_function([](const AnyValue&, 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_value_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"));
+
+        // Math.tan(x)
+        Math.define_data_property("tan", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::tan);
+        }, "tan"));
+
+        // Math.tanh(x)
+        Math.define_data_property("tanh", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::tanh);
+        }, "tanh"));
+
+        // Math.trunc(x)
+        Math.define_data_property("trunc", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+            return MathFunc1(args, std::trunc);
+        }, "trunc"));
+    }
+} mathInit;

package/src/prelude/library/object.hpp

@@ -0,0 +1,288 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/access.hpp"
+#include "exception.hpp"
+
+// Define Object constructor
+inline auto Object = jspp::AnyValue::make_class([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                {
+    if (args.empty() || args[0].is_undefined() || args[0].is_null()) {
+        return jspp::AnyValue::make_object({});
+    }
+    // Return argument if it is an object
+    if (args[0].is_object() || args[0].is_array() || args[0].is_function() || args[0].is_promise() || args[0].is_iterator()) {
+        return args[0];
+    }
+    // TODO: Wrapper objects for primitives
+    return jspp::AnyValue::make_object({}); }, "Object");
+
+struct ObjectInit
+{
+    ObjectInit()
+    {
+        // Object.keys(obj)
+        Object.define_data_property("keys", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                          {
+            if (args.empty()) throw jspp::Exception::make_exception("Object.keys called on non-object", "TypeError");
+            auto obj = args[0];
+            if (obj.is_null() || obj.is_undefined()) throw jspp::Exception::make_exception("Object.keys called on null or undefined", "TypeError");
+            
+            auto keys = jspp::Access::get_object_keys(obj);
+            std::vector<jspp::AnyValue> keyValues;
+            for(const auto& k : keys) {
+                keyValues.push_back(jspp::AnyValue::make_string(k));
+            }
+            return jspp::AnyValue::make_array(std::move(keyValues)); }, "keys"));
+
+        // Object.values(obj)
+        Object.define_data_property("values", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                            {
+            if (args.empty()) throw jspp::Exception::make_exception("Object.values called on non-object", "TypeError");
+            auto obj = args[0];
+            if (obj.is_null() || obj.is_undefined()) throw jspp::Exception::make_exception("Object.values called on null or undefined", "TypeError");
+            
+            auto keys = jspp::Access::get_object_keys(obj);
+            std::vector<jspp::AnyValue> values;
+            for(const auto& k : keys) {
+                values.push_back(obj.get_property_with_receiver(k, obj));
+            }
+            return jspp::AnyValue::make_array(std::move(values)); }, "values"));
+
+        // Object.entries(obj)
+        Object.define_data_property("entries", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                             {
+            if (args.empty()) throw jspp::Exception::make_exception("Object.entries called on non-object", "TypeError");
+            auto obj = args[0];
+            if (obj.is_null() || obj.is_undefined()) throw jspp::Exception::make_exception("Object.entries called on null or undefined", "TypeError");
+            
+            auto keys = jspp::Access::get_object_keys(obj);
+            std::vector<jspp::AnyValue> entries;
+            for(const auto& k : keys) {
+                std::vector<jspp::AnyValue> entry;
+                entry.push_back(jspp::AnyValue::make_string(k));
+                entry.push_back(obj.get_property_with_receiver(k, obj));
+                entries.push_back(jspp::AnyValue::make_array(std::move(entry)));
+            }
+            return jspp::AnyValue::make_array(std::move(entries)); }, "entries"));
+
+        // Object.assign(target, ...sources)
+        Object.define_data_property("assign", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                            {
+            if (args.empty()) throw jspp::Exception::make_exception("Cannot convert undefined or null to object", "TypeError");
+            auto target = args[0];
+            if (target.is_null() || target.is_undefined()) throw jspp::Exception::make_exception("Cannot convert undefined or null to object", "TypeError");
+
+            // In JS, Object.assign modifies target in place if it's an object. 
+            // If it's a primitive, it wraps it (but our primitives are tricky, let's assume objects for now).
+            
+            for (size_t i = 1; i < args.size(); ++i) {
+                auto source = args[i];
+                if (source.is_null() || source.is_undefined()) continue;
+                
+                auto keys = jspp::Access::get_object_keys(source);
+                for(const auto& k : keys) {
+                     auto val = source.get_property_with_receiver(k, source);
+                     target.set_own_property(k, val);
+                }
+            }
+            return target; }, "assign"));
+
+        // Object.is(value1, value2)
+        Object.define_data_property("is", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                        {
+            jspp::AnyValue v1 = args.size() > 0 ? args[0] : jspp::AnyValue::make_undefined();
+            jspp::AnyValue v2 = args.size() > 1 ? args[1] : jspp::AnyValue::make_undefined();
+            
+            if (v1.is_number() && v2.is_number()) {
+                double d1 = v1.as_double();
+                double d2 = v2.as_double();
+                if (std::isnan(d1) && std::isnan(d2)) return jspp::Constants::TRUE;
+                if (d1 == 0 && d2 == 0) {
+                    // check signs
+                    return jspp::AnyValue::make_boolean(std::signbit(d1) == std::signbit(d2));
+                }
+                return jspp::AnyValue::make_boolean(d1 == d2);
+            }
+            
+            return jspp::is_strictly_equal_to(v1, v2); }, "is"));
+
+        // Object.getPrototypeOf(obj)
+        Object.define_data_property("getPrototypeOf", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                    {
+             if (args.empty()) throw jspp::Exception::make_exception("Object.getPrototypeOf called on non-object", "TypeError");
+             auto obj = args[0];
+             // In ES6+, primitives are coerced to objects.
+             // We'll focus on Objects/Arrays/Functions for now.
+             
+             if (obj.is_object()) {
+                 auto p = obj.as_object()->proto;
+                 return p ? *p : jspp::AnyValue::make_null();
+             }
+             if (obj.is_array()) {
+                 auto p = obj.as_array()->proto;
+                 return p ? *p : jspp::AnyValue::make_null();
+             }
+             if (obj.is_function()) {
+                 auto p = obj.as_function()->proto;
+                 return p ? *p : jspp::AnyValue::make_null();
+             }
+             
+             // For primitives, they use their prototype from the global constructors usually
+             // e.g. Number.prototype. For now return null or implement if needed.
+             return jspp::AnyValue::make_null(); }, "getPrototypeOf"));
+
+        // Object.setPrototypeOf(obj, proto)
+        Object.define_data_property("setPrototypeOf", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                    {
+             if (args.size() < 2) throw jspp::Exception::make_exception("Object.setPrototypeOf requires at least 2 arguments", "TypeError");
+             auto obj = args[0];
+             auto proto = args[1];
+             
+             if (!proto.is_object() && !proto.is_null()) {
+                 throw jspp::Exception::make_exception("Object prototype may only be an Object or null", "TypeError");
+             }
+             
+             if (obj.is_object()) {
+                 obj.as_object()->proto = std::make_shared<jspp::AnyValue>(proto);
+             } else if (obj.is_array()) {
+                 obj.as_array()->proto = std::make_shared<jspp::AnyValue>(proto);
+             } else if (obj.is_function()) {
+                 obj.as_function()->proto = std::make_shared<jspp::AnyValue>(proto);
+             }
+             
+             return obj; }, "setPrototypeOf"));
+
+        // Object.create(proto, [propertiesObject])
+        Object.define_data_property("create", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                            {
+             if (args.empty()) throw jspp::Exception::make_exception("Object prototype may only be an Object or null", "TypeError");
+             auto proto = args[0];
+             if (!proto.is_object() && !proto.is_null()) {
+                 throw jspp::Exception::make_exception("Object prototype may only be an Object or null", "TypeError");
+             }
+             
+             auto newObj = jspp::AnyValue::make_object_with_proto({}, proto);
+             
+             if (args.size() > 1 && !args[1].is_undefined()) {
+                 // Object.defineProperties(newObj, propertiesObject)
+                 // TODO: implement defineProperties logic if needed.
+             }
+             
+             return newObj; }, "create"));
+
+        // Object.defineProperty(obj, prop, descriptor)
+        Object.define_data_property("defineProperty", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                    {
+             if (args.size() < 3) throw jspp::Exception::make_exception("Object.defineProperty requires 3 arguments", "TypeError");
+             auto obj = args[0];
+             if (!obj.is_object() && !obj.is_array() && !obj.is_function()) throw jspp::Exception::make_exception("Object.defineProperty called on non-object", "TypeError");
+             
+             std::string prop = args[1].to_std_string();
+             auto descObj = args[2];
+             
+             bool enumerable = false;
+             bool configurable = false;
+             bool writable = false;
+             
+             if (descObj.has_property("enumerable")) enumerable = jspp::is_truthy(descObj.get_own_property("enumerable"));
+             if (descObj.has_property("configurable")) configurable = jspp::is_truthy(descObj.get_own_property("configurable"));
+             if (descObj.has_property("writable")) writable = jspp::is_truthy(descObj.get_own_property("writable"));
+             
+             bool hasValue = descObj.has_property("value");
+             bool hasGet = descObj.has_property("get");
+             bool hasSet = descObj.has_property("set");
+             
+             if (hasValue && (hasGet || hasSet)) {
+                 throw jspp::Exception::make_exception("Invalid property descriptor. Cannot both specify accessors and a value or writable attribute", "TypeError");
+             }
+             
+             if (hasValue) {
+                 auto value = descObj.get_own_property("value");
+                 obj.define_data_property(prop, value, writable, enumerable, configurable);
+             } else {
+                 jspp::AnyValue getter = jspp::AnyValue::make_undefined();
+                 jspp::AnyValue setter = jspp::AnyValue::make_undefined();
+                 
+                 if (hasGet) getter = descObj.get_own_property("get");
+                 if (hasSet) setter = descObj.get_own_property("set");
+                 
+                 if (!getter.is_undefined() && !getter.is_function()) throw jspp::Exception::make_exception("Getter must be a function: " + getter.to_std_string(), "TypeError");
+                 if (!setter.is_undefined() && !setter.is_function()) throw jspp::Exception::make_exception("Setter must be a function", "TypeError");
+
+                 if (obj.is_object()) {
+                    auto o_ptr = obj.as_object();
+                    std::optional<std::function<jspp::AnyValue(const jspp::AnyValue &, std::span<const jspp::AnyValue>)>> getFunc;
+                    std::optional<std::function<jspp::AnyValue(const jspp::AnyValue &, std::span<const jspp::AnyValue>)>> setFunc;
+                    
+                    if (getter.is_function()) {
+                        getFunc = [getter](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+                            return getter.call(thisVal, args);
+                        };
+                    }
+                    if (setter.is_function()) {
+                        setFunc = [setter](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+                            return setter.call(thisVal, args);
+                        };
+                    }
+                    
+                    auto desc = jspp::AnyValue::make_accessor_descriptor(getFunc, setFunc, enumerable, configurable);
+                    auto offset = o_ptr->shape->get_offset(prop);
+                    if (offset.has_value()) {
+                        o_ptr->storage[offset.value()] = desc;
+                    } else {
+                        o_ptr->shape = o_ptr->shape->transition(prop);
+                        o_ptr->storage.push_back(desc);
+                    }
+                 }
+                 // TODO: Handle Array/Function/others
+             }
+             
+             return obj; }, "defineProperty"));
+
+        // Object.hasOwn(obj, prop)
+        Object.define_data_property("hasOwn", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                            {
+            if (args.empty()) throw jspp::Exception::make_exception("Object.hasOwn called on non-object", "TypeError");
+            auto obj = args[0];
+            if (obj.is_null() || obj.is_undefined()) throw jspp::Exception::make_exception("Object.hasOwn called on null or undefined", "TypeError");
+            std::string prop = args.size() > 1 ? args[1].to_std_string() : "undefined";
+            
+            if (obj.is_object()) return jspp::AnyValue::make_boolean(obj.as_object()->shape->get_offset(prop).has_value());
+            if (obj.is_function()) return jspp::AnyValue::make_boolean(obj.as_function()->props.count(prop));
+            if (obj.is_array()) {
+                if (prop == "length") return jspp::Constants::TRUE;
+                if (jspp::JsArray::is_array_index(prop)) {
+                    uint32_t idx = static_cast<uint32_t>(std::stoull(prop));
+                    auto arr = obj.as_array();
+                    if (idx < arr->dense.size() && !(arr->dense[idx].is_uninitialized())) return jspp::Constants::TRUE;
+                    if (arr->sparse.count(idx)) return jspp::Constants::TRUE;
+                    return jspp::Constants::FALSE;
+                }
+                return jspp::AnyValue::make_boolean(obj.as_array()->props.count(prop));
+            }
+            
+            return jspp::Constants::FALSE; }, "hasOwn"));
+
+        // Object.prototype.hasOwnProperty
+        auto proto = Object.get_own_property("prototype");
+        proto.define_data_property("hasOwnProperty", jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                   {
+             std::string prop = args.size() > 0 ? args[0].to_std_string() : "undefined";
+             if (thisVal.is_object()) return jspp::AnyValue::make_boolean(thisVal.as_object()->shape->get_offset(prop).has_value());
+             if (thisVal.is_function()) return jspp::AnyValue::make_boolean(thisVal.as_function()->props.count(prop));
+             if (thisVal.is_array()) {
+                 if (prop == "length") return jspp::Constants::TRUE;
+                 if (jspp::JsArray::is_array_index(prop)) {
+                     uint32_t idx = static_cast<uint32_t>(std::stoull(prop));
+                     auto arr = thisVal.as_array();
+                     if (idx < arr->dense.size() && !(arr->dense[idx].is_uninitialized())) return jspp::Constants::TRUE;
+                     if (arr->sparse.count(idx)) return jspp::Constants::TRUE;
+                     return jspp::Constants::FALSE;
+                 }
+                 return jspp::AnyValue::make_boolean(thisVal.as_array()->props.count(prop));
+             }
+             return jspp::Constants::FALSE; }, "hasOwnProperty"));
+    }
+} objectInit;

package/src/prelude/library/performance.hpp

@@ -13,7 +13,7 @@ inline auto performance = jspp::AnyValue::make_object({
          // [C++14 Feature] Generalized Lambda Capture
          // We initialize 'startTime' RIGHT HERE inside the [].
          // It acts like a private variable stored inside this specific function.
-         [startTime = std::chrono::steady_clock::now()](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &)
+         [startTime = std::chrono::steady_clock::now()](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue>)
          {
              // We calculate the diff against the captured startTime
              std::chrono::duration<double, std::milli> duration =

package/src/prelude/library/process.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+
+#ifdef _WIN32
+#define JSPP_PLATFORM "win32"
+#else
+#define JSPP_PLATFORM "linux"
+#endif
+
+inline auto process = jspp::AnyValue::make_object({
+    {"argv", jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{})},
+    {"env", jspp::AnyValue::make_object({})},
+    {"platform", jspp::AnyValue::make_string(JSPP_PLATFORM)},
+    {"exit", jspp::AnyValue::make_function([](const jspp::AnyValue&, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+        int code = 0;
+        if (!args.empty() && args[0].is_number()) {
+            code = static_cast<int>(args[0].as_double());
+        }
+        std::exit(code);
+        return jspp::Constants::UNDEFINED;
+    }, "exit")}
+});
+
+namespace jspp {
+    inline void setup_process_argv(int argc, char** argv) {
+        std::vector<jspp::AnyValue> args;
+        if (argc > 0) {
+            args.push_back(jspp::AnyValue::make_string(argv[0]));
+            args.push_back(jspp::AnyValue::make_string("index.js"));
+            for (int i = 1; i < argc; ++i) {
+                args.push_back(jspp::AnyValue::make_string(argv[i]));
+            }
+        }
+        process.set_own_property("argv", jspp::AnyValue::make_array(std::move(args)));
+    }
+}
+