@ugo-studio/jspp 0.1.5 → 0.1.7

package/src/prelude/any_value_access.hpp

@@ -3,149 +3,188 @@
 #include "types.hpp"
 #include "any_value.hpp"
 
-jspp::AnyValue jspp::AnyValue::get_own_property(const std::string &key) const
+namespace jspp
 {
-    return get_property_with_receiver(key, *this);
-}
-bool jspp::AnyValue::has_property(const std::string &key) const
-{
-    switch (get_type())
+    AnyValue AnyValue::get_own_property(const std::string &key) const
+    {
+        return get_property_with_receiver(key, *this);
+    }
+    bool AnyValue::has_property(const std::string &key) const
     {
-    case JsType::Object:
-        return std::get<std::shared_ptr<JsObject>>(storage)->has_property(key);
-    case JsType::Array:
-        return std::get<std::shared_ptr<JsArray>>(storage)->has_property(key);
-    case JsType::Function:
-        return std::get<std::shared_ptr<JsFunction>>(storage)->has_property(key);
-    case JsType::Promise:
-        // Promises don't have their own props usually, but could.
-        return false;
-    case JsType::Iterator:
-        return false;
-    case JsType::Symbol:
-        return false;
-    case JsType::String:
-        if (key == "length")
-            return true;
-        if (JsArray::is_array_index(key))
+        switch (get_type())
         {
-            uint32_t idx = static_cast<uint32_t>(std::stoull(key));
-            return idx < std::get<std::shared_ptr<JsString>>(storage)->value.length();
+        case JsType::Object:
+            return std::get<std::shared_ptr<JsObject>>(storage)->has_property(key);
+        case JsType::Array:
+            return std::get<std::shared_ptr<JsArray>>(storage)->has_property(key);
+        case JsType::Function:
+            return std::get<std::shared_ptr<JsFunction>>(storage)->has_property(key);
+        case JsType::Promise:
+            // Promises don't have their own props usually, but could.
+            return false;
+        case JsType::Iterator:
+            return false;
+        case JsType::AsyncIterator:
+            return false;
+        case JsType::Symbol:
+            return false;
+        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 < std::get<std::shared_ptr<JsString>>(storage)->value.length();
+            }
+            return false;
+        case JsType::Number:
+            return false;
+        case JsType::Uninitialized:
+            Exception::throw_uninitialized_reference("#<Object>");
+            return false;
+        default:
+            return false;
         }
-        return false;
-    case JsType::Number:
-        return false;
-    case JsType::Uninitialized:
-        Exception::throw_uninitialized_reference("#<Object>");
-        return false;
-    default:
-        return false;
     }
-}
-jspp::AnyValue jspp::AnyValue::get_own_property(uint32_t idx) const
-{
-    switch (storage.index())
+    AnyValue AnyValue::get_own_property(uint32_t idx) const
     {
-    case 7: // Array
-        return std::get<std::shared_ptr<JsArray>>(storage)->get_property(idx);
-    case 5: // String
-        return std::get<std::shared_ptr<JsString>>(storage)->get_property(idx);
-    case 4: // Number
-        return get_own_property(std::to_string(idx));
-    default:
-        return get_own_property(std::to_string(idx));
+        switch (storage.index())
+        {
+        case 7: // Array
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(idx);
+        case 5: // String
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(idx);
+        case 4: // Number
+            return get_own_property(std::to_string(idx));
+        default:
+            return get_own_property(std::to_string(idx));
+        }
     }
-}
-jspp::AnyValue jspp::AnyValue::get_own_property(const AnyValue &key) const
-{
-    if (key.is_number() && is_array())
-        return std::get<std::shared_ptr<JsArray>>(storage)->get_property(key.as_double());
-    if (key.is_number() && is_string())
-        return std::get<std::shared_ptr<JsString>>(storage)->get_property(key.as_double());
+    AnyValue AnyValue::get_own_property(const AnyValue &key) const
+    {
+        if (key.is_number() && is_array())
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(key.as_double());
+        if (key.is_number() && is_string())
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(key.as_double());
 
-    // If the key is a Symbol, use its internal key string
-    if (key.is_symbol())
-        return get_own_property(key.as_symbol()->key);
+        // If the key is a Symbol, use its internal key string
+        if (key.is_symbol())
+            return get_own_property(key.as_symbol()->key);
 
-    return get_own_property(key.to_std_string());
-}
+        return get_own_property(key.to_std_string());
+    }
 
