@ugo-studio/jspp 0.1.3 → 0.1.5

package/src/prelude/library/promise.hpp

@@ -0,0 +1,131 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/promise.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+
+inline auto Promise = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                    {
+                                                        if (args.empty() || !args[0].is_function())
+                                                        {
+                                                            throw jspp::Exception::make_exception("Promise resolver undefined is not a function", "TypeError");
+                                                        }
+                                                        auto executor = args[0].as_function();
+
+                                                        jspp::JsPromise promise;
+                                                        auto state = promise.state; // Share state
+
+                                                        // resolve function
+                                                        auto resolveFn = jspp::AnyValue::make_function([state](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                       {
+        jspp::JsPromise p; p.state = state;
+        p.resolve(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+        return jspp::AnyValue::make_undefined(); }, "resolve");
+
+                                                        // reject function
+                                                        auto rejectFn = jspp::AnyValue::make_function([state](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                      {
+        jspp::JsPromise p; p.state = state;
+        p.reject(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+        return jspp::AnyValue::make_undefined(); }, "reject");
+
+                                                        try
+                                                        {
+                                                            const jspp::AnyValue executorArgs[] = {resolveFn, rejectFn};
+                                                            executor->call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(executorArgs, 2));
+                                                        }
+                                                        catch (const jspp::Exception &e)
+                                                        {
+                                                            promise.reject(*e.data);
+                                                        }
+                                                        catch (...)
+                                                        {
+                                                            promise.reject(jspp::AnyValue::make_string("Unknown error during Promise execution"));
+                                                        }
+
+                                                        return jspp::AnyValue::make_promise(promise); },
+                                                    "Promise");
+
+struct PromiseInit
+{
+    PromiseInit()
+    {
+        // Promise.resolve(value)
+        Promise.define_data_property("resolve", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                              {
+            jspp::JsPromise p;
+            p.resolve(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+            return jspp::AnyValue::make_promise(p); }, "resolve"));
+
+        // Promise.reject(reason)
+        Promise.define_data_property("reject", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                             {
+            jspp::JsPromise p;
+            p.reject(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+            return jspp::AnyValue::make_promise(p); }, "reject"));
+
+        // Promise.all(iterable)
+        Promise.define_data_property("all", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                          {
+             // Basic implementation for arrays
+             if (args.empty() || !args[0].is_array()) {
+                  // If not array, reject? Or treat as non-iterable?
+                  // Should throw TypeError if not iterable. For now assume array.
+                  // If empty array, return resolved empty array.
+                  // TODO: Strict iterable check
+             }
+             
+             // Handle non-array iterable or empty args
+             if (args.empty() || !args[0].is_array()) {
+                 jspp::JsPromise p; p.reject(jspp::AnyValue::make_string("Promise.all argument must be an array"));
+                 return jspp::AnyValue::make_promise(p);
+             }
+
+             auto arr = args[0].as_array();
+             size_t len = static_cast<size_t>(arr->length);
+             if (len == 0) {
+                 jspp::JsPromise p; p.resolve(jspp::AnyValue::make_array(std::vector<jspp::AnyValue>()));
+                 return jspp::AnyValue::make_promise(p);
+             }
+
+             jspp::JsPromise masterPromise;
+             auto masterState = masterPromise.state;
+             
+             auto results = std::make_shared<std::vector<jspp::AnyValue>>(len, jspp::Constants::UNDEFINED);
+             auto count = std::make_shared<size_t>(len);
+             
+             // Check if already rejected to avoid further processing
+             auto rejected = std::make_shared<bool>(false);
+
+             for (size_t i = 0; i < len; ++i) {
+                 jspp::AnyValue item = arr->get_property(static_cast<uint32_t>(i));
+                 
+                 auto handleResult = [masterState, results, count, i, rejected](const jspp::AnyValue& res) {
+                      if (*rejected) return;
+                      (*results)[i] = res;
+                      (*count)--;
+                      if (*count == 0) {
+                          jspp::JsPromise p; p.state = masterState;
+                          p.resolve(jspp::AnyValue::make_array(std::move(*results))); 
+                      }
+                 };
+                 
+                 auto handleReject = [masterState, rejected](const jspp::AnyValue& reason) {
+                      if (*rejected) return;
+                      *rejected = true;
+                      jspp::JsPromise p; p.state = masterState;
+                      masterState->status =jspp::PromiseStatus::Rejected; // ensure master state updated
+                      p.reject(reason);
+                 };
+
+                 if (item.is_promise()) {
+                     item.as_promise()->then(handleResult, handleReject);
+                 } else {
+                     handleResult(item);
+                 }
+             }
+             
+             return jspp::AnyValue::make_promise(masterPromise); }, "all"));
+    }
+} promiseInit;

package/src/prelude/library/symbol.hpp

@@ -1,65 +1,52 @@
 #pragma once
 
 #include "types.hpp"
-#include "well_known_symbols.hpp"
-
+#include "utils/well_known_symbols.hpp"
 #include "values/object.hpp"
 #include "any_value.hpp"
 
-inline auto Symbol = jspp::AnyValue::make_object({
-    {"iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator)},
-    {"toString", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toString)},
-});
-
-// #pragma once
-
-// #include "types.hpp"
-// #include "well_known_symbols.hpp"
-// #include "values/object.hpp"
-// #include "any_value.hpp"
-
-// // We define the Symbol constructor function
-// inline auto symbolConstructor = [](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
-//     std::string desc = "";
-//     if (!args.empty() && !args[0].is_undefined()) {
-//         desc = args[0].to_std_string();
-//     }
-//     return jspp::AnyValue::make_symbol(desc);
-// };
-
-// inline auto Symbol = jspp::AnyValue::make_function(symbolConstructor, "Symbol");
-
-// // Implementation of Symbol.for(key)
-// inline auto forFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
-//     std::string key = "";
-//     if (!args.empty()) {
-//         key = args[0].to_std_string();
-//     }
-//     auto symPtr = jspp::JsSymbol::for_global(key);
-//     return jspp::AnyValue::from_symbol(symPtr);
-// }, "for");
-
-// // Implementation of Symbol.keyFor(sym)
-// inline auto keyForFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
-//     if (args.empty() || !args[0].is_symbol()) {
-//         throw jspp::RuntimeError::make_error("Symbol.keyFor requires a symbol argument", "TypeError");
-//     }
-
-//     jspp::JsSymbol* sym = args[0].as_symbol();
-//     auto result = jspp::JsSymbol::key_for(sym);
-
-//     if (result.has_value()) {
-//         return jspp::AnyValue::make_string(result.value());
-//     } else {
-//         return jspp::AnyValue::make_undefined();
-//     }
-// }, "keyFor");
-
-// // Attach static properties/methods to the Symbol object
-// struct SymbolInit {
-//     SymbolInit() {
-//         Symbol.set_own_property("iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator));
-//         Symbol.set_own_property("for", forFn);
-//         Symbol.set_own_property("keyFor", keyForFn);
-//     }
-// } symbolInit;
+// Define Symbol as a function
+inline auto Symbol = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                   {
+    std::string description = "";
+    if (!args.empty() && !args[0].is_undefined()) {
+        description = args[0].to_std_string();
+    }
+    return jspp::AnyValue::make_symbol(description); }, "Symbol", false);
+
+// Initialize Symbol properties
+struct SymbolInit
+{
+    SymbolInit()
+    {
+        // Static methods
+        Symbol.define_data_property("for", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                         {
+             std::string key = "";
+             if (!args.empty()) key = args[0].to_std_string();
+             return jspp::AnyValue::from_symbol(jspp::JsSymbol::for_global(key)); }, "for"));
+
+        Symbol.define_data_property("keyFor", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                            {
+             if (args.empty() || !args[0].is_symbol()) throw jspp::Exception::make_exception("Symbol.keyFor requires a symbol", "TypeError");
+             auto sym = args[0].as_symbol();
+             auto key = jspp::JsSymbol::key_for(sym);
+             if (key.has_value()) return jspp::AnyValue::make_string(key.value());
+             return jspp::AnyValue::make_undefined(); }, "keyFor"));
+
+        // Well-known symbols
+        Symbol.define_data_property("iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator), false, false, false);
+        Symbol.define_data_property("asyncIterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::asyncIterator), false, false, false);
+        Symbol.define_data_property("hasInstance", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::hasInstance), false, false, false);
+        Symbol.define_data_property("isConcatSpreadable", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::isConcatSpreadable), false, false, false);
+        Symbol.define_data_property("match", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::match), false, false, false);
+        Symbol.define_data_property("matchAll", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::matchAll), false, false, false);
+        Symbol.define_data_property("replace", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::replace), false, false, false);
+        Symbol.define_data_property("search", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::search), false, false, false);
+        Symbol.define_data_property("species", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), false, false, false);
+        Symbol.define_data_property("split", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::split), false, false, false);
+        Symbol.define_data_property("toPrimitive", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toPrimitive), false, false, false);
+        Symbol.define_data_property("toStringTag", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toStringTag), false, false, false);
+        Symbol.define_data_property("unscopables", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::unscopables), false, false, false);
+    }
+} symbolInit;

