@ugo-studio/jspp 0.3.1 → 0.3.2

package/src/prelude/any_value.hpp

@@ -65,8 +65,7 @@ namespace jspp
 
         // default ctor (Undefined)
         AnyValue() noexcept : storage(TAG_SPECIAL | VAL_UNDEFINED) {}
-
-        explicit AnyValue(double d) noexcept
+        AnyValue(double d) noexcept
         {
             std::memcpy(&storage, &d, 8);
             if (storage >= TAG_BASE) [[unlikely]]
@@ -74,20 +73,28 @@ namespace jspp
                 storage = 0x7FF8000000000000ULL;
             }
         }
-
+        AnyValue(int i) noexcept
+        {
+            double d = static_cast<double>(i);
+            std::memcpy(&storage, &d, 8);
+        }
         explicit AnyValue(bool b) noexcept : storage(TAG_BOOLEAN | (b ? 1 : 0)) {}
-
         AnyValue(const AnyValue &other) noexcept : storage(other.storage)
         {
             if (is_heap_object())
                 get_ptr()->ref();
         }
-
         AnyValue(AnyValue &&other) noexcept : storage(other.storage)
         {
             other.storage = TAG_SPECIAL | VAL_UNDEFINED;
         }
+        ~AnyValue()
+        {
+            if (is_heap_object())
+                get_ptr()->deref();
+        }
 
+        // Assignments
         AnyValue &operator=(const AnyValue &other) noexcept
         {
             if (this != &other)
@@ -100,7 +107,6 @@ namespace jspp
             }
             return *this;
         }
-
         AnyValue &operator=(AnyValue &&other) noexcept
         {
             if (this != &other)
@@ -112,14 +118,6 @@ namespace jspp
             }
             return *this;
         }
-
-        ~AnyValue()
-        {
-            if (is_heap_object())
-                get_ptr()->deref();
-        }
-
-        // Assignments
         AnyValue &operator=(double val) noexcept
         {
             if (is_heap_object())
@@ -268,13 +266,13 @@ namespace jspp
 
         bool is_generator() const noexcept;
 
-        double as_double() const noexcept
+        inline double as_double() const noexcept
         {
             double d;
             std::memcpy(&d, &storage, 8);
             return d;
         }
-        bool as_boolean() const noexcept
+        inline bool as_boolean() const noexcept
         {
             return static_cast<bool>(storage & 1);
         }
@@ -330,7 +328,6 @@ namespace jspp
         AnyValue construct(std::span<const AnyValue> args, const std::optional<std::string> &name = std::nullopt) const;
         AnyValue &set_prototype(AnyValue proto);
         std::string to_std_string() const;
-        std::string to_property_key() const;
 
         inline uint64_t get_storage() const noexcept { return storage; }
         inline void *get_raw_ptr() const noexcept { return reinterpret_cast<void *>(storage & PAYLOAD_MASK); }
@@ -338,26 +335,27 @@ namespace jspp
         bool operator==(const AnyValue &other) const noexcept;
         bool operator==(const std::string &other) const noexcept;
         bool operator<(const AnyValue &other) const noexcept;
-        };
+    };
 
-        struct AnyValueAwaiter
-        {
+    struct AnyValueAwaiter
+    {
         AnyValue value;
         bool await_ready();
         void await_suspend(std::coroutine_handle<> h);
         AnyValue await_resume();
-        };
+    };
 
-        inline auto AnyValue::operator co_await() const
-        {
+    inline auto AnyValue::operator co_await() const
+    {
         return AnyValueAwaiter{*this};
-        }
-        }
+    }
+}
 
-        namespace jspp
-        {
-        namespace Constants
-        {        inline const AnyValue UNINITIALIZED = AnyValue::make_uninitialized();
+namespace jspp
+{
+    namespace Constants
+    {
+        inline const AnyValue UNINITIALIZED = AnyValue::make_uninitialized();
         inline const AnyValue UNDEFINED = AnyValue::make_undefined();
         inline const AnyValue Null = AnyValue::make_null();
         inline const AnyValue NaN = AnyValue::make_nan();
@@ -366,4 +364,4 @@ namespace jspp
         inline const AnyValue ZERO = AnyValue::make_number(0.0);
         inline const AnyValue ONE = AnyValue::make_number(1.0);
     }
-}
+}

package/src/prelude/jspp.hpp

@@ -32,9 +32,10 @@
 #include "values/prototypes/promise.hpp"
 #include "values/prototypes/string.hpp"
 #include "values/prototypes/number.hpp"
+#include "values/prototypes/boolean.hpp"
 
 // utilities
-#include "utils/operators_primitive.hpp"
+#include "utils/operators_native.hpp"
 #include "utils/operators.hpp"
 #include "utils/assignment_operators.hpp"
 #include "utils/access.hpp"
@@ -50,6 +51,7 @@
 #include "library/math.hpp"
 #include "library/object.hpp"
 #include "library/array.hpp"
+#include "library/boolean.hpp"
 #include "library/global.hpp"
 
 #include "iterator_instantiations.hpp"

package/src/prelude/library/boolean.cpp

@@ -0,0 +1,30 @@
+#include "jspp.hpp"
+#include "library/boolean.hpp"
+
+namespace jspp
+{
+    // TODO: implement boolean constructor
+    jspp::AnyValue Boolean = jspp::AnyValue::make_function(
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                     {
+                                                                         if (args.empty())
+                                                                             return jspp::Constants::FALSE;
+                                                                         return jspp::AnyValue::make_boolean(jspp::is_truthy(args[0])); }),
+        "Boolean");
+
+    struct BooleanInit
+    {
+        BooleanInit()
+        { // TODO: implement boolean prototypes
+          // auto proto = Boolean.get_own_property("prototype");
+          // proto.define_data_property("valueOf", jspp::BooleanPrototypes::get("valueOf").value(), true, false, true);
+          // proto.define_data_property("toString", jspp::BooleanPrototypes::get("toString").value(), true, false, true);
+        }
+    };
+
+    void init_boolean()
+    {
+        static BooleanInit booleanInit;
+    }
+
+}