-jspp::AnyValue jspp::AnyValue::get_property_with_receiver(const std::string &key, const AnyValue &receiver) const
-{
-    switch (get_type())
+    AnyValue AnyValue::get_property_with_receiver(const std::string &key, const AnyValue &receiver) const
+    {
+        switch (get_type())
+        {
+        case JsType::Object:
+            return std::get<std::shared_ptr<JsObject>>(storage)->get_property(key, receiver);
+        case JsType::Array:
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(key, receiver);
+        case JsType::Function:
+            return std::get<std::shared_ptr<JsFunction>>(storage)->get_property(key, receiver);
+        case JsType::Promise:
+            return std::get<std::shared_ptr<JsPromise>>(storage)->get_property(key, receiver);
+        case JsType::Iterator:
+            return std::get<std::shared_ptr<JsIterator<AnyValue>>>(storage)->get_property(key, receiver);
+        case JsType::AsyncIterator:
+            return std::get<std::shared_ptr<JsAsyncIterator<AnyValue>>>(storage)->get_property(key, receiver);
+        case JsType::Symbol:
+            return std::get<std::shared_ptr<JsSymbol>>(storage)->get_property(key, receiver);
+        case JsType::String:
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(key, receiver);
+        case JsType::Number:
+        {
+            auto proto_it = NumberPrototypes::get(key, std::get<double>(storage));
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);
+            }
+            return AnyValue::make_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 AnyValue::make_undefined();
+        }
+    }
+
+    AnyValue AnyValue::set_own_property(const std::string &key, const AnyValue &value) const
     {
-    case JsType::Object:
-        return std::get<std::shared_ptr<JsObject>>(storage)->get_property(key, receiver);
-    case JsType::Array:
-        return std::get<std::shared_ptr<JsArray>>(storage)->get_property(key, receiver);
-    case JsType::Function:
-        return std::get<std::shared_ptr<JsFunction>>(storage)->get_property(key, receiver);
-    case JsType::Promise:
-        return std::get<std::shared_ptr<JsPromise>>(storage)->get_property(key, receiver);
-    case JsType::Iterator:
-        return std::get<std::shared_ptr<JsIterator<AnyValue>>>(storage)->get_property(key, receiver);
-    case JsType::Symbol:
-        return std::get<std::shared_ptr<JsSymbol>>(storage)->get_property(key, receiver);
-    case JsType::String:
-        return std::get<std::shared_ptr<JsString>>(storage)->get_property(key, receiver);
-    case JsType::Number:
+        switch (get_type())
+        {
+        case JsType::Object:
+            return std::get<std::shared_ptr<JsObject>>(storage)->set_property(key, value, *this);
+        case JsType::Array:
+            return std::get<std::shared_ptr<JsArray>>(storage)->set_property(key, value, *this);
+        case JsType::Function:
+            return std::get<std::shared_ptr<JsFunction>>(storage)->set_property(key, value, *this);
+        case JsType::Promise:
+            return std::get<std::shared_ptr<JsPromise>>(storage)->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, const AnyValue &value) const
     {
-        auto proto_it = NumberPrototypes::get(key, std::get<double>(storage));
-        if (proto_it.has_value())
+        if (is_array())
         {
-            return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);
+            return std::get<std::shared_ptr<JsArray>>(storage)->set_property(idx, value);
         }
-        return AnyValue::make_undefined();
+        return set_own_property(std::to_string(idx), value);
     }
-    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 AnyValue::make_undefined();
+    AnyValue AnyValue::set_own_property(const AnyValue &key, const AnyValue &value) const
+    {
+        if (key.is_number() && is_array())
+        {
+            return std::get<std::shared_ptr<JsArray>>(storage)->set_property(key.as_double(), value);
+        }
+
+        // If the key is a Symbol, use its internal key string
+        if (key.is_symbol())
+            return set_own_property(key.as_symbol()->key, value);
+
+        return set_own_property(key.to_std_string(), value);
     }
-}
 
