jseption 0.0.5 → 0.0.7

package/dist/builtins/iterator.js

@@ -0,0 +1,624 @@
+/*
+ * The Iterator global, %IteratorPrototype% helpers (map, filter, take, drop,
+ * flatMap, reduce, toArray, forEach, some, every, find), Iterator.from with
+ * %WrapForValidIteratorPrototype%, %IteratorHelperPrototype% and
+ * Iterator.concat. Port of the "Iterator" section of quickjs.c 2026-06-04
+ * (js_iterator_*, js_create_iterator_helper, js_iterator_helper_next).
+ *
+ * The guest's %IteratorPrototype% is ctx.iterator_proto (builtins/index.ts):
+ * every guest iterator prototype (array, map, set, string, regexp string,
+ * generator) already inherits from it, so the helpers apply to all of them.
+ *
+ * Deviations from the C, where the C does not follow the specification
+ * (each one checked against the host engine, which implements these
+ * natively, by tests/iterator.test.ts):
+ *  - %IteratorHelperPrototype%.return closes the underlying iterator with
+ *    IteratorClose (a missing `return` method is not an error) and returns
+ *    {value: undefined, done: true}; the C calls the underlying `return` as
+ *    if it were `next`, throws when it is missing and passes its result on.
+ *  - a helper whose step throws is finished, as a generator is; in the C a
+ *    later next() goes on with the underlying iterator.
+ *  - drop() reads only `done` of the results it skips (IteratorStep).
+ *  - flatMap() reads the inner iterator's `next` once.
+ *  - reduce() on an empty iterator with no initial value throws without
+ *    closing the (exhausted) iterator, and a failed `next` lookup is not
+ *    followed by IteratorClose.
+ *  - %WrapForValidIteratorPrototype%.next and .return return the result of
+ *    the underlying call as it is, instead of a new result object.
+ *  - Iterator.concat returns an Iterator Helper (%IteratorHelperPrototype%,
+ *    tag "Iterator Helper") as the specification says, not an object of its
+ *    own class; a step that throws finishes it.
+ *  - the Iterator.prototype.constructor setter follows
+ *    SetterThatIgnoresPrototypeProperties like the Symbol.toStringTag one.
+ */
+import { JS_EXCEPTION, JS_IsException, JS_IsUndefined, JS_IsObject, JS_IsFunction, JS_IsNull, JS_NewObjectProto, JS_NewObjectClass, JS_NewArray, JS_NewCFunction2, JS_NewCFunctionData, JS_SetOpaque, JS_GetOpaque2, JS_GetProperty, JS_SetProperty, JS_Call, JS_GetIterator2, JS_IteratorNext, JS_IteratorNext2, JS_IteratorClose, JS_OrdinaryIsInstanceOf, JS_ThrowTypeError, JS_ThrowRangeError, JS_ThrowTypeErrorNotAnObject, JS_ToNumber, JS_ToFloat64, JS_ToBoolFree, JS_DefineProperty, JS_DefinePropertyValue, JS_DefinePropertyValueInt64, JS_DefinePropertyValueStr, JS_GetOwnProperty, JS_SetPropertyFunctionList, JS_SetConstructor, js_create_from_ctor, js_meta, hooks, JS_NewClass1, JS_IsRegisteredClass, JS_CFUNC_DEF, JS_CFUNC_MAGIC_DEF, JS_CGETSET_DEF, JS_ITERATOR_NEXT_DEF, JS_PROP_STRING_DEF, JS_PROP_WRITABLE, JS_PROP_CONFIGURABLE, JS_PROP_C_W_E, JS_PROP_THROW, JS_PROP_HAS_GET, JS_PROP_HAS_SET, JS_PROP_HAS_CONFIGURABLE, JS_PROP_HAS_ENUMERABLE, JS_ATOM_next, JS_ATOM_return, JS_ATOM_length, JS_ATOM_constructor, JS_ATOM_Symbol_iterator, JS_ATOM_Symbol_toStringTag, } from "../quickjs.js";
+import { GEN_MAGIC_NEXT, GEN_MAGIC_RETURN } from "../interpreter.js";
+const MAX_SAFE_INTEGER = 9007199254740991;
+/* pdone.done for an iterator_next function: return the value as it is,
+   without wrapping it in a new result object (js_call_c_function) */
+const RAW_RESULT = 2;
+function check_function(ctx, obj) {
+    if (JS_IsFunction(ctx, obj))
+        return 0;
+    JS_ThrowTypeError(ctx, 'not a function');
+    return -1;
+}
+/* the Iterator constructor of each context (ctx->iterator_ctor) */
+const iterator_ctors = new WeakMap();
+/* ------------------------------------------------------------------ */
+/* Iterator Wrap (%WrapForValidIteratorPrototype%)                      */
+class JSIteratorWrapData {
+    wrapped_iter;
+    wrapped_next;
+    constructor(wrapped_iter, wrapped_next) {
+        this.wrapped_iter = wrapped_iter;
+        this.wrapped_next = wrapped_next;
+    }
+}
+function js_iterator_wrap_next(ctx, this_val, argv, pdone, magic) {
+    const it = JS_GetOpaque2(ctx, this_val, 59 /* JSClassID.ITERATOR_WRAP */);
+    if (!it)
+        return JS_EXCEPTION;
+    if (magic === GEN_MAGIC_NEXT) {
+        /* Return ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]) */
+        pdone.done = RAW_RESULT;
+        return JS_Call(ctx, it.wrapped_next, it.wrapped_iter, []);
+    }
+    const method = JS_GetProperty(ctx, it.wrapped_iter, JS_ATOM_return);
+    if (JS_IsException(method))
+        return JS_EXCEPTION;
+    if (JS_IsNull(method) || JS_IsUndefined(method)) {
+        pdone.done = 1;
+        return undefined;
+    }
+    pdone.done = RAW_RESULT;
+    return JS_Call(ctx, method, it.wrapped_iter, []);
+}
+const js_iterator_wrap_proto_funcs = [
+    JS_ITERATOR_NEXT_DEF('next', 0, js_iterator_wrap_next, GEN_MAGIC_NEXT),
+    JS_ITERATOR_NEXT_DEF('return', 0, js_iterator_wrap_next, GEN_MAGIC_RETURN),
+];
+/* ------------------------------------------------------------------ */
+/* Iterator                                                             */
+/* SetterThatIgnoresPrototypeProperties(this, %Iterator.prototype%, p, v) */
+function js_iterator_proto_setter(ctx, this_val, prop, val) {
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    if (this_val === ctx.class_proto[57 /* JSClassID.ITERATOR */])
+        return JS_ThrowTypeError(ctx, 'Cannot assign to read only property');
+    const res = JS_GetOwnProperty(ctx, null, this_val, prop);
+    if (res < 0)
+        return JS_EXCEPTION;
+    if (res) {
+        if (JS_SetProperty(ctx, this_val, prop, val) < 0)
+            return JS_EXCEPTION;
+    }
+    else {
+        if (JS_DefinePropertyValue(ctx, this_val, prop, val, JS_PROP_C_W_E | JS_PROP_THROW) < 0)
+            return JS_EXCEPTION;
+    }
+    return undefined;
+}
+function js_iterator_constructor_getset(ctx, this_val, argv, magic, func_data) {
+    if (argv.length > 0)
+        return js_iterator_proto_setter(ctx, this_val, JS_ATOM_constructor, argv[0]); /* setter */
+    return func_data[0];
+}
+function js_iterator_constructor(ctx, new_target, argv) {
+    if (!JS_IsObject(new_target))
+        return JS_ThrowTypeError(ctx, "constructor requires 'new'");
+    const cf = js_meta.get(new_target)?.cfunc;
+    if (cf !== undefined && cf !== null && cf.func === js_iterator_constructor) {
+        return JS_ThrowTypeError(ctx, 'abstract class not constructable');
+    }
+    return js_create_from_ctor(ctx, new_target, 57 /* JSClassID.ITERATOR */);
+}
+/* ------------------------------------------------------------------ */
+/* Iterator.from                                                        */
+function js_iterator_from(ctx, this_val, argv) {
+    const obj = argv[0];
+    if (!JS_IsObject(obj) && typeof obj !== 'string')
+        return JS_ThrowTypeError(ctx, 'Iterator.from called on non-object');
+    let method = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_iterator);
+    if (JS_IsException(method))
+        return JS_EXCEPTION;
+    let iter;
+    if (JS_IsNull(method) || JS_IsUndefined(method)) {
+        iter = obj;
+    }
+    else {
+        iter = JS_GetIterator2(ctx, obj, method);
+        if (JS_IsException(iter))
+            return JS_EXCEPTION;
+    }
+    method = JS_GetProperty(ctx, iter, JS_ATOM_next);
+    if (JS_IsException(method))
+        return JS_EXCEPTION;
+    const ret = JS_OrdinaryIsInstanceOf(ctx, iter, iterator_ctors.get(ctx));
+    if (ret < 0)
+        return JS_EXCEPTION;
+    if (ret)
+        return iter;
+    const wrapper = JS_NewObjectClass(ctx, 59 /* JSClassID.ITERATOR_WRAP */);
+    if (JS_IsException(wrapper))
+        return JS_EXCEPTION;
+    JS_SetOpaque(wrapper, new JSIteratorWrapData(iter, method));
+    return wrapper;
+}
+class JSIteratorHelperData {
+    kind;
+    obj;
+    next;
+    func;
+    count;
+    inner = undefined; /* innerValue (flatMap) */
+    inner_next = undefined;
+    executing = false;
+    done = false;
+    /* concat: the (iterable, @@iterator method) pairs and the next pair to open */
+    values = [];
+    index = 0;
+    constructor(kind, obj, /* the underlying iterator (concat: the open one, or undefined) */ next, /* its next method */ func, /* predicate (filter) or mapper (flatMap, map) */ count) {
+        this.kind = kind;
+        this.obj = obj;
+        this.next = next;
+        this.func = func;
+        this.count = count;
+    } /* limit (drop, take) or counter (filter, map, flatMap) */
+}
+function js_create_iterator_helper(ctx, this_val, argv, magic) {
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    let func = undefined;
+    let count = 0;
+    fail: {
+        switch (magic) {
+            case 0 /* Kind.DROP */:
+            case 8 /* Kind.TAKE */: {
+                const v = JS_ToNumber(ctx, argv[0]);
+                if (JS_IsException(v))
+                    break fail;
+                const dlimit = JS_ToFloat64(ctx, v);
+                if (JS_IsException(dlimit))
+                    break fail;
+                const d = dlimit;
+                if (Number.isNaN(d)) {
+                    JS_ThrowRangeError(ctx, 'must be positive');
+                    break fail;
+                }
+                if (!Number.isFinite(d)) {
+                    if (d < 0) {
+                        JS_ThrowRangeError(ctx, 'must be positive');
+                        break fail;
+                    }
+                    count = MAX_SAFE_INTEGER;
+                }
+                else {
+                    count = Math.trunc(d);
+                }
+                if (count < 0) {
+                    JS_ThrowRangeError(ctx, 'must be positive');
+                    break fail;
+                }
+                break;
+            }
+            case 2 /* Kind.FILTER */:
+            case 4 /* Kind.FLAT_MAP */:
+            case 6 /* Kind.MAP */:
+                func = argv[0];
+                if (check_function(ctx, func))
+                    break fail;
+                break;
+        }
+        const method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
+        if (JS_IsException(method))
+            return JS_EXCEPTION; /* GetIteratorDirect: no IteratorClose */
+        const obj = JS_NewObjectClass(ctx, 58 /* JSClassID.ITERATOR_HELPER */);
+        if (JS_IsException(obj))
+            break fail;
+        JS_SetOpaque(obj, new JSIteratorHelperData(magic, this_val, method, func, count));
+        return obj;
+    }
+    JS_IteratorClose(ctx, this_val, true);
+    return JS_EXCEPTION;
+}
+/* Iterator.concat(...items) */
+function js_iterator_concat(ctx, this_val, argv) {
+    const values = [];
+    for (let i = 0; i < argv.length; i++) {
+        const obj = argv[i];
+        if (!JS_IsObject(obj))
+            return JS_ThrowTypeErrorNotAnObject(ctx);
+        const method = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_iterator);
+        if (JS_IsException(method))
+            return JS_EXCEPTION;
+        if (!JS_IsFunction(ctx, method))
+            return JS_ThrowTypeError(ctx, 'not a function');
+        values.push(obj, method);
+    }
+    const obj = JS_NewObjectClass(ctx, 58 /* JSClassID.ITERATOR_HELPER */);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    const it = new JSIteratorHelperData(9 /* Kind.CONCAT */, undefined, undefined, undefined, 0);
+    it.values = values;
+    JS_SetOpaque(obj, it);
+    return obj;
+}
+/* every, find, forEach, some */
+function js_iterator_proto_func(ctx, this_val, argv, magic) {
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    const func = argv[0];
+    if (check_function(ctx, func)) {
+        JS_IteratorClose(ctx, this_val, true);
+        return JS_EXCEPTION;
+    }
+    const method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
+    if (JS_IsException(method))
+        return JS_EXCEPTION;
+    const pdone = { done: 0 };
+    let r = magic === 1 /* Kind.EVERY */ ? true : magic === 7 /* Kind.SOME */ ? false : undefined;
+    for (let idx = 0;; idx++) {
+        const item = JS_IteratorNext(ctx, this_val, method, [], pdone);
+        if (JS_IsException(item))
+            return JS_EXCEPTION;
+        if (pdone.done)
+            break;
+        const ret = JS_Call(ctx, func, undefined, [item, idx]);
+        if (JS_IsException(ret)) {
+            JS_IteratorClose(ctx, this_val, true);
+            return JS_EXCEPTION;
+        }
+        if (magic === 5 /* Kind.FOR_EACH */)
+            continue;
+        const b = JS_ToBoolFree(ctx, ret);
+        let stop, result;
+        switch (magic) {
+            case 1 /* Kind.EVERY */:
+                stop = !b;
+                result = false;
+                break;
+            case 3 /* Kind.FIND */:
+                stop = b;
+                result = item;
+                break;
+            default:
+                stop = b;
+                result = true;
+                break; /* SOME */
+        }
+        if (stop) {
+            if (JS_IteratorClose(ctx, this_val, false) < 0)
+                return JS_EXCEPTION;
+            r = result;
+            break;
+        }
+    }
+    return r;
+}
+function js_iterator_proto_reduce(ctx, this_val, argv) {
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    const func = argv[0];
+    if (check_function(ctx, func)) {
+        JS_IteratorClose(ctx, this_val, true);
+        return JS_EXCEPTION;
+    }
+    const method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
+    if (JS_IsException(method))
+        return JS_EXCEPTION;
+    const pdone = { done: 0 };
+    let acc, idx;
+    if (argv.length > 1) {
+        acc = argv[1];
+        idx = 0;
+    }
+    else {
+        acc = JS_IteratorNext(ctx, this_val, method, [], pdone);
+        if (JS_IsException(acc))
+            return JS_EXCEPTION;
+        if (pdone.done)
+            return JS_ThrowTypeError(ctx, 'empty iterator');
+        idx = 1;
+    }
+    for (;; idx++) {
+        const item = JS_IteratorNext(ctx, this_val, method, [], pdone);
+        if (JS_IsException(item))
+            return JS_EXCEPTION;
+        if (pdone.done)
+            break;
+        const ret = JS_Call(ctx, func, undefined, [acc, item, idx]);
+        if (JS_IsException(ret)) {
+            JS_IteratorClose(ctx, this_val, true);
+            return JS_EXCEPTION;
+        }
+        acc = ret;
+    }
+    return acc;
+}
+function js_iterator_proto_toArray(ctx, this_val, argv) {
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    const method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
+    if (JS_IsException(method))
+        return JS_EXCEPTION;
+    const result = JS_NewArray(ctx);
+    if (JS_IsException(result))
+        return JS_EXCEPTION;
+    const pdone = { done: 0 };
+    let idx = 0;
+    for (;; idx++) {
+        const item = JS_IteratorNext(ctx, this_val, method, [], pdone);
+        if (JS_IsException(item))
+            return JS_EXCEPTION;
+        if (pdone.done)
+            break;
+        if (JS_DefinePropertyValueInt64(ctx, result, idx, item, JS_PROP_C_W_E | JS_PROP_THROW) < 0)
+            return JS_EXCEPTION;
+    }
+    if (JS_SetProperty(ctx, result, JS_ATOM_length, idx) < 0)
+        return JS_EXCEPTION;
+    return result;
+}
+function js_iterator_proto_get_toStringTag(ctx, this_val) {
+    return 'Iterator';
+}
+function js_iterator_proto_set_toStringTag(ctx, this_val, val) {
+    return js_iterator_proto_setter(ctx, this_val, JS_ATOM_Symbol_toStringTag, val);
+}
+/* one step of Iterator.concat: the next value, or done when every iterable is exhausted */
+function concat_step(ctx, it, pdone) {
+    for (;;) {
+        if (JS_IsUndefined(it.obj)) {
+            if (it.index >= it.values.length) {
+                pdone.done = 1;
+                return undefined;
+            }
+            const iter = JS_GetIterator2(ctx, it.values[it.index], it.values[it.index + 1]);
+            it.values[it.index] = it.values[it.index + 1] = undefined;
+            it.index += 2;
+            if (JS_IsException(iter))
+                return JS_EXCEPTION;
+            const next = JS_GetProperty(ctx, iter, JS_ATOM_next);
+            if (JS_IsException(next))
+                return JS_EXCEPTION;
+            it.obj = iter;
+            it.next = next;
+        }
+        const d = { done: 0 };
+        const item = JS_IteratorNext(ctx, it.obj, it.next, [], d);
+        if (JS_IsException(item))
+            return JS_EXCEPTION;
+        if (!d.done)
+            return item;
+        /* this iterable is exhausted: go on with the next one */
+        it.obj = undefined;
+        it.next = undefined;
+    }
+}
+function js_iterator_helper_next(ctx, this_val, argv, pdone, magic) {
+    pdone.done = 0;
+    const it = JS_GetOpaque2(ctx, this_val, 58 /* JSClassID.ITERATOR_HELPER */);
+    if (!it)
+        return JS_EXCEPTION;
+    if (it.executing)
+        return JS_ThrowTypeError(ctx, 'cannot invoke a running iterator');
+    if (it.done) {
+        pdone.done = 1;
+        return undefined;
+    }
+    it.executing = true;
+    let ret;
+    if (magic === GEN_MAGIC_RETURN) {
+        /* GeneratorResumeAbrupt with a return completion: close the inner
+           (flatMap) and the underlying iterator, then report done */
+        ret = undefined;
+        pdone.done = 1;
+        it.done = true;
+        it.values = [];
+        if (!JS_IsUndefined(it.inner)) {
+            const inner = it.inner;
+            it.inner = undefined;
+            if (JS_IteratorClose(ctx, inner, false) < 0) {
+                if (!JS_IsUndefined(it.obj))
+                    JS_IteratorClose(ctx, it.obj, true);
+                ret = JS_EXCEPTION;
+            }
+        }
+        if (!JS_IsException(ret) && !JS_IsUndefined(it.obj) && JS_IteratorClose(ctx, it.obj, false) < 0)
+            ret = JS_EXCEPTION;
+        it.executing = false;
+        return ret;
+    }
+    const method = it.next;
+    done: {
+        fail: {
+            switch (it.kind) {
+                case 0 /* Kind.DROP */: {
+                    while (it.count > 0) {
+                        it.count--;
+                        /* IteratorStep: only `done` is read */
+                        const r = JS_IteratorNext2(ctx, it.obj, method, [], pdone);
+                        if (JS_IsException(r)) {
+                            ret = JS_EXCEPTION;
+                            break done;
+                        }
+                        if (pdone.done) {
+                            ret = undefined;
+                            break done;
+                        }
+                    }
+                    ret = JS_IteratorNext(ctx, it.obj, method, [], pdone);
+                    break done;
+                }
+                case 2 /* Kind.FILTER */: {
+                    for (;;) {
+                        const item = JS_IteratorNext(ctx, it.obj, method, [], pdone);
+                        if (JS_IsException(item)) {
+                            ret = JS_EXCEPTION;
+                            break done;
+                        }
+                        if (pdone.done) {
+                            ret = item;
+                            break done;
+                        }
+                        const selected = JS_Call(ctx, it.func, undefined, [item, it.count++]);
+                        if (JS_IsException(selected))
+                            break fail;
+                        if (JS_ToBoolFree(ctx, selected)) {
+                            ret = item;
+                            break done;
+                        }
+                    }
+                }
+                case 4 /* Kind.FLAT_MAP */: {
+                    for (;;) {
+                        if (JS_IsUndefined(it.inner)) {
+                            const item = JS_IteratorNext(ctx, it.obj, method, [], pdone);
+                            if (JS_IsException(item)) {
+                                ret = JS_EXCEPTION;
+                                break done;
+                            }
+                            if (pdone.done) {
+                                ret = item;
+                                break done;
+                            }
+                            const mapped = JS_Call(ctx, it.func, undefined, [item, it.count++]);
+                            if (JS_IsException(mapped))
+                                break fail;
+                            /* GetIteratorFlattenable(mapped, reject-primitives) */
+                            if (!JS_IsObject(mapped)) {
+                                JS_ThrowTypeError(ctx, 'not an object');
+                                break fail;
+                            }
+                            const m = JS_GetProperty(ctx, mapped, JS_ATOM_Symbol_iterator);
+                            if (JS_IsException(m))
+                                break fail;
+                            let iter;
+                            if (JS_IsNull(m) || JS_IsUndefined(m)) {
+                                iter = mapped;
+                            }
+                            else {
+                                iter = JS_GetIterator2(ctx, mapped, m);
+                                if (JS_IsException(iter))
+                                    break fail;
+                            }
+                            const inner_next = JS_GetProperty(ctx, iter, JS_ATOM_next);
+                            if (JS_IsException(inner_next))
+                                break fail;
+                            it.inner = iter;
+                            it.inner_next = inner_next;
+                        }
+                        const d = { done: 0 };
+                        const item = JS_IteratorNext(ctx, it.inner, it.inner_next, [], d);
+                        if (JS_IsException(item)) {
+                            it.inner = it.inner_next = undefined;
+                            break fail;
+                        }
+                        if (d.done) {
+                            /* the inner iterator is exhausted: the outer one goes on */
+                            it.inner = it.inner_next = undefined;
+                            continue;
+                        }
+                        ret = item;
+                        break done;
+                    }
+                }
+                case 6 /* Kind.MAP */: {
+                    const item = JS_IteratorNext(ctx, it.obj, method, [], pdone);
+                    if (JS_IsException(item)) {
+                        ret = JS_EXCEPTION;
+                        break done;
+                    }
+                    if (pdone.done) {
+                        ret = item;
+                        break done;
+                    }
+                    ret = JS_Call(ctx, it.func, undefined, [item, it.count++]);
+                    if (JS_IsException(ret))
+                        break fail;
+                    break done;
+                }
+                case 8 /* Kind.TAKE */: {
+                    if (it.count > 0) {
+                        it.count--;
+                        ret = JS_IteratorNext(ctx, it.obj, method, [], pdone);
+                        break done;
+                    }
+                    pdone.done = 1;
+                    ret = JS_IteratorClose(ctx, it.obj, false) < 0 ? JS_EXCEPTION : undefined;
+                    break done;
+                }
+                case 9 /* Kind.CONCAT */:
+                    ret = concat_step(ctx, it, pdone);
+                    break done;
+                default:
+                    throw new Error('iterator helper: bad kind');
+            }
+        }
+        /* close the iterator object, preserving the pending exception */
+        JS_IteratorClose(ctx, it.obj, true);
+        ret = JS_EXCEPTION;
+    }
+    /* an exception ends the helper, as it ends a generator */
+    if (JS_IsException(ret) || pdone.done) {
+        it.done = true;
+        it.values = [];
+    }
+    it.executing = false;
+    return ret;
+}
+const js_iterator_funcs = [
+    JS_CFUNC_DEF('concat', 0, js_iterator_concat),
+    JS_CFUNC_DEF('from', 1, js_iterator_from),
+];
+const js_iterator_proto_funcs = [
+    JS_CFUNC_MAGIC_DEF('drop', 1, js_create_iterator_helper, 0 /* Kind.DROP */),
+    JS_CFUNC_MAGIC_DEF('filter', 1, js_create_iterator_helper, 2 /* Kind.FILTER */),
+    JS_CFUNC_MAGIC_DEF('flatMap', 1, js_create_iterator_helper, 4 /* Kind.FLAT_MAP */),
+    JS_CFUNC_MAGIC_DEF('map', 1, js_create_iterator_helper, 6 /* Kind.MAP */),
+    JS_CFUNC_MAGIC_DEF('take', 1, js_create_iterator_helper, 8 /* Kind.TAKE */),
+    JS_CFUNC_MAGIC_DEF('every', 1, js_iterator_proto_func, 1 /* Kind.EVERY */),
+    JS_CFUNC_MAGIC_DEF('find', 1, js_iterator_proto_func, 3 /* Kind.FIND */),
+    JS_CFUNC_MAGIC_DEF('forEach', 1, js_iterator_proto_func, 5 /* Kind.FOR_EACH */),
+    JS_CFUNC_MAGIC_DEF('some', 1, js_iterator_proto_func, 7 /* Kind.SOME */),
+    JS_CFUNC_DEF('reduce', 1, js_iterator_proto_reduce),
+    JS_CFUNC_DEF('toArray', 0, js_iterator_proto_toArray),
+    /* [Symbol.iterator] is defined with %IteratorPrototype% (builtins/index.ts) */
+    JS_CGETSET_DEF(JS_ATOM_Symbol_toStringTag, js_iterator_proto_get_toStringTag, js_iterator_proto_set_toStringTag),
+];
+const js_iterator_helper_proto_funcs = [
+    JS_ITERATOR_NEXT_DEF('next', 0, js_iterator_helper_next, GEN_MAGIC_NEXT),
+    JS_ITERATOR_NEXT_DEF('return', 0, js_iterator_helper_next, GEN_MAGIC_RETURN),
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'Iterator Helper', JS_PROP_CONFIGURABLE),
+];
+/* the class ids of this file, registered in every runtime */
+hooks.init_runtime.push((rt) => {
+    for (const [id, name] of [[57 /* JSClassID.ITERATOR */, 'Iterator'], [58 /* JSClassID.ITERATOR_HELPER */, 'Iterator Helper'],
+        [59 /* JSClassID.ITERATOR_WRAP */, 'Iterator Wrap']]) {
+        if (!JS_IsRegisteredClass(rt, id))
+            JS_NewClass1(rt, id, { class_name: rt.atoms.newAtomStr(name) });
+    }
+});
+/* Iterator and its prototypes; %IteratorPrototype% is ctx.iterator_proto */
+export function JS_AddIntrinsicIterator(ctx) {
+    const proto = ctx.iterator_proto;
+    ctx.class_proto[57 /* JSClassID.ITERATOR */] = proto;
+    JS_SetPropertyFunctionList(ctx, proto, js_iterator_proto_funcs);
+    const ctor = JS_NewCFunction2(ctx, js_iterator_constructor, 'Iterator', 0, 4 /* JSCFunctionEnum.constructor_or_func */, 0);
+    JS_SetPropertyFunctionList(ctx, ctor, js_iterator_funcs);
+    JS_DefinePropertyValueStr(ctx, ctx.global_obj, 'Iterator', ctor, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    JS_SetConstructor(ctx, ctor, proto);
+    /* quirk: Iterator.prototype.constructor is an accessor property */
+    const getset = JS_NewCFunctionData(ctx, js_iterator_constructor_getset, 0, 0, [ctor]);
+    JS_DefineProperty(ctx, proto, JS_ATOM_constructor, undefined, getset, getset, JS_PROP_HAS_GET | JS_PROP_HAS_SET | JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE |
+        JS_PROP_HAS_ENUMERABLE);
+    iterator_ctors.set(ctx, ctor);
+    for (const [id, funcs] of [[58 /* JSClassID.ITERATOR_HELPER */, js_iterator_helper_proto_funcs],
+        [59 /* JSClassID.ITERATOR_WRAP */, js_iterator_wrap_proto_funcs]]) {
+        const p = JS_NewObjectProto(ctx, proto);
+        ctx.class_proto[id] = p;
+        JS_SetPropertyFunctionList(ctx, p, funcs);
+    }
+}
+//# sourceMappingURL=iterator.js.map