@ugo-studio/jspp 0.1.4 → 0.1.5

package/src/prelude/library/promise.hpp

@@ -5,59 +5,69 @@
 #include "any_value.hpp"
 #include "exception.hpp"
 
-inline auto Promise = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<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();
+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
+                                                        jspp::JsPromise promise;
+                                                        auto state = promise.state; // Share state
 
-    // resolve function
-    auto resolveFn = jspp::AnyValue::make_function([state](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+                                                        // 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");
+        return jspp::AnyValue::make_undefined(); }, "resolve");
 
-    // reject function
-    auto rejectFn = jspp::AnyValue::make_function([state](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+                                                        // 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 {
-        executor->call(jspp::AnyValue::make_undefined(), {resolveFn, rejectFn});
-    } 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_undefined(); }, "reject");
 
-    return jspp::AnyValue::make_promise(promise);
+                                                        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"));
+                                                        }
 
-}, "Promise");
+                                                        return jspp::AnyValue::make_promise(promise); },
+                                                    "Promise");
 
-struct PromiseInit {
-    PromiseInit() {
+struct PromiseInit
+{
+    PromiseInit()
+    {
         // Promise.resolve(value)
-        Promise.define_data_property("resolve", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+        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"));
+            return jspp::AnyValue::make_promise(p); }, "resolve"));
 
         // Promise.reject(reason)
-        Promise.define_data_property("reject", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+        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"));
-        
+            return jspp::AnyValue::make_promise(p); }, "reject"));
+
         // Promise.all(iterable)
-        Promise.define_data_property("all", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+        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?
@@ -73,16 +83,16 @@ struct PromiseInit {
              }
 
              auto arr = args[0].as_array();
-             size_t len = arr->length;
+             size_t len = static_cast<size_t>(arr->length);
              if (len == 0) {
-                 jspp::JsPromise p; p.resolve(jspp::AnyValue::make_array({}));
+                 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<std::optional<jspp::AnyValue>>>(len);
+             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
@@ -91,20 +101,21 @@ struct PromiseInit {
              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](jspp::AnyValue res) {
+                 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(*results)); 
+                          p.resolve(jspp::AnyValue::make_array(std::move(*results))); 
                       }
                  };
                  
-                 auto handleReject = [masterState, rejected](jspp::AnyValue reason) {
+                 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);
                  };
 
@@ -115,7 +126,6 @@ struct PromiseInit {
                  }
              }
              
-             return jspp::AnyValue::make_promise(masterPromise);
-        }, "all"));
+             return jspp::AnyValue::make_promise(masterPromise); }, "all"));
     }
 } promiseInit;

package/src/prelude/library/symbol.hpp

@@ -2,63 +2,51 @@
 
 #include "types.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)},
-});
-
-// #pragma once
-
-// #include "types.hpp"
-// #include "utils/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::Exception::make_exception("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

@@ -7,7 +7,7 @@
 #include "exception.hpp"
 
 // setTimeout(callback, delay, ...args)
-inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+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");
     }
@@ -26,7 +26,7 @@ inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue&
 
     auto task = [callback, callArgs]() {
          try {
-             callback.as_function()->call(jspp::AnyValue::make_undefined(), callArgs);
+             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) {
@@ -41,7 +41,7 @@ inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue&
 }, "setTimeout");
 
 // clearTimeout(id)
-inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+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);
@@ -50,7 +50,7 @@ inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue
 }, "clearTimeout");
 
 // setInterval(callback, delay, ...args)
-inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+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");
     }
@@ -68,7 +68,7 @@ inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue&
 
     auto task = [callback, callArgs]() {
          try {
-             callback.as_function()->call(jspp::AnyValue::make_undefined(), callArgs);
+             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) {
@@ -83,7 +83,7 @@ inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue&
 }, "setInterval");
 
 // clearInterval(id)
-inline auto clearInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+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);

package/src/prelude/types.hpp

@@ -14,6 +14,7 @@
 #include <set>
 #include <cmath>
 #include <optional>
+#include <span>
 
 // JSPP standard library
 namespace jspp
@@ -42,7 +43,50 @@ namespace jspp
     // 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
@@ -54,6 +98,10 @@ namespace jspp
     {
         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);

package/src/prelude/utils/access.hpp

@@ -64,9 +64,12 @@ namespace jspp
             return var;
         }
 
-        inline AnyValue typeof(const AnyValue &val)
+        inline const AnyValue type_of(const std::optional<AnyValue> &val = std::nullopt)
         {
-            switch (val.get_type())
+            if (!val.has_value())
+                return AnyValue::make_string("undefined");
+
+            switch (val.value().get_type())
             {
             case JsType::Undefined:
                 return AnyValue::make_string("undefined");
@@ -83,17 +86,15 @@ namespace jspp
             case JsType::Function:
                 return AnyValue::make_string("function");
             case JsType::Object:
+                return AnyValue::make_string("object");
             case JsType::Array:
+                return AnyValue::make_string("object");
             case JsType::Iterator:
                 return AnyValue::make_string("object");
             default:
                 return AnyValue::make_string("undefined");
             }
         }
-        inline AnyValue typeof() // for undeclared variables
-        {
-            return AnyValue::make_string("undefined");
-        }
 
         // Helper function to get enumerable own property keys/values of an object
         inline std::vector<std::string> get_object_keys(const AnyValue &obj)
