@ugo-studio/jspp 0.1.4 → 0.1.6

package/src/prelude/any_value_helpers.hpp

@@ -3,217 +3,62 @@
 #include "types.hpp"
 #include "any_value.hpp"
 #include "values/string.hpp"
+#include "exception.hpp"
 
 namespace jspp
 {
-    const bool AnyValue::is_truthy() const noexcept
+    std::string AnyValue::to_std_string() const
     {
-        switch (storage.type)
-        {
-        case JsType::Boolean:
-            return storage.boolean;
-        case JsType::Number:
-            return storage.number != 0.0;
-        case JsType::String:
-            return !storage.str->value.empty();
-        case JsType::Undefined:
-            return false;
-        case JsType::Null:
-            return false;
-        case JsType::Uninitialized:
-            return false;
-        default:
-            return true;
-        }
-    }
-
-    const bool AnyValue::is_strictly_equal_to_primitive(const AnyValue &other) const noexcept
-    {
-        if (storage.type == other.storage.type)
-        {
-            switch (storage.type)
-            {
-            case JsType::Boolean:
-                return storage.boolean == other.storage.boolean;
-            case JsType::Number:
-                return storage.number == other.storage.number;
-            case JsType::String:
-                return (storage.str->value == other.storage.str->value);
-            case JsType::Array:
-                return (storage.array == other.storage.array);
-            case JsType::Object:
-                return (storage.object == other.storage.object);
-            case JsType::Function:
-                return (storage.function == other.storage.function);
-            case JsType::Iterator:
-                return (storage.iterator == other.storage.iterator);
-            case JsType::Promise:
-                return (storage.promise == other.storage.promise);
-            case JsType::Symbol:
-                // Symbols are unique by reference/pointer identity
-                return (storage.symbol == other.storage.symbol);
-            case JsType::DataDescriptor:
-                return storage.data_desc == other.storage.data_desc;
-            case JsType::AccessorDescriptor:
-                return storage.accessor_desc == other.storage.accessor_desc;
-            default:
-                return true;
-            }
-        }
-        return false;
-    }
-    const bool AnyValue::is_equal_to_primitive(const AnyValue &other) const noexcept
-    {
-        // Implements JavaScript's Abstract Equality Comparison Algorithm (==)
-        // Step 1: If types are the same, use strict equality (===)
-        if (storage.type == other.storage.type)
-        {
-            return is_strictly_equal_to_primitive(other);
-        }
-        // Steps 2 & 3: null == undefined
-        if ((is_null() && other.is_undefined()) || (is_undefined() && other.is_null()))
-        {
-            return true;
-        }
-        // Step 4 & 5: number == string
-        if (is_number() && other.is_string())
-        {
-            double num_this = this->as_double();
-            double num_other;
-            try
-            {
-                const std::string &s = other.as_string()->value;
-                // JS considers empty string or whitespace-only string to be 0
-                if (s.empty() || std::all_of(s.begin(), s.end(), [](unsigned char c)
-                                             { return std::isspace(c); }))
-                {
-                    num_other = 0.0;
-                }
-                else
-                {
-                    size_t pos;
-                    num_other = std::stod(s, &pos);
-                    // Check if the entire string was consumed, allowing for trailing whitespace
-                    while (pos < s.length() && std::isspace(static_cast<unsigned char>(s[pos])))
-                    {
-                        pos++;
-                    }
-                    if (pos != s.length())
-                    {
-                        num_other = std::numeric_limits<double>::quiet_NaN();
-                    }
-                }
-            }
-            catch (...)
-            {
-                num_other = std::numeric_limits<double>::quiet_NaN();
-            }
-            return num_this == num_other;
-        }
-        if (is_string() && other.is_number())
-        {
-            // Delegate to the other operand to avoid code duplication
-            return other.is_equal_to_primitive(*this);
-        }
-        // Step 6 & 7: boolean == any
-        if (is_boolean())
-        {
-            // Convert boolean to number and re-compare
-            return AnyValue::make_number(as_boolean() ? 1.0 : 0.0).is_equal_to_primitive(other);
-        }
-        if (other.is_boolean())
-        {
-            // Convert boolean to number and re-compare
-            return is_equal_to_primitive(AnyValue::make_number(other.as_boolean() ? 1.0 : 0.0));
-        }
-        // Step 8 & 9: object == (string or number or symbol)
-        // Simplified: Objects convert to primitives.
-        if ((is_object() || is_array() || is_function() || is_promise() || is_iterator()) && (other.is_string() || other.is_number() || other.is_symbol()))
-        {
-            // Convert object to primitive (string) and re-compare.
-            // This is a simplification of JS's ToPrimitive.
-            return AnyValue::make_string(to_std_string()).is_equal_to_primitive(other);
-        }
-        if ((other.is_object() || other.is_array() || other.is_function() || other.is_promise() || other.is_iterator()) && (is_string() || is_number() || is_symbol()))
-        {
-            return other.is_equal_to_primitive(*this);
-        }
-        // Step 10: Datacriptor or accessor descriptor
-        if (is_data_descriptor() || is_accessor_descriptor())
-        {
-            return (*this).is_strictly_equal_to_primitive(other);
-        }
-        // Step 11: All other cases (e.g., object == null) are false.
-        return false;
-    }
-
-    const AnyValue AnyValue::is_strictly_equal_to(const AnyValue &other) const noexcept
-    {
-        return AnyValue::make_boolean(is_strictly_equal_to_primitive(other));
-    }
-    const AnyValue AnyValue::is_equal_to(const AnyValue &other) const noexcept
-    {
-        return AnyValue::make_boolean(is_equal_to_primitive(other));
-    }
-
-    const AnyValue AnyValue::not_strictly_equal_to(const AnyValue &other) const noexcept
-    {
-        return AnyValue::make_boolean(!is_strictly_equal_to_primitive(other));
-    }
-    const AnyValue AnyValue::not_equal_to(const AnyValue &other) const noexcept
-    {
-        return AnyValue::make_boolean(!is_equal_to_primitive(other));
-    }
-
-    const std::string AnyValue::to_std_string() const noexcept
-    {
-        switch (storage.type)
+        switch (get_type())
         {
         case JsType::Undefined:
             return "undefined";
         case JsType::Null:
             return "null";
         case JsType::Boolean:
-            return storage.boolean ? "true" : "false";
+            return std::get<bool>(storage) ? "true" : "false";
         case JsType::String:
-            return storage.str->to_std_string();
+            return std::get<std::shared_ptr<JsString>>(storage)->to_std_string();
         case JsType::Object:
-            return storage.object->to_std_string();
+            return std::get<std::shared_ptr<JsObject>>(storage)->to_std_string();
         case JsType::Array:
-            return storage.array->to_std_string();
+            return std::get<std::shared_ptr<JsArray>>(storage)->to_std_string();
         case JsType::Function:
-            return storage.function->to_std_string();
+            return std::get<std::shared_ptr<JsFunction>>(storage)->to_std_string();
         case JsType::Iterator:
-            return storage.iterator->to_std_string();
+            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 storage.promise->to_std_string();
+            return std::get<std::shared_ptr<JsPromise>>(storage)->to_std_string();
         case JsType::Symbol:
-            return storage.symbol->to_std_string();
+            return std::get<std::shared_ptr<JsSymbol>>(storage)->to_std_string();
         case JsType::DataDescriptor:
-            return storage.data_desc->value->to_std_string();
+            return std::get<std::shared_ptr<DataDescriptor>>(storage)->value->to_std_string();
         case JsType::AccessorDescriptor:
         {
-            if (storage.accessor_desc->get.has_value())
-                return storage.accessor_desc->get.value()(*this, {}).to_std_string();
+            if (std::get<std::shared_ptr<AccessorDescriptor>>(storage)->get.has_value())
+                return std::get<std::shared_ptr<AccessorDescriptor>>(storage)->get.value()(*this, {}).to_std_string();
             else
                 return "undefined";
         }
         case JsType::Number:
         {
-            if (std::isnan(storage.number))
+            double num = std::get<double>(storage);
+            if (std::isnan(num))
             {
                 return "NaN";
             }
-            if (std::abs(storage.number) >= 1e21 || (std::abs(storage.number) > 0 && std::abs(storage.number) < 1e-6))
+            if (std::abs(num) >= 1e21 || (std::abs(num) > 0 && std::abs(num) < 1e-6))
             {
                 std::ostringstream oss;
-                oss << std::scientific << std::setprecision(4) << storage.number;
+                oss << std::scientific << std::setprecision(4) << num;
                 return oss.str();
             }
             else
             {
                 std::ostringstream oss;
-                oss << std::setprecision(6) << std::fixed << storage.number;
+                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() == '.')
@@ -223,9 +68,8 @@ namespace jspp
                 return s;
             }
         }
-        // Uninitialized and default should not be reached under normal circumstances
         case JsType::Uninitialized:
-            return "<uninitialized>";
+            Exception::throw_uninitialized_reference("#<Object>");
         default:
             return "";
         }
@@ -235,12 +79,63 @@ namespace jspp
     {
         if (is_object())
         {
-            storage.object->proto = std::make_shared<AnyValue>(proto);
+            std::get<std::shared_ptr<JsObject>>(storage)->proto = std::make_shared<AnyValue>(proto);
+        }
+        else if (is_array())
+        {
+            std::get<std::shared_ptr<JsArray>>(storage)->proto = std::make_shared<AnyValue>(proto);
         }
         else if (is_function())
         {
-            storage.function->proto = std::make_shared<AnyValue>(proto);
+            std::get<std::shared_ptr<JsFunction>>(storage)->proto = std::make_shared<AnyValue>(proto);
+        }
+        else if (is_uninitialized())
+        {
+            Exception::throw_uninitialized_reference("#<Object>");
+        }
+    }
+
+    // AnyValue::call implementation
+    const AnyValue AnyValue::call(const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr = std::nullopt) 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); // Convert to function before calling, to avoid an infinite loop
+    }
+
+    // AnyValue::construct implementation
+    const AnyValue AnyValue::construct(std::span<const AnyValue> args, const std::optional<std::string> &name) const
+    {
+        if (!is_function() || !as_function()->is_constructor)
+        {
+            // std::cerr << "Construct fail: " << name.value_or(to_std_string()) << " is_function=" << is_function() << " is_constructor=" << (is_function() ? as_function()->is_constructor : false) << std::endl;
+            throw Exception::make_exception(name.value_or(to_std_string()) + " is not a constructor", "TypeError");
+        }
+
+        // 1. Get prototype
+        AnyValue proto = get_own_property("prototype");
+        // If prototype is not an object, default to a plain object (which ideally inherits from Object.prototype)
+        // Here we just make a plain object.
+        if (!proto.is_object())
+        {
+            proto = AnyValue::make_object({});
+        }
+
+        // 2. Create instance
+        AnyValue instance = AnyValue::make_object_with_proto({}, proto);
+
+        // 3. Call function
+        // We pass 'instance' as 'this'
+        AnyValue result = call(instance, args);
+
+        // 4. Return result if object, else instance
+        if (result.is_object() || result.is_function() || result.is_array() || result.is_promise())
+        {
+            return result;
         }
+        return instance;
     }
 
 }

