@ugo-studio/jspp 0.2.9 → 0.3.1

package/src/prelude/{exception_helpers.hpp → exception.cpp}

@@ -1,53 +1,53 @@
-#pragma once
-
-#include "types.hpp"
-#include "exception.hpp"
-#include "any_value.hpp"
-
-const char *jspp::Exception::what() const noexcept
-{
-    // Note: this returns a pointer to a temporary string if we are not careful.
-    // In a real implementation, we might need to store the message string in the Exception object.
-    static thread_local std::string last_msg;
-    last_msg = data.to_std_string();
-    return last_msg.c_str();
-}
-
-jspp::Exception jspp::Exception::make_exception(const std::string &message, const std::string &name)
-{
-    // Use the global Error object to construct the exception
-    std::vector<AnyValue> args = {AnyValue::make_string(message)};
-    AnyValue errorObj = ::Error.construct(args, name);
-    errorObj.define_data_property("name", AnyValue::make_string(name), true, false, true);
-
-    return Exception(errorObj);
-}
-jspp::AnyValue jspp::Exception::exception_to_any_value(const std::exception &ex)
-{
-    if (const jspp::Exception *err = dynamic_cast<const jspp::Exception *>(&ex))
-    {
-        return err->data;
-    }
-    else
-    {
-        return AnyValue::make_string(ex.what());
-    }
-}
-
-// --- THROWERS
-jspp::AnyValue jspp::Exception::throw_unresolved_reference(const std::string &var_name)
-{
-    throw Exception::make_exception(var_name + " is not defined", "ReferenceError");
-}
-jspp::AnyValue jspp::Exception::throw_uninitialized_reference(const std::string &var_name)
-{
-    throw Exception::make_exception("Cannot access '" + var_name + "' before initialization", "ReferenceError");
-}
-jspp::AnyValue jspp::Exception::throw_immutable_assignment()
-{
-    throw Exception::make_exception("Assignment to constant variable.", "TypeError");
-}
-jspp::AnyValue jspp::Exception::throw_invalid_return_statement()
-{
-    throw Exception::make_exception("Return statements are only valid inside functions.", "SyntaxError");
-}
+#include "jspp.hpp"
+#include "exception.hpp"
+#include "any_value.hpp"
+
+namespace jspp {
+
+const char *Exception::what() const noexcept
+{
+    static thread_local std::string last_msg;
+    last_msg = data.to_std_string();
+    return last_msg.c_str();
+}
+
+Exception Exception::make_exception(const std::string &message, const std::string &name)
+{
+    std::vector<AnyValue> args = {AnyValue::make_string(message)};
+    AnyValue errorObj = ::Error.construct(args, name);
+    errorObj.define_data_property("name", AnyValue::make_string(name), true, false, true);
+
+    return Exception(errorObj);
+}
+
+AnyValue Exception::exception_to_any_value(const std::exception &ex)
+{
+    if (const jspp::Exception *err = dynamic_cast<const jspp::Exception *>(&ex))
+    {
+        return err->data;
+    }
+    else
+    {
+        return AnyValue::make_string(ex.what());
+    }
+}
+
+// --- THROWERS
+AnyValue Exception::throw_unresolved_reference(const std::string &var_name)
+{
+    throw Exception::make_exception(var_name + " is not defined", "ReferenceError");
+}
+AnyValue Exception::throw_uninitialized_reference(const std::string &var_name)
+{
+    throw Exception::make_exception("Cannot access '" + var_name + "' before initialization", "ReferenceError");
+}
+AnyValue Exception::throw_immutable_assignment()
+{
+    throw Exception::make_exception("Assignment to constant variable.", "TypeError");
+}
+AnyValue Exception::throw_invalid_return_statement()
+{
+    throw Exception::make_exception("Return statements are only valid inside functions.", "SyntaxError");
+}
+
+} // namespace jspp

package/src/prelude/exception.hpp

