@ugo-studio/jspp 0.1.3 → 0.1.4

package/src/prelude/values/promise.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "types.hpp"
+#include <vector>
+#include <functional>
+#include <memory>
+#include <variant>
+#include <coroutine>
+#include <unordered_map>
+#include <string>
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    enum class PromiseStatus { Pending, Fulfilled, Rejected };
+
+    struct PromiseState
+    {
+        PromiseStatus status = PromiseStatus::Pending;
+        std::shared_ptr<AnyValue> result; // Value if fulfilled, reason if rejected
+        std::vector<std::function<void(AnyValue)>> onFulfilled;
+        std::vector<std::function<void(AnyValue)>> onRejected;
+        
+        PromiseState(); // Defined in helpers
+    };
+
+    struct JsPromisePromiseType; // Forward declaration
+
+    struct JsPromise
+    {
+        using promise_type = JsPromisePromiseType;
+
+        std::shared_ptr<PromiseState> state;
+        std::unordered_map<std::string, AnyValue> props;
+
+        JsPromise();
+
+        // --- Promise Logic ---
+        void resolve(const AnyValue& value);
+        void reject(const AnyValue& reason);
+        void then(std::function<void(AnyValue)> onFulfilled, std::function<void(AnyValue)> onRejected = nullptr);
+        
+        // --- Methods ---
+        std::string to_std_string() const;
+        AnyValue get_property(const std::string& key, const AnyValue& thisVal);
+        AnyValue set_property(const std::string& key, const AnyValue& value, const AnyValue& thisVal);
+    };
+
+    struct JsPromisePromiseType {
+        JsPromise promise;
+
+        JsPromise get_return_object() { return promise; }
+        std::suspend_never initial_suspend() { return {}; }
+        std::suspend_never final_suspend() noexcept { return {}; }
+        
+        void return_value(const AnyValue& val);
+        
+        void unhandled_exception();
+        
+        // await_transform for AnyValue
+        auto await_transform(const AnyValue& value);
+    };
+    
+    // Awaiter for AnyValue
+    struct AnyValueAwaiter {
+        const AnyValue& value; // Reference to the value being awaited
+        bool await_ready();
+        void await_suspend(std::coroutine_handle<> h);
+        AnyValue await_resume();
+    };
+}

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

@@ -3,8 +3,8 @@
 #include "types.hpp"
 #include "values/array.hpp"
 #include "any_value.hpp"
-#include "error.hpp"
-#include "operators.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
 #include <algorithm>
 #include <vector>
 