package/src/prelude/library/timer.hpp

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "scheduler.hpp"
+#include "values/function.hpp"
+#include "exception.hpp"
+
+// setTimeout(callback, delay, ...args)
+inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+    if (args.empty() || !args[0].is_function()) {
+        throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
+    }
+    
+    auto callback = args[0];
+    double delay = 0;
+    if (args.size() > 1 && args[1].is_number()) {
+        delay = args[1].as_double();
+    }
+    
+    // Capture arguments
+    std::vector<jspp::AnyValue> callArgs;
+    for (size_t i = 2; i < args.size(); ++i) {
+        callArgs.push_back(args[i]);
+    }
+
+    auto task = [callback, callArgs]() {
+         try {
+             callback.call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(callArgs));
+         } catch (const jspp::Exception& e) {
+             std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
+         } catch (const std::exception& e) {
+             std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
+         } catch (...) {
+             std::cerr << "Uncaught unknown exception in setTimeout\n";
+         }
+    };
+
+    size_t id = jspp::Scheduler::instance().set_timeout(task, static_cast<size_t>(delay));
+    return jspp::AnyValue::make_number(static_cast<double>(id));
+}, "setTimeout");
+
+// clearTimeout(id)
+inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+    if (!args.empty() && args[0].is_number()) {
+        size_t id = static_cast<size_t>(args[0].as_double());
+        jspp::Scheduler::instance().clear_timer(id);
+    }
+    return jspp::AnyValue::make_undefined();
+}, "clearTimeout");
+
+// setInterval(callback, delay, ...args)
+inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+    if (args.empty() || !args[0].is_function()) {
+        throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
+    }
+    
+    auto callback = args[0];
+    double delay = 0;
+    if (args.size() > 1 && args[1].is_number()) {
+        delay = args[1].as_double();
+    }
+    
+    std::vector<jspp::AnyValue> callArgs;
+    for (size_t i = 2; i < args.size(); ++i) {
+        callArgs.push_back(args[i]);
+    }
+
+    auto task = [callback, callArgs]() {
+         try {
+             callback.call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(callArgs));
+         } catch (const jspp::Exception& e) {
+             std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
+         } catch (const std::exception& e) {
+             std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
+         } catch (...) {
+             std::cerr << "Uncaught unknown exception in setInterval\n";
+         }
+    };
+
+    size_t id = jspp::Scheduler::instance().set_interval(task, static_cast<size_t>(delay));
+    return jspp::AnyValue::make_number(static_cast<double>(id));
+}, "setInterval");
+
+// clearInterval(id)
+inline auto clearInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+    if (!args.empty() && args[0].is_number()) {
+        size_t id = static_cast<size_t>(args[0].as_double());
+        jspp::Scheduler::instance().clear_timer(id);
+    }
+    return jspp::AnyValue::make_undefined();
+}, "clearInterval");