@@ -1,28 +1,28 @@
-#pragma once
-
-#include <exception>
-#include "types.hpp"
-#include "any_value.hpp"
-
-namespace jspp
-{
-    struct Exception : std::exception
-    {
-        AnyValue data;
-
-        explicit Exception(const AnyValue &value)
-            : data(value) {}
-        explicit Exception(AnyValue &&value)
-            : data(std::move(value)) {}
-
-        const char *what() const noexcept override;
-        static Exception make_exception(const std::string &message, const std::string &name);
-        static AnyValue exception_to_any_value(const std::exception &ex);
-
-        // --- THROWERS
-        static AnyValue throw_unresolved_reference(const std::string &var_name);
-        static AnyValue throw_uninitialized_reference(const std::string &var_name);
-        static AnyValue throw_immutable_assignment();
-        static AnyValue throw_invalid_return_statement();
-    };
+#pragma once
+
+#include <exception>
+#include "types.hpp"
+#include "any_value.hpp"
+
+namespace jspp
+{
+    struct Exception : std::exception
+    {
+        AnyValue data;
+
+        explicit Exception(const AnyValue &value)
+            : data(value) {}
+        explicit Exception(AnyValue &&value)
+            : data(std::move(value)) {}
+
+        const char *what() const noexcept override;
+        static Exception make_exception(const std::string &message, const std::string &name);
+        static AnyValue exception_to_any_value(const std::exception &ex);
+
+        // --- THROWERS
+        static AnyValue throw_unresolved_reference(const std::string &var_name);
+        static AnyValue throw_uninitialized_reference(const std::string &var_name);
+        static AnyValue throw_immutable_assignment();
+        static AnyValue throw_invalid_return_statement();
+    };
 }

package/src/prelude/iterator_instantiations.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include "values/iterator.hpp"
+#include "values/async_iterator.hpp"
+
+namespace jspp {
+    // Explicit template instantiation declarations
+    // This tells the compiler that the implementation is in libjspp.a
+    extern template class JsIterator<AnyValue>;
+    extern template class JsAsyncIterator<AnyValue>;
+}

package/src/prelude/{index.hpp → jspp.hpp}

@@ -1,4 +1,5 @@
-#pragma once
+#ifndef JSPP_PRELUDE_JSPP_HPP
+#define JSPP_PRELUDE_JSPP_HPP
 
 #include "types.hpp"
 #include "utils/well_known_symbols.hpp"
@@ -7,21 +8,19 @@
 #include "values/shape.hpp"
 #include "values/symbol.hpp"
 #include "values/non_values.hpp"
+#include "values/string.hpp"
+
+#include "any_value.hpp" // Must be before iterators for AnyValueAwaiter
 #include "values/iterator.hpp"
 #include "values/async_iterator.hpp"
-#include "values/string.hpp"
 
-#include "any_value.hpp"
 #include "values/object.hpp"
 #include "values/array.hpp"
 #include "values/function.hpp"
 #include "values/promise.hpp"
 #include "values/descriptors.hpp"
-#include "any_value_helpers.hpp"
-#include "any_value_access.hpp"
-#include "any_value_defines.hpp"
+#include "exception.hpp"
 #include "library/error.hpp"
-#include "exception_helpers.hpp"
 #include "scheduler.hpp"
 
 #include "values/prototypes/symbol.hpp"
@@ -34,15 +33,6 @@
 #include "values/prototypes/string.hpp"
 #include "values/prototypes/number.hpp"
 
-#include "values/helpers/symbol.hpp"
-#include "values/helpers/object.hpp"
-#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"
-
 // utilities
 #include "utils/operators_primitive.hpp"
 #include "utils/operators.hpp"
@@ -61,3 +51,7 @@
 #include "library/object.hpp"
 #include "library/array.hpp"
 #include "library/global.hpp"
+
+#include "iterator_instantiations.hpp"
+
+#endif // JSPP_PRELUDE_JSPP_HPP

package/src/prelude/library/array.cpp

@@ -0,0 +1,191 @@
+#include "jspp.hpp"
+#include "library/array.hpp"
+
+namespace jspp {
+    jspp::AnyValue Array = jspp::AnyValue::make_class(
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+    {
+        if (args.size() == 1 && args[0].is_number()) {
+            double len = args[0].as_double();
+            if (len < 0 || len > 4294967295.0) { // Max uint32
+                 throw jspp::Exception::make_exception("Invalid array length", "RangeError");
+            }
+            auto arr = jspp::AnyValue::make_array(std::vector<jspp::AnyValue>());
+            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;
+        for(const auto& arg : args) {
+            elements.push_back(arg);
+        }
+        return jspp::AnyValue::make_array(std::move(elements)); 
+    }), "Array");
+
+    struct ArrayInit
+    {
+        ArrayInit()
+        {
+            Array.define_data_property("isArray", jspp::AnyValue::make_function(
+                std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+            {
+                if (args.empty()) return jspp::Constants::FALSE;
+                return jspp::AnyValue::make_boolean(args[0].is_array()); 
+            }), "isArray"));
+
+            Array.define_data_property("of", jspp::AnyValue::make_function(
+                std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+            {
+                std::vector<jspp::AnyValue> elements;
+                for(const auto& arg : args) {
+                    elements.push_back(arg);
+                }
+                return jspp::AnyValue::make_array(std::move(elements)); 
+            }), "of"));
+
+            Array.define_data_property("from", jspp::AnyValue::make_function(
+                std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+            {
+                if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
+                    throw jspp::Exception::make_exception("Array.from requires an array-like object", "TypeError");
+                }
+
+                const auto& items = args[0];
+                const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
+                const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
+
+                std::vector<jspp::AnyValue> result;
+
+                auto iteratorSym = jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator);
+                if (items.has_property(iteratorSym)) {
+                    auto iter = jspp::Access::get_object_iterator(items, "Array.from source");
+                    auto nextFn = iter.get_own_property("next");
+                    
+                    size_t k = 0;
+                    while (true) {
+                        auto nextRes = nextFn.call(iter, std::span<const jspp::AnyValue>{}, "next");
+                        if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
+                        
+                        auto val = nextRes.get_own_property("value");
+                        if (mapFn.is_function()) {
+                            jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
+                            const jspp::AnyValue mapArgs[] = {val, kVal};
+                            val = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                        }
+                        result.push_back(val);
+                        k++;
+                    }
+                } else {
+                    auto lenVal = items.get_property_with_receiver("length", items);
+                    size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                    
+                    for (size_t k = 0; k < len; ++k) {
+                        auto kVal = items.get_property_with_receiver(std::to_string(k), items);
+                        if (mapFn.is_function()) {
+                            jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
+                            const jspp::AnyValue mapArgs[] = {kVal, kNum};
+                            kVal = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                        }
+                        result.push_back(kVal);
+                    }
+                }
+                
+                return jspp::AnyValue::make_array(std::move(result)); 
+            }), "from"));
+
+            Array.define_data_property("fromAsync", jspp::AnyValue::make_async_function(
+                std::function<JsPromise(AnyValue, std::vector<AnyValue>)>([](jspp::AnyValue, std::vector<jspp::AnyValue> args) -> jspp::JsPromise
+            {
+                if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
+                    throw jspp::Exception::make_exception("Array.fromAsync requires an iterable or array-like object", "TypeError");
+                }
+
+                const auto& items = args[0];
+                const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
+                const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
+
+                std::vector<jspp::AnyValue> result;
+                bool isAsync = false;
+                jspp::AnyValue iter = jspp::Constants::UNDEFINED;
+                jspp::AnyValue nextFn = jspp::Constants::UNDEFINED;
+
+                auto asyncIterSym = jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::asyncIterator);
+                if (items.has_property(asyncIterSym)) {
+                    auto method = items.get_own_property(asyncIterSym);
+                    if (method.is_function()) {
+                        iter = method.call(items, {});
+                        nextFn = iter.get_own_property("next");
+                        isAsync = true;
+                    }
+                } 
+                
+                auto iterSym = jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator);
+                if (!isAsync && items.has_property(iterSym)) {
+                    auto method = items.get_own_property(iterSym);
+                    if (method.is_function()) {
+                        iter = method.call(items, {});
+                        nextFn = iter.get_own_property("next");
+                    }
+                }
+
+                if (!iter.is_undefined()) {
+                    size_t k = 0;
+                    while (true) {
+                        auto nextRes = nextFn.call(iter, {});
+                        if (nextRes.is_promise()) {
+                            nextRes = co_await nextRes;
+                        }
+                        if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
+                        auto val = nextRes.get_own_property("value");
+                        if (mapFn.is_function()) {
+                            jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
+                            const jspp::AnyValue mapArgs[] = {val, kVal};
+                            auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                            if (mapRes.is_promise()) val = co_await mapRes; else val = mapRes;
+                        }
+                        result.push_back(val);
+                        k++;
+                    }
+                } else {
+                    auto lenVal = items.get_property_with_receiver("length", items);
+                    size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                    for (size_t k = 0; k < len; ++k) {
+                        auto kVal = items.get_property_with_receiver(std::to_string(k), items);
+                        if (kVal.is_promise()) kVal = co_await kVal;
+                        if (mapFn.is_function()) {
+                            jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
+                            const jspp::AnyValue mapArgs[] = {kVal, kNum};
+                            auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                            if (mapRes.is_promise()) kVal = co_await mapRes; else kVal = mapRes;
+                        }
+                        result.push_back(kVal);
+                    }
+                }
+                co_return jspp::AnyValue::make_array(std::move(result)); 
+            }), "fromAsync"));
+
+            // Array[Symbol.species]
+            Array.define_getter(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+            { return thisVal; }, "get [Symbol.species]"));
+
+            auto proto = Array.get_own_property("prototype");
+            const char *methods[] = {"push", "pop", "shift", "unshift", "join", "forEach", "map", "filter", "slice", "splice", "concat", "indexOf", "lastIndexOf", "includes", "every", "some", "reduce", "reduceRight", "flat", "flatMap", "fill", "reverse", "sort", "at", "values", "keys", "entries", "toString", "toLocaleString"};
+            for (const char *m : methods)
+            {
+                auto method_fn = jspp::ArrayPrototypes::get(m);
+                if (method_fn.has_value())
+                {
+                    proto.define_data_property(m, method_fn.value(), true, false, true);
+                }
+            }
+    
+            auto iteratorSym = jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator);
+            proto.define_data_property(iteratorSym, jspp::ArrayPrototypes::get(iteratorSym).value(), true, false, true);
+        }
+    };
+    void init_array()
+    {
+        static ArrayInit arrayInit;
+    }
+}