-jspp::AnyValue jspp::AnyValue::set_own_property(const std::string &key, const AnyValue &value) const
-{
-    switch (get_type())
+    AnyValue AnyValue::call_own_property(const std::string &key, std::span<const AnyValue> args) const
     {
-    case JsType::Object:
-        return std::get<std::shared_ptr<JsObject>>(storage)->set_property(key, value, *this);
-    case JsType::Array:
-        return std::get<std::shared_ptr<JsArray>>(storage)->set_property(key, value, *this);
-    case JsType::Function:
-        return std::get<std::shared_ptr<JsFunction>>(storage)->set_property(key, value, *this);
-    case JsType::Promise:
-        return std::get<std::shared_ptr<JsPromise>>(storage)->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;
+        return get_own_property(key).call((*this), args, key);
     }
-}
-jspp::AnyValue jspp::AnyValue::set_own_property(uint32_t idx, const AnyValue &value) const
-{
-    if (is_array())
+    AnyValue AnyValue::call_own_property(uint32_t idx, std::span<const AnyValue> args) const
     {
-        return std::get<std::shared_ptr<JsArray>>(storage)->set_property(idx, value);
+        switch (storage.index())
+        {
+        case 7: // Array
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
+        case 5: // String
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
+        case 4: // Number
+            return call_own_property(std::to_string(idx), args);
+        default:
+            return call_own_property(std::to_string(idx), args);
+        }
     }
-    return set_own_property(std::to_string(idx), value);
-}
-jspp::AnyValue jspp::AnyValue::set_own_property(const AnyValue &key, const AnyValue &value) const
-{
-    if (key.is_number() && is_array())
+    AnyValue AnyValue::call_own_property(const AnyValue &key, std::span<const AnyValue> args) const
     {
-        return std::get<std::shared_ptr<JsArray>>(storage)->set_property(key.as_double(), value);
-    }
+        if (key.is_number() && is_array())
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
+        if (key.is_number() && is_string())
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
 
-    // If the key is a Symbol, use its internal key string
-    if (key.is_symbol())
-        return set_own_property(key.as_symbol()->key, value);
+        // If the key is a Symbol, use its internal key string
+        if (key.is_symbol())
+            return call_own_property(key.as_symbol()->key, args);
 
-    return set_own_property(key.to_std_string(), value);
-}
+        return call_own_property(key.to_std_string(), args);
+    }
+}

package/src/prelude/any_value_helpers.hpp

@@ -27,6 +27,8 @@ namespace jspp
             return std::get<std::shared_ptr<JsFunction>>(storage)->to_std_string();
         case JsType::Iterator:
             return std::get<std::shared_ptr<JsIterator<AnyValue>>>(storage)->to_std_string();
+        case JsType::AsyncIterator:
+            return std::get<std::shared_ptr<JsAsyncIterator<AnyValue>>>(storage)->to_std_string();
         case JsType::Promise:
             return std::get<std::shared_ptr<JsPromise>>(storage)->to_std_string();
         case JsType::Symbol:

package/src/prelude/index.hpp

@@ -11,6 +11,7 @@
 #include "values/array.hpp"
 #include "values/function.hpp"
 #include "values/iterator.hpp"
+#include "values/async_iterator.hpp"
 #include "values/promise.hpp"
 #include "values/string.hpp"
 
@@ -28,6 +29,7 @@
 #include "values/prototypes/array.hpp"
 #include "values/prototypes/function.hpp"
 #include "values/prototypes/iterator.hpp"
+#include "values/prototypes/async_iterator.hpp"
 #include "values/prototypes/promise.hpp"
 #include "values/prototypes/string.hpp"
 #include "values/prototypes/number.hpp"
@@ -37,6 +39,7 @@
 #include "values/helpers/array.hpp"
 #include "values/helpers/function.hpp"
 #include "values/helpers/iterator.hpp"
+#include "values/helpers/async_iterator.hpp"
 #include "values/helpers/promise.hpp"
 #include "values/helpers/string.hpp"
 

package/src/prelude/library/promise.hpp