package/src/prelude/library/boolean.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+
+namespace jspp
+{
+    extern AnyValue Boolean;
+    void init_boolean();
+}
+
+using jspp::Boolean;

package/src/prelude/library/error.cpp

@@ -14,7 +14,7 @@ namespace jspp
         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))
+            if (!obj->proto.is_null() && !obj->proto.is_undefined() && is_strictly_equal_to_native(obj->proto, proto))
             {
                 is_construct_call = true;
             }
@@ -58,7 +58,7 @@ namespace jspp
         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 (is_strictly_equal_to_native(current, proto)) return jspp::Constants::TRUE;
                  if (current.is_object()) current = current.as_object()->proto;
                  else break;
             }

package/src/prelude/library/global.cpp

@@ -19,6 +19,7 @@ namespace jspp {
         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>
@@ -52,6 +53,7 @@ namespace jspp {
             {"Math", jspp::Math},
             {"Object", jspp::Object},
             {"Array", jspp::Array},
+            {"Boolean", jspp::Boolean},
         });
 
         auto objectProto = ::Object.get_own_property("prototype");

package/src/prelude/library/math.cpp

@@ -32,6 +32,9 @@ namespace jspp {
             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);
@@ -42,78 +45,78 @@ namespace jspp {
             defConst("SQRT1_2", std::numbers::sqrt2 / 2.0);
             defConst("SQRT2", std::numbers::sqrt2);
 
-            jspp::Math.define_data_property("abs", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("abs", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return AnyValue::make_number(std::abs(GetArgAsDouble(args, 0)));
             }, "abs"));
 
-            jspp::Math.define_data_property("acos", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("acos", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::acos);
             }, "acos"));
 
-            jspp::Math.define_data_property("acosh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("acosh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::acosh);
             }, "acosh"));
 
-            jspp::Math.define_data_property("asin", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("asin", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::asin);
             }, "asin"));
 
-            jspp::Math.define_data_property("asinh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("asinh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::asinh);
             }, "asinh"));
 
-            jspp::Math.define_data_property("atan", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("atan", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::atan);
             }, "atan"));
 
-            jspp::Math.define_data_property("atan2", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("atan2", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc2(args, std::atan2);
             }, "atan2"));
 
-            jspp::Math.define_data_property("atanh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("atanh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::atanh);
             }, "atanh"));
 
-            jspp::Math.define_data_property("cbrt", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("cbrt", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::cbrt);
             }, "cbrt"));
 
-            jspp::Math.define_data_property("ceil", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("ceil", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::ceil);
             }, "ceil"));
 
-            jspp::Math.define_data_property("clz32", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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"));
 
-            jspp::Math.define_data_property("cos", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("cos", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::cos);
             }, "cos"));
 
-            jspp::Math.define_data_property("cosh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("cosh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::cosh);
             }, "cosh"));
 
-            jspp::Math.define_data_property("exp", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("exp", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::exp);
             }, "exp"));
 
-            jspp::Math.define_data_property("expm1", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("expm1", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::expm1);
             }, "expm1"));
 
-            jspp::Math.define_data_property("floor", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("floor", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::floor);
             }, "floor"));
 
-            jspp::Math.define_data_property("fround", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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"));
 
-            jspp::Math.define_data_property("hypot", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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);
@@ -123,29 +126,29 @@ namespace jspp {
                 return AnyValue::make_number(result);
             }, "hypot"));
 
-            jspp::Math.define_data_property("imul", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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"));
 
-            jspp::Math.define_data_property("log", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("log", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::log);
             }, "log"));
 
-            jspp::Math.define_data_property("log10", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("log10", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::log10);
             }, "log10"));
 
-            jspp::Math.define_data_property("log1p", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("log1p", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::log1p);
             }, "log1p"));
 
-            jspp::Math.define_data_property("log2", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("log2", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::log2);
             }, "log2"));
 