package/src/prelude/library/array.hpp

@@ -1,186 +1,13 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-#include "utils/operators.hpp"
-#include "utils/access.hpp"
-
-inline auto Array = jspp::AnyValue::make_class([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                               {
-    if (args.size() == 1 && args[0].is_number()) {
-        double len = args[0].as_double();
-        if (len < 0 || len > 4294967295.0) { // Max uint32
-             throw jspp::Exception::make_exception("Invalid array length", "RangeError");
-        }
-        auto arr = jspp::AnyValue::make_array(std::vector<jspp::AnyValue>());
-        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;
-    for(const auto& arg : args) {
-        elements.push_back(arg);
-    }
-    return jspp::AnyValue::make_array(std::move(elements)); }, "Array");
-
-struct ArrayInit
-{
-    ArrayInit()
-    {
-        // Array.isArray(value)
-        Array.define_data_property("isArray", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                            {
-            if (args.empty()) return jspp::Constants::FALSE;
-            return jspp::AnyValue::make_boolean(args[0].is_array()); }, "isArray"));
-
-        // Array.of(...elements)
-        Array.define_data_property("of", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                       {
-            std::vector<jspp::AnyValue> elements;
-            for(const auto& arg : args) {
-                elements.push_back(arg);
-            }
-            return jspp::AnyValue::make_array(std::move(elements)); }, "of"));
-
-        // Array.from(arrayLike, mapFn?, thisArg?)
-        Array.define_data_property("from", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                         {
-            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
-                throw jspp::Exception::make_exception("Array.from requires an array-like object", "TypeError");
-            }
-
-            const auto& items = args[0];
-            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
-            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
-
-            std::vector<jspp::AnyValue> result;
-
-            auto iteratorSym = jspp::WellKnownSymbols::iterator;
-            if (items.has_property(iteratorSym->key)) {
-                auto iter = jspp::Access::get_object_iterator(items, "Array.from source");
-                auto nextFn = iter.get_own_property("next");
-                
-                size_t k = 0;
-                while (true) {
-                    auto nextRes = nextFn.call(iter, std::span<const jspp::AnyValue>{}, "next");
-                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
-                    
-                    auto val = nextRes.get_own_property("value");
-                    if (mapFn.is_function()) {
-                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
-                        const jspp::AnyValue mapArgs[] = {val, kVal};
-                        val = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
-                    }
-                    result.push_back(val);
-                    k++;
-                }
-            } else {
-                // Array-like (length property)
-                auto lenVal = items.get_property_with_receiver("length", items);
-                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
-                
-                for (size_t k = 0; k < len; ++k) {
-                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
-                    if (mapFn.is_function()) {
-                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
-                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
-                        kVal = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
-                    }
-                    result.push_back(kVal);
-                }
-            }
-            
-            return jspp::AnyValue::make_array(std::move(result)); }, "from"));
-
-        // Array.fromAsync(iterableOrArrayLike, mapFn?, thisArg?)
-        Array.define_data_property("fromAsync", jspp::AnyValue::make_async_function([](jspp::AnyValue, std::vector<jspp::AnyValue> args) -> jspp::JsPromise
-                                                                                    {
-            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
-                throw jspp::Exception::make_exception("Array.fromAsync requires an iterable or array-like object", "TypeError");
-            }
-
-            const auto& items = args[0];
-            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
-            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
-
-            std::vector<jspp::AnyValue> result;
-            
-            bool isAsync = false;
-            jspp::AnyValue iter = jspp::Constants::UNDEFINED;
-            jspp::AnyValue nextFn = jspp::Constants::UNDEFINED;
-
-            if (items.has_property(jspp::WellKnownSymbols::asyncIterator->key)) {
-                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::asyncIterator->key, items);
-                if (method.is_function()) {
-                    iter = method.call(items, {});
-                    nextFn = iter.get_own_property("next");
-                    isAsync = true;
-                }
-            } 
-            
-            if (!isAsync && items.has_property(jspp::WellKnownSymbols::iterator->key)) {
-                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::iterator->key, items);
-                if (method.is_function()) {
-                    iter = method.call(items, {});
-                    nextFn = iter.get_own_property("next");
-                }
-            }
-
-            if (!iter.is_undefined()) {
-                size_t k = 0;
-                while (true) {
-                    auto nextRes = nextFn.call(iter, {});
-                    
-                    if (nextRes.is_promise()) {
-                        nextRes = co_await nextRes;
-                    }
-                    
-                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
-                    
-                    auto val = nextRes.get_own_property("value");
-                    
-                    if (mapFn.is_function()) {
-                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
-                        const jspp::AnyValue mapArgs[] = {val, kVal};
-                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
-                        if (mapRes.is_promise()) {
-                            val = co_await mapRes;
-                        } else {
-                            val = mapRes;
-                        }
-                    }
-                    result.push_back(val);
-                    k++;
-                }
-            } else {
-                auto lenVal = items.get_property_with_receiver("length", items);
-                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
-                
-                for (size_t k = 0; k < len; ++k) {
-                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
-                    if (kVal.is_promise()) {
-                        kVal = co_await kVal;
-                    }
-
-                    if (mapFn.is_function()) {
-                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
-                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
-                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
-                        if (mapRes.is_promise()) {
-                            kVal = co_await mapRes;
-                        } else {
-                            kVal = mapRes;
-                        }
-                    }
-                    result.push_back(kVal);
-                }
-            }
-
-            co_return jspp::AnyValue::make_array(std::move(result)); }, "fromAsync"));
-
-        // Array[Symbol.species]
-        Array.define_getter(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                                                        { return thisVal; }, "get [Symbol.species]"));
-    }
-} arrayInit;
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+
+namespace jspp {
+    extern AnyValue Array; 
+    void init_array();
+}
+
+using jspp::Array;