@ugo-studio/jspp 0.3.1 → 0.3.3

package/src/prelude/utils/operators_native.hpp

@@ -0,0 +1,360 @@
+#pragma once
+
+#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
+#include <algorithm> // For std::all_of
+#include <limits>    // For numeric_limits
+
+namespace jspp
+{
+    // Private namespace for helper functions that implement JS type conversions.
+    namespace Operators_Private
+    {
+        // Implements the ToNumber abstract operation from ECMA-262.
+        inline double ToNumber(const AnyValue &val)
+        {
+            if (val.is_number())
+                return val.as_double();
+            if (val.is_null())
+                return 0.0;
+            if (val.is_undefined())
+                return std::numeric_limits<double>::quiet_NaN();
+            if (val.is_boolean())
+                return val.as_boolean() ? 1.0 : 0.0;
+            if (val.is_string())
+            {
+                const std::string &s = val.as_string()->value;
+                if (s.empty() || std::all_of(s.begin(), s.end(), [](unsigned char c)
+                                             { return std::isspace(c); }))
+                    return 0.0;
+                try
+                {
+                    size_t pos;
+                    double num = std::stod(s, &pos);
+                    while (pos < s.length() && std::isspace(static_cast<unsigned char>(s[pos])))
+                        pos++;
+                    if (pos != s.length())
+                        return std::numeric_limits<double>::quiet_NaN();
+                    return num;
+                }
+                catch (...)
+                {
+                    return std::numeric_limits<double>::quiet_NaN();
+                }
+            }
+            if (val.is_uninitialized())
+            {
+                // THROW
+                Exception::throw_uninitialized_reference("#<Object>");
+            }
+            // Default to NaN
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+        // Implements the ToInt32 abstract operation from ECMA-262.
+        inline int32_t ToInt32(const AnyValue &val)
+        {
+            double num = ToNumber(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));
+            double int32bit = fmod(posInt, 4294967296.0); // 2^32
+
+            if (int32bit >= 2147483648.0) // 2^31
+                return static_cast<int32_t>(int32bit - 4294967296.0);
+            else
+                return static_cast<int32_t>(int32bit);
+        }
+        // Implements the ToUint32 abstract operation from ECMA-262.
+        inline uint32_t ToUint32(const AnyValue &val)
+        {
+            double num = ToNumber(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));
+            uint32_t uint32bit = static_cast<uint32_t>(fmod(posInt, 4294967296.0));
+            return uint32bit;
+        }
+    }
+
+    // --- TRUTHY CHECKER ---
+    inline const bool is_truthy(const double &val) noexcept
+    {
+        return val != 0.0 && !std::isnan(val);
+    }
+    inline const bool is_truthy(const std::string &val) noexcept
+    {
+        return !val.empty();
+    }
+    inline const bool is_truthy(const AnyValue &val) noexcept
+    {
+        switch (val.get_type())
+        {
+        case JsType::Number:
+            return is_truthy(val.as_double());
+        case JsType::String:
+            return is_truthy(val.as_string()->value);
+        case JsType::Boolean:
+            return val.as_boolean();
+        case JsType::Null:
+        case JsType::Undefined:
+        case JsType::Uninitialized:
+            return false;
+        default:
+            return true;
+        }
+    }
+
+    // --- UNARY NATIVE ---
+    inline double plus_native(const AnyValue &val) { return Operators_Private::ToNumber(val); }
+    inline double plus_native(double val) { return val; }
+    inline double negate_native(const AnyValue &val) { return -Operators_Private::ToNumber(val); }
+    inline double negate_native(double val) { return -val; }
+    inline double bitwise_not_native(const AnyValue &val) { return static_cast<double>(~Operators_Private::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)
+    inline const bool is_strictly_equal_to_native(const AnyValue &lhs, const double &rhs) noexcept
+    {
+        if (lhs.is_number())
+            return lhs.as_double() == rhs;
+        return false;
+    }
+    inline const bool is_strictly_equal_to_native(const double &lhs, const AnyValue &rhs) noexcept
+    {
+        if (rhs.is_number())
+            return lhs == rhs.as_double();
+        return false;
+    }
+    inline const bool is_strictly_equal_to_native(const double &lhs, const double &rhs) noexcept
+    {
+        return lhs == rhs;
+    }
+    inline const bool is_strictly_equal_to_native(const AnyValue &lhs, const AnyValue &rhs) noexcept
+    {
+        JsType type = lhs.get_type();
+        if (type != rhs.get_type())
+            return false;
+        switch (type)
+        {
+        case JsType::Boolean:
+            return lhs.as_boolean() == rhs.as_boolean();
+        case JsType::Number:
+            return lhs.as_double() == rhs.as_double();
+        case JsType::String:
+            return lhs.as_string()->value == rhs.as_string()->value;
+        case JsType::Array:
+            return lhs.as_array() == rhs.as_array();
+        case JsType::Object:
+            return lhs.as_object() == rhs.as_object();
+        case JsType::Function:
+            return lhs.as_function() == rhs.as_function();
+        case JsType::Iterator:
+            return lhs.as_iterator() == rhs.as_iterator();
+        case JsType::AsyncIterator:
+            return lhs.as_async_iterator() == rhs.as_async_iterator();
+        case JsType::Promise:
+            return lhs.as_promise() == rhs.as_promise();
+        case JsType::Symbol:
+            return lhs.as_symbol() == rhs.as_symbol();
+        case JsType::DataDescriptor:
+            return lhs.as_data_descriptor() == rhs.as_data_descriptor();
+        case JsType::AccessorDescriptor:
+            return lhs.as_accessor_descriptor() == rhs.as_accessor_descriptor();
+        default:
+            return true;
+        }
+    }
+
+    // Operator == (returns primitive boolean)
+    inline const bool is_equal_to_native(const AnyValue &lhs, const double &rhs) noexcept
+    {
+        return is_equal_to_native(lhs, AnyValue::make_number(rhs));
+    }
+    inline const bool is_equal_to_native(const double &lhs, const AnyValue &rhs) noexcept
+    {
+        return is_equal_to_native(AnyValue::make_number(lhs), rhs);
+    }
+    inline const bool is_equal_to_native(const double &lhs, const double &rhs) noexcept
+    {
+        return lhs == rhs;
+    }
+    inline const bool is_equal_to_native(const AnyValue &lhs, const AnyValue &rhs) noexcept
+    {
+        JsType lhs_type = lhs.get_type();
+        JsType rhs_type = rhs.get_type();
+        if (lhs_type == rhs_type)
+        {
+            return is_strictly_equal_to_native(lhs, rhs);
+        }
+        if ((lhs_type == JsType::Null && rhs_type == JsType::Undefined) || (lhs_type == JsType::Undefined && rhs_type == JsType::Null))
+        {
+            return true;
+        }
+        if (lhs_type == JsType::Number && rhs_type == JsType::String)
+        {
+            return lhs.as_double() == Operators_Private::ToNumber(rhs);
+        }
+        if (lhs_type == JsType::String && rhs_type == JsType::Number)
+        {
+            return Operators_Private::ToNumber(lhs) == rhs.as_double();
+        }
+        if (lhs_type == JsType::Boolean)
+        {
+            return is_equal_to_native(lhs.as_boolean() ? 1.0 : 0.0, rhs);
+        }
+        if (rhs_type == JsType::Boolean)
+        {
+            return is_equal_to_native(lhs, AnyValue::make_number(rhs.as_boolean() ? 1.0 : 0.0));
+        }
+        if ((lhs_type == JsType::Object || lhs_type == JsType::Array || lhs_type == JsType::Function || lhs_type == JsType::Promise || lhs_type == JsType::Iterator) &&
+            (rhs_type == JsType::String || rhs_type == JsType::Number || rhs_type == JsType::Symbol))
+        {
+            return is_equal_to_native(AnyValue::make_string(lhs.to_std_string()), rhs);
+        }
+        if ((rhs_type == JsType::Object || rhs_type == JsType::Array || rhs_type == JsType::Function || rhs_type == JsType::Promise || rhs_type == JsType::Iterator) &&
+            (lhs_type == JsType::String || lhs_type == JsType::Number || lhs_type == JsType::Symbol))
+        {
+            return is_equal_to_native(lhs, AnyValue::make_string(rhs.to_std_string()));
+        }
+        if (lhs_type == JsType::DataDescriptor || lhs_type == JsType::AccessorDescriptor)
+        {
+            return is_strictly_equal_to_native(lhs, rhs);
+        }
+        return false;
+    }
+
+    // Operator !== (returns primitive boolean)
+    inline const bool not_strictly_equal_to_native(const AnyValue &lhs, const double &rhs) noexcept { return !is_strictly_equal_to_native(lhs, rhs); }
+    inline const bool not_strictly_equal_to_native(const double &lhs, const AnyValue &rhs) noexcept { return !is_strictly_equal_to_native(lhs, rhs); }
+    inline const bool not_strictly_equal_to_native(const double &lhs, const double &rhs) noexcept { return !is_strictly_equal_to_native(lhs, rhs); }
+    inline const bool not_strictly_equal_to_native(const AnyValue &lhs, const AnyValue &rhs) noexcept { return !is_strictly_equal_to_native(lhs, rhs); }
+
+    // Operator != (returns primitive boolean)
+    inline const bool not_equal_to_native(const AnyValue &lhs, const double &rhs) noexcept { return !is_equal_to_native(lhs, rhs); }
+    inline const bool not_equal_to_native(const double &lhs, const AnyValue &rhs) noexcept { return !is_equal_to_native(lhs, rhs); }
+    inline const bool not_equal_to_native(const double &lhs, const double &rhs) noexcept { return !is_equal_to_native(lhs, rhs); }
+    inline const bool not_equal_to_native(const AnyValue &lhs, const AnyValue &rhs) noexcept { return !is_equal_to_native(lhs, rhs); }
+
+    // --- 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 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 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 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 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 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)); }
+
+    // --- 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 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 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 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 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 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)); }
+
+    // --- 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_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_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 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 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 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)); }
+
+}