@@ -15,9 +15,9 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsArray *self)
         {
             // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toString->key)
+            if (key == "toString" )
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &_) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }
@@ -25,7 +25,7 @@ namespace jspp
             // --- [Symbol.iterator]() method ---
             if (key == WellKnownSymbols::iterator->key)
             {
-                return AnyValue::make_generator([self](const std::vector<AnyValue> &_) -> AnyValue
+                return AnyValue::make_generator([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
                                                 { return AnyValue::from_iterator(self->get_iterator()); },
                                                 key);
             }
@@ -33,12 +33,12 @@ namespace jspp
             // --- length property ---
             if (key == "length")
             {
-                auto getter = [self](const std::vector<AnyValue> &args) -> AnyValue
+                auto getter = [self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                 {
                     return AnyValue::make_number(self->length);
                 };
 
-                auto setter = [self](const std::vector<AnyValue> &args) -> AnyValue
+                auto setter = [self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                 {
                     if (args.empty())
                     {
@@ -50,7 +50,7 @@ namespace jspp
 
                     if (new_len_double < 0 || std::isnan(new_len_double) || std::isinf(new_len_double) || new_len_double != static_cast<uint64_t>(new_len_double))
                     {
-                        throw RuntimeError::make_error("Invalid array length", "RangeError");
+                        throw Exception::make_exception("Invalid array length", "RangeError");
                     }
                     uint64_t new_len = static_cast<uint64_t>(new_len_double);
 
@@ -86,7 +86,7 @@ namespace jspp
             // --- push() method ---
             if (key == "push")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            for (const auto &arg : args)
                                                                                            {
@@ -99,7 +99,7 @@ namespace jspp
             // --- pop() method ---
             if (key == "pop")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (self->length == 0)
                                                                                            {
@@ -124,7 +124,7 @@ namespace jspp
             // --- shift() method ---
             if (key == "shift")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (self->length == 0)
                                                                                            {
@@ -155,7 +155,7 @@ namespace jspp
             // --- unshift() method ---
             if (key == "unshift")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                              size_t args_count = args.size();
                                                                                              if (args_count == 0)
@@ -182,7 +182,7 @@ namespace jspp
             // --- join() method ---
             if (key == "join")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            std::string sep = ",";
                                                                                            if (!args.empty() && !args[0].is_undefined())
@@ -210,11 +210,11 @@ namespace jspp
             // --- forEach() method ---
             if (key == "forEach")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                                                                                            if (args.empty() || !args[0].is_function())
                                                                                            {
-                                                                                               throw RuntimeError::make_error("callback is not a function", "TypeError");
+                                                                                               throw Exception::make_exception("callback is not a function", "TypeError");
                                                                                            }
                                                                                            auto callback = args[0].as_function();
                                                                                            for (uint64_t i = 0; i < self->length; ++i)
@@ -222,7 +222,7 @@ namespace jspp
                                                                                                AnyValue val = self->get_property(static_cast<uint32_t>(i));
                                                                                                if (!val.is_undefined())
                                                                                                { // forEach skips empty slots
-                                                                                                   callback->call({val, AnyValue::make_number(i)});
+                                                                                                   callback->call(thisVal, {val, AnyValue::make_number(i)});
                                                                                                }
                                                                                            }
                                                                                            return AnyValue::make_undefined(); },

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

@@ -3,8 +3,8 @@
 #include "types.hpp"
 #include "values/function.hpp"
 #include "any_value.hpp"
-#include "error.hpp"
-#include "operators.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
 
 namespace jspp
 {
@@ -13,9 +13,9 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsFunction *self)
         {
             // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toString->key)
+            if (key == "toString" )
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &_) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }

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

@@ -3,8 +3,8 @@
 #include "types.hpp"
 #include "values/iterator.hpp"
 #include "any_value.hpp"
-#include "error.hpp"
-#include "operators.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
 
 namespace jspp
 {
@@ -13,17 +13,17 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self)
         {
             // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toString->key)
+            if (key == "toString" )
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }
             // --- [Symbol.iterator]() method ---
             if (key == WellKnownSymbols::iterator->key)
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
-                                               {
+                return AnyValue::make_generator([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                                                {
                                                    // An iterator's iterator is itself.
                                                    // We need to return an AnyValue that holds a shared_ptr to this JsIterator.
                                                    // Since we only have a raw pointer `self`, we can't directly make a new shared_ptr.
@@ -32,21 +32,22 @@ namespace jspp
                                                    // A better solution might involve passing a shared_ptr to `self` into the prototype getters.
                                                    // For now, let's assume the object containing the iterator is alive.
                                                    return AnyValue::from_iterator_ref(self); },
-                                               key);
+                                                key);
             }
             // --- next() method ---
             if (key == "next")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
-                                                auto res = self->next();
+                                                AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
+                                                auto res = self->next(val);
                                                 return AnyValue::make_object({{"value",res.value.value_or(AnyValue::make_undefined())},{"done",AnyValue::make_boolean(res.done)},}); },
                                                key);
             }
             // --- toArray() method ---
             if (key == "toArray")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
                                                { return AnyValue::make_array(self->to_vector()); },
                                                key);
             }

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/object.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp
+{
+    namespace ObjectPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsObject *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" )
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &_) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

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

@@ -0,0 +1,124 @@
+#pragma once
+
+#include "types.hpp"
+#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 {
+                    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();
+                    
+                    // "then" returns a new Promise
+                    JsPromise newPromise; 
+                    AnyValue newPromiseVal = AnyValue::make_promise(newPromise);
+                    
+                    // Capture shared pointer to the new promise's state to keep it alive and modify it
+                    auto newPromiseState = newPromise.state; 
+                    // Helper wrapper to interact with state
+                    auto resolveNew = [newPromiseState](const AnyValue& v) {
+                        JsPromise p; p.state = newPromiseState;
+                        p.resolve(v);
+                    };
+                    auto rejectNew = [newPromiseState](const AnyValue& r) {
+                        JsPromise p; p.state = newPromiseState;
+                        p.reject(r);
+                    };
+
+
+                    // Resolve handler
+                    auto resolveHandler = [resolveNew, rejectNew, onFulfilled](AnyValue val) mutable {
+                        if (onFulfilled.is_function()) {
+                            try {
+                                auto res = onFulfilled.as_function()->call(AnyValue::make_undefined(), {val});
+                                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); }
+                                    );
+                                } else {
+                                    resolveNew(res);
+                                }
+                            } catch (const Exception& e) {
+                                rejectNew(*e.data);
+                            } catch (...) {
+                                rejectNew(AnyValue::make_string("Unknown error"));
+                            }
+                        } else {
+                            resolveNew(val); // Fallthrough
+                        }
+                    };
+
+                    // Reject handler
+                    auto rejectHandler = [resolveNew, rejectNew, onRejected](AnyValue reason) mutable {
+                         if (onRejected.is_function()) {
+                            try {
+                                auto res = onRejected.as_function()->call(AnyValue::make_undefined(), {reason});
+                                if (res.is_promise()) {
+                                    auto chained = res.as_promise();
+                                    chained->then(
+                                        [resolveNew](AnyValue v) { resolveNew(v); },
+                                        [rejectNew](AnyValue e) { rejectNew(e); }
+                                    );
+                                } else {
+                                    resolveNew(res); // Recovered
+                                }
+                            } catch (const Exception& e) {
+                                rejectNew(*e.data);
+                            } catch (...) {
+                                rejectNew(AnyValue::make_string("Unknown error"));
+                            }
+                        } else {
+                            rejectNew(reason); // Fallthrough
+                        }
+                    };
+
+                    self->then(resolveHandler, rejectHandler);
+                    return newPromiseVal;
+                }, "then");
+            }
+
+            if (key == "catch") {
+                 return AnyValue::make_function([self](const AnyValue& thisVal, const std::vector<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");
+            }
+
+            if (key == "finally") {
+                return AnyValue::make_function([self](const AnyValue& thisVal, const std::vector<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 {
+                            AnyValue val = args.empty() ? AnyValue::make_undefined() : args[0];
+                            if (onFinally.is_function()) {
+                                onFinally.as_function()->call(AnyValue::make_undefined(), {});
+                            }
+                            return val;
+                        }, ""),
+                        AnyValue::make_function([onFinally](const AnyValue&, const std::vector<AnyValue>& args) -> AnyValue {
+                            AnyValue reason = args.empty() ? AnyValue::make_undefined() : args[0];
+                            if (onFinally.is_function()) {
+                                onFinally.as_function()->call(AnyValue::make_undefined(), {});
+                            }
+                            throw Exception(reason);
+                        }, "")
+                    });
+                }, "finally");
+            }
+            
+            return std::nullopt;
+        }
+    }
+}

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