package/src/prelude/scheduler.hpp

@@ -0,0 +1,145 @@
+#pragma once
+#include <deque>
+#include <functional>
+#include <chrono>
+#include <queue>
+#include <unordered_set>
+#include <vector>
+#include <thread>
+#include <iostream>
+
+namespace jspp {
+    class Scheduler {
+    public:
+        using Task = std::function<void()>;
+        using TimePoint = std::chrono::steady_clock::time_point;
+        
+        struct Timer {
+            size_t id;
+            TimePoint next_run;
+            std::chrono::milliseconds interval; // 0 if not repeating
+            Task task;
+            
+            // Min-heap priority queue (smallest time at top)
+            bool operator>(const Timer& other) const {
+                return next_run > other.next_run;
+            }
+        };
+
+        static Scheduler& instance() {
+            static Scheduler s;
+            return s;
+        }
+
+        void enqueue(Task task) {
+            tasks.push_back(std::move(task));
+        }
+
+        size_t set_timeout(Task task, size_t delay_ms) {
+            return schedule_timer(std::move(task), delay_ms, false);
+        }
+
+        size_t set_interval(Task task, size_t delay_ms) {
+             return schedule_timer(std::move(task), delay_ms, true);
+        }
+        
+        void clear_timer(size_t id) {
+            cancelled_timers.insert(id);
+        }
+
+        void run() {
+            while (true) {
+                bool has_work = false;
+
+                // 1. Process all immediate tasks (microtask/task queue)
+                while (!tasks.empty()) {
+                    Task task = tasks.front();
+                    tasks.pop_front();
+                    task();
+                    has_work = true;
+                }
+
+                // 2. Process timers
+                auto now = std::chrono::steady_clock::now();
+                while (!timers.empty()) {
+                    // Peek top
+                    const auto& top = timers.top();
+                    
+                    // Cleanup cancelled timers lazily
+                    if (cancelled_timers.count(top.id)) {
+                        cancelled_timers.erase(top.id);
+                        timers.pop();
+                        continue;
+                    }
+                    
+                    if (top.next_run <= now) {
+                        // Timer is ready
+                        Timer t = top;
+                        timers.pop();
+                        
+                        // Execute task
+                        t.task();
+                        has_work = true;
+                        
+                        // Reschedule if interval and not cancelled during execution
+                        if (t.interval.count() > 0 && cancelled_timers.find(t.id) == cancelled_timers.end()) {
+                            // Drift-safe(ish) scheduling: run next interval relative to now
+                            // Note: JS allows drift.
+                            t.next_run = std::chrono::steady_clock::now() + t.interval;
+                            timers.push(t);
+                        }
+                    } else {
+                        break; // Next timer is in the future
+                    }
+                }
+
+                // 3. Exit or Wait
+                if (!has_work) {
+                    if (tasks.empty() && timers.empty()) {
+                        break; // No pending work, exit event loop
+                    }
+                    
+                    if (!timers.empty()) {
+                        auto next_time = timers.top().next_run;
+                        std::this_thread::sleep_until(next_time);
+                    }
+                }
+            }
+        }
+        
+        bool has_tasks() const {
+            return !tasks.empty() || !timers.empty();
+        }
+
+    private:
+        std::deque<Task> tasks;
+        std::priority_queue<Timer, std::vector<Timer>, std::greater<Timer>> timers;
+        std::unordered_set<size_t> cancelled_timers;
+        size_t next_timer_id = 1;
+        const size_t MAX_TIMER_ID = 2147483647; // 2^31 - 1
+
+        size_t schedule_timer(Task task, size_t delay_ms, bool repeat) {
+            size_t id = next_timer_id++;
+            if (next_timer_id > MAX_TIMER_ID) {
+                next_timer_id = 1;
+            }
+            
+            // If we wrap around, ensure we don't accidentally treat this new ID as cancelled
+            // (in case an old timer with this ID is still lingering in the 'cancelled' set)
+            if (cancelled_timers.count(id)) {
+                cancelled_timers.erase(id);
+            }
+            
+            auto now = std::chrono::steady_clock::now();
+            
+            Timer t;
+            t.id = id;
+            t.next_run = now + std::chrono::milliseconds(delay_ms);
+            t.interval = repeat ? std::chrono::milliseconds(delay_ms) : std::chrono::milliseconds(0);
+            t.task = std::move(task);
+            
+            timers.push(t);
+            return id;
+        }
+    };
+}

