@ugo-studio/jspp 0.2.8 → 0.2.9

package/src/prelude/library/math.hpp

@@ -60,84 +60,84 @@ struct MathInit {
         // --- Methods ---
         
         // Math.abs(x)
-        Math.define_data_property("abs", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("abs", AnyValue::make_function([](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 {
+        Math.define_data_property("acos", AnyValue::make_function([](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 {
+        Math.define_data_property("acosh", AnyValue::make_function([](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 {
+        Math.define_data_property("asin", AnyValue::make_function([](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 {
+        Math.define_data_property("asinh", AnyValue::make_function([](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 {
+        Math.define_data_property("atan", AnyValue::make_function([](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 {
+        Math.define_data_property("atan2", AnyValue::make_function([](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 {
+        Math.define_data_property("atanh", AnyValue::make_function([](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 {
+        Math.define_data_property("cbrt", AnyValue::make_function([](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 {
+        Math.define_data_property("ceil", AnyValue::make_function([](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 {
+        Math.define_data_property("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"));
 
         // Math.cos(x)
-        Math.define_data_property("cos", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("cos", AnyValue::make_function([](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 {
+        Math.define_data_property("cosh", AnyValue::make_function([](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 {
+        Math.define_data_property("exp", AnyValue::make_function([](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 {
+        Math.define_data_property("expm1", AnyValue::make_function([](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 {
+        Math.define_data_property("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)));
@@ -150,18 +150,18 @@ struct MathInit {
         }, "f16round"));
 
         // Math.floor(x)
-        Math.define_data_property("floor", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("floor", AnyValue::make_function([](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 {
+        Math.define_data_property("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"));
 
         // Math.hypot(...args)
-        Math.define_data_property("hypot", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("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);
@@ -172,34 +172,34 @@ struct MathInit {
         }, "hypot"));
 
         // Math.imul(x, y)
-        Math.define_data_property("imul", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("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"));
 
         // Math.log(x)
-        Math.define_data_property("log", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("log", AnyValue::make_function([](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 {
+        Math.define_data_property("log10", AnyValue::make_function([](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 {
+        Math.define_data_property("log1p", AnyValue::make_function([](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 {
+        Math.define_data_property("log2", AnyValue::make_function([](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 {
+        Math.define_data_property("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);
@@ -210,7 +210,7 @@ struct MathInit {
         }, "max"));
 
         // Math.min(...args)
-        Math.define_data_property("min", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("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);
@@ -221,24 +221,24 @@ struct MathInit {
         }, "min"));
 
         // Math.pow(base, exponent)
-        Math.define_data_property("pow", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("pow", AnyValue::make_function([](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 {
+        Math.define_data_property("random", AnyValue::make_function([](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 {
+        Math.define_data_property("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"));
 
         // Math.sign(x)
-        Math.define_data_property("sign", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("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);
@@ -246,25 +246,25 @@ struct MathInit {
         }, "sign"));
 
         // Math.sin(x)
-        Math.define_data_property("sin", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("sin", AnyValue::make_function([](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 {
+        Math.define_data_property("sinh", AnyValue::make_function([](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 {
+        Math.define_data_property("sqrt", AnyValue::make_function([](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 {
+        Math.define_data_property("sumPrecise", AnyValue::make_function([](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 iterObj = jspp::Access::get_object_iterator(args[0], "iterable");
             auto nextFunc = iterObj.get_own_property("next");
             
             double sum = 0;
@@ -291,17 +291,17 @@ struct MathInit {
         }, "sumPrecise"));
 
         // Math.tan(x)
-        Math.define_data_property("tan", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
+        Math.define_data_property("tan", AnyValue::make_function([](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 {
+        Math.define_data_property("tanh", AnyValue::make_function([](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 {
+        Math.define_data_property("trunc", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
             return MathFunc1(args, std::trunc);
         }, "trunc"));
     }

package/src/prelude/library/object.hpp

@@ -6,7 +6,7 @@
 #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
+inline auto Object = jspp::AnyValue::make_class([](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({});
@@ -23,7 +23,7 @@ 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
+        Object.define_data_property("keys", jspp::AnyValue::make_function([](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];
@@ -37,7 +37,7 @@ struct ObjectInit
             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
+        Object.define_data_property("values", jspp::AnyValue::make_function([](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];
@@ -51,7 +51,7 @@ struct ObjectInit
             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
+        Object.define_data_property("entries", jspp::AnyValue::make_function([](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];
@@ -68,7 +68,7 @@ struct ObjectInit
             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
+        Object.define_data_property("assign", jspp::AnyValue::make_function([](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];
@@ -87,7 +87,7 @@ struct ObjectInit
             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
+        Object.define_data_property("is", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                         {
             jspp::AnyValue v1 = args.size() > 0 ? args[0] : jspp::Constants::UNDEFINED;
             jspp::AnyValue v2 = args.size() > 1 ? args[1] : jspp::Constants::UNDEFINED;
@@ -105,7 +105,7 @@ struct ObjectInit
             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
+        Object.define_data_property("getPrototypeOf", jspp::AnyValue::make_function([](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];
@@ -123,7 +123,7 @@ struct ObjectInit
              return jspp::Constants::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
+        Object.define_data_property("setPrototypeOf", jspp::AnyValue::make_function([](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];
@@ -144,7 +144,7 @@ struct ObjectInit
              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
+        Object.define_data_property("create", jspp::AnyValue::make_function([](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];
@@ -162,7 +162,7 @@ struct ObjectInit
              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
+        Object.define_data_property("defineProperty", jspp::AnyValue::make_function([](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];
@@ -202,16 +202,16 @@ struct ObjectInit
 
                  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;
+                    std::optional<std::function<jspp::AnyValue(jspp::AnyValue, std::span<const jspp::AnyValue>)>> getFunc;
+                    std::optional<std::function<jspp::AnyValue(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 {
+                        getFunc = [getter](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 {
+                        setFunc = [setter](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
                             return setter.call(thisVal, args);
                         };
                     }
@@ -230,7 +230,7 @@ struct ObjectInit
              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
+        Object.define_data_property("hasOwn", jspp::AnyValue::make_function([](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];
@@ -255,7 +255,7 @@ struct ObjectInit
 
         // 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
+        proto.define_data_property("hasOwnProperty", jspp::AnyValue::make_function([](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());

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, std::span<const jspp::AnyValue>)
+         [startTime = std::chrono::steady_clock::now()](jspp::AnyValue, 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

@@ -13,7 +13,7 @@ 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 {
+    {"exit", jspp::AnyValue::make_function([](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());

package/src/prelude/library/promise.hpp

@@ -5,7 +5,7 @@
 #include "any_value.hpp"
 #include "exception.hpp"
 
-inline auto Promise = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+inline auto Promise = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                     {
                                                         if (args.empty() || !args[0].is_function())
                                                         {
@@ -17,14 +17,14 @@ inline auto Promise = jspp::AnyValue::make_function([](const jspp::AnyValue &thi
                                                         auto state = promise.state; // Share state
 
                                                         // resolve function
-                                                        auto resolveFn = jspp::AnyValue::make_function([state](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                        auto resolveFn = jspp::AnyValue::make_function([state](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                                                        {
         jspp::JsPromise p; p.state = state;
         p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
         return jspp::Constants::UNDEFINED; }, "resolve");
 
                                                         // reject function
-                                                        auto rejectFn = jspp::AnyValue::make_function([state](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                        auto rejectFn = jspp::AnyValue::make_function([state](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                                                       {
         jspp::JsPromise p; p.state = state;
         p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
@@ -52,21 +52,21 @@ struct PromiseInit
     PromiseInit()
     {
         // Promise.resolve(value)
-        Promise.define_data_property("resolve", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        Promise.define_data_property("resolve", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                               {
             jspp::JsPromise p;
             p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
             return jspp::AnyValue::make_promise(p); }, "resolve"));
 
         // Promise.reject(reason)
-        Promise.define_data_property("reject", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        Promise.define_data_property("reject", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                              {
             jspp::JsPromise p;
             p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
             return jspp::AnyValue::make_promise(p); }, "reject"));
 
         // Promise.all(iterable)
-        Promise.define_data_property("all", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        Promise.define_data_property("all", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                           {
              // Handle non-array iterable or empty args
              if (args.empty() || !args[0].is_array()) {
@@ -93,7 +93,7 @@ struct PromiseInit
              for (size_t i = 0; i < len; ++i) {
                  jspp::AnyValue item = arr->get_property(static_cast<uint32_t>(i));
                  
-                 auto handleResult = [masterState, results, count, i, rejected](const jspp::AnyValue& res) {
+                 auto handleResult = [masterState, results, count, i, rejected](jspp::AnyValue res) {
                       if (*rejected) return;
                       (*results)[i] = res;
                       (*count)--;
@@ -103,7 +103,7 @@ struct PromiseInit
                       }
                  };
                  
-                 auto handleReject = [masterState, rejected](const jspp::AnyValue& reason) {
+                 auto handleReject = [masterState, rejected](jspp::AnyValue reason) {
                       if (*rejected) return;
                       *rejected = true;
                       jspp::JsPromise p; p.state = masterState;

package/src/prelude/library/symbol.hpp

@@ -6,7 +6,7 @@
 #include "any_value.hpp"
 
 // Define Symbol as a function
-inline auto Symbol = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+inline auto Symbol = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                    {
     std::string description = "";
     if (!args.empty() && !args[0].is_undefined()) {
@@ -20,13 +20,13 @@ struct SymbolInit
     SymbolInit()
     {
         // Static methods
-        Symbol.define_data_property("for", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        Symbol.define_data_property("for", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                          {
              std::string key = "";
              if (!args.empty()) key = args[0].to_std_string();
              return jspp::AnyValue::from_symbol(jspp::JsSymbol::for_global(key)); }, "for"));
 
-        Symbol.define_data_property("keyFor", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        Symbol.define_data_property("keyFor", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                             {
              if (args.empty() || !args[0].is_symbol()) throw jspp::Exception::make_exception("Symbol.keyFor requires a symbol", "TypeError");
              auto sym = args[0].as_symbol();

package/src/prelude/library/timer.hpp

@@ -7,7 +7,7 @@
 #include "exception.hpp"
 
 // setTimeout(callback, delay, ...args)
-inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+inline auto setTimeout = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
     if (args.empty() || !args[0].is_function()) {
         throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
     }
@@ -41,7 +41,7 @@ inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue&
 }, "setTimeout");
 
 // clearTimeout(id)
-inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+inline auto clearTimeout = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
     if (!args.empty() && args[0].is_number()) {
         size_t id = static_cast<size_t>(args[0].as_double());
         jspp::Scheduler::instance().clear_timer(id);
@@ -50,7 +50,7 @@ inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue
 }, "clearTimeout");
 
 // setInterval(callback, delay, ...args)
-inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+inline auto setInterval = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
     if (args.empty() || !args[0].is_function()) {
         throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
     }
@@ -83,7 +83,7 @@ inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue&
 }, "setInterval");
 
 // clearInterval(id)
-inline auto clearInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+inline auto clearInterval = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
     if (!args.empty() && args[0].is_number()) {
         size_t id = static_cast<size_t>(args[0].as_double());
         jspp::Scheduler::instance().clear_timer(id);

package/src/prelude/types.hpp

@@ -89,10 +89,10 @@ namespace jspp
     class AnyValue;
 
     using JsFunctionCallable = std::variant<
-        std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>,
-        std::function<JsIterator<AnyValue>(const AnyValue &, std::span<const AnyValue>)>,
-        std::function<JsPromise(const AnyValue &, std::span<const AnyValue>)>,
-        std::function<JsAsyncIterator<AnyValue>(const AnyValue &, std::span<const AnyValue>)>>;
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>,
+        std::function<JsIterator<AnyValue>(AnyValue, std::vector<AnyValue>)>,
+        std::function<JsPromise(AnyValue, std::vector<AnyValue>)>,
+        std::function<JsAsyncIterator<AnyValue>(AnyValue, std::vector<AnyValue>)>>;
 
     // Awaiter for AnyValue
     struct AnyValueAwaiter;

package/src/prelude/utils/access.hpp

@@ -83,7 +83,7 @@ namespace jspp
         }
 
         // Helper function to get enumerable own property keys/values of an object
-        inline std::vector<std::string> get_object_keys(const AnyValue &obj)
+        inline std::vector<std::string> get_object_keys(const AnyValue &obj, bool include_symbols = false)
         {
             std::vector<std::string> keys;
 
@@ -95,7 +95,7 @@ namespace jspp
                     if (ptr->deleted_keys.count(key))
                         continue;
 
-                    if (JsSymbol::is_internal_key(key))
+                    if (!include_symbols && JsSymbol::is_internal_key(key))
                         continue;
 
                     auto offset_opt = ptr->shape->get_offset(key);
@@ -125,7 +125,7 @@ namespace jspp
                 auto ptr = obj.as_function();
                 for (const auto &pair : ptr->props)
                 {
-                    if (!JsSymbol::is_internal_key(pair.first))
+                    if (include_symbols || !JsSymbol::is_internal_key(pair.first))
                     {
                         if (!pair.second.is_data_descriptor() && !pair.second.is_accessor_descriptor())
                             keys.push_back(pair.first);
@@ -155,7 +155,7 @@ namespace jspp
             return keys;
         }
 
-        inline AnyValue get_object_value_iterator(const AnyValue &obj, const std::string &name)
+        inline AnyValue get_object_iterator(const AnyValue &obj, const std::string &name)
         {
             if (obj.is_iterator())
             {
@@ -183,7 +183,7 @@ namespace jspp
             throw jspp::Exception::make_exception(name + " is not iterable", "TypeError");
         }
 
-        inline AnyValue get_async_object_value_iterator(const AnyValue &obj, const std::string &name)
+        inline AnyValue get_object_async_iterator(const AnyValue &obj, const std::string &name)
         {
             if (obj.is_async_iterator())
                 return obj;
@@ -362,7 +362,7 @@ namespace jspp
             }
             else if (source.is_object() || source.is_function() || source.is_iterator())
             {
-                auto iter = get_object_value_iterator(source, "spread target");
+                auto iter = get_object_iterator(source, "spread target");
                 auto next_fn = iter.get_own_property("next");
                 while (true)
                 {
@@ -390,5 +390,23 @@ namespace jspp
             }
         }
 
+        inline AnyValue get_rest_object(const AnyValue &source, const std::vector<std::string> &excluded_keys)
+        {
+            if (source.is_null() || source.is_undefined())
+                return AnyValue::make_object({});
+
+            auto result = AnyValue::make_object({});
+            auto keys = get_object_keys(source, true);
+            std::unordered_set<std::string> excluded(excluded_keys.begin(), excluded_keys.end());
+
+            for (const auto &key : keys)
+            {
+                if (excluded.find(key) == excluded.end())
+                {
+                    result.set_own_property(key, source.get_property_with_receiver(key, source));
+                }
+            }
+            return result;
+        }
     }
 }