@ugo-studio/jspp 0.3.2 → 0.3.3

package/dist/interpreter/core/codegen/expression-handlers.js

@@ -247,6 +247,17 @@ export function visitPrefixUnaryExpression(node, context) {
     const operand = this.visit(prefixUnaryExpr.operand, context);
     const operator = ts.tokenToString(prefixUnaryExpr.operator);
     if (operator === "++" || operator === "--") {
+        const opFunc = operator === "++" ? "add" : "sub";
+        if (ts.isPropertyAccessExpression(prefixUnaryExpr.operand)) {
+            const obj = this.visit(prefixUnaryExpr.operand.expression, context);
+            const prop = visitObjectPropertyName.call(this, prefixUnaryExpr.operand.name, context);
+            return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), 1.0))`;
+        }
+        else if (ts.isElementAccessExpression(prefixUnaryExpr.operand)) {
+            const obj = this.visit(prefixUnaryExpr.operand.expression, context);
+            const prop = visitObjectPropertyName.call(this, prefixUnaryExpr.operand.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), 1.0))`;
+        }
         let target = operand;
         if (ts.isIdentifier(prefixUnaryExpr.operand)) {
             const scope = this.getScopeForNode(prefixUnaryExpr.operand);
@@ -289,6 +300,20 @@ export function visitPostfixUnaryExpression(node, context) {
     const postfixUnaryExpr = node;
     const operand = this.visit(postfixUnaryExpr.operand, context);
     const operator = ts.tokenToString(postfixUnaryExpr.operator);
+    if (ts.isPropertyAccessExpression(postfixUnaryExpr.operand)) {
+        const obj = this.visit(postfixUnaryExpr.operand.expression, context);
+        const prop = visitObjectPropertyName.call(this, postfixUnaryExpr.operand.name, context);
+        const opFunc = operator === "++" ? "add" : "sub";
+        // Postfix needs IILE to return old value
+        return `([&]() { auto oldVal = ${obj}.get_own_property(${prop}); ${obj}.set_own_property(${prop}, jspp::${opFunc}(oldVal, 1.0)); return oldVal; })()`;
+    }
+    else if (ts.isElementAccessExpression(postfixUnaryExpr.operand)) {
+        const obj = this.visit(postfixUnaryExpr.operand.expression, context);
+        const prop = visitObjectPropertyName.call(this, postfixUnaryExpr.operand.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+        const opFunc = operator === "++" ? "add" : "sub";
+        // Postfix needs IILE to return old value
+        return `([&]() { auto oldVal = ${obj}.get_own_property(${prop}); ${obj}.set_own_property(${prop}, jspp::${opFunc}(oldVal, 1.0)); return oldVal; })()`;
+    }
     let target = operand;
     if (ts.isIdentifier(postfixUnaryExpr.operand)) {
         const scope = this.getScopeForNode(postfixUnaryExpr.operand);
@@ -402,42 +427,36 @@ export function visitBinaryExpression(node, context) {
     if (assignmentOperators.includes(opToken.kind)) {
         if (opToken.kind ===
             ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
-            const leftText = this.visit(binExpr.left, visitContext);
             const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
+                const leftText = this.visit(binExpr.left, visitContext);
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
+                const target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
-                return `${target} = jspp::unsigned_right_shift(${target}, ${rightText})`;
+                return `jspp::unsigned_right_shift_assign(${target}, ${rightText})`;
             }
-        }
-        if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
-            const leftText = this.visit(binExpr.left, visitContext);
-            const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
-            if (ts.isIdentifier(binExpr.left)) {
-                const scope = this.getScopeForNode(binExpr.left);
-                const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
-                    ? `*${leftText}`
-                    : leftText;
-                return `${target} = jspp::pow(${target}, ${rightText})`;
+            else if (ts.isPropertyAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+                return `${obj}.set_own_property(${prop}, jspp::unsigned_right_shift(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else if (ts.isElementAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+                return `${obj}.set_own_property(${prop}, jspp::unsigned_right_shift(${obj}.get_own_property(${prop}), ${rightText}))`;
             }
-            // For complex LHS, we need a different approach, but this is a start.
         }
         if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
             opToken.kind === ts.SyntaxKind.BarBarEqualsToken ||
             opToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-            const leftText = this.visit(binExpr.left, visitContext);
             const rightText = this.visit(binExpr.right, visitContext);
-            let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
+                const leftText = this.visit(binExpr.left, visitContext);
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo?.needsHeapAllocation
+                const target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
@@ -450,6 +469,29 @@ export function visitBinaryExpression(node, context) {
                     return `jspp::nullish_coalesce_assign(${target}, ${rightText})`;
                 }
             }
+            else if (ts.isPropertyAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+                const func = opToken.kind ===
+                    ts.SyntaxKind.AmpersandAmpersandEqualsToken
+                    ? "logical_and"
+                    : (opToken.kind === ts.SyntaxKind.BarBarEqualsToken
+                        ? "logical_or"
+                        : "nullish_coalesce");
+                // Logical assignments return newVal, set_own_property returns newVal.
+                return `${obj}.set_own_property(${prop}, jspp::${func}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else if (ts.isElementAccessExpression(binExpr.left)) {
+                const obj = this.visit(binExpr.left.expression, context);
+                const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+                const func = opToken.kind ===
+                    ts.SyntaxKind.AmpersandAmpersandEqualsToken
+                    ? "logical_and"
+                    : (opToken.kind === ts.SyntaxKind.BarBarEqualsToken
+                        ? "logical_or"
+                        : "nullish_coalesce");
+                return `${obj}.set_own_property(${prop}, jspp::${func}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
         }
         const leftText = this.visit(binExpr.left, visitContext);
         let rightText = ts.isNumericLiteral(binExpr.right)
@@ -460,6 +502,35 @@ export function visitBinaryExpression(node, context) {
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope);
             rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
+        if (ts.isPropertyAccessExpression(binExpr.left)) {
+            const obj = this.visit(binExpr.left.expression, context);
+            const prop = visitObjectPropertyName.call(this, binExpr.left.name, context);
+            const opBase = op.slice(0, -1); // "+=", "-=" -> "+", "-"
+            const opFunc = opBase === "+" ? "add" : (opBase === "-" ? "sub" : (opBase === "*" ? "mul" : (opBase === "/" ? "div" : (opBase === "%" ? "mod" : (opBase === "&" ? "bitwise_and" : (opBase === "|" ? "bitwise_or" : (opBase === "^" ? "bitwise_xor" : (opBase === "<<" ? "left_shift" : (opBase === ">>"
+                ? "right_shift"
+                : "")))))))));
+            if (opFunc) {
+                return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else {
+                // Fallback to IILE if we don't have an opFunc mapping
+                return `([&]() { auto val = ${obj}.get_own_property(${prop}); val ${op} ${rightText}; ${obj}.set_own_property(${prop}, val); return val; })()`;
+            }
+        }
+        else if (ts.isElementAccessExpression(binExpr.left)) {
+            const obj = this.visit(binExpr.left.expression, context);
+            const prop = visitObjectPropertyName.call(this, binExpr.left.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            const opBase = op.slice(0, -1);
+            const opFunc = opBase === "+" ? "add" : (opBase === "-" ? "sub" : (opBase === "*" ? "mul" : (opBase === "/" ? "div" : (opBase === "%" ? "mod" : (opBase === "&" ? "bitwise_and" : (opBase === "|" ? "bitwise_or" : (opBase === "^" ? "bitwise_xor" : (opBase === "<<" ? "left_shift" : (opBase === ">>"
+                ? "right_shift"
+                : "")))))))));
+            if (opFunc) {
+                return `${obj}.set_own_property(${prop}, jspp::${opFunc}(${obj}.get_own_property(${prop}), ${rightText}))`;
+            }
+            else {
+                return `([&]() { auto val = ${obj}.get_own_property(${prop}); val ${op} ${rightText}; ${obj}.set_own_property(${prop}, val); return val; })()`;
+            }
+        }
         let target = leftText;
         if (ts.isIdentifier(binExpr.left)) {
             const scope = this.getScopeForNode(binExpr.left);
@@ -1266,7 +1337,7 @@ export function visitTypeOfExpression(node, context) {
             derefExpr = this.getDerefCode(exprText, this.getJsVarName(typeOfExpr.expression), context, typeInfo);
         }
     }
-    return `jspp::Access::type_of(${derefExpr})`;
+    return `jspp::type_of(${derefExpr})`;
 }
 export function visitAwaitExpression(node, context) {
     const awaitExpr = node;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -14,7 +14,7 @@
     "scripts"
   ],
   "scripts": {
-    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts && bun run scripts/precompile-headers.ts",
+    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts && bun run scripts/precompile-headers.ts --mode debug",
     "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",

package/scripts/precompile-headers.ts

@@ -112,6 +112,14 @@ if (process.platform === "win32") {
     MODES[1].flags.push("-Wa,-mbig-obj");
 }
 
+const pkgDir = path.dirname(import.meta.dirname);
+const emsdkEnv = {
+    ...process.env,
+    PATH: `${path.join(pkgDir, ".emsdk")}${path.delimiter}${
+        path.join(pkgDir, ".emsdk", "upstream", "emscripten")
+    }${path.delimiter}${process.env.PATH}`,
+};
+
 async function getLatestMtime(
     dirPath: string,
     filter?: (name: string) => boolean,
@@ -146,11 +154,11 @@ async function findCppFiles(dir: string): Promise<string[]> {
 }
 
 async function runCommand(cmd: string, args: string[]): Promise<boolean> {
-    // console.log(`${COLORS.dim}> ${cmd} ${args.join(" ")}${COLORS.reset}`);
     return new Promise((resolve) => {
         const proc = spawn(cmd, args, {
             stdio: "inherit",
             shell: process.platform === "win32",
+            env: emsdkEnv,
         });
         proc.on("close", (code) => resolve(code === 0));
     });

package/src/prelude/utils/access.hpp

@@ -48,40 +48,6 @@ namespace jspp
             return var;
         }
 
-        inline AnyValue type_of(const std::optional<AnyValue> &val = std::nullopt)
-        {
-            if (!val.has_value())
-                return AnyValue::make_string("undefined");
-
-            switch (val.value().get_type())
-            {
-            case JsType::Undefined:
-                return AnyValue::make_string("undefined");
-            case JsType::Null:
-                return AnyValue::make_string("object");
-            case JsType::Boolean:
-                return AnyValue::make_string("boolean");
-            case JsType::Number:
-                return AnyValue::make_string("number");
-            case JsType::String:
-                return AnyValue::make_string("string");
-            case JsType::Symbol:
-                return AnyValue::make_string("symbol");
-            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");
-            case JsType::AsyncIterator:
-                return AnyValue::make_string("object");
-            default:
-                return AnyValue::make_string("undefined");
-            }
-        }
-
         // Helper function to get enumerable own property keys/values of an object
         inline std::vector<AnyValue> get_object_keys(const AnyValue &obj, bool include_symbols = false)
         {

package/src/prelude/utils/assignment_operators.hpp

@@ -39,6 +39,42 @@ namespace jspp
         return lhs;
     }
 
+    inline AnyValue &operator&=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_and(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator|=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_or(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator^=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::bitwise_xor(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator<<=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::left_shift(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &operator>>=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::right_shift(lhs, rhs);
+        return lhs;
+    }
+
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = jspp::unsigned_right_shift(lhs, rhs);
+        return lhs;
+    }
+
     inline AnyValue &operator++(AnyValue &val)
     {
         val = jspp::add(val, 1.0);
@@ -116,4 +152,64 @@ namespace jspp
     {
         return lhs %= static_cast<double>(rhs);
     }
+
+    inline AnyValue &operator&=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_and(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator&=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs &= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator|=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_or(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator|=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs |= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator^=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::bitwise_xor(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator^=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs ^= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator<<=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::left_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator<<=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs <<= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator>>=(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::right_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &operator>>=(AnyValue &lhs, const int &rhs)
+    {
+        return lhs >>= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const double &rhs)
+    {
+        lhs = jspp::unsigned_right_shift(lhs, rhs);
+        return lhs;
+    }
+    inline AnyValue &unsigned_right_shift_assign(AnyValue &lhs, const int &rhs)
+    {
+        return unsigned_right_shift_assign(lhs, static_cast<double>(rhs));
+    }
 }

package/src/prelude/utils/operators.hpp

@@ -11,6 +11,41 @@
 
 namespace jspp
 {
+    // --- TYPE OF ---
+    inline AnyValue type_of(const std::optional<AnyValue> &val = std::nullopt)
+    {
+        if (!val.has_value())
+            return AnyValue::make_string("undefined");
+
+        switch (val.value().get_type())
+        {
+        case JsType::Undefined:
+            return AnyValue::make_string("undefined");
+        case JsType::Null:
+            return AnyValue::make_string("object");
+        case JsType::Boolean:
+            return AnyValue::make_string("boolean");
+        case JsType::Number:
+            return AnyValue::make_string("number");
+        case JsType::String:
+            return AnyValue::make_string("string");
+        case JsType::Symbol:
+            return AnyValue::make_string("symbol");
+        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");
+        case JsType::AsyncIterator:
+            return AnyValue::make_string("object");
+        default:
+            return AnyValue::make_string("undefined");
+        }
+    }
+
     // Operator === (returns boolean wrapped in AnyValue)
     inline const AnyValue is_strictly_equal_to(const AnyValue &lhs, const double &rhs) noexcept
     {
@@ -349,4 +384,4 @@ namespace jspp
             return lhs;
         return rhs;
     }
-}
+}

package/src/prelude/utils/operators_native.hpp

@@ -2,6 +2,7 @@
 
 #include "types.hpp"
 #include "any_value.hpp"
+#include "exception.hpp"
 #include <cstdint>   // For int32_t
 #include <cmath>     // For fmod, isnan, isinf, floor, abs, pow
 #include <string>    // For std::to_string, std::stod
@@ -109,6 +110,16 @@ namespace jspp
         }
     }
 
+    // --- UNARY NATIVE ---
+    inline double plus_native(const AnyValue &val) { return Operators_Private::ToNumber(val); }
+    inline double plus_native(double val) { return val; }
+    inline double negate_native(const AnyValue &val) { return -Operators_Private::ToNumber(val); }
+    inline double negate_native(double val) { return -val; }
+    inline double bitwise_not_native(const AnyValue &val) { return static_cast<double>(~Operators_Private::ToInt32(val)); }
+    inline double bitwise_not_native(double val) { return static_cast<double>(~static_cast<int32_t>(val)); }
+    inline bool logical_not_native(const AnyValue &val) { return !is_truthy(val); }
+    inline bool logical_not_native(double val) { return !is_truthy(val); }
+
     // --- BASIC EQUALITY ---
 
     // Operator === (returns primitive boolean)
@@ -346,4 +357,4 @@ namespace jspp
     inline double unsigned_right_shift_native(const AnyValue &lhs, const double &rhs) { return unsigned_right_shift_native(Operators_Private::ToUint32(lhs), rhs); }
     inline double unsigned_right_shift_native(const double &lhs, const AnyValue &rhs) { return unsigned_right_shift_native(lhs, Operators_Private::ToInt32(rhs)); }
 
-}
+}

package/src/prelude/values/iterator.cpp

@@ -2,210 +2,251 @@
 #include "values/iterator.hpp"
 #include "values/prototypes/iterator.hpp"
 
-namespace jspp {
-
-template <typename T>
-JsIterator<T>::JsIterator(handle_type h) : handle(h) {}
-
-template <typename T>
-JsIterator<T>::JsIterator(JsIterator &&other) noexcept 
-    : handle(std::exchange(other.handle, nullptr)),
-      props(std::move(other.props)),
-      symbol_props(std::move(other.symbol_props)) {}
-
-template <typename T>
-JsIterator<T>::~JsIterator() { if (handle) handle.destroy(); }
-
-template <typename T>
-JsIterator<T> JsIterator<T>::promise_type::get_return_object() {
-    return JsIterator{std::coroutine_handle<promise_type>::from_promise(*this)};
-}
-
-template <typename T>
-std::suspend_always JsIterator<T>::promise_type::initial_suspend() noexcept { return {}; }
-
-template <typename T>
-std::suspend_always JsIterator<T>::promise_type::final_suspend() noexcept { return {}; }
-
-template <typename T>
-void JsIterator<T>::promise_type::unhandled_exception() {
-    try {
-        throw;
-    } catch (const GeneratorReturnException&) {
-    } catch (...) {
-        exception_ = std::current_exception();
+namespace jspp
+{
+
+    template <typename T>
+    JsIterator<T>::JsIterator(handle_type h) : handle(h) {}
+
+    template <typename T>
+    JsIterator<T>::JsIterator(JsIterator &&other) noexcept
+        : handle(std::exchange(other.handle, nullptr)),
+          props(std::move(other.props)),
+          symbol_props(std::move(other.symbol_props)) {}
+
+    template <typename T>
+    JsIterator<T>::~JsIterator()
+    {
+        if (handle)
+            handle.destroy();
     }
-}
 
-template <typename T>
-std::string JsIterator<T>::to_std_string() const { return "[object Generator]"; }
+    template <typename T>
+    JsIterator<T> JsIterator<T>::promise_type::get_return_object()
+    {
+        return JsIterator{std::coroutine_handle<promise_type>::from_promise(*this)};
+    }
 
-template <typename T>
-typename JsIterator<T>::NextResult JsIterator<T>::next(const T &val)
-{
-    if (!handle || handle.done()) return {std::nullopt, true};
-    handle.promise().input_value = val;
-    handle.resume();
-    if (handle.promise().exception_) std::rethrow_exception(handle.promise().exception_);
-    bool is_done = handle.done();
-    return {handle.promise().current_value, is_done};
-}
-
-template <typename T>
-typename JsIterator<T>::NextResult JsIterator<T>::return_(const T &val)
-{
-    if (!handle || handle.done()) return {val, true};
-    handle.promise().pending_return = true;
-    handle.promise().current_value = val;
-    handle.resume();
-    if (handle.promise().exception_) std::rethrow_exception(handle.promise().exception_);
-    return {handle.promise().current_value, true};
-}
-
-template <typename T>
-typename JsIterator<T>::NextResult JsIterator<T>::throw_(const AnyValue &err)
-{
-    if (!handle || handle.done()) throw Exception(err);
-    handle.promise().pending_exception = std::make_exception_ptr(Exception(err));
-    handle.resume();
-    if (handle.promise().exception_) std::rethrow_exception(handle.promise().exception_);
-    bool is_done = handle.done();
-    return {handle.promise().current_value, is_done};
-}
-
-template <typename T>
-std::vector<T> JsIterator<T>::to_vector()
-{
-    std::vector<T> result;
-    while (true) {
-        auto next_res = this->next();
-        if (next_res.done) break;
-        result.push_back(next_res.value.value_or(Constants::UNDEFINED));
+    template <typename T>
+    std::suspend_always JsIterator<T>::promise_type::initial_suspend() noexcept { return {}; }
+
+    template <typename T>
+    std::suspend_always JsIterator<T>::promise_type::final_suspend() noexcept { return {}; }
+
+    template <typename T>
+    void JsIterator<T>::promise_type::unhandled_exception()
+    {
+        try
+        {
+            throw;
+        }
+        catch (const GeneratorReturnException &)
+        {
+        }
+        catch (...)
+        {
+            exception_ = std::current_exception();
+        }
     }
-    return result;
-}
 
-template <typename T>
-bool JsIterator<T>::has_symbol_property(const AnyValue &key) const { return symbol_props.count(key) > 0; }
+    template <typename T>
+    std::string JsIterator<T>::to_std_string() const { return "[object Generator]"; }
+
+    template <typename T>
+    typename JsIterator<T>::NextResult JsIterator<T>::next(const T &val)
+    {
+        if (!handle || handle.done())
+            return {std::nullopt, true};
+        handle.promise().input_value = val;
+        handle.resume();
+        if (handle.promise().exception_)
+            std::rethrow_exception(handle.promise().exception_);
+        bool is_done = handle.done();
+        return {handle.promise().current_value, is_done};
+    }
 
-template <typename T>
-AnyValue JsIterator<T>::get_property(const std::string &key, AnyValue thisVal)
-{
-    auto it = props.find(key);
-    if (it == props.end()) {
-        if constexpr (std::is_same_v<T, AnyValue>) {
-            auto proto_it = IteratorPrototypes::get(key);
-            if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+    template <typename T>
+    typename JsIterator<T>::NextResult JsIterator<T>::return_(const T &val)
+    {
+        if (!handle || handle.done())
+            return {val, true};
+        handle.promise().pending_return = true;
+        handle.promise().current_value = val;
+        handle.resume();
+        if (handle.promise().exception_)
+            std::rethrow_exception(handle.promise().exception_);
+        return {handle.promise().current_value, true};
+    }
+
+    template <typename T>
+    typename JsIterator<T>::NextResult JsIterator<T>::throw_(const AnyValue &err)
+    {
+        if (!handle || handle.done())
+            throw Exception(err);
+        handle.promise().pending_exception = std::make_exception_ptr(Exception(err));
+        handle.resume();
+        if (handle.promise().exception_)
+            std::rethrow_exception(handle.promise().exception_);
+        bool is_done = handle.done();
+        return {handle.promise().current_value, is_done};
+    }
+
+    template <typename T>
+    std::vector<T> JsIterator<T>::to_vector()
+    {
+        std::vector<T> result;
+        while (true)
+        {
+            auto next_res = this->next();
+            if (next_res.done)
+                break;
+            result.push_back(next_res.value.value_or(Constants::UNDEFINED));
         }
-        return Constants::UNDEFINED;
+        return result;
     }
-    return AnyValue::resolve_property_for_read(it->second, thisVal, key);
-}
 
-template <typename T>
-AnyValue JsIterator<T>::get_symbol_property(const AnyValue &key, AnyValue thisVal)
-{
-    auto it = symbol_props.find(key);
-    if (it == symbol_props.end()) {
-        if constexpr (std::is_same_v<T, AnyValue>) {
-            auto proto_it = IteratorPrototypes::get(key);
-            if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key.to_std_string());
+    template <typename T>
+    bool JsIterator<T>::has_symbol_property(const AnyValue &key) const { return symbol_props.count(key) > 0; }
+
+    template <typename T>
+    AnyValue JsIterator<T>::get_property(const std::string &key, AnyValue thisVal)
+    {
+        auto it = props.find(key);
+        if (it == props.end())
+        {
+            if constexpr (std::is_same_v<T, AnyValue>)
+            {
+                auto proto_it = IteratorPrototypes::get(key);
+                if (proto_it.has_value())
+                    return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+            }
+            return Constants::UNDEFINED;
         }
-        return Constants::UNDEFINED;
+        return AnyValue::resolve_property_for_read(it->second, thisVal, key);
     }
-    return AnyValue::resolve_property_for_read(it->second, thisVal, key.to_std_string());
-}
 
-template <typename T>
-AnyValue JsIterator<T>::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
-{
-    if constexpr (std::is_same_v<T, AnyValue>) {
-        auto proto_it = IteratorPrototypes::get(key);
-        if (proto_it.has_value()) {
-            auto proto_value = proto_it.value();
-            if (proto_value.is_accessor_descriptor()) return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
-            if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable) return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+    template <typename T>
+    AnyValue JsIterator<T>::get_symbol_property(const AnyValue &key, AnyValue thisVal)
+    {
+        auto it = symbol_props.find(key);
+        if (it == symbol_props.end())
+        {
+            if constexpr (std::is_same_v<T, AnyValue>)
+            {
+                auto proto_it = IteratorPrototypes::get(key);
+                if (proto_it.has_value())
+                    return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key.to_std_string());
+            }
+            return Constants::UNDEFINED;
         }
+        return AnyValue::resolve_property_for_read(it->second, thisVal, key.to_std_string());
     }
-    auto it = props.find(key);
-    if (it != props.end()) return jspp::AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
-    else { props[key] = value; return value; }
-}
 
-template <typename T>
-AnyValue JsIterator<T>::set_symbol_property(const AnyValue &key, AnyValue value, AnyValue thisVal)
-{
-    auto it = symbol_props.find(key);
-    if (it != symbol_props.end()) return AnyValue::resolve_property_for_write(it->second, thisVal, value, key.to_std_string());
-    else { symbol_props[key] = value; return value; }
-}
+    template <typename T>
+    AnyValue JsIterator<T>::set_property(const std::string &key, AnyValue value, AnyValue thisVal)
+    {
+        if constexpr (std::is_same_v<T, AnyValue>)
+        {
+            auto proto_it = IteratorPrototypes::get(key);
+            if (proto_it.has_value())
+            {
+                auto proto_value = proto_it.value();
+                if (proto_value.is_accessor_descriptor())
+                    return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+                if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
+                    return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+            }
+        }
+        auto it = props.find(key);
+        if (it != props.end())
+            return jspp::AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
+        else
+        {
+            props[key] = value;
+            return value;
+        }
+    }
 
-// Explicit template instantiation
-template class JsIterator<AnyValue>;
+    template <typename T>
+    AnyValue JsIterator<T>::set_symbol_property(const AnyValue &key, AnyValue value, AnyValue thisVal)
+    {
+        auto it = symbol_props.find(key);
+        if (it != symbol_props.end())
+            return AnyValue::resolve_property_for_write(it->second, thisVal, value, key.to_std_string());
+        else
+        {
+            symbol_props[key] = value;
+            return value;
+        }
+    }
 
-namespace IteratorPrototypes {
+    // Explicit template instantiation
+    template class JsIterator<AnyValue>;
 
-AnyValue &get_toString_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                 { return AnyValue::make_string(thisVal.as_iterator()->to_std_string()); },
-                                                 "toString");
-    return fn;
-}
+    namespace IteratorPrototypes
+    {
 
-AnyValue &get_iterator_fn()
-{
-    static AnyValue fn = AnyValue::make_generator([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                  { return thisVal; },
-                                                  "Symbol.iterator");
-    return fn;
-}
+        AnyValue &get_toString_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                         { return AnyValue::make_string(thisVal.as_iterator()->to_std_string()); },
+                                                         "toString");
+            return fn;
+        }
 
-AnyValue &get_next_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                 {
+        AnyValue &get_iterator_fn()
+        {
+            static AnyValue fn = AnyValue::make_generator([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                          { return thisVal; },
+                                                          "Symbol.iterator");
+            return fn;
+        }
+
+        AnyValue &get_next_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
                                                      AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
                                                      auto res = thisVal.as_iterator()->next(val);
                                                      return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
-                                                 "next");
-    return fn;
-}
+                                                         "next");
+            return fn;
+        }
 
-AnyValue &get_return_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                 {
+        AnyValue &get_return_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
                                                      AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
                                                      auto res = thisVal.as_iterator()->return_(val);
                                                      return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
-                                                 "return");
-    return fn;
-}
+                                                         "return");
+            return fn;
+        }
 
-AnyValue &get_throw_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                 {
+        AnyValue &get_throw_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
                                                      AnyValue err = args.empty() ? Constants::UNDEFINED : args[0];
                                                      auto res = thisVal.as_iterator()->throw_(err);
                                                      return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
-                                                 "throw");
-    return fn;
-}
+                                                         "throw");
+            return fn;
+        }
 
-AnyValue &get_toArray_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                 { return AnyValue::make_array(thisVal.as_iterator()->to_vector()); },
-                                                 "toArray");
-    return fn;
-}
+        AnyValue &get_toArray_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                         { return AnyValue::make_array(thisVal.as_iterator()->to_vector()); },
+                                                         "toArray");
+            return fn;
+        }
 
-AnyValue &get_drop_fn()
-{
-    static AnyValue fn = AnyValue::make_generator([](AnyValue thisVal, std::vector<AnyValue> args) -> JsIterator<AnyValue>
-                                                  { 
+        AnyValue &get_drop_fn()
+        {
+            static AnyValue fn = AnyValue::make_generator([](AnyValue thisVal, std::vector<AnyValue> args) -> JsIterator<AnyValue>
+                                                          { 
                                                     auto self = thisVal.as_iterator();
                                                     size_t skip_count = 0;
                                                     if (!args.empty()) {
@@ -224,14 +265,14 @@ AnyValue &get_drop_fn()
                                                         co_yield next_res.value.value_or(Constants::UNDEFINED);
                                                     }
                                                     co_return jspp::Constants::UNDEFINED; },
-                                                  "drop");
-    return fn;
-}
+                                                          "drop");
+            return fn;
+        }
 
-AnyValue &get_take_fn()
-{
-    static AnyValue fn = AnyValue::make_generator([](AnyValue thisVal, std::vector<AnyValue> args) -> JsIterator<AnyValue>
-                                                  { 
+        AnyValue &get_take_fn()
+        {
+            static AnyValue fn = AnyValue::make_generator([](AnyValue thisVal, std::vector<AnyValue> args) -> JsIterator<AnyValue>
+                                                          { 
                                                     auto self = thisVal.as_iterator();
                                                     size_t take_count = 0;
                                                     if (!args.empty()) {
@@ -254,14 +295,14 @@ AnyValue &get_take_fn()
                                                         }
                                                     }
                                                     co_return jspp::Constants::UNDEFINED; },
-                                                  "take");
-    return fn;
-}
+                                                          "take");
+            return fn;
+        }
 
-AnyValue &get_some_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                 { 
+        AnyValue &get_some_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         { 
                                                     auto self = thisVal.as_iterator();
                                                     if (args.empty() || !args[0].is_function()) throw Exception::make_exception("callback is not a function", "TypeError");
                                                     auto callback = args[0].as_function();
@@ -269,7 +310,8 @@ AnyValue &get_some_fn()
                                                     {
                                                         auto next_res = self->next();
                                                         if (next_res.done) { break; }
-                                                        if (is_truthy(callback->call(thisVal, std::span<const AnyValue>((const jspp::AnyValue[]){next_res.value.value_or(Constants::UNDEFINED)}, 1))))
+                                                       AnyValue cb_arg = next_res.value.value_or(Constants::UNDEFINED);
+                                                        if (is_truthy(callback->call(thisVal, std::span<const AnyValue>(&cb_arg, 1))))
                                                         {
                                                             self->return_();
                                                             return Constants::TRUE;
@@ -277,33 +319,43 @@ AnyValue &get_some_fn()
                                                     }
                                                     return jspp::Constants::FALSE; },
                                                          "some");
-    return fn;
-}
+            return fn;
+        }
 
-std::optional<AnyValue> get(const std::string &key)
-{
-    if (key == "toString") return get_toString_fn();
-    if (key == "next") return get_next_fn();
-    if (key == "return") return get_return_fn();
-    if (key == "throw") return get_throw_fn();
-    if (key == "toArray") return get_toArray_fn();
-    if (key == "drop") return get_drop_fn();
-    if (key == "take") return get_take_fn();
-    if (key == "some") return get_some_fn();
-    return std::nullopt;
-}
-
-std::optional<AnyValue> get(const AnyValue &key)
-{
-    if (key.is_string())
-        return get(key.as_string()->value);
+        std::optional<AnyValue> get(const std::string &key)
+        {
+            if (key == "toString")
+                return get_toString_fn();
+            if (key == "next")
+                return get_next_fn();
+            if (key == "return")
+                return get_return_fn();
+            if (key == "throw")
+                return get_throw_fn();
+            if (key == "toArray")
+                return get_toArray_fn();
+            if (key == "drop")
+                return get_drop_fn();
+            if (key == "take")
+                return get_take_fn();
+            if (key == "some")
+                return get_some_fn();
+            return std::nullopt;
+        }
+
+        std::optional<AnyValue> get(const AnyValue &key)
+        {
+            if (key.is_string())
+                return get(key.as_string()->value);
 
-    if (key == AnyValue::from_symbol(WellKnownSymbols::toStringTag)) return get_toString_fn();
-    if (key == AnyValue::from_symbol(WellKnownSymbols::iterator)) return get_iterator_fn();
+            if (key == AnyValue::from_symbol(WellKnownSymbols::toStringTag))
+                return get_toString_fn();
+            if (key == AnyValue::from_symbol(WellKnownSymbols::iterator))
+                return get_iterator_fn();
 
-    return std::nullopt;
-}
+            return std::nullopt;
+        }
 
-} // namespace IteratorPrototypes
+    } // namespace IteratorPrototypes
 
 } // namespace jspp