@@ -103,10 +104,35 @@ namespace jspp
             if (obj.is_object())
             {
                 auto ptr = obj.as_object();
-                for (const auto &pair : ptr->props)
+                // Use shape's property_names for stable iteration order
+                for (const auto &key : ptr->shape->property_names)
                 {
-                    if (!JsSymbol::is_internal_key(pair.first))
-                        keys.push_back(pair.first);
+                    if (ptr->deleted_keys.count(key))
+                        continue;
+
+                    if (JsSymbol::is_internal_key(key))
+                        continue;
+
+                    auto offset_opt = ptr->shape->get_offset(key);
+                    if (!offset_opt.has_value())
+                        continue;
+
+                    const auto &val = ptr->storage[offset_opt.value()];
+
+                    if (val.is_data_descriptor())
+                    {
+                        if (val.as_data_descriptor()->enumerable)
+                            keys.push_back(key);
+                    }
+                    else if (val.is_accessor_descriptor())
+                    {
+                        if (val.as_accessor_descriptor()->enumerable)
+                            keys.push_back(key);
+                    }
+                    else
+                    {
+                        keys.push_back(key);
+                    }
                 }
             }
             if (obj.is_function())
@@ -153,7 +179,7 @@ namespace jspp
             auto gen_fn = obj.get_own_property(WellKnownSymbols::iterator->key);
             if (gen_fn.is_function())
             {
-                auto iter = gen_fn.as_function()->call(gen_fn, {});
+                auto iter = gen_fn.call(obj, {}, WellKnownSymbols::iterator->key);
                 if (iter.is_iterator())
                 {
                     return iter;
@@ -170,5 +196,150 @@ namespace jspp
 
             throw jspp::Exception::make_exception(name + " is not iterable", "TypeError");
         }
+
+        inline AnyValue in(const AnyValue &lhs, const AnyValue &rhs)
+        {
+            if (!rhs.is_object() && !rhs.is_array() && !rhs.is_function() && !rhs.is_promise() && !rhs.is_iterator())
+            {
+                throw jspp::Exception::make_exception("Cannot use 'in' operator to search for '" + lhs.to_std_string() + "' in " + rhs.to_std_string(), "TypeError");
+            }
+            return AnyValue::make_boolean(rhs.has_property(lhs.to_std_string()));
+        }
+
+        inline AnyValue instance_of(const AnyValue &lhs, const AnyValue &rhs)
+        {
+            if (!rhs.is_function())
+            {
+                throw jspp::Exception::make_exception("Right-hand side of 'instanceof' is not callable", "TypeError");
+            }
+            if (!lhs.is_object() && !lhs.is_array() && !lhs.is_function() && !lhs.is_promise() && !lhs.is_iterator())
+            {
+                return Constants::FALSE;
+            }
+            AnyValue targetProto = rhs.get_own_property("prototype");
+            if (!targetProto.is_object() && !targetProto.is_array() && !targetProto.is_function())
+            {
+                throw jspp::Exception::make_exception("Function has non-object prototype in instanceof check", "TypeError");
+            }
+            // Walk prototype chain of lhs
+            AnyValue current = lhs;
+
+            while (true)
+            {
+                AnyValue proto;
+                if (current.is_object())
+                {
+                    auto p = current.as_object()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_array())
+                {
+                    auto p = current.as_array()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_function())
+                {
+                    auto p = current.as_function()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_promise())
+                {
+                    // Promises don't store explicit proto yet in our impl
+                    break;
+                }
+                else
+                {
+                    break;
+                }
+                if (proto.is_null() || proto.is_undefined())
+                    break;
+                if (is_strictly_equal_to_primitive(proto, targetProto))
+                    return Constants::TRUE;
+                current = proto;
+            }
+            return Constants::FALSE;
+        }
+
+        inline AnyValue delete_property(const AnyValue &obj, const AnyValue &key)
+        {
+            if (obj.is_object())
+            {
+                auto ptr = obj.as_object();
+                std::string key_str = key.to_std_string();
+                if (ptr->shape->get_offset(key_str).has_value())
+                {
+                    ptr->deleted_keys.insert(key_str);
+                }
+                return Constants::TRUE;
+            }
+            if (obj.is_array())
+            {
+                auto ptr = obj.as_array();
+                std::string key_str = key.to_std_string();
+                if (JsArray::is_array_index(key_str))
+                {
+                    uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
+                    if (idx < ptr->dense.size())
+                    {
+                        ptr->dense[idx] = Constants::UNINITIALIZED;
+                    }
+                    else
+                    {
+                        ptr->sparse.erase(idx);
+                    }
+                }
+                else
+                {
+                    ptr->props.erase(key_str);
+                }
+                return Constants::TRUE;
+            }
+            if (obj.is_function())
+            {
+                auto ptr = obj.as_function();
+                ptr->props.erase(key.to_std_string());
+                return Constants::TRUE;
+            }
+            return Constants::TRUE;
+        }
+
+        inline AnyValue optional_get_property(const AnyValue &obj, const std::string &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(key);
+        }
+
+        inline AnyValue optional_get_element(const AnyValue &obj, const AnyValue &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(key);
+        }
+
+        inline AnyValue optional_get_element(const AnyValue &obj, const double &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(static_cast<uint32_t>(key));
+        }
+
+        inline AnyValue optional_call(const AnyValue &fn, const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &name = std::nullopt)
+        {
+            if (fn.is_null() || fn.is_undefined())
+                return Constants::UNDEFINED;
+            return fn.call(thisVal, args, name);
+        }
+
     }
-}
+
+}