-            jspp::Math.define_data_property("max", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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);
@@ -155,7 +158,7 @@ namespace jspp {
                 return AnyValue::make_number(maxVal);
             }, "max"));
 
-            jspp::Math.define_data_property("min", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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);
@@ -165,63 +168,63 @@ namespace jspp {
                 return AnyValue::make_number(minVal);
             }, "min"));
 
-            jspp::Math.define_data_property("pow", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("pow", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc2(args, std::pow);
             }, "pow"));
 
-            jspp::Math.define_data_property("random", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("random", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return AnyValue::make_number(dis(gen));
             }, "random"));
 
-            jspp::Math.define_data_property("round", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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"));
 
-            jspp::Math.define_data_property("sign", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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"));
 
-            jspp::Math.define_data_property("sin", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("sin", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::sin);
             }, "sin"));
 
-            jspp::Math.define_data_property("sinh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("sinh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::sinh);
             }, "sinh"));
 
-            jspp::Math.define_data_property("sqrt", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("sqrt", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::sqrt);
             }, "sqrt"));
 
-            jspp::Math.define_data_property("tan", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("tan", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::tan);
             }, "tan"));
 
-            jspp::Math.define_data_property("tanh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("tanh", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::tanh);
             }, "tanh"));
 
-            jspp::Math.define_data_property("trunc", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            defMutable("trunc", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
                 return MathFunc1(args, std::trunc);
             }, "trunc"));
 
             // Math.f16round(x)
-            jspp::Math.define_data_property("f16round", AnyValue::make_function([](AnyValue, std::span<const AnyValue> args) -> AnyValue {
+            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
+                #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)
-            jspp::Math.define_data_property("sumPrecise", AnyValue::make_function([](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue {
+            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");

package/src/prelude/library/math.hpp

@@ -6,7 +6,9 @@
 #include <algorithm>
 #include <bit>
 #include <numbers>
+#if __has_include(<stdfloat>)
 #include <stdfloat>
+#endif
 
 #include "types.hpp"
 #include "any_value.hpp"

package/src/prelude/library/object.cpp

@@ -362,7 +362,7 @@ namespace jspp {
                 }
                 
                 while (!current.is_null()) {
-                    if (jspp::is_strictly_equal_to_primitive(current, thisVal)) return jspp::Constants::TRUE;
+                    if (jspp::is_strictly_equal_to_native(current, thisVal)) return jspp::Constants::TRUE;
                     if (current.is_object()) current = current.as_object()->proto;
                     else if (current.is_array()) current = current.as_array()->proto;
                     else if (current.is_function()) current = current.as_function()->proto;

package/src/prelude/types.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <iostream>
+#include <exception>
 #include <string>
 #include <vector>
 #include <variant>
@@ -100,15 +101,15 @@ namespace jspp
     const bool is_truthy(const AnyValue &val) noexcept;
 
     // Basic equality operators
-    inline const bool is_strictly_equal_to_primitive(const AnyValue &lhs, const double &rhs) noexcept;
-    inline const bool is_strictly_equal_to_primitive(const double &lhs, const AnyValue &rhs) noexcept;
-    inline const bool is_strictly_equal_to_primitive(const double &lhs, const double &rhs) noexcept;
-    inline const bool is_strictly_equal_to_primitive(const AnyValue &lhs, const AnyValue &rhs) noexcept;
-
-    inline const bool is_equal_to_primitive(const AnyValue &lhs, const double &rhs) noexcept;
-    inline const bool is_equal_to_primitive(const double &lhs, const AnyValue &rhs) noexcept;
-    inline const bool is_equal_to_primitive(const double &lhs, const double &rhs) noexcept;
-    inline const bool is_equal_to_primitive(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+    inline const bool is_strictly_equal_to_native(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const bool is_strictly_equal_to_native(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const bool is_strictly_equal_to_native(const double &lhs, const double &rhs) noexcept;
+    inline const bool is_strictly_equal_to_native(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const bool is_equal_to_native(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const bool is_equal_to_native(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const bool is_equal_to_native(const double &lhs, const double &rhs) noexcept;
+    inline const bool is_equal_to_native(const AnyValue &lhs, const AnyValue &rhs) noexcept;
 
     inline const AnyValue is_strictly_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
     inline const AnyValue is_strictly_equal_to(const double &lhs, const AnyValue &rhs) noexcept;

package/src/prelude/utils/access.hpp

@@ -331,7 +331,7 @@ namespace jspp
 
                 if (proto.is_null() || proto.is_undefined())
                     break;
-                if (is_strictly_equal_to_primitive(proto, targetProto))
+                if (is_strictly_equal_to_native(proto, targetProto))
                     return Constants::TRUE;
                 current = proto;
             }
@@ -477,7 +477,7 @@ namespace jspp
             {
                 for (const auto &ex : excluded_keys)
                 {
-                    if (is_strictly_equal_to_primitive(key, ex))
+                    if (is_strictly_equal_to_native(key, ex))
                         return true;
                 }
                 return false;