package/src/prelude/exception.hpp

@@ -1,6 +1,7 @@
 
 #pragma once
 
+#include <exception>
 #include "types.hpp"
 
 namespace jspp

package/src/prelude/exception_helpers.hpp

@@ -12,10 +12,10 @@ const char *jspp::Exception::what() const noexcept
 jspp::Exception jspp::Exception::make_exception(const std::string &message, const std::string &name = "Error")
 {
     // Use the global Error object to construct the exception
-    std::vector<AnyValue> args = { AnyValue::make_string(message) };
-    AnyValue errorObj = ::Error.construct(args);
-    errorObj.define_data_property("name", AnyValue::make_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);
 }
 jspp::AnyValue jspp::Exception::exception_to_any_value(const std::exception &ex)

package/src/prelude/index.hpp

@@ -4,18 +4,19 @@
 #include "utils/well_known_symbols.hpp"
 
 // values
+#include "values/shape.hpp"
 #include "values/symbol.hpp"
 #include "values/non_values.hpp"
 #include "values/object.hpp"
 #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"
 
-#include "exception.hpp"
-#include "values/descriptors.hpp"
 #include "any_value.hpp"
+#include "values/descriptors.hpp"
 #include "any_value_helpers.hpp"
 #include "any_value_access.hpp"
 #include "any_value_defines.hpp"