package/src/prelude/types.hpp

@@ -14,6 +14,7 @@
 #include <set>
 #include <cmath>
 #include <optional>
+#include <span>
 
 // JSPP standard library
 namespace jspp
@@ -26,6 +27,7 @@ namespace jspp
     struct JsObject;        // can set property
     struct JsArray;         // can set property
     struct JsFunction;      // can set property
+    struct JsPromise;       // can set property
     struct JsSymbol;        // can set property (but usually doesn't have own props)
 
     template <typename T>
@@ -36,19 +38,70 @@ namespace jspp
     struct AccessorDescriptor;
 
     // Custom runtime exception
-    struct RuntimeError;
+    struct Exception;
 
     // Dynamic AnyValue
     class AnyValue;
 
+    // Truthiness checker
+    const bool is_truthy(const double &val) noexcept;
+    const bool is_truthy(const std::string &val) noexcept;
+    const bool is_truthy(const AnyValue &val) noexcept;
+
+    // Basic equality operators
+    inline const bool is_strictly_equal_to_primitive(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const bool is_strictly_equal_to_primitive(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const bool is_strictly_equal_to_primitive(const double &lhs, const double &rhs) noexcept;
+    inline const bool is_strictly_equal_to_primitive(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const bool is_equal_to_primitive(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const bool is_equal_to_primitive(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const bool is_equal_to_primitive(const double &lhs, const double &rhs) noexcept;
+    inline const bool is_equal_to_primitive(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const AnyValue is_strictly_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const AnyValue is_strictly_equal_to(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const AnyValue is_strictly_equal_to(const double &lhs, const double &rhs) noexcept;
+    inline const AnyValue is_strictly_equal_to(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const AnyValue is_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const AnyValue is_equal_to(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const AnyValue is_equal_to(const double &lhs, const double &rhs) noexcept;
+    inline const AnyValue is_equal_to(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const AnyValue not_strictly_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const AnyValue not_strictly_equal_to(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const AnyValue not_strictly_equal_to(const double &lhs, const double &rhs) noexcept;
+    inline const AnyValue not_strictly_equal_to(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const AnyValue not_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const AnyValue not_equal_to(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const AnyValue not_equal_to(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    // Bitwise operators
+    inline AnyValue unsigned_right_shift(const AnyValue &lhs, const AnyValue &rhs);
+    inline AnyValue unsigned_right_shift(const AnyValue &lhs, const double &rhs);
+    inline AnyValue unsigned_right_shift(const double &lhs, const AnyValue &rhs);
+
     // Arithemetic operators
+
+    inline AnyValue pow(const double &lhs, const double &rhs);
+    inline AnyValue pow(const AnyValue &lhs, const double &rhs);
     inline AnyValue pow(const AnyValue &lhs, const AnyValue &rhs);
 
     // AnyValue prototypes
+    namespace ObjectPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsObject *self);
+    }
     namespace StringPrototypes
     {
         inline std::optional<AnyValue> get(const std::string &key, JsString *self);
     }
+    namespace NumberPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, double self);
+    }
     namespace ArrayPrototypes
     {
         inline std::optional<AnyValue> get(const std::string &key, JsArray *self);
@@ -57,6 +110,10 @@ namespace jspp
     {
         inline std::optional<AnyValue> get(const std::string &key, JsFunction *self);
     }
+    namespace PromisePrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsPromise *self);
+    }
     namespace IteratorPrototypes
     {
         inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self);