package/src/prelude/utils/well_known_symbols.hpp

@@ -7,18 +7,18 @@ namespace jspp
     namespace WellKnownSymbols
     {
         // We use a specific prefix "@@" for well-known symbols to distinguish them from user symbols
-        inline JsSymbol* iterator = new JsSymbol("Symbol.iterator", "@@iterator");
-        inline JsSymbol* asyncIterator = new JsSymbol("Symbol.asyncIterator", "@@asyncIterator");
-        inline JsSymbol* hasInstance = new JsSymbol("Symbol.hasInstance", "@@hasInstance");
-        inline JsSymbol* isConcatSpreadable = new JsSymbol("Symbol.isConcatSpreadable", "@@isConcatSpreadable");
-        inline JsSymbol* match = new JsSymbol("Symbol.match", "@@match");
-        inline JsSymbol* matchAll = new JsSymbol("Symbol.matchAll", "@@matchAll");
-        inline JsSymbol* replace = new JsSymbol("Symbol.replace", "@@replace");
-        inline JsSymbol* search = new JsSymbol("Symbol.search", "@@search");
-        inline JsSymbol* species = new JsSymbol("Symbol.species", "@@species");
-        inline JsSymbol* split = new JsSymbol("Symbol.split", "@@split");
-        inline JsSymbol* toPrimitive = new JsSymbol("Symbol.toPrimitive", "@@toPrimitive");
-        inline JsSymbol* toStringTag = new JsSymbol("Symbol.toStringTag", "@@toStringTag");
-        inline JsSymbol* unscopables = new JsSymbol("Symbol.unscopables", "@@unscopables");
+        inline JsSymbol *iterator = new JsSymbol("Symbol.iterator", "@@iterator");
+        inline JsSymbol *asyncIterator = new JsSymbol("Symbol.asyncIterator", "@@asyncIterator");
+        inline JsSymbol *hasInstance = new JsSymbol("Symbol.hasInstance", "@@hasInstance");
+        inline JsSymbol *isConcatSpreadable = new JsSymbol("Symbol.isConcatSpreadable", "@@isConcatSpreadable");
+        inline JsSymbol *match = new JsSymbol("Symbol.match", "@@match");
+        inline JsSymbol *matchAll = new JsSymbol("Symbol.matchAll", "@@matchAll");
+        inline JsSymbol *replace = new JsSymbol("Symbol.replace", "@@replace");
+        inline JsSymbol *search = new JsSymbol("Symbol.search", "@@search");
+        inline JsSymbol *species = new JsSymbol("Symbol.species", "@@species");
+        inline JsSymbol *split = new JsSymbol("Symbol.split", "@@split");
+        inline JsSymbol *toPrimitive = new JsSymbol("Symbol.toPrimitive", "@@toPrimitive");
+        inline JsSymbol *toStringTag = new JsSymbol("Symbol.toStringTag", "@@toStringTag");
+        inline JsSymbol *unscopables = new JsSymbol("Symbol.unscopables", "@@unscopables");
     }
 }