@@ -28,25 +29,34 @@
 #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"
 
 #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.hpp"
+#include "utils/assignment_operators.hpp"
 #include "utils/access.hpp"
 #include "utils/log_any_value/log_any_value.hpp"
 
 // js standard libraries
 #include "library/symbol.hpp"
+#include "library/process.hpp"
+#include "library/function.hpp"
 #include "library/console.hpp"
 #include "library/performance.hpp"
 #include "library/promise.hpp"
+#include "library/math.hpp"
+#include "library/object.hpp"
+#include "library/array.hpp"
 #include "library/global.hpp"

package/src/prelude/library/array.hpp

@@ -0,0 +1,190 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+
+inline auto Array = jspp::AnyValue::make_class([](const 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>());
+        arr.as_array()->length = static_cast<uint64_t>(len);
+        arr.as_array()->dense.resize(static_cast<size_t>(len), jspp::AnyValue::make_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()
+    {
+        // Set Array.prototype.proto to Object.prototype
+        // Array.get_own_property("prototype").set_prototype(::Object.get_own_property("prototype"));
+
+        // Array.isArray(value)
+        Array.define_data_property("isArray", jspp::AnyValue::make_function([](const 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([](const 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([](const 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;
+
+            // Check if iterable
+            // Simple check: does it have [Symbol.iterator]?
+            auto iteratorSym = jspp::WellKnownSymbols::iterator;
+            if (items.has_property(iteratorSym->key)) {
+                auto iter = jspp::Access::get_object_value_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([](const jspp::AnyValue &, std::span<const 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::AnyValue nextFn;
+
+            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([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                        { return thisVal; }, "get [Symbol.species]"));
+    }
+} arrayInit;

package/src/prelude/library/console.hpp

@@ -6,6 +6,7 @@
 #include "values/object.hpp"
 #include "values/function.hpp"
 #include "utils/operators.hpp"
+#include "exception.hpp"
 #include "utils/log_any_value/log_any_value.hpp"
 
 #include <cmath>
@@ -14,7 +15,7 @@
 
 static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
 
-auto logFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto logFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                            {
                                                for (size_t i = 0; i < args.size(); ++i)
                                                {
@@ -24,7 +25,7 @@ auto logFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, con
                                                }
                                                std::cout << "\n" << std::flush;
                                                return jspp::AnyValue::make_undefined(); }, "log");
-auto warnFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto warnFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                             {
                                                 std::cerr << "\033[33m";
                                                 for (size_t i = 0; i < args.size(); ++i)
@@ -35,7 +36,7 @@ auto warnFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, co
                                                 }
                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
                                                 return jspp::AnyValue::make_undefined(); }, "warn");
-auto errorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto errorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                              {
                                                  std::cerr << "\033[31m";
                                                  for (size_t i = 0; i < args.size(); ++i)
@@ -46,7 +47,7 @@ auto errorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, c
                                                  }
                                                  std::cerr << "\033[0m" << "\n" << std::flush; // reset
                                                  return jspp::AnyValue::make_undefined(); }, "error");
-auto timeFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto timeFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                             {
                                                 auto start = std::chrono::steady_clock::now(); // capture immediately
                                                 auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
@@ -83,7 +84,7 @@ static auto format_duration = [](double ms) -> std::string
     return ss.str();
 };
 
-auto timeEndFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
+auto timeEndFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args)
                                                {
                                                    auto end = std::chrono::steady_clock::now(); // capture immediately
                                                    auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";