@@ -3,7 +3,7 @@
 #include "types.hpp"
 #include "values/string.hpp" // Make sure this is included
 #include "any_value.hpp"
-#include "operators.hpp"
+#include "utils/operators.hpp"
 #include <optional>
 #include <string>
 #include <vector>
@@ -19,9 +19,9 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsString *self)
         {
             // --- toString() & valueOf() ---
-            if (key == "toString" || key == WellKnownSymbols::toString->key || key == "valueOf")
+            if (key == "toString"  || key == "valueOf")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &_) -> AnyValue
+                return AnyValue::make_generator([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue>) -> AnyValue
+                return AnyValue::make_accessor_descriptor([self](const AnyValue &thisVal, const std::vector<AnyValue>) -> AnyValue
                                                           { return AnyValue::make_number(self->value.length()); },
-                                                          [self](const std::vector<AnyValue>) -> AnyValue
+                                                          [self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                     int len = self->value.length();
                     int start = args.empty() ? 0 : Operators_Private::ToInt32(args[0]);
@@ -242,7 +242,7 @@ namespace jspp
             // --- split(separator) ---
             if (key == "split")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                     std::string separator = (args.empty() || args[0].is_undefined()) ? "" : args[0].to_std_string();
                     std::vector<std::optional<AnyValue>> result_vec;
@@ -267,7 +267,7 @@ namespace jspp
             // --- startsWith(searchString, position) ---
             if (key == "startsWith")
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<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 std::vector<AnyValue> &args) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
                                                {
                     const char* whitespace = " \t\n\r\f\v";
                     std::string result = self->value;