@ugo-studio/jspp 0.2.5 → 0.2.7

package/src/prelude/any_value.hpp

@@ -40,74 +40,93 @@ namespace jspp
     private:
         uint64_t storage;
 
-        static constexpr uint64_t TAG_BASE          = 0xFFFC000000000000ULL;
-        static constexpr uint64_t TAG_POINTER       = 0xFFFC000000000000ULL;
-        static constexpr uint64_t TAG_BOOLEAN       = 0xFFFD000000000000ULL;
-        static constexpr uint64_t TAG_SPECIAL       = 0xFFFE000000000000ULL;
-        
-        static constexpr uint64_t VAL_UNDEFINED     = 0x1ULL;
-        static constexpr uint64_t VAL_NULL          = 0x2ULL;
+        static constexpr uint64_t TAG_BASE = 0xFFFC000000000000ULL;
+        static constexpr uint64_t TAG_POINTER = 0xFFFC000000000000ULL;
+        static constexpr uint64_t TAG_BOOLEAN = 0xFFFD000000000000ULL;
+        static constexpr uint64_t TAG_SPECIAL = 0xFFFE000000000000ULL;
+
+        static constexpr uint64_t VAL_UNDEFINED = 0x1ULL;
+        static constexpr uint64_t VAL_NULL = 0x2ULL;
         static constexpr uint64_t VAL_UNINITIALIZED = 0x3ULL;
 
-        static constexpr uint64_t TAG_MASK          = 0xFFFF000000000000ULL;
-        static constexpr uint64_t PAYLOAD_MASK      = 0x0000FFFFFFFFFFFFULL;
+        static constexpr uint64_t TAG_MASK = 0xFFFF000000000000ULL;
+        static constexpr uint64_t PAYLOAD_MASK = 0x0000FFFFFFFFFFFFULL;
 
