@ugo-studio/jspp 0.1.4 → 0.1.6

package/src/prelude/values/prototypes/async_iterator.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/async_iterator.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp
+{
+    namespace AsyncIteratorPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsAsyncIterator<AnyValue> *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+            // --- [Symbol.asyncIterator]() method ---
+            // For async iterators, the async iterator is itself (similar to sync iterators)
+            if (key == WellKnownSymbols::asyncIterator->key)
+            {
+                // We return 'this'. Since we can't easily create a shared_ptr from raw pointer,
+                // we rely on the context to hold the reference or implement better shared_from_this strategy.
+                // For now, assume it works like Iterator.
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                               { 
+                                                    // This is slightly dangerous as we create a new shared_ptr from raw.
+                                                    // TODO: fix lifetime management
+                                                    return thisVal; },
+                                               key);
+            }
+            // --- next() method ---
+            if (key == "next")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                               {
+                                                AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
+                                                auto res = self->next(val);
+                                                return AnyValue::make_promise(res); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

package/src/prelude/values/prototypes/function.hpp

@@ -13,9 +13,9 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsFunction *self)
         {
             // --- toString() method ---
-            if (key == "toString" )
+            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }

package/src/prelude/values/prototypes/iterator.hpp

@@ -13,16 +13,16 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self)
         {
             // --- toString() method ---
-            if (key == "toString" )
+            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }
             // --- [Symbol.iterator]() method ---
             if (key == WellKnownSymbols::iterator->key)
             {
-                return AnyValue::make_generator([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                return AnyValue::make_generator([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
                                                 {
                                                    // An iterator's iterator is itself.
                                                    // We need to return an AnyValue that holds a shared_ptr to this JsIterator.
@@ -37,7 +37,7 @@ namespace jspp
             // --- next() method ---
             if (key == "next")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                                                 AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
                                                 auto res = self->next(val);
@@ -47,7 +47,7 @@ namespace jspp
             // --- toArray() method ---
             if (key == "toArray")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
                                                { return AnyValue::make_array(self->to_vector()); },
                                                key);
             }

package/src/prelude/values/prototypes/number.hpp

@@ -0,0 +1,153 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
+#include <string>
+#include <vector>
+#include <iomanip>
+#include <sstream>
+#include <cmath>
+#include <algorithm>
+
+namespace jspp
+{
+    namespace NumberPrototypes
+    {
+        // Helper for radix conversion
+        inline std::string number_to_radix_string(double value, int radix)
+        {
+            if (std::isnan(value))
+                return "NaN";
+            if (!std::isfinite(value))
+                return value > 0 ? "Infinity" : "-Infinity";
+
+            // For radix != 10, we only support integer part for now
+            // as implementing full float-to-radix is complex.
+            long long intPart = static_cast<long long>(value);
+
+            if (radix == 10)
+            {
+                return AnyValue::make_number(value).to_std_string();
+            }
+
+            bool negative = intPart < 0;
+            if (negative)
+                intPart = -intPart;
+
+            std::string chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+            std::string res = "";
+
+            if (intPart == 0)
+                res = "0";
+            else
+            {
+                while (intPart > 0)
+                {
+                    res += chars[intPart % radix];
+                    intPart /= radix;
+                }
+            }
+            if (negative)
+                res += "-";
+            std::reverse(res.begin(), res.end());
+            return res;
+        }
+
+        inline std::optional<AnyValue> get(const std::string &key, double self)
+        {
+            // --- toExponential(fractionDigits) ---
+            if (key == "toExponential")
+            {
+                return AnyValue::make_function([self](const AnyValue &, std::span<const AnyValue> args) -> AnyValue
+                                               {
+                    int digits = -1;
+                    if (!args.empty() && !args[0].is_undefined()) {
+                        digits = Operators_Private::ToInt32(args[0]);
+                        if (digits < 0 || digits > 100) {
+                            throw Exception::make_exception("toExponential() digits argument must be between 0 and 100", "RangeError");
+                        }
+                    }
+
+                    std::ostringstream ss;
+                    if (digits >= 0) {
+                        ss << std::scientific << std::setprecision(digits) << self;
+                    } else {
+                        ss << std::scientific << self;
+                    }
+                    
+                    std::string res = ss.str();
+                    return AnyValue::make_string(res); }, "toExponential");
+            }
+
+            // --- toFixed(digits) ---
+            if (key == "toFixed")
+            {
+                return AnyValue::make_function([self](const AnyValue &, std::span<const AnyValue> args) -> AnyValue
+                                               {
+                    int digits = 0;
+                    if (!args.empty() && !args[0].is_undefined()) {
+                        digits = Operators_Private::ToInt32(args[0]);
+                    }
+                    if (digits < 0 || digits > 100) {
+                        throw Exception::make_exception("toFixed() digits argument must be between 0 and 100", "RangeError");
+                    }
+
+                    std::ostringstream ss;
+                    ss << std::fixed << std::setprecision(digits) << self;
+                    return AnyValue::make_string(ss.str()); }, "toFixed");
+            }
+
+            // --- toPrecision(precision) ---
+            if (key == "toPrecision")
+            {
+                return AnyValue::make_function([self](const AnyValue &, std::span<const AnyValue> args) -> AnyValue
+                                               {
+                    if (args.empty() || args[0].is_undefined()) {
+                        return AnyValue::make_number(self).get_own_property("toString").call(AnyValue::make_number(self), {}, "toString");
+                    }
+                    int precision = Operators_Private::ToInt32(args[0]);
+                    if (precision < 1 || precision > 100) {
+                        throw Exception::make_exception("toPrecision() precision argument must be between 1 and 100", "RangeError");
+                    }
+
+                    std::ostringstream ss;
+                    ss << std::setprecision(precision) << self;
+                    return AnyValue::make_string(ss.str()); }, "toPrecision");
+            }
+
+            // --- toString(radix) ---
+            if (key == "toString")
+            {
+                return AnyValue::make_function([self](const AnyValue &, std::span<const AnyValue> args) -> AnyValue
+                                               {
+                    int radix = 10;
+                    if (!args.empty() && !args[0].is_undefined()) {
+                        radix = Operators_Private::ToInt32(args[0]);
+                    }
+                    if (radix < 2 || radix > 36) {
+                        throw Exception::make_exception("toString() radix argument must be between 2 and 36", "RangeError");
+                    }
+                    
+                    return AnyValue::make_string(number_to_radix_string(self, radix)); }, "toString");
+            }
+
+            // --- valueOf() ---
+            if (key == "valueOf")
+            {
+                return AnyValue::make_function([self](const AnyValue &, std::span<const AnyValue>) -> AnyValue
+                                               { return AnyValue::make_number(self); }, "valueOf");
+            }
+
+            // --- toLocaleString() ---
+            if (key == "toLocaleString")
+            {
+                return AnyValue::make_function([self](const AnyValue &, std::span<const AnyValue>) -> AnyValue
+                                               { return AnyValue::make_string(AnyValue::make_number(self).to_std_string()); }, "toLocaleString");
+            }
+
+            return std::nullopt;
+        }
+    }
+}

package/src/prelude/values/prototypes/object.hpp

@@ -13,9 +13,9 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsObject *self)
         {
             // --- toString() method ---
-            if (key == "toString" )
+            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }

package/src/prelude/values/prototypes/promise.hpp

@@ -4,12 +4,17 @@
 #include "values/promise.hpp"
 #include "any_value.hpp"
 
-namespace jspp {
-    namespace PromisePrototypes {
-        inline std::optional<AnyValue> get(const std::string& key, JsPromise* self) {
-            
-            if (key == "then") {
-                return AnyValue::make_function([self](const AnyValue& thisVal, const std::vector<AnyValue>& args) -> AnyValue {
+namespace jspp
+{
+    namespace PromisePrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsPromise *self)
+        {
+
+            if (key == "then")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                               {
                     AnyValue onFulfilled = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
                     AnyValue onRejected = (args.size() > 1 && args[1].is_function()) ? args[1] : AnyValue::make_undefined();
                     
@@ -31,16 +36,17 @@ namespace jspp {
 
 
                     // Resolve handler
-                    auto resolveHandler = [resolveNew, rejectNew, onFulfilled](AnyValue val) mutable {
+                    auto resolveHandler = [resolveNew, rejectNew, onFulfilled](const AnyValue& val) mutable {
                         if (onFulfilled.is_function()) {
                             try {
-                                auto res = onFulfilled.as_function()->call(AnyValue::make_undefined(), {val});
+                                const AnyValue cbArgs[] = {val};
+                                auto res = onFulfilled.call(AnyValue::make_undefined(), cbArgs, "onFulfilled");
                                 if (res.is_promise()) {
                                     // Chaining: newPromise follows res
                                     auto chained = res.as_promise();
                                     chained->then(
-                                        [resolveNew](AnyValue v) { resolveNew(v); },
-                                        [rejectNew](AnyValue e) { rejectNew(e); }
+                                        [resolveNew](const AnyValue& v) { resolveNew(v); },
+                                        [rejectNew](const AnyValue& e) { rejectNew(e); }
                                     );
                                 } else {
                                     resolveNew(res);
@@ -56,15 +62,16 @@ namespace jspp {
                     };
 
                     // Reject handler
-                    auto rejectHandler = [resolveNew, rejectNew, onRejected](AnyValue reason) mutable {
+                    auto rejectHandler = [resolveNew, rejectNew, onRejected](const AnyValue& reason) mutable {
                          if (onRejected.is_function()) {
                             try {
-                                auto res = onRejected.as_function()->call(AnyValue::make_undefined(), {reason});
+                                const AnyValue cbArgs[] = {reason};
+                                auto res = onRejected.call(AnyValue::make_undefined(), cbArgs,"onRejected");
                                 if (res.is_promise()) {
                                     auto chained = res.as_promise();
                                     chained->then(
-                                        [resolveNew](AnyValue v) { resolveNew(v); },
-                                        [rejectNew](AnyValue e) { rejectNew(e); }
+                                        [resolveNew](const AnyValue& v) { resolveNew(v); },
+                                        [rejectNew](const AnyValue& e) { rejectNew(e); }
                                     );
                                 } else {
                                     resolveNew(res); // Recovered
@@ -80,44 +87,47 @@ namespace jspp {
                     };
 
                     self->then(resolveHandler, rejectHandler);
-                    return newPromiseVal;
-                }, "then");
+                    return newPromiseVal; }, "then");
             }
 
-            if (key == "catch") {
-                 return AnyValue::make_function([self](const AnyValue& thisVal, const std::vector<AnyValue>& args) -> AnyValue {
+            if (key == "catch")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                               {
                     // catch(onRejected) is then(undefined, onRejected)
                     AnyValue onRejected = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
-                    return thisVal.get_own_property("then").as_function()->call(thisVal, {AnyValue::make_undefined(), onRejected});
-                 }, "catch");
+                    const AnyValue thenArgs[] = {AnyValue::make_undefined(), onRejected};
+                    return thisVal.get_own_property("then").call(thisVal, thenArgs,"then"); }, "catch");
             }
 
-            if (key == "finally") {
-                return AnyValue::make_function([self](const AnyValue& thisVal, const std::vector<AnyValue>& args) -> AnyValue {
+            if (key == "finally")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                               {
                     AnyValue onFinally = (args.size() > 0 && args[0].is_function()) ? args[0] : AnyValue::make_undefined();
                     
                     // finally(onFinally) returns a promise that passes through value/reason, 
                     // but executes onFinally first.
                     
-                    return thisVal.get_own_property("then").as_function()->call(thisVal, {
-                        AnyValue::make_function([onFinally](const AnyValue&, const std::vector<AnyValue>& args) -> AnyValue {
+                    const AnyValue thenArgs[] = {
+                        AnyValue::make_function([onFinally](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
                             AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
                             if (onFinally.is_function()) {
-                                onFinally.as_function()->call(AnyValue::make_undefined(), {});
+                                onFinally.call(AnyValue::make_undefined(), {}, "onFinally");
                             }
                             return val;
                         }, ""),
-                        AnyValue::make_function([onFinally](const AnyValue&, const std::vector<AnyValue>& args) -> AnyValue {
+                        AnyValue::make_function([onFinally](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
                             AnyValue reason = args.empty() ? AnyValue::make_undefined() : args[0];
                             if (onFinally.is_function()) {
-                                onFinally.as_function()->call(AnyValue::make_undefined(), {});
+                                onFinally.call(AnyValue::make_undefined(), {}, "onFinally");
                             }
                             throw Exception(reason);
                         }, "")
-                    });
-                }, "finally");
+                    };
+                    return thisVal.get_own_property("then").call(thisVal, thenArgs,"then"); }, "finally");
             }
-            
+
             return std::nullopt;
         }
     }

package/src/prelude/values/prototypes/string.hpp

@@ -19,9 +19,9 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsString *self)
         {
             // --- toString() & valueOf() ---
-            if (key == "toString"  || key == "valueOf")
+            if (key == "toString"  || key == "valueOf" || key == WellKnownSymbols::toStringTag->key)
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                { return AnyValue::make_string(self->value); },
                                                key);
             }
@@ -29,7 +29,7 @@ namespace jspp
             // --- [Symbol.iterator]() method ---
             if (key == WellKnownSymbols::iterator->key)
             {
-                return AnyValue::make_generator([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
+                return AnyValue::make_generator([self](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
                                                 { return AnyValue::from_iterator(self->get_iterator()); },
                                                 key);
             }
@@ -37,9 +37,9 @@ namespace jspp
             // --- length property ---
             if (key == "length")
             {
-                return AnyValue::make_accessor_descriptor([self](const AnyValue &thisVal, const std::vector<AnyValue>) -> AnyValue
+                return AnyValue::make_accessor_descriptor([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
                                                           { return AnyValue::make_number(self->value.length()); },
-                                                          [self](const AnyValue &thisVal, const std::vector<AnyValue>) -> AnyValue
+                                                          [self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
                                                           { return AnyValue::make_undefined(); },
                                                           false,
                                                           false);
@@ -48,7 +48,7 @@ namespace jspp
             // --- charAt(pos) ---
             if (key == "charAt")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     double pos = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
                     int index = static_cast<int>(pos);
@@ -62,7 +62,7 @@ namespace jspp
             // --- concat(str1, str2, ...) ---
             if (key == "concat")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     std::string result = self->value;
                     for (const auto& arg : args)
@@ -76,7 +76,7 @@ namespace jspp
             // --- endsWith(searchString, endPosition) ---
             if (key == "endsWith")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     if(args.empty()) return AnyValue::make_boolean(false);
                     std::string search = args[0].to_std_string();
@@ -92,7 +92,7 @@ namespace jspp
             // --- includes(searchString, position) ---
             if (key == "includes")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     if(args.empty()) return AnyValue::make_boolean(false);
                     std::string search = args[0].to_std_string();
@@ -105,7 +105,7 @@ namespace jspp
             // --- indexOf(searchString, position) ---
             if (key == "indexOf")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     if (args.empty()) return AnyValue::make_number(-1);
                     std::string search = args[0].to_std_string();
@@ -118,7 +118,7 @@ namespace jspp
             // --- lastIndexOf(searchString, position) ---
             if (key == "lastIndexOf")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     if (args.empty()) return AnyValue::make_number(-1);
                     std::string search = args[0].to_std_string();
@@ -131,7 +131,7 @@ namespace jspp
             // --- padEnd(targetLength, padString) ---
             if (key == "padEnd")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     size_t target_length = args.empty() ? 0 : static_cast<size_t>(Operators_Private::ToNumber(args[0]));
                     if (self->value.length() >= target_length) return AnyValue::make_string(self->value);
@@ -148,7 +148,7 @@ namespace jspp
             // --- padStart(targetLength, padString) ---
             if (key == "padStart")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     size_t target_length = args.empty() ? 0 : static_cast<size_t>(Operators_Private::ToNumber(args[0]));
                     if (self->value.length() >= target_length) return AnyValue::make_string(self->value);
@@ -165,7 +165,7 @@ namespace jspp
             // --- repeat(count) ---
             if (key == "repeat")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     double count = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
                     if (count < 0) {
@@ -184,7 +184,7 @@ namespace jspp
             // --- replace(substr, newSubstr) ---
             if (key == "replace")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     if (args.size() < 2) return AnyValue::make_string(self->value);
                     std::string search = args[0].to_std_string();
@@ -202,7 +202,7 @@ namespace jspp
             // --- replaceAll(substr, newSubstr) ---
             if (key == "replaceAll")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     if (args.size() < 2) return AnyValue::make_string(self->value);
                     std::string search = args[0].to_std_string();
@@ -222,7 +222,7 @@ namespace jspp
             // --- slice(beginIndex, endIndex) ---
             if (key == "slice")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     int len = self->value.length();
                     int start = args.empty() ? 0 : Operators_Private::ToInt32(args[0]);
@@ -242,10 +242,10 @@ namespace jspp
             // --- split(separator) ---
             if (key == "split")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     std::string separator = (args.empty() || args[0].is_undefined()) ? "" : args[0].to_std_string();
-                    std::vector<std::optional<AnyValue>> result_vec;
+                    std::vector<jspp::AnyValue> result_vec;
                     
                     if (separator.empty()) {
                         for (char c : (self->value)) {
@@ -260,14 +260,14 @@ namespace jspp
                         }
                         result_vec.push_back(AnyValue::make_string(temp));
                     }
-                    return AnyValue::make_array(result_vec); },
+                    return AnyValue::make_array(std::move(result_vec)); },
                                                key);
             }
 
             // --- startsWith(searchString, position) ---
             if (key == "startsWith")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     if(args.empty()) return AnyValue::make_boolean(false);
                     std::string search = args[0].to_std_string();
@@ -281,7 +281,7 @@ namespace jspp
             // --- substring(indexStart, indexEnd) ---
             if (key == "substring")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     int len = self->value.length();
                     int start = args.empty() ? 0 : Operators_Private::ToInt32(args[0]);
@@ -302,7 +302,7 @@ namespace jspp
             // --- toLowerCase() ---
             if (key == "toLowerCase")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     std::string result = self->value;
                     std::transform(result.begin(), result.end(), result.begin(),
@@ -314,7 +314,7 @@ namespace jspp
             // --- toUpperCase() ---
             if (key == "toUpperCase")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     std::string result = self->value;
                     std::transform(result.begin(), result.end(), result.begin(),
@@ -326,7 +326,7 @@ namespace jspp
             // --- trim() ---
             if (key == "trim")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     const char* whitespace = " \t\n\r\f\v";
                     std::string result = self->value;
@@ -339,7 +339,7 @@ namespace jspp
             // --- trimEnd() ---
             if (key == "trimEnd")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     const char* whitespace = " \t\n\r\f\v";
                     std::string result = self->value;
@@ -351,7 +351,7 @@ namespace jspp
             // --- trimStart() ---
             if (key == "trimStart")
             {
-                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                                                {
                     const char* whitespace = " \t\n\r\f\v";
                     std::string result = self->value;
@@ -363,4 +363,4 @@ namespace jspp
             return std::nullopt;
         }
     }
-}
+}