@ugo-studio/jspp 0.3.2 → 0.3.4

package/src/prelude/utils/operators_native.hpp

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

package/src/prelude/values/array.cpp

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