package/src/prelude/values/array.cpp

@@ -513,7 +513,7 @@ AnyValue &get_includes_fn()
                                                          AnyValue element = self->get_property(static_cast<uint32_t>(i));
                                                          // SameValueZero algorithm (includes handles NaN)
                                                          if (element.is_number() && searchElement.is_number() && std::isnan(element.as_double()) && std::isnan(searchElement.as_double())) return Constants::TRUE;
-                                                         if (is_strictly_equal_to_primitive(element, searchElement)) return Constants::TRUE;
+                                                         if (is_strictly_equal_to_native(element, searchElement)) return Constants::TRUE;
                                                      }
                                                      return Constants::FALSE; },
                                                  "includes");
@@ -538,7 +538,7 @@ AnyValue &get_indexOf_fn()
                                                      {
                                                          if (self->has_property(std::to_string(i))) {
                                                              AnyValue element = self->get_property(static_cast<uint32_t>(i));
-                                                             if (is_strictly_equal_to_primitive(element, searchElement)) return AnyValue::make_number(i);
+                                                             if (is_strictly_equal_to_native(element, searchElement)) return AnyValue::make_number(i);
                                                          }
                                                      }
                                                      return AnyValue::make_number(-1); },
@@ -565,7 +565,7 @@ AnyValue &get_lastIndexOf_fn()
                                                      {
                                                          if (self->has_property(std::to_string(i))) {
                                                              AnyValue element = self->get_property(static_cast<uint32_t>(i));
-                                                             if (is_strictly_equal_to_primitive(element, searchElement)) return AnyValue::make_number(i);
+                                                             if (is_strictly_equal_to_native(element, searchElement)) return AnyValue::make_number(i);
                                                          }
                                                      }
                                                      return AnyValue::make_number(-1); },