@@ -20,15 +20,15 @@ inline auto Promise = jspp::AnyValue::make_function([](const jspp::AnyValue &thi
                                                         auto resolveFn = jspp::AnyValue::make_function([state](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                                                        {
         jspp::JsPromise p; p.state = state;
-        p.resolve(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
-        return jspp::AnyValue::make_undefined(); }, "resolve");
+        p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+        return jspp::Constants::UNDEFINED; }, "resolve");
 
                                                         // reject function
                                                         auto rejectFn = jspp::AnyValue::make_function([state](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                                                       {
         jspp::JsPromise p; p.state = state;
-        p.reject(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
-        return jspp::AnyValue::make_undefined(); }, "reject");
+        p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+        return jspp::Constants::UNDEFINED; }, "reject");
 
                                                         try
                                                         {
@@ -55,27 +55,19 @@ struct PromiseInit
         Promise.define_data_property("resolve", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                               {
             jspp::JsPromise p;
-            p.resolve(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+            p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
             return jspp::AnyValue::make_promise(p); }, "resolve"));
 
         // Promise.reject(reason)
         Promise.define_data_property("reject", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                              {
             jspp::JsPromise p;
-            p.reject(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+            p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
             return jspp::AnyValue::make_promise(p); }, "reject"));
 
         // Promise.all(iterable)
         Promise.define_data_property("all", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                           {
-             // Basic implementation for arrays
-             if (args.empty() || !args[0].is_array()) {
-                  // If not array, reject? Or treat as non-iterable?
-                  // Should throw TypeError if not iterable. For now assume array.
-                  // If empty array, return resolved empty array.
-                  // TODO: Strict iterable check
-             }
-             
              // Handle non-array iterable or empty args
              if (args.empty() || !args[0].is_array()) {
                  jspp::JsPromise p; p.reject(jspp::AnyValue::make_string("Promise.all argument must be an array"));

package/src/prelude/types.hpp

@@ -33,6 +33,9 @@ namespace jspp
     template <typename T>
     class JsIterator; // can set property
 
+    template <typename T>
+    class JsAsyncIterator; // can set property
+
     // Object property configuration forward declarations
     struct DataDescriptor;
     struct AccessorDescriptor;
@@ -43,6 +46,9 @@ namespace jspp
     // Dynamic AnyValue
     class AnyValue;
 
+    // Awaiter for AnyValue
+    struct AnyValueAwaiter;
+
     // Truthiness checker
     const bool is_truthy(const double &val) noexcept;
     const bool is_truthy(const std::string &val) noexcept;

package/src/prelude/utils/access.hpp

@@ -91,6 +91,8 @@ namespace jspp
                 return AnyValue::make_string("object");
             case JsType::Iterator:
                 return AnyValue::make_string("object");
+            case JsType::AsyncIterator:
+                return AnyValue::make_string("object");
             default:
                 return AnyValue::make_string("undefined");
             }
@@ -169,6 +171,7 @@ namespace jspp
 
             return keys;
         }
+
         inline AnyValue get_object_value_iterator(const AnyValue &obj, const std::string &name)
         {
             if (obj.is_iterator())
@@ -197,6 +200,32 @@ namespace jspp
             throw jspp::Exception::make_exception(name + " is not iterable", "TypeError");
         }
 
+        inline AnyValue get_async_object_value_iterator(const AnyValue &obj, const std::string &name)
+        {
+            if (obj.is_async_iterator())
+                return obj;
+
+            // 1. Try Symbol.asyncIterator
+            auto method = obj.get_own_property(WellKnownSymbols::asyncIterator->key);
+            if (method.is_function())
+            {
+                auto iter = method.call(obj, {}, WellKnownSymbols::asyncIterator->key);
+                if (iter.is_object() || iter.is_async_iterator() || iter.is_iterator())
+                    return iter;
+            }
+
+            // 2. Try Symbol.iterator (sync fallback)
+            auto syncMethod = obj.get_own_property(WellKnownSymbols::iterator->key);
+            if (syncMethod.is_function())
+            {
+                auto iter = syncMethod.call(obj, {}, WellKnownSymbols::iterator->key);
+                if (iter.is_object() || iter.is_iterator())
+                    return iter;
+            }
+
+            throw jspp::Exception::make_exception(name + " is not async iterable", "TypeError");
+        }
+
         inline AnyValue in(const AnyValue &lhs, const AnyValue &rhs)
         {
             if (!rhs.is_object() && !rhs.is_array() && !rhs.is_function() && !rhs.is_promise() && !rhs.is_iterator())
@@ -212,7 +241,7 @@ namespace jspp
             {
                 throw jspp::Exception::make_exception("Right-hand side of 'instanceof' is not callable", "TypeError");
             }
-            if (!lhs.is_object() && !lhs.is_array() && !lhs.is_function() && !lhs.is_promise() && !lhs.is_iterator())
+            if (!lhs.is_object() && !lhs.is_array() && !lhs.is_function() && !lhs.is_promise() && !lhs.is_iterator() && !lhs.is_async_iterator())
             {
                 return Constants::FALSE;
             }
@@ -256,6 +285,11 @@ namespace jspp
                     // Promises don't store explicit proto yet in our impl
                     break;
                 }
+                else if (current.is_async_iterator())
+                {
+                    // AsyncIterators don't store explicit proto yet in our impl
+                    break;
+                }
                 else
                 {
                     break;
@@ -341,5 +375,4 @@ namespace jspp
         }
 
     }
-
 }

package/src/prelude/values/array.hpp

@@ -17,8 +17,8 @@ namespace jspp
         uint64_t length = 0;
 
         JsArray() : proto(nullptr) {}
-        explicit JsArray(const std::vector<AnyValue> &items) : dense(items), proto(nullptr), length(items.size()) {}
-        explicit JsArray(std::vector<AnyValue> &&items) : dense(std::move(items)), proto(nullptr), length(dense.size()) {}
+        explicit JsArray(const std::vector<AnyValue> &items);
+        explicit JsArray(std::vector<AnyValue> &&items);
 
         std::string to_std_string() const;
         JsIterator<AnyValue> get_iterator();

package/src/prelude/values/async_iterator.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "types.hpp"
+#include <coroutine>
+#include <optional>
+#include <queue>
+#include <iostream>
+#include <utility>
+#include <exception>
+#include "values/promise.hpp"
+#include "scheduler.hpp"
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    template <typename T>
+    class JsAsyncIterator
+    {
+    public:
+        struct promise_type
+        {
+            std::queue<std::pair<JsPromise, T>> pending_calls;
+            bool is_awaiting = false;
+            bool is_running = false;
+            T current_input;
+
+            JsAsyncIterator get_return_object()
+            {
+                return JsAsyncIterator{
+                    std::coroutine_handle<promise_type>::from_promise(*this)};
+            }
+
+            std::suspend_always initial_suspend() noexcept { return {}; }
+
+            std::suspend_always final_suspend() noexcept { return {}; }
+
+            // Declarations
+            template <typename From>
+            auto yield_value(From &&from);
+
+            template <typename From>
+            void return_value(From &&from);
+
+            void unhandled_exception();
+
+            void fail_all(const AnyValue &reason);
+
+            auto await_transform(AnyValue value);
+        };
+
+        using handle_type = std::coroutine_handle<promise_type>;
+        handle_type handle;
+
+        explicit JsAsyncIterator(handle_type h) : handle(h) {}
+        JsAsyncIterator(JsAsyncIterator &&other) noexcept : handle(std::exchange(other.handle, nullptr)) {}
+
+        JsAsyncIterator(const JsAsyncIterator &) = delete;
+        JsAsyncIterator &operator=(const JsAsyncIterator &) = delete;
+
+        ~JsAsyncIterator()
+        {
+            if (handle)
+                handle.destroy();
+        }
+
+        std::unordered_map<std::string, AnyValue> props;
+
+        std::string to_std_string() const;
+
+        JsPromise next(const T &val = T());
+
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+        AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
+
+        void resume_next();
+    };
+}

package/src/prelude/values/function.hpp

@@ -11,7 +11,8 @@ namespace jspp
 
   using JsFunctionCallable = std::variant<std::function<AnyValue(const AnyValue &, std::span<const AnyValue>)>,                               // 0: Normal
                                           std::function<jspp::JsIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)>, // 1: Generator
-                                          std::function<jspp::JsPromise(const AnyValue &, std::span<const AnyValue>)>>;                 // 2: Async
+                                          std::function<jspp::JsPromise(const AnyValue &, std::span<const AnyValue>)>,                 // 2: Async
+                                          std::function<jspp::JsAsyncIterator<jspp::AnyValue>(const AnyValue &, std::span<const AnyValue>)>>; // 3: Async Generator
 
   struct JsFunction
   {

package/src/prelude/values/helpers/array.hpp

@@ -6,6 +6,9 @@
 #include "any_value.hpp"
 #include "values/prototypes/array.hpp"
 
+jspp::JsArray::JsArray(const std::vector<jspp::AnyValue> &items) : dense(items), proto(nullptr), length(items.size()) {}
+jspp::JsArray::JsArray(std::vector<jspp::AnyValue> &&items) : dense(std::move(items)), proto(nullptr), length(dense.size()) {}
+
 std::string jspp::JsArray::to_std_string() const
 {
     if (length == 0)