@ugo-studio/jspp 0.3.1 → 0.3.2

package/src/prelude/any_value.cpp

@@ -11,626 +11,878 @@
 #include "values/descriptors.hpp"
 #include "exception.hpp"
 
-namespace jspp {
-
-// --- AnyValue methods that were in any_value_helpers.hpp ---
-
-bool AnyValue::operator==(const AnyValue &other) const noexcept {
-    return storage == other.storage;
-}
-bool AnyValue::operator==(const std::string &other) const noexcept {
-    if (!is_string())
-        return false;
-    return as_string()->value == other;
-}
-bool AnyValue::operator<(const AnyValue &other) const noexcept {
-    return storage < other.storage;
-}
-
-JsString *AnyValue::as_string() const noexcept { return static_cast<JsString *>(get_ptr()); }
-JsObject *AnyValue::as_object() const noexcept { return static_cast<JsObject *>(get_ptr()); }
-JsArray *AnyValue::as_array() const noexcept { return static_cast<JsArray *>(get_ptr()); }
-JsFunction *AnyValue::as_function() const noexcept { return static_cast<JsFunction *>(get_ptr()); }
-JsSymbol *AnyValue::as_symbol() const noexcept { return static_cast<JsSymbol *>(get_ptr()); }
-JsPromise *AnyValue::as_promise() const noexcept { return static_cast<JsPromise *>(get_ptr()); }
-DataDescriptor *AnyValue::as_data_descriptor() const noexcept { return static_cast<DataDescriptor *>(get_ptr()); }
-AccessorDescriptor *AnyValue::as_accessor_descriptor() const noexcept { return static_cast<AccessorDescriptor *>(get_ptr()); }
-
-bool AnyValue::is_generator() const noexcept { return is_function() && as_function()->is_generator; }
-
-// --- AnyValue FACTORIES ---
-AnyValue AnyValue::make_string(const std::string &raw_s) noexcept
+namespace jspp
 {
-    return from_ptr(new JsString(raw_s));
-}
-AnyValue AnyValue::make_object(std::initializer_list<std::pair<std::string, AnyValue>> props) noexcept
-{
-    return from_ptr(new JsObject(props, make_null()));
-}
-AnyValue AnyValue::make_object(const std::map<std::string, AnyValue> &props) noexcept
-{
-    return from_ptr(new JsObject(props, make_null()));
-}
-AnyValue AnyValue::make_array(std::span<const AnyValue> dense) noexcept
-{
-    std::vector<AnyValue> vec;
-    vec.reserve(dense.size());
-    for (const auto &item : dense)
-        vec.push_back(item);
-    return from_ptr(new JsArray(std::move(vec)));
-}
-AnyValue AnyValue::make_array(const std::vector<AnyValue> &dense) noexcept
-{
-    return from_ptr(new JsArray(dense));
-}
-AnyValue AnyValue::make_array(std::vector<AnyValue> &&dense) noexcept
-{
-    return from_ptr(new JsArray(std::move(dense)));
-}
-AnyValue AnyValue::make_function(const JsFunctionCallable &call, const std::optional<std::string> &name, bool is_constructor) noexcept
-{
-    auto v = from_ptr(new JsFunction(call, name, {}, {}, false, is_constructor));
-    auto proto = make_object({});
-    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-    return v;
-}
-AnyValue AnyValue::make_class(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
-{
-    auto v = from_ptr(new JsFunction(call, name, {}, {}, true));
-    auto proto = make_object({});
-    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-    return v;
-}
-AnyValue AnyValue::make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
-{
-    auto v = from_ptr(new JsFunction(call, true, name, {}, {}, false));
-    auto proto = make_object({});
-    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-    return v;
-}
-AnyValue AnyValue::make_async_function(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
-{
-    auto v = from_ptr(new JsFunction(call, false, true, name, {}, {}, false));
-    auto proto = make_object({});
-    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-    return v;
-}
-AnyValue AnyValue::make_async_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
-{
-    auto v = from_ptr(new JsFunction(call, true, true, name, {}, {}, false));
-    auto proto = make_object({});
-    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
-    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
-    return v;
-}
-AnyValue AnyValue::make_symbol(const std::string &description) noexcept
-{
-    return from_ptr(new JsSymbol(description));
-}
-AnyValue AnyValue::make_promise(const JsPromise &promise) noexcept
-{
-    auto p = new JsPromise();
-    *p = promise;
-    return from_ptr(p);
-}
-AnyValue AnyValue::make_data_descriptor(AnyValue value, bool writable, bool enumerable, bool configurable) noexcept
-{
-    return from_ptr(new DataDescriptor(value, writable, enumerable, configurable));
-}
-AnyValue AnyValue::make_accessor_descriptor(const std::optional<std::function<AnyValue(AnyValue, std::span<const AnyValue>)>> &get,
-                                                   const std::optional<std::function<AnyValue(AnyValue, std::span<const AnyValue>)>> &set,
-                                                   bool enumerable,
-                                                   bool configurable) noexcept
-{
-    return from_ptr(new AccessorDescriptor(get, set, enumerable, configurable));
-}
-
-AnyValue AnyValue::from_symbol(JsSymbol *sym) noexcept {
-    return from_ptr(sym);
-}
-AnyValue AnyValue::from_string(JsString *str) noexcept {
-    return from_ptr(str);
-}
-AnyValue AnyValue::from_promise(JsPromise &&promise) noexcept {
-    auto it = new JsPromise(std::move(promise));
-    return from_ptr(it);
-}
-AnyValue AnyValue::from_iterator(JsIterator<AnyValue> &&iterator) noexcept {
-    auto it = new JsIterator<AnyValue>(std::move(iterator));
-    return from_ptr(it);
-}
-AnyValue AnyValue::from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept {
-    return from_ptr(iterator);
-}
-AnyValue AnyValue::from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept {
-    auto it = new JsAsyncIterator<AnyValue>(std::move(iterator));
-    return from_ptr(it);
-}
-
-AnyValue AnyValue::resolve_property_for_read(const AnyValue &val, AnyValue thisVal, const std::string &propName) noexcept {
-    if (val.is_data_descriptor()) {
-        return val.as_data_descriptor()->value;
-    }
-    if (val.is_accessor_descriptor()) {
-        auto accessor = val.as_accessor_descriptor();
-        if (accessor->get.has_value())
-            return accessor->get.value()(thisVal, std::span<const AnyValue>{});
-        else {
-            return Constants::UNDEFINED;
+
+    // --- AnyValue methods that were in any_value_helpers.hpp ---
+
+    bool AnyValue::operator==(const AnyValue &other) const noexcept
+    {
+        return storage == other.storage;
+    }
+    bool AnyValue::operator==(const std::string &other) const noexcept
+    {
+        if (!is_string())
+            return false;
+        return as_string()->value == other;
+    }
+    bool AnyValue::operator<(const AnyValue &other) const noexcept
+    {
+        return storage < other.storage;
+    }
+
+    JsString *AnyValue::as_string() const noexcept { return static_cast<JsString *>(get_ptr()); }
+    JsObject *AnyValue::as_object() const noexcept { return static_cast<JsObject *>(get_ptr()); }
+    JsArray *AnyValue::as_array() const noexcept { return static_cast<JsArray *>(get_ptr()); }
+    JsFunction *AnyValue::as_function() const noexcept { return static_cast<JsFunction *>(get_ptr()); }
+    JsSymbol *AnyValue::as_symbol() const noexcept { return static_cast<JsSymbol *>(get_ptr()); }
+    JsPromise *AnyValue::as_promise() const noexcept { return static_cast<JsPromise *>(get_ptr()); }
+    DataDescriptor *AnyValue::as_data_descriptor() const noexcept { return static_cast<DataDescriptor *>(get_ptr()); }
+    AccessorDescriptor *AnyValue::as_accessor_descriptor() const noexcept { return static_cast<AccessorDescriptor *>(get_ptr()); }
+
+    bool AnyValue::is_generator() const noexcept { return is_function() && as_function()->is_generator; }
+
+    // --- AnyValue FACTORIES ---
+    AnyValue AnyValue::make_string(const std::string &raw_s) noexcept
+    {
+        return from_ptr(new JsString(raw_s));
+    }
+    AnyValue AnyValue::make_object(std::initializer_list<std::pair<std::string, AnyValue>> props) noexcept
+    {
+        return from_ptr(new JsObject(props, make_null()));
+    }
+    AnyValue AnyValue::make_object(const std::map<std::string, AnyValue> &props) noexcept
+    {
+        return from_ptr(new JsObject(props, make_null()));
+    }
+    AnyValue AnyValue::make_array(std::span<const AnyValue> dense) noexcept
+    {
+        std::vector<AnyValue> vec;
+        vec.reserve(dense.size());
+        for (const auto &item : dense)
+            vec.push_back(item);
+        return from_ptr(new JsArray(std::move(vec)));
+    }
+    AnyValue AnyValue::make_array(const std::vector<AnyValue> &dense) noexcept
+    {
+        return from_ptr(new JsArray(dense));
+    }
+    AnyValue AnyValue::make_array(std::vector<AnyValue> &&dense) noexcept
+    {
+        return from_ptr(new JsArray(std::move(dense)));
+    }
+    AnyValue AnyValue::make_function(const JsFunctionCallable &call, const std::optional<std::string> &name, bool is_constructor) noexcept
+    {
+        auto v = from_ptr(new JsFunction(call, name, {}, {}, false, is_constructor));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    AnyValue AnyValue::make_class(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+    {
+        auto v = from_ptr(new JsFunction(call, name, {}, {}, true));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    AnyValue AnyValue::make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+    {
+        auto v = from_ptr(new JsFunction(call, true, name, {}, {}, false));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    AnyValue AnyValue::make_async_function(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+    {
+        auto v = from_ptr(new JsFunction(call, false, true, name, {}, {}, false));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    AnyValue AnyValue::make_async_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+    {
+        auto v = from_ptr(new JsFunction(call, true, true, name, {}, {}, false));
+        auto proto = make_object({});
+        proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+        v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+        return v;
+    }
+    AnyValue AnyValue::make_symbol(const std::string &description) noexcept
+    {
+        return from_ptr(new JsSymbol(description));
+    }
+    AnyValue AnyValue::make_promise(const JsPromise &promise) noexcept
+    {
+        auto p = new JsPromise();
+        *p = promise;
+        return from_ptr(p);
+    }
+    AnyValue AnyValue::make_data_descriptor(AnyValue value, bool writable, bool enumerable, bool configurable) noexcept
+    {
+        return from_ptr(new DataDescriptor(value, writable, enumerable, configurable));
+    }
+    AnyValue AnyValue::make_accessor_descriptor(const std::optional<std::function<AnyValue(AnyValue, std::span<const AnyValue>)>> &get,
+                                                const std::optional<std::function<AnyValue(AnyValue, std::span<const AnyValue>)>> &set,
+                                                bool enumerable,
+                                                bool configurable) noexcept
+    {
+        return from_ptr(new AccessorDescriptor(get, set, enumerable, configurable));
+    }
+
+    AnyValue AnyValue::from_symbol(JsSymbol *sym) noexcept
+    {
+        return from_ptr(sym);
+    }
+    AnyValue AnyValue::from_string(JsString *str) noexcept
+    {
+        return from_ptr(str);
+    }
+    AnyValue AnyValue::from_promise(JsPromise &&promise) noexcept
+    {
+        auto it = new JsPromise(std::move(promise));
+        return from_ptr(it);
+    }
+    AnyValue AnyValue::from_iterator(JsIterator<AnyValue> &&iterator) noexcept
+    {
+        auto it = new JsIterator<AnyValue>(std::move(iterator));
+        return from_ptr(it);
+    }
+    AnyValue AnyValue::from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept
+    {
+        return from_ptr(iterator);
+    }
+    AnyValue AnyValue::from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept
+    {
+        auto it = new JsAsyncIterator<AnyValue>(std::move(iterator));
+        return from_ptr(it);
+    }
+
+    AnyValue AnyValue::resolve_property_for_read(const AnyValue &val, AnyValue thisVal, const std::string &propName) noexcept
+    {
+        if (val.is_data_descriptor())
+        {
+            return val.as_data_descriptor()->value;
+        }
+        if (val.is_accessor_descriptor())
+        {
+            auto accessor = val.as_accessor_descriptor();
+            if (accessor->get.has_value())
+                return accessor->get.value()(thisVal, std::span<const AnyValue>{});
+            else
+            {
+                return Constants::UNDEFINED;
+            }
         }
+        return val;
     }
-    return val;
-}
-
-AnyValue AnyValue::resolve_property_for_write(AnyValue &val, AnyValue thisVal, const AnyValue &new_val, const std::string &propName) {
-    if (val.is_data_descriptor()) {
-        auto data = val.as_data_descriptor();
-        if (data->writable) {
-            data->value = new_val;
-            return new_val;
-        } else {
-            throw Exception::make_exception("Cannot assign to read only property '" + propName + "' of object '#<Object>'", "TypeError");
-        }
-    }
-    if (val.is_accessor_descriptor()) {
-        auto accessor = val.as_accessor_descriptor();
-        if (accessor->set.has_value()) {
-            const AnyValue args[] = {new_val};
-            accessor->set.value()(thisVal, std::span<const AnyValue>(args, 1));
-            return new_val;
-        } else {
-            throw Exception::make_exception("Cannot set property of #<Object> which has only a getter", "TypeError");
-        }
-    }
-    val = new_val;
-    return new_val;
-}
-
-std::string AnyValue::to_std_string() const {
-    switch (get_type()) {
-    case JsType::Undefined: return "undefined";
-    case JsType::Null: return "null";
-    case JsType::Boolean: return as_boolean() ? "true" : "false";
-    case JsType::String: return as_string()->to_std_string();
-    case JsType::Object: return as_object()->to_std_string();
-    case JsType::Array: return as_array()->to_std_string();
-    case JsType::Function: return as_function()->to_std_string();
-    case JsType::Iterator: return as_iterator()->to_std_string();
-    case JsType::AsyncIterator: return as_async_iterator()->to_std_string();
-    case JsType::Promise: return as_promise()->to_std_string();
-    case JsType::Symbol: return as_symbol()->to_std_string();
-    case JsType::DataDescriptor: return as_data_descriptor()->value.to_std_string();
-    case JsType::AccessorDescriptor: {
-        if (as_accessor_descriptor()->get.has_value())
-            return as_accessor_descriptor()->get.value()(*this, {}).to_std_string();
-        else
+
+    AnyValue AnyValue::resolve_property_for_write(AnyValue &val, AnyValue thisVal, const AnyValue &new_val, const std::string &propName)
+    {
+        if (val.is_data_descriptor())
+        {
+            auto data = val.as_data_descriptor();
+            if (data->writable)
+            {
+                data->value = new_val;
+                return new_val;
+            }
+            else
+            {
+                throw Exception::make_exception("Cannot assign to read only property '" + propName + "'", "TypeError");
+            }
+        }
+        if (val.is_accessor_descriptor())
+        {
+            auto accessor = val.as_accessor_descriptor();
+            if (accessor->set.has_value())
+            {
+                const AnyValue args[] = {new_val};
+                accessor->set.value()(thisVal, std::span<const AnyValue>(args, 1));
+                return new_val;
+            }
+            else
+            {
+                throw Exception::make_exception("Cannot set property of #<Object> which has only a getter", "TypeError");
+            }
+        }
+        val = new_val;
+        return new_val;
+    }
+
+    std::string AnyValue::to_std_string() const
+    {
+        switch (get_type())
+        {
+        case JsType::Undefined:
             return "undefined";
+        case JsType::Null:
+            return "null";
+        case JsType::Boolean:
+            return JsBoolean::to_std_string(as_boolean());
+        case JsType::String:
+            return as_string()->to_std_string();
+        case JsType::Object:
+            return as_object()->to_std_string();
+        case JsType::Array:
+            return as_array()->to_std_string();
+        case JsType::Function:
+            return as_function()->to_std_string();
+        case JsType::Iterator:
+            return as_iterator()->to_std_string();
+        case JsType::AsyncIterator:
+            return as_async_iterator()->to_std_string();
+        case JsType::Promise:
+            return as_promise()->to_std_string();
+        case JsType::Symbol:
+            return as_symbol()->to_std_string();
+        case JsType::DataDescriptor:
+            return as_data_descriptor()->value.to_std_string();
+        case JsType::AccessorDescriptor:
+        {
+            if (as_accessor_descriptor()->get.has_value())
+                return as_accessor_descriptor()->get.value()(*this, {}).to_std_string();
+            else
+                return "undefined";
+        }
+        case JsType::Number:
+            return JsNumber::to_std_string(as_double());
+        case JsType::Uninitialized:
+            Exception::throw_uninitialized_reference("#<Object>");
+        default:
+            return "";
+        }
     }
-    case JsType::Number: {
-        double num = as_double();
-        if (std::isnan(num)) return "NaN";
-        if (std::abs(num) >= 1e21 || (std::abs(num) > 0 && std::abs(num) < 1e-6)) {
-            std::ostringstream oss;
-            oss << std::scientific << std::setprecision(4) << num;
-            return oss.str();
-        } else {
-            std::ostringstream oss;
-            oss << std::setprecision(6) << std::fixed << num;
-            std::string s = oss.str();
-            s.erase(s.find_last_not_of('0') + 1, std::string::npos);
-            if (!s.empty() && s.back() == '.') s.pop_back();
-            return s;
-        }
-    }
-    case JsType::Uninitialized: Exception::throw_uninitialized_reference("#<Object>");
-    default: return "";
-    }
-}
-
-std::string AnyValue::to_property_key() const {
-    if (is_symbol()) return as_symbol()->key;
-    return to_std_string();
-}
-
-AnyValue &AnyValue::set_prototype(AnyValue proto) {
-    if (is_object()) as_object()->proto = proto;
-    else if (is_array()) as_array()->proto = proto;
-    else if (is_function()) as_function()->proto = proto;
-    else if (is_uninitialized()) Exception::throw_uninitialized_reference("#<Object>");
-    return *this;
-}
-
-AnyValue AnyValue::call(AnyValue thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr) const {
-    if (!is_function())
-        throw Exception::make_exception(expr.value_or(to_std_string()) + " is not a function", "TypeError");
-    return as_function()->call(thisVal, args);
-}
-AnyValue AnyValue::optional_call(AnyValue thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr) const {
-    if (is_null() || is_undefined()) return Constants::UNDEFINED;
-    return as_function()->call(thisVal, args);
-}
-
-AnyValue AnyValue::construct(std::span<const AnyValue> args, const std::optional<std::string> &name) const {
-    if (!is_function() || !as_function()->is_constructor) {
-        throw Exception::make_exception(name.value_or(to_std_string()) + " is not a constructor", "TypeError");
-    }
-    AnyValue proto = get_own_property("prototype");
-    if (!proto.is_object()) proto = AnyValue::make_object({});
-    AnyValue instance = AnyValue::make_object({}).set_prototype(proto);
-    AnyValue result = call(instance, args);
-    if (result.is_object() || result.is_function() || result.is_array() || result.is_promise()) return result;
-    return instance;
-}
-
-// --- AnyValue methods that were in any_value_access.hpp ---
-
-AnyValue AnyValue::get_own_property(const std::string &key) const {
-    return get_property_with_receiver(key, *this);
-}
-
-AnyValue AnyValue::get_own_property_descriptor(const AnyValue &key) const {
-    if (key.is_symbol()) {
-        switch (get_type()) {
-        case JsType::Object: {
+
+    AnyValue &AnyValue::set_prototype(AnyValue proto)
+    {
+        if (is_object())
+            as_object()->proto = proto;
+        else if (is_array())
+            as_array()->proto = proto;
+        else if (is_function())
+            as_function()->proto = proto;
+        else if (is_uninitialized())
+            Exception::throw_uninitialized_reference("#<Object>");
+        return *this;
+    }
+
+    AnyValue AnyValue::call(AnyValue thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr) const
+    {
+        if (!is_function())
+            throw Exception::make_exception(expr.value_or(to_std_string()) + " is not a function", "TypeError");
+        return as_function()->call(thisVal, args);
+    }
+    AnyValue AnyValue::optional_call(AnyValue thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr) const
+    {
+        if (is_null() || is_undefined())
+            return Constants::UNDEFINED;
+        return as_function()->call(thisVal, args);
+    }
+
+    AnyValue AnyValue::construct(std::span<const AnyValue> args, const std::optional<std::string> &name) const
+    {
+        if (!is_function() || !as_function()->is_constructor)
+        {
+            throw Exception::make_exception(name.value_or(to_std_string()) + " is not a constructor", "TypeError");
+        }
+        AnyValue proto = get_own_property("prototype");
+        if (!proto.is_object())
+            proto = AnyValue::make_object({});
+        AnyValue instance = AnyValue::make_object({}).set_prototype(proto);
+        AnyValue result = call(instance, args);
+        if (result.is_object() || result.is_function() || result.is_array() || result.is_promise())
+            return result;
+        return instance;
+    }
+
+    // --- AnyValue methods that were in any_value_access.hpp ---
+
+    AnyValue AnyValue::get_own_property(const std::string &key) const
+    {
+        return get_property_with_receiver(key, *this);
+    }
+
+    AnyValue AnyValue::get_own_property_descriptor(const AnyValue &key) const
+    {
+        if (key.is_symbol())
+        {
+            switch (get_type())
+            {
+            case JsType::Object:
+            {
+                auto obj = as_object();
+                auto it = obj->symbol_props.find(key);
+                if (it != obj->symbol_props.end())
+                    return it->second;
+                return Constants::UNDEFINED;
+            }
+            case JsType::Array:
+            {
+                auto arr = as_array();
+                auto it = arr->symbol_props.find(key);
+                if (it != arr->symbol_props.end())
+                    return it->second;
+                return Constants::UNDEFINED;
+            }
+            case JsType::Function:
+            {
+                auto func = as_function();
+                auto it = func->symbol_props.find(key);
+                if (it != func->symbol_props.end())
+                    return it->second;
+                return Constants::UNDEFINED;
+            }
+            default:
+                return Constants::UNDEFINED;
+            }
+        }
+
+        std::string key_str = key.to_std_string();
+        switch (get_type())
+        {
+        case JsType::Object:
+        {
             auto obj = as_object();
-            auto it = obj->symbol_props.find(key);
-            if (it != obj->symbol_props.end()) return it->second;
+            if (obj->deleted_keys.count(key_str))
+                return Constants::UNDEFINED;
+            auto offset = obj->shape->get_offset(key_str);
+            if (offset.has_value())
+                return obj->storage[offset.value()];
             return Constants::UNDEFINED;
         }
-        case JsType::Array: {
+        case JsType::Array:
+        {
             auto arr = as_array();
-            auto it = arr->symbol_props.find(key);
-            if (it != arr->symbol_props.end()) return it->second;
+            if (key_str == "length")
+                return AnyValue::make_number(arr->length);
+            if (JsArray::is_array_index(key_str))
+            {
+                uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
+                if (idx < arr->dense.size() && !arr->dense[idx].is_uninitialized())
+                    return arr->dense[idx];
+                if (arr->sparse.count(idx))
+                    return arr->sparse[idx];
+            }
+            if (arr->props.count(key_str))
+                return arr->props.at(key_str);
             return Constants::UNDEFINED;
         }
-        case JsType::Function: {
+        case JsType::Function:
+        {
             auto func = as_function();
-            auto it = func->symbol_props.find(key);
-            if (it != func->symbol_props.end()) return it->second;
+            if (func->props.count(key_str))
+                return func->props.at(key_str);
+            return Constants::UNDEFINED;
+        }
+        case JsType::String:
+        {
+            auto str = as_string();
+            if (key_str == "length")
+                return AnyValue::make_number(str->value.length());
+            if (JsArray::is_array_index(key_str))
+            {
+                uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
+                if (idx < str->value.length())
+                    return AnyValue::make_string(std::string(1, str->value[idx]));
+            }
+            return Constants::UNDEFINED;
+        }
+        default:
+            return Constants::UNDEFINED;
+        }
+    }
+
+    bool AnyValue::has_property(const std::string &key) const
+    {
+        switch (get_type())
+        {
+        case JsType::Object:
+            return as_object()->has_property(key);
+        case JsType::Array:
+            return as_array()->has_property(key);
+        case JsType::Function:
+            return as_function()->has_property(key);
+        case JsType::Promise:
+            return as_promise()->get_property(key, *this).is_undefined() == false;
+        case JsType::Iterator:
+            return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_property(key, *this).is_undefined() == false;
+        case JsType::AsyncIterator:
+            return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_property(key, *this).is_undefined() == false;
+        case JsType::Symbol:
+            return SymbolPrototypes::get(key).has_value();
+        case JsType::String:
+            if (key == "length")
+                return true;
+            if (JsArray::is_array_index(key))
+            {
+                uint32_t idx = static_cast<uint32_t>(std::stoull(key));
+                return idx < as_string()->value.length();
+            }
+            return StringPrototypes::get(key).has_value();
+        case JsType::Number:
+            return NumberPrototypes::get(key).has_value();
+        case JsType::Uninitialized:
+            Exception::throw_uninitialized_reference("#<Object>");
+            return false;
+        default:
+            return false;
+        }
+    }
+
+    bool AnyValue::has_property(const AnyValue &key) const
+    {
+        if (key.is_symbol())
+        {
+            switch (get_type())
+            {
+            case JsType::Object:
+                return as_object()->has_symbol_property(key);
+            case JsType::Array:
+                return as_array()->has_symbol_property(key);
+            case JsType::Function:
+                return as_function()->has_symbol_property(key);
+            case JsType::Promise:
+                return as_promise()->has_symbol_property(key);
+            case JsType::Iterator:
+                return static_cast<JsIterator<AnyValue> *>(get_ptr())->has_symbol_property(key);
+            case JsType::AsyncIterator:
+                return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->has_symbol_property(key);
+            default:
+                return false;
+            }
+        }
+        return has_property(key.to_std_string());
+    }
+
+    AnyValue AnyValue::get_own_property(uint32_t idx) const
+    {
+        if (is_array())
+            return as_array()->get_property(idx);
+        if (is_string())
+            return as_string()->get_property(idx);
+        return get_own_property(std::to_string(idx));
+    }
+
+    AnyValue AnyValue::get_own_property(const AnyValue &key) const
+    {
+        if (key.is_number() && is_array())
+            return as_array()->get_property(key.as_double());
+        if (key.is_number() && is_string())
+            return as_string()->get_property(key.as_double());
+        if (key.is_symbol())
+            return get_own_symbol_property(key);
+        return get_own_property(key.to_std_string());
+    }
+
+    AnyValue AnyValue::get_own_symbol_property(const AnyValue &key) const
+    {
+        return get_symbol_property_with_receiver(key, *this);
+    }
+
+    AnyValue AnyValue::get_property_with_receiver(const std::string &key, AnyValue receiver) const
+    {
+        switch (get_type())
+        {
+        case JsType::Object:
+            return as_object()->get_property(key, receiver);
+        case JsType::Array:
+            return as_array()->get_property(key, receiver);
+        case JsType::Function:
+            return as_function()->get_property(key, receiver);
+        case JsType::Promise:
+            return as_promise()->get_property(key, receiver);
+        case JsType::Iterator:
+            return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_property(key, receiver);
+        case JsType::AsyncIterator:
+            return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_property(key, receiver);
+        case JsType::Symbol:
+            return as_symbol()->get_property(key, receiver);
+        case JsType::String:
+            return as_string()->get_property(key, receiver);
+        case JsType::Number:
+        {
+            auto proto_it = NumberPrototypes::get(key);
+            if (proto_it.has_value())
+                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);
+            return Constants::UNDEFINED;
+        }
+        case JsType::Boolean:
+        {
+            auto proto_it = BooleanPrototypes::get(key);
+            if (proto_it.has_value())
+                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);
+            return Constants::UNDEFINED;
+        }
+        case JsType::Undefined:
+            throw Exception::make_exception("Cannot read properties of undefined (reading '" + key + "')", "TypeError");
+        case JsType::Null:
+            throw Exception::make_exception("Cannot read properties of null (reading '" + key + "')", "TypeError");
+        case JsType::Uninitialized:
+            Exception::throw_uninitialized_reference("#<Object>");
+        default:
+            return Constants::UNDEFINED;
+        }
+    }
+
+    AnyValue AnyValue::get_symbol_property_with_receiver(const AnyValue &key, AnyValue receiver) const
+    {
+        switch (get_type())
+        {
+        case JsType::Object:
+            return as_object()->get_symbol_property(key, receiver);
+        case JsType::Array:
+            return as_array()->get_symbol_property(key, receiver);
+        case JsType::Function:
+            return as_function()->get_symbol_property(key, receiver);
+        case JsType::Promise:
+            return as_promise()->get_symbol_property(key, receiver);
+        case JsType::Iterator:
+            return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_symbol_property(key, receiver);
+        case JsType::AsyncIterator:
+            return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_symbol_property(key, receiver);
+        case JsType::Symbol:
+        {
+            auto proto_it = SymbolPrototypes::get(key);
+            if (proto_it.has_value())
+                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
+            return Constants::UNDEFINED;
+        }
+        case JsType::String:
+        {
+            auto proto_it = StringPrototypes::get(key);
+            if (proto_it.has_value())
+                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
+            return Constants::UNDEFINED;
+        }
+        case JsType::Number:
+        {
+            auto proto_it = NumberPrototypes::get(key);
+            if (proto_it.has_value())
+                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
+            return Constants::UNDEFINED;
+        }
+        case JsType::Boolean:
+        {
+            auto proto_it = BooleanPrototypes::get(key);
+            if (proto_it.has_value())
+                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
+            return Constants::UNDEFINED;
+        }
+        case JsType::Undefined:
+            throw Exception::make_exception("Cannot read properties of undefined (reading Symbol)", "TypeError");
+        case JsType::Null:
+            throw Exception::make_exception("Cannot read properties of null (reading Symbol)", "TypeError");
+        case JsType::Uninitialized:
+            Exception::throw_uninitialized_reference("#<Object>");
+        default:
             return Constants::UNDEFINED;
         }
-        default: return Constants::UNDEFINED;
-        }
-    }
-
-    std::string key_str = key.to_std_string();
-    switch (get_type()) {
-    case JsType::Object: {
-        auto obj = as_object();
-        if (obj->deleted_keys.count(key_str)) return Constants::UNDEFINED;
-        auto offset = obj->shape->get_offset(key_str);
-        if (offset.has_value()) return obj->storage[offset.value()];
-        return Constants::UNDEFINED;
-    }
-    case JsType::Array: {
-        auto arr = as_array();
-        if (key_str == "length") return AnyValue::make_number(arr->length);
-        if (JsArray::is_array_index(key_str)) {
-            uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
-            if (idx < arr->dense.size() && !arr->dense[idx].is_uninitialized()) return arr->dense[idx];
-            if (arr->sparse.count(idx)) return arr->sparse[idx];
-        }
-        if (arr->props.count(key_str)) return arr->props.at(key_str);
-        return Constants::UNDEFINED;
-    }
-    case JsType::Function: {
-        auto func = as_function();
-        if (func->props.count(key_str)) return func->props.at(key_str);
-        return Constants::UNDEFINED;
-    }
-    case JsType::String: {
-        auto str = as_string();
-        if (key_str == "length") return AnyValue::make_number(str->value.length());
-        if (JsArray::is_array_index(key_str)) {
-            uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
-            if (idx < str->value.length()) return AnyValue::make_string(std::string(1, str->value[idx]));
-        }
-        return Constants::UNDEFINED;
-    }
-    default: return Constants::UNDEFINED;
-    }
-}
-
-bool AnyValue::has_property(const std::string &key) const {
-    switch (get_type()) {
-    case JsType::Object: return as_object()->has_property(key);
-    case JsType::Array: return as_array()->has_property(key);
-    case JsType::Function: return as_function()->has_property(key);
-    case JsType::Promise: return as_promise()->get_property(key, *this).is_undefined() == false;
-    case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_property(key, *this).is_undefined() == false;
-    case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_property(key, *this).is_undefined() == false;
-    case JsType::Symbol: return SymbolPrototypes::get(key).has_value();
-    case JsType::String:
-        if (key == "length") return true;
-        if (JsArray::is_array_index(key)) {
-            uint32_t idx = static_cast<uint32_t>(std::stoull(key));
-            return idx < as_string()->value.length();
-        }
-        return StringPrototypes::get(key).has_value();
-    case JsType::Number: return NumberPrototypes::get(key).has_value();
-    case JsType::Uninitialized: Exception::throw_uninitialized_reference("#<Object>"); return false;
-    default: return false;
-    }
-}
-
-bool AnyValue::has_property(const AnyValue &key) const {
-    if (key.is_symbol()) {
-        switch (get_type()) {
-        case JsType::Object: return as_object()->has_symbol_property(key);
-        case JsType::Array: return as_array()->has_symbol_property(key);
-        case JsType::Function: return as_function()->has_symbol_property(key);
-        case JsType::Promise: return as_promise()->has_symbol_property(key);
-        case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->has_symbol_property(key);
-        case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->has_symbol_property(key);
-        default: return false;
-        }
-    }
-    return has_property(key.to_std_string());
-}
-
-AnyValue AnyValue::get_own_property(uint32_t idx) const {
-    if (is_array()) return as_array()->get_property(idx);
-    if (is_string()) return as_string()->get_property(idx);
-    return get_own_property(std::to_string(idx));
-}
-
-AnyValue AnyValue::get_own_property(const AnyValue &key) const {
-    if (key.is_number() && is_array()) return as_array()->get_property(key.as_double());
-    if (key.is_number() && is_string()) return as_string()->get_property(key.as_double());
-    if (key.is_symbol()) return get_own_symbol_property(key);
-    return get_own_property(key.to_std_string());
-}
-
-AnyValue AnyValue::get_own_symbol_property(const AnyValue &key) const {
-    return get_symbol_property_with_receiver(key, *this);
-}
-
-AnyValue AnyValue::get_property_with_receiver(const std::string &key, AnyValue receiver) const {
-    switch (get_type()) {
-    case JsType::Object: return as_object()->get_property(key, receiver);
-    case JsType::Array: return as_array()->get_property(key, receiver);
-    case JsType::Function: return as_function()->get_property(key, receiver);
-    case JsType::Promise: return as_promise()->get_property(key, receiver);
-    case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_property(key, receiver);
-    case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_property(key, receiver);
-    case JsType::Symbol: return as_symbol()->get_property(key, receiver);
-    case JsType::String: return as_string()->get_property(key, receiver);
-    case JsType::Number: {
-        auto proto_it = NumberPrototypes::get(key);
-        if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);
-        return Constants::UNDEFINED;
-    }
-    case JsType::Undefined: throw Exception::make_exception("Cannot read properties of undefined (reading '" + key + "')", "TypeError");
-    case JsType::Null: throw Exception::make_exception("Cannot read properties of null (reading '" + key + "')", "TypeError");
-    case JsType::Uninitialized: Exception::throw_uninitialized_reference("#<Object>");
-    default: return Constants::UNDEFINED;
-    }
-}
-
-AnyValue AnyValue::get_symbol_property_with_receiver(const AnyValue &key, AnyValue receiver) const {
-    switch (get_type()) {
-    case JsType::Object: return as_object()->get_symbol_property(key, receiver);
-    case JsType::Array: return as_array()->get_symbol_property(key, receiver);
-    case JsType::Function: return as_function()->get_symbol_property(key, receiver);
-    case JsType::Promise: return as_promise()->get_symbol_property(key, receiver);
-    case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_symbol_property(key, receiver);
-    case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_symbol_property(key, receiver);
-    case JsType::Symbol: {
-        auto proto_it = SymbolPrototypes::get(key);
-        if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
-        return Constants::UNDEFINED;
-    }
-    case JsType::String: {
-        auto proto_it = StringPrototypes::get(key);
-        if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
-        return Constants::UNDEFINED;
-    }
-    case JsType::Number: {
-        auto proto_it = NumberPrototypes::get(key);
-        if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
-        return Constants::UNDEFINED;
-    }
-    case JsType::Undefined: throw Exception::make_exception("Cannot read properties of undefined (reading Symbol)", "TypeError");
-    case JsType::Null: throw Exception::make_exception("Cannot read properties of null (reading Symbol)", "TypeError");
-    case JsType::Uninitialized: Exception::throw_uninitialized_reference("#<Object>");
-    default: return Constants::UNDEFINED;
-    }
-}
-
-AnyValue AnyValue::set_own_property(const std::string &key, AnyValue value) const {
-    switch (get_type()) {
-    case JsType::Object: return as_object()->set_property(key, value, *this);
-    case JsType::Array: return as_array()->set_property(key, value, *this);
-    case JsType::Function: return as_function()->set_property(key, value, *this);
-    case JsType::Promise: return as_promise()->set_property(key, value, *this);
-    case JsType::Undefined: throw Exception::make_exception("Cannot set properties of undefined (setting '" + key + "')", "TypeError");
-    case JsType::Null: throw Exception::make_exception("Cannot set properties of null (setting '" + key + "')", "TypeError");
-    default: return value;
-    }
-}
-
-AnyValue AnyValue::set_own_property(uint32_t idx, AnyValue value) const {
-    if (is_array()) return as_array()->set_property(idx, value);
-    return set_own_property(std::to_string(idx), value);
-}
-
-AnyValue AnyValue::set_own_property(const AnyValue &key, AnyValue value) const {
-    if (key.is_number() && is_array()) return as_array()->set_property(key.as_double(), value);
-    if (key.is_symbol()) return set_own_symbol_property(key, value);
-    return set_own_property(key.to_std_string(), value);
-}
-
-AnyValue AnyValue::set_own_symbol_property(const AnyValue &key, AnyValue value) const {
-    switch (get_type()) {
-    case JsType::Object: return as_object()->set_symbol_property(key, value, *this);
-    case JsType::Array: return as_array()->set_symbol_property(key, value, *this);
-    case JsType::Function: return as_function()->set_symbol_property(key, value, *this);
-    case JsType::Promise: return as_promise()->set_symbol_property(key, value, *this);
-    case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->set_symbol_property(key, value, *this);
-    case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->set_symbol_property(key, value, *this);
-    case JsType::Undefined: throw Exception::make_exception("Cannot set properties of undefined (setting Symbol)", "TypeError");
-    case JsType::Null: throw Exception::make_exception("Cannot set properties of null (setting Symbol)", "TypeError");
-    default: return value;
-    }
-}
-
-AnyValue AnyValue::call_own_property(const std::string &key, std::span<const AnyValue> args) const {
-    return get_own_property(key).call((*this), args, key);
-}
-AnyValue AnyValue::call_own_property(uint32_t idx, std::span<const AnyValue> args) const {
-    if (is_array()) return as_array()->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
-    if (is_string()) return as_string()->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
-    return call_own_property(std::to_string(idx), args);
-}
-AnyValue AnyValue::call_own_property(const AnyValue &key, std::span<const AnyValue> args) const {
-    if (key.is_number() && is_array()) return as_array()->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
-    if (key.is_number() && is_string()) return as_string()->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
-    if (key.is_symbol()) return get_own_symbol_property(key).call((*this), args, key.to_std_string());
-    return call_own_property(key.to_std_string(), args);
-}
-
-// --- AnyValue methods that were in any_value_defines.hpp ---
-
-void AnyValue::define_data_property(const std::string &key, AnyValue value) {
-    if (is_object()) {
-        auto obj = as_object();
-        auto offset = obj->shape->get_offset(key);
-        if (offset.has_value()) obj->storage[offset.value()] = value;
-        else {
-            obj->shape = obj->shape->transition(key);
-            obj->storage.push_back(value);
-        }
-    } else if (is_function()) as_function()->props[key] = value;
-}
-
-void AnyValue::define_data_property(const AnyValue &key, AnyValue value) {
-    if (key.is_symbol()) {
-        if (is_object()) as_object()->symbol_props[key] = value;
-        else if (is_function()) as_function()->symbol_props[key] = value;
-    } else define_data_property(key.to_std_string(), value);
-}
-
-void AnyValue::define_data_property(const std::string &key, AnyValue value, bool writable, bool enumerable, bool configurable) {
-    define_data_property(key, AnyValue::make_data_descriptor(value, writable, enumerable, configurable));
-}
-
-void AnyValue::define_getter(const std::string &key, AnyValue getter) {
-    if (is_object()) {
-        auto obj = as_object();
-        auto offset = obj->shape->get_offset(key);
-        if (offset.has_value()) {
-            auto &val = obj->storage[offset.value()];
-            if (val.is_accessor_descriptor()) {
-                auto desc = val.as_accessor_descriptor();
-                desc->get = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
-            } else {
-                auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
-                obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+    }
+
+    AnyValue AnyValue::set_own_property(const std::string &key, AnyValue value) const
+    {
+        switch (get_type())
+        {
+        case JsType::Object:
+            return as_object()->set_property(key, value, *this);
+        case JsType::Array:
+            return as_array()->set_property(key, value, *this);
+        case JsType::Function:
+            return as_function()->set_property(key, value, *this);
+        case JsType::Promise:
+            return as_promise()->set_property(key, value, *this);
+        case JsType::Undefined:
+            throw Exception::make_exception("Cannot set properties of undefined (setting '" + key + "')", "TypeError");
+        case JsType::Null:
+            throw Exception::make_exception("Cannot set properties of null (setting '" + key + "')", "TypeError");
+        default:
+            return value;
+        }
+    }
+
+    AnyValue AnyValue::set_own_property(uint32_t idx, AnyValue value) const
+    {
+        if (is_array())
+            return as_array()->set_property(idx, value);
+        return set_own_property(std::to_string(idx), value);
+    }
+
+    AnyValue AnyValue::set_own_property(const AnyValue &key, AnyValue value) const
+    {
+        if (key.is_number() && is_array())
+            return as_array()->set_property(key.as_double(), value);
+        if (key.is_symbol())
+            return set_own_symbol_property(key, value);
+        return set_own_property(key.to_std_string(), value);
+    }
+
+    AnyValue AnyValue::set_own_symbol_property(const AnyValue &key, AnyValue value) const
+    {
+        switch (get_type())
+        {
+        case JsType::Object:
+            return as_object()->set_symbol_property(key, value, *this);
+        case JsType::Array:
+            return as_array()->set_symbol_property(key, value, *this);
+        case JsType::Function:
+            return as_function()->set_symbol_property(key, value, *this);
+        case JsType::Promise:
+            return as_promise()->set_symbol_property(key, value, *this);
+        case JsType::Iterator:
+            return static_cast<JsIterator<AnyValue> *>(get_ptr())->set_symbol_property(key, value, *this);
+        case JsType::AsyncIterator:
+            return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->set_symbol_property(key, value, *this);
+        case JsType::Undefined:
+            throw Exception::make_exception("Cannot set properties of undefined (setting Symbol)", "TypeError");
+        case JsType::Null:
+            throw Exception::make_exception("Cannot set properties of null (setting Symbol)", "TypeError");
+        default:
+            return value;
+        }
+    }
+
+    AnyValue AnyValue::call_own_property(const std::string &key, std::span<const AnyValue> args) const
+    {
+        return get_own_property(key).call((*this), args, key);
+    }
+    AnyValue AnyValue::call_own_property(uint32_t idx, std::span<const AnyValue> args) const
+    {
+        if (is_array())
+            return as_array()->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
+        if (is_string())
+            return as_string()->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
+        return call_own_property(std::to_string(idx), args);
+    }
+    AnyValue AnyValue::call_own_property(const AnyValue &key, std::span<const AnyValue> args) const
+    {
+        if (key.is_number() && is_array())
+            return as_array()->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
+        if (key.is_number() && is_string())
+            return as_string()->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
+        if (key.is_symbol())
+            return get_own_symbol_property(key).call((*this), args, key.to_std_string());
+        return call_own_property(key.to_std_string(), args);
+    }
+
+    // --- AnyValue methods that were in any_value_defines.hpp ---
+
+    void AnyValue::define_data_property(const std::string &key, AnyValue value)
+    {
+        if (is_object())
+        {
+            auto obj = as_object();
+            auto offset = obj->shape->get_offset(key);
+            if (offset.has_value())
+                obj->storage[offset.value()] = value;
+            else
+            {
+                obj->shape = obj->shape->transition(key);
+                obj->storage.push_back(value);
             }
-        } else {
-            auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
-            obj->shape = obj->shape->transition(key);
-            obj->storage.push_back(AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true));
-        }
-    } else if (is_function()) {
-        auto &props = as_function()->props;
-        auto it = props.find(key);
-        if (it != props.end() && it->second.is_accessor_descriptor()) {
-            auto desc = it->second.as_accessor_descriptor();
-            desc->get = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
-        } else {
-            auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
-            props[key] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
-        }
-    }
-}
-
-void AnyValue::define_data_property(const AnyValue &key, AnyValue value, bool writable, bool enumerable, bool configurable) {
-    if (key.is_symbol()) {
-        auto desc = AnyValue::make_data_descriptor(value, writable, enumerable, configurable);
-        if (is_object()) as_object()->symbol_props[key] = desc;
-        else if (is_function()) as_function()->symbol_props[key] = desc;
-    } else define_data_property(key.to_std_string(), value, writable, enumerable, configurable);
-}
-
-void AnyValue::define_getter(const AnyValue &key, AnyValue getter) {
-    if (key.is_symbol()) {
-        auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
-        auto desc = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
-        if (is_object()) as_object()->symbol_props[key] = desc;
-        else if (is_function()) as_function()->symbol_props[key] = desc;
-    } else define_getter(key.to_std_string(), getter);
-}
-
-void AnyValue::define_setter(const std::string &key, AnyValue setter) {
-    if (is_object()) {
-        auto obj = as_object();
-        auto offset = obj->shape->get_offset(key);
-        if (offset.has_value()) {
-            auto &val = obj->storage[offset.value()];
-            if (val.is_accessor_descriptor()) {
-                auto desc = val.as_accessor_descriptor();
-                desc->set = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue {
-                    if (args.empty()) return Constants::UNDEFINED;
+        }
+        else if (is_function())
+            as_function()->props[key] = value;
+    }
+
+    void AnyValue::define_data_property(const AnyValue &key, AnyValue value)
+    {
+        if (key.is_symbol())
+        {
+            if (is_object())
+                as_object()->symbol_props[key] = value;
+            else if (is_function())
+                as_function()->symbol_props[key] = value;
+        }
+        else
+            define_data_property(key.to_std_string(), value);
+    }
+
+    void AnyValue::define_data_property(const std::string &key, AnyValue value, bool writable, bool enumerable, bool configurable)
+    {
+        define_data_property(key, AnyValue::make_data_descriptor(value, writable, enumerable, configurable));
+    }
+
+    void AnyValue::define_getter(const std::string &key, AnyValue getter)
+    {
+        if (is_object())
+        {
+            auto obj = as_object();
+            auto offset = obj->shape->get_offset(key);
+            if (offset.has_value())
+            {
+                auto &val = obj->storage[offset.value()];
+                if (val.is_accessor_descriptor())
+                {
+                    auto desc = val.as_accessor_descriptor();
+                    desc->get = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+                    { return getter.call(thisVal, args); };
+                }
+                else
+                {
+                    auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+                    { return getter.call(thisVal, args); };
+                    obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+                }
+            }
+            else
+            {
+                auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+                { return getter.call(thisVal, args); };
+                obj->shape = obj->shape->transition(key);
+                obj->storage.push_back(AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true));
+            }
+        }
+        else if (is_function())
+        {
+            auto &props = as_function()->props;
+            auto it = props.find(key);
+            if (it != props.end() && it->second.is_accessor_descriptor())
+            {
+                auto desc = it->second.as_accessor_descriptor();
+                desc->get = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+                { return getter.call(thisVal, args); };
+            }
+            else
+            {
+                auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+                { return getter.call(thisVal, args); };
+                props[key] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+            }
+        }
+    }
+
+    void AnyValue::define_data_property(const AnyValue &key, AnyValue value, bool writable, bool enumerable, bool configurable)
+    {
+        if (key.is_symbol())
+        {
+            auto desc = AnyValue::make_data_descriptor(value, writable, enumerable, configurable);
+            if (is_object())
+                as_object()->symbol_props[key] = desc;
+            else if (is_function())
+                as_function()->symbol_props[key] = desc;
+        }
+        else
+            define_data_property(key.to_std_string(), value, writable, enumerable, configurable);
+    }
+
+    void AnyValue::define_getter(const AnyValue &key, AnyValue getter)
+    {
+        if (key.is_symbol())
+        {
+            auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+            { return getter.call(thisVal, args); };
+            auto desc = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+            if (is_object())
+                as_object()->symbol_props[key] = desc;
+            else if (is_function())
+                as_function()->symbol_props[key] = desc;
+        }
+        else
+            define_getter(key.to_std_string(), getter);
+    }
+
+    void AnyValue::define_setter(const std::string &key, AnyValue setter)
+    {
+        if (is_object())
+        {
+            auto obj = as_object();
+            auto offset = obj->shape->get_offset(key);
+            if (offset.has_value())
+            {
+                auto &val = obj->storage[offset.value()];
+                if (val.is_accessor_descriptor())
+                {
+                    auto desc = val.as_accessor_descriptor();
+                    desc->set = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+                    {
+                        if (args.empty())
+                            return Constants::UNDEFINED;
+                        return setter.call(thisVal, args);
+                    };
+                }
+                else
+                {
+                    auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                    {
+                        if (args.empty())
+                            return jspp::Constants::UNDEFINED;
+                        return setter.call(thisVal, args);
+                    };
+                    obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+                }
+            }
+            else
+            {
+                auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                {
+                    if (args.empty())
+                        return jspp::Constants::UNDEFINED;
                     return setter.call(thisVal, args);
                 };
-            } else {
-                auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-                    if (args.empty()) return jspp::Constants::UNDEFINED;
+                obj->shape = obj->shape->transition(key);
+                obj->storage.push_back(AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true));
+            }
+        }
+        else if (is_function())
+        {
+            auto &props = as_function()->props;
+            auto it = props.find(key);
+            if (it != props.end() && it->second.is_accessor_descriptor())
+            {
+                auto desc = it->second.as_accessor_descriptor();
+                desc->set = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+                {
+                    if (args.empty())
+                        return Constants::UNDEFINED;
                     return setter.call(thisVal, args);
                 };
-                obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
             }
-        } else {
-            auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-                if (args.empty()) return jspp::Constants::UNDEFINED;
-                return setter.call(thisVal, args);
-            };
-            obj->shape = obj->shape->transition(key);
-            obj->storage.push_back(AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true));
-        }
-    } else if (is_function()) {
-        auto &props = as_function()->props;
-        auto it = props.find(key);
-        if (it != props.end() && it->second.is_accessor_descriptor()) {
-            auto desc = it->second.as_accessor_descriptor();
-            desc->set = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue {
-                if (args.empty()) return Constants::UNDEFINED;
-                return setter.call(thisVal, args);
-            };
-        } else {
-            auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-                if (args.empty()) return jspp::Constants::UNDEFINED;
+            else
+            {
+                auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                {
+                    if (args.empty())
+                        return jspp::Constants::UNDEFINED;
+                    return setter.call(thisVal, args);
+                };
+                props[key] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+            }
+        }
+    }
+
+    void AnyValue::define_setter(const AnyValue &key, AnyValue setter)
+    {
+        if (key.is_symbol())
+        {
+            auto setFunc = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue
+            {
+                if (args.empty())
+                    return Constants::UNDEFINED;
                 return setter.call(thisVal, args);
             };
-            props[key] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
-        }
-    }
-}
-
-void AnyValue::define_setter(const AnyValue &key, AnyValue setter) {
-    if (key.is_symbol()) {
-        auto setFunc = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue {
-            if (args.empty()) return Constants::UNDEFINED;
-            return setter.call(thisVal, args);
-        };
-        auto desc = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
-        if (is_object()) as_object()->symbol_props[key] = desc;
-        else if (is_function()) as_function()->symbol_props[key] = desc;
-    } else define_setter(key.to_std_string(), setter);
-}
-
-// AnyValue iterator methods from runtime.cpp
-JsIterator<AnyValue>* AnyValue::as_iterator() const noexcept { 
-    return static_cast<JsIterator<AnyValue> *>(get_ptr()); 
-}
-
-JsAsyncIterator<AnyValue>* AnyValue::as_async_iterator() const noexcept { 
-    return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr()); 
-}
+            auto desc = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+            if (is_object())
+                as_object()->symbol_props[key] = desc;
+            else if (is_function())
+                as_function()->symbol_props[key] = desc;
+        }
+        else
+            define_setter(key.to_std_string(), setter);
+    }
+
+    // AnyValue iterator methods from runtime.cpp
+    JsIterator<AnyValue> *AnyValue::as_iterator() const noexcept
+    {
+        return static_cast<JsIterator<AnyValue> *>(get_ptr());
+    }
+
+    JsAsyncIterator<AnyValue> *AnyValue::as_async_iterator() const noexcept
+    {
+        return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr());
+    }
 
 } // namespace jspp