package/src/prelude/values/boolean.cpp

@@ -0,0 +1,64 @@
+#include "jspp.hpp"
+#include "values/prototypes/boolean.hpp"
+
+namespace jspp
+{
+
+    // --- JsBoolean Implementation ---
+
+    namespace JsBoolean
+    {
+        std::string to_std_string(bool value)
+        {
+            return value ? "true" : "false";
+        }
+
+        std::string to_std_string(const AnyValue &value)
+        {
+            return to_std_string(value.as_boolean());
+        }
+
+    }
+
+    // --- BooleanPrototypes Implementation ---
+
+    namespace BooleanPrototypes
+    {
+
+        AnyValue &get_toString_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         { return AnyValue::make_string(JsBoolean::to_std_string(thisVal.as_boolean())); },
+                                                         "toString");
+            return fn;
+        }
+
+        AnyValue &get_valueOf_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                         { return AnyValue::make_boolean(thisVal.as_boolean()); },
+                                                         "valueOf");
+            return fn;
+        }
+
+        std::optional<AnyValue> get(const std::string &key)
+        {
+            if (key == "toString")
+                return get_toString_fn();
+            if (key == "valueOf")
+                return get_valueOf_fn();
+            return std::nullopt;
+        }
+
+        std::optional<AnyValue> get(const AnyValue &key)
+        {
+            if (key == "toString")
+                return get_toString_fn();
+            if (key == "valueOf")
+                return get_valueOf_fn();
+            return std::nullopt;
+        }
+
+    } // namespace BooleanPrototypes
+
+} // namespace jspp