-        inline bool has_tag(uint64_t tag) const noexcept {
+        inline bool has_tag(uint64_t tag) const noexcept
+        {
             return (storage & TAG_MASK) == tag;
         }
 
     public:
-        inline HeapObject* get_ptr() const noexcept {
-            return reinterpret_cast<HeapObject*>(storage & PAYLOAD_MASK);
+        inline HeapObject *get_ptr() const noexcept
+        {
+            return reinterpret_cast<HeapObject *>(storage & PAYLOAD_MASK);
         }
 
         // default ctor (Undefined)
         AnyValue() noexcept : storage(TAG_SPECIAL | VAL_UNDEFINED) {}
 
-        explicit AnyValue(double d) noexcept {
+        explicit AnyValue(double d) noexcept
+        {
             std::memcpy(&storage, &d, 8);
-            if (storage >= TAG_BASE) [[unlikely]] {
+            if (storage >= TAG_BASE) [[unlikely]]
+            {
                 storage = 0x7FF8000000000000ULL;
             }
         }
 
         explicit AnyValue(bool b) noexcept : storage(TAG_BOOLEAN | (b ? 1 : 0)) {}
 
-        AnyValue(const AnyValue &other) noexcept : storage(other.storage) {
-            if (is_heap_object()) get_ptr()->ref();
+        AnyValue(const AnyValue &other) noexcept : storage(other.storage)
+        {
+            if (is_heap_object())
+                get_ptr()->ref();
         }
 
-        AnyValue(AnyValue &&other) noexcept : storage(other.storage) {
+        AnyValue(AnyValue &&other) noexcept : storage(other.storage)
+        {
             other.storage = TAG_SPECIAL | VAL_UNDEFINED;
         }
 
-        AnyValue &operator=(const AnyValue &other) noexcept {
-            if (this != &other) {
-                if (is_heap_object()) get_ptr()->deref();
+        AnyValue &operator=(const AnyValue &other) noexcept
+        {
+            if (this != &other)
+            {
+                if (is_heap_object())
+                    get_ptr()->deref();
                 storage = other.storage;
-                if (is_heap_object()) get_ptr()->ref();
+                if (is_heap_object())
+                    get_ptr()->ref();
             }
             return *this;
         }
 
-        AnyValue &operator=(AnyValue &&other) noexcept {
-            if (this != &other) {
-                if (is_heap_object()) get_ptr()->deref();
+        AnyValue &operator=(AnyValue &&other) noexcept
+        {
+            if (this != &other)
+            {
+                if (is_heap_object())
+                    get_ptr()->deref();
                 storage = other.storage;
                 other.storage = TAG_SPECIAL | VAL_UNDEFINED;
             }
             return *this;
         }
 
-        ~AnyValue() {
-            if (is_heap_object()) get_ptr()->deref();
+        ~AnyValue()
+        {
+            if (is_heap_object())
+                get_ptr()->deref();
         }
 
         // Assignments
-        AnyValue &operator=(double val) noexcept {
-            if (is_heap_object()) get_ptr()->deref();
+        AnyValue &operator=(double val) noexcept
+        {
+            if (is_heap_object())
+                get_ptr()->deref();
             std::memcpy(&storage, &val, 8);
-            if (storage >= TAG_BASE) [[unlikely]] {
+            if (storage >= TAG_BASE) [[unlikely]]
+            {
                 storage = 0x7FF8000000000000ULL;
             }
             return *this;
@@ -173,6 +192,7 @@ namespace jspp
         static AnyValue make_array(std::vector<AnyValue> &&dense) noexcept;
         static AnyValue make_array_with_proto(std::span<const AnyValue> dense, AnyValue proto) noexcept;
         static AnyValue make_array_with_proto(const std::vector<AnyValue> &dense, AnyValue proto) noexcept;
+        static AnyValue make_array_with_proto(std::vector<AnyValue> &&dense, AnyValue proto) noexcept;
         static AnyValue make_function(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt, bool is_constructor = true) noexcept;
         static AnyValue make_class(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept;
         static AnyValue make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name = std::nullopt) noexcept;
@@ -188,12 +208,14 @@ namespace jspp
 
         static AnyValue from_symbol(JsSymbol *sym) noexcept;
         static AnyValue from_string(JsString *str) noexcept;
+        static AnyValue from_promise(JsPromise &&promise) noexcept;
         static AnyValue from_iterator(JsIterator<AnyValue> &&iterator) noexcept;
         static AnyValue from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept;
         static AnyValue from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept;
 
         // internal factory for wrapping raw heap object pointers
-        static AnyValue from_ptr(HeapObject* ptr) noexcept {
+        static AnyValue from_ptr(HeapObject *ptr) noexcept
+        {
             AnyValue v;
             v.storage = TAG_POINTER | reinterpret_cast<uint64_t>(ptr);
             ptr->ref();
@@ -204,13 +226,20 @@ namespace jspp
         static AnyValue resolve_property_for_write(AnyValue &val, const AnyValue &thisVal, const AnyValue &new_val, const std::string &propName);
 
         // TYPE CHECKERS AND ACCESSORS ---------------------------------------
-        JsType get_type() const noexcept {
-            if (is_number()) return JsType::Number;
-            if (is_heap_object()) return get_ptr()->get_heap_type();
-            if (is_boolean()) return JsType::Boolean;
-            if (is_undefined()) return JsType::Undefined;
-            if (is_null()) return JsType::Null;
-            if (is_uninitialized()) return JsType::Uninitialized;
+        inline JsType get_type() const noexcept
+        {
+            if (is_number())
+                return JsType::Number;
+            if (is_heap_object())
+                return get_ptr()->get_heap_type();
+            if (is_boolean())
+                return JsType::Boolean;
+            if (is_undefined())
+                return JsType::Undefined;
+            if (is_null())
+                return JsType::Null;
+            if (is_uninitialized())
+                return JsType::Uninitialized;
             return JsType::Undefined;
         }
 
@@ -230,18 +259,18 @@ namespace jspp
         inline bool is_data_descriptor() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::DataDescriptor; }
         inline bool is_accessor_descriptor() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::AccessorDescriptor; }
         inline bool is_async_iterator() const noexcept { return is_heap_object() && get_ptr()->get_heap_type() == JsType::AsyncIterator; }
-        
-        JsString* as_string() const noexcept;
-        JsObject* as_object() const noexcept;
-        JsArray* as_array() const noexcept;
-        JsFunction* as_function() const noexcept;
-        JsSymbol* as_symbol() const noexcept;
-        JsPromise* as_promise() const noexcept;
-        JsIterator<AnyValue>* as_iterator() const noexcept;
-        JsAsyncIterator<AnyValue>* as_async_iterator() const noexcept;
-        DataDescriptor* as_data_descriptor() const noexcept;
-        AccessorDescriptor* as_accessor_descriptor() const noexcept;
-        
+
+        JsString *as_string() const noexcept;
+        JsObject *as_object() const noexcept;
+        JsArray *as_array() const noexcept;
+        JsFunction *as_function() const noexcept;
+        JsSymbol *as_symbol() const noexcept;
+        JsPromise *as_promise() const noexcept;
+        JsIterator<AnyValue> *as_iterator() const noexcept;
+        JsAsyncIterator<AnyValue> *as_async_iterator() const noexcept;
+        DataDescriptor *as_data_descriptor() const noexcept;
+        AccessorDescriptor *as_accessor_descriptor() const noexcept;
+
         bool is_generator() const noexcept;
 
         double as_double() const noexcept
@@ -258,50 +287,51 @@ namespace jspp
         auto operator co_await() const;
 
         bool has_property(const std::string &key) const;
-        bool has_property(const char* key) const { return has_property(std::string(key)); }
+        bool has_property(const char *key) const { return has_property(std::string(key)); }
 
         AnyValue get_own_property(const std::string &key) const;
-        AnyValue get_own_property(const char* key) const { return get_own_property(std::string(key)); }
+        AnyValue get_own_property(const char *key) const { return get_own_property(std::string(key)); }
         AnyValue get_own_property(uint32_t idx) const;
         AnyValue get_own_property(int idx) const { return get_own_property(static_cast<uint32_t>(idx)); }
         AnyValue get_own_property(const AnyValue &key) const;
 
         AnyValue get_property_with_receiver(const std::string &key, const AnyValue &receiver) const;
-        AnyValue get_property_with_receiver(const char* key, const AnyValue &receiver) const { return get_property_with_receiver(std::string(key), receiver); }
+        AnyValue get_property_with_receiver(const char *key, const AnyValue &receiver) const { return get_property_with_receiver(std::string(key), receiver); }
 
         AnyValue set_own_property(const std::string &key, const AnyValue &value) const;
-        AnyValue set_own_property(const char* key, const AnyValue &value) const { return set_own_property(std::string(key), value); }
+        AnyValue set_own_property(const char *key, const AnyValue &value) const { return set_own_property(std::string(key), value); }
         AnyValue set_own_property(uint32_t idx, const AnyValue &value) const;
         AnyValue set_own_property(int idx, const AnyValue &value) const { return set_own_property(static_cast<uint32_t>(idx), value); }
         AnyValue set_own_property(const AnyValue &key, const AnyValue &value) const;
 
         AnyValue call_own_property(const std::string &key, std::span<const AnyValue> args) const;
-        AnyValue call_own_property(const char* key, std::span<const AnyValue> args) const { return call_own_property(std::string(key), args); }
+        AnyValue call_own_property(const char *key, std::span<const AnyValue> args) const { return call_own_property(std::string(key), args); }
         AnyValue call_own_property(uint32_t idx, std::span<const AnyValue> args) const;
         AnyValue call_own_property(int idx, std::span<const AnyValue> args) const { return call_own_property(static_cast<uint32_t>(idx), args); }
         AnyValue call_own_property(const AnyValue &key, std::span<const AnyValue> args) const;
 
         void define_data_property(const std::string &key, const AnyValue &value);
-        void define_data_property(const char* key, const AnyValue &value) { define_data_property(std::string(key), value); }
+        void define_data_property(const char *key, const AnyValue &value) { define_data_property(std::string(key), value); }
         void define_data_property(const AnyValue &key, const AnyValue &value);
         void define_data_property(const std::string &key, const AnyValue &value, bool writable, bool enumerable, bool configurable);
-        void define_data_property(const char* key, const AnyValue &value, bool writable, bool enumerable, bool configurable) { define_data_property(std::string(key), value, writable, enumerable, configurable); }
+        void define_data_property(const char *key, const AnyValue &value, bool writable, bool enumerable, bool configurable) { define_data_property(std::string(key), value, writable, enumerable, configurable); }
 
         void define_getter(const std::string &key, const AnyValue &getter);
-        void define_getter(const char* key, const AnyValue &getter) { define_getter(std::string(key), getter); }
+        void define_getter(const char *key, const AnyValue &getter) { define_getter(std::string(key), getter); }
         void define_getter(const AnyValue &key, const AnyValue &getter);
 
         void define_setter(const std::string &key, const AnyValue &setter);
-        void define_setter(const char* key, const AnyValue &setter) { define_setter(std::string(key), setter); }
+        void define_setter(const char *key, const AnyValue &setter) { define_setter(std::string(key), setter); }
         void define_setter(const AnyValue &key, const AnyValue &setter);
 
         AnyValue call(const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr = std::nullopt) const;
+        AnyValue optional_call(const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr = std::nullopt) const;
         AnyValue construct(std::span<const AnyValue> args, const std::optional<std::string> &name = std::nullopt) const;
         void set_prototype(const AnyValue &proto);
         std::string to_std_string() const;
 
         inline uint64_t get_storage() const noexcept { return storage; }
-        inline void* get_raw_ptr() const noexcept { return reinterpret_cast<void*>(storage & PAYLOAD_MASK); }
+        inline void *get_raw_ptr() const noexcept { return reinterpret_cast<void *>(storage & PAYLOAD_MASK); }
     };
 
     struct AnyValueAwaiter

package/src/prelude/any_value_access.hpp

@@ -86,7 +86,7 @@ namespace jspp
             return as_string()->get_property(key, receiver);
         case JsType::Number:
         {
-            auto proto_it = NumberPrototypes::get(key, as_double());
+            auto proto_it = NumberPrototypes::get(key);
             if (proto_it.has_value())
             {
                 return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);

package/src/prelude/any_value_helpers.hpp

@@ -16,128 +16,166 @@
 namespace jspp
 {
     // --- AnyValue GETTERS ---
-    inline JsString* AnyValue::as_string() const noexcept { return static_cast<JsString*>(get_ptr()); }
-    inline JsObject* AnyValue::as_object() const noexcept { return static_cast<JsObject*>(get_ptr()); }
-    inline JsArray* AnyValue::as_array() const noexcept { return static_cast<JsArray*>(get_ptr()); }
-    inline JsFunction* AnyValue::as_function() const noexcept { return static_cast<JsFunction*>(get_ptr()); }
-    inline JsSymbol* AnyValue::as_symbol() const noexcept { return static_cast<JsSymbol*>(get_ptr()); }
-    inline JsPromise* AnyValue::as_promise() const noexcept { return static_cast<JsPromise*>(get_ptr()); }
-    inline JsIterator<AnyValue>* AnyValue::as_iterator() const noexcept { return static_cast<JsIterator<AnyValue>*>(get_ptr()); }
-    inline JsAsyncIterator<AnyValue>* AnyValue::as_async_iterator() const noexcept { return static_cast<JsAsyncIterator<AnyValue>*>(get_ptr()); }
-    inline DataDescriptor* AnyValue::as_data_descriptor() const noexcept { return static_cast<DataDescriptor*>(get_ptr()); }
-    inline AccessorDescriptor* AnyValue::as_accessor_descriptor() const noexcept { return static_cast<AccessorDescriptor*>(get_ptr()); }
-    
+    inline JsString *AnyValue::as_string() const noexcept { return static_cast<JsString *>(get_ptr()); }
+    inline JsObject *AnyValue::as_object() const noexcept { return static_cast<JsObject *>(get_ptr()); }
+    inline JsArray *AnyValue::as_array() const noexcept { return static_cast<JsArray *>(get_ptr()); }
+    inline JsFunction *AnyValue::as_function() const noexcept { return static_cast<JsFunction *>(get_ptr()); }
+    inline JsSymbol *AnyValue::as_symbol() const noexcept { return static_cast<JsSymbol *>(get_ptr()); }
+    inline JsPromise *AnyValue::as_promise() const noexcept { return static_cast<JsPromise *>(get_ptr()); }
+    inline JsIterator<AnyValue> *AnyValue::as_iterator() const noexcept { return static_cast<JsIterator<AnyValue> *>(get_ptr()); }
+    inline JsAsyncIterator<AnyValue> *AnyValue::as_async_iterator() const noexcept { return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr()); }
+    inline DataDescriptor *AnyValue::as_data_descriptor() const noexcept { return static_cast<DataDescriptor *>(get_ptr()); }
+    inline AccessorDescriptor *AnyValue::as_accessor_descriptor() const noexcept { return static_cast<AccessorDescriptor *>(get_ptr()); }
+
     inline bool AnyValue::is_generator() const noexcept { return is_function() && as_function()->is_generator; }
 
     // --- AnyValue FACTORIES ---
-    inline AnyValue AnyValue::make_string(const std::string &raw_s) noexcept {
+    inline AnyValue AnyValue::make_string(const std::string &raw_s) noexcept
+    {
         return from_ptr(new JsString(raw_s));
     }
-    inline AnyValue AnyValue::make_object(std::initializer_list<std::pair<std::string, AnyValue>> props) noexcept {
+    inline AnyValue AnyValue::make_object(std::initializer_list<std::pair<std::string, AnyValue>> props) noexcept
+    {
         return from_ptr(new JsObject(props, make_null()));
     }
-    inline AnyValue AnyValue::make_object(const std::map<std::string, AnyValue> &props) noexcept {
+    inline AnyValue AnyValue::make_object(const std::map<std::string, AnyValue> &props) noexcept
+    {
         return from_ptr(new JsObject(props, make_null()));
     }
-    inline AnyValue AnyValue::make_object_with_proto(std::initializer_list<std::pair<std::string, AnyValue>> props, AnyValue proto) noexcept {
+    inline AnyValue AnyValue::make_object_with_proto(std::initializer_list<std::pair<std::string, AnyValue>> props, AnyValue proto) noexcept
+    {
         return from_ptr(new JsObject(props, proto));
     }
-    inline AnyValue AnyValue::make_object_with_proto(const std::map<std::string, AnyValue> &props, AnyValue proto) noexcept {
+    inline AnyValue AnyValue::make_object_with_proto(const std::map<std::string, AnyValue> &props, AnyValue proto) noexcept
+    {
         return from_ptr(new JsObject(props, proto));
     }
-    inline AnyValue AnyValue::make_array(std::span<const AnyValue> dense) noexcept {
+    inline 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);
+        for (const auto &item : dense)
+            vec.push_back(item);
         return from_ptr(new JsArray(std::move(vec)));
     }
-    inline AnyValue AnyValue::make_array(const std::vector<AnyValue> &dense) noexcept {
+    inline AnyValue AnyValue::make_array(const std::vector<AnyValue> &dense) noexcept
+    {
         return from_ptr(new JsArray(dense));
     }
-    inline AnyValue AnyValue::make_array(std::vector<AnyValue> &&dense) noexcept {
+    inline AnyValue AnyValue::make_array(std::vector<AnyValue> &&dense) noexcept
+    {
         return from_ptr(new JsArray(std::move(dense)));
     }
-    inline AnyValue AnyValue::make_array_with_proto(std::span<const AnyValue> dense, AnyValue proto) noexcept {
+    inline AnyValue AnyValue::make_array_with_proto(std::span<const AnyValue> dense, AnyValue proto) noexcept
+    {
         auto arr = new JsArray();
         arr->dense.reserve(dense.size());
-        for (const auto &item : dense) arr->dense.push_back(item);
+        for (const auto &item : dense)
+            arr->dense.push_back(item);
         arr->length = dense.size();
         arr->proto = proto;
         return from_ptr(arr);
     }
-    inline AnyValue AnyValue::make_array_with_proto(const std::vector<AnyValue> &dense, AnyValue proto) noexcept {
+    inline AnyValue AnyValue::make_array_with_proto(const std::vector<AnyValue> &dense, AnyValue proto) noexcept
+    {
         auto arr = new JsArray(dense);
         arr->proto = proto;
         return from_ptr(arr);
     }
-    inline AnyValue AnyValue::make_function(const JsFunctionCallable &call, const std::optional<std::string> &name, bool is_constructor) noexcept {
+    inline AnyValue AnyValue::make_array_with_proto(std::vector<AnyValue> &&dense, AnyValue proto) noexcept
+    {
+        auto arr = new JsArray(std::move(dense));
+        arr->proto = proto;
+        return from_ptr(arr);
+    }
+    inline 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;
     }
-    inline AnyValue AnyValue::make_class(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept {
+    inline 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;
     }
-    inline AnyValue AnyValue::make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept {
+    inline AnyValue AnyValue::make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+    {
         auto v = from_ptr(new JsFunction(call, true, name));
         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;
     }
-    inline AnyValue AnyValue::make_async_function(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept {
+    inline 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));
         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;
     }
-    inline AnyValue AnyValue::make_async_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept {
+    inline 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));
         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;
     }
-    inline AnyValue AnyValue::make_symbol(const std::string &description) noexcept {
+    inline AnyValue AnyValue::make_symbol(const std::string &description) noexcept
+    {
         return from_ptr(new JsSymbol(description));
     }
-    inline AnyValue AnyValue::make_promise(const JsPromise &promise) noexcept {
+    inline AnyValue AnyValue::make_promise(const JsPromise &promise) noexcept
+    {
         auto p = new JsPromise();
         *p = promise;
         return from_ptr(p);
     }
-    inline AnyValue AnyValue::make_data_descriptor(AnyValue value, bool writable, bool enumerable, bool configurable) noexcept {
+    inline AnyValue AnyValue::make_data_descriptor(AnyValue value, bool writable, bool enumerable, bool configurable) noexcept
+    {
         return from_ptr(new DataDescriptor(value, writable, enumerable, configurable));
     }
     inline AnyValue AnyValue::make_accessor_descriptor(const std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> &get,
-                                                     const std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> &set,
-                                                     bool enumerable,
-                                                     bool configurable) noexcept {
+                                                       const std::optional<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>> &set,
+                                                       bool enumerable,
+                                                       bool configurable) noexcept
+    {
         return from_ptr(new AccessorDescriptor(get, set, enumerable, configurable));
     }
 
-    inline AnyValue AnyValue::from_symbol(JsSymbol *sym) noexcept {
+    inline AnyValue AnyValue::from_symbol(JsSymbol *sym) noexcept
+    {
         return from_ptr(sym);
     }
-    inline AnyValue AnyValue::from_string(JsString *str) noexcept {
+    inline AnyValue AnyValue::from_string(JsString *str) noexcept
+    {
         return from_ptr(str);
     }
 
-    inline AnyValue AnyValue::from_iterator(JsIterator<AnyValue> &&iterator) noexcept {
+    inline AnyValue AnyValue::from_promise(JsPromise &&promise) noexcept
+    {
+        auto it = new JsPromise(std::move(promise));
+        return from_ptr(it);
+    }
+
+    inline AnyValue AnyValue::from_iterator(JsIterator<AnyValue> &&iterator) noexcept
+    {
         auto it = new JsIterator<AnyValue>(std::move(iterator));
         return from_ptr(it);
     }
-    inline AnyValue AnyValue::from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept {
-        return from_ptr(iterator); 
+    inline AnyValue AnyValue::from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept
+    {
+        return from_ptr(iterator);
     }
-    inline AnyValue AnyValue::from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept {
+    inline AnyValue AnyValue::from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept
+    {
         auto it = new JsAsyncIterator<AnyValue>(std::move(iterator));
         return from_ptr(it);
     }
@@ -285,10 +323,14 @@ namespace jspp
     inline AnyValue AnyValue::call(const 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); 
+        return as_function()->call(thisVal, args);
+    }
+    inline AnyValue AnyValue::optional_call(const 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::construct implementation

package/src/prelude/index.hpp

@@ -44,6 +44,7 @@
 #include "values/helpers/string.hpp"
 
 // utilities
+#include "utils/operators_primitive.hpp"
 #include "utils/operators.hpp"
 #include "utils/assignment_operators.hpp"
 #include "utils/access.hpp"

package/src/prelude/library/array.hpp

@@ -13,8 +13,9 @@ inline auto Array = jspp::AnyValue::make_class([](const jspp::AnyValue &thisVal,
              throw jspp::Exception::make_exception("Invalid array length", "RangeError");
         }
         auto arr = jspp::AnyValue::make_array(std::vector<jspp::AnyValue>());
-        arr.as_array()->length = static_cast<uint64_t>(len);
-        arr.as_array()->dense.resize(static_cast<size_t>(len), jspp::Constants::UNINITIALIZED);
+        auto arr_ptr = arr.as_array();
+        arr_ptr->length = static_cast<uint64_t>(len);
+        arr_ptr->dense.resize(static_cast<size_t>(len), jspp::Constants::UNINITIALIZED);
         return arr;
     }
     std::vector<jspp::AnyValue> elements;