jseption 0.0.0-stage → 0.0.2

package/dist/interpreter.js

@@ -0,0 +1,3768 @@
+/*
+ * jseption: TypeScript port of QuickJS
+ *
+ * Port of the bytecode interpreter of quickjs.c: JS_CallInternal, closures,
+ * variable references, the arguments objects, private fields/brands,
+ * class definition, generators, async functions and async generators.
+ */
+import { jit_hooks, JIT_NOT_COMPILED } from "./jit_hook.js";
+import { JS_EXCEPTION, JS_UNINITIALIZED, JS_IsException, JS_IsUndefined, JS_IsObject, JS_IsUninitialized, JS_IsCatchOffset, JS_NewCatchOffset, JSFunctionData, JSVarRef, JSStackFrame, EMPTY_VAR_REFS, JSAsyncFunctionState, JSGeneratorData, JS_CALL_FLAG_CONSTRUCTOR, JS_CALL_FLAG_COPY_ARGV, JS_CALL_FLAG_GENERATOR, JS_MODE_STRICT, JS_MODE_ASYNC, JS_PROP_CONFIGURABLE, JS_PROP_WRITABLE, JS_PROP_ENUMERABLE, JS_PROP_C_W_E, JS_PROP_THROW, JS_PROP_THROW_STRICT, JS_PROP_HAS_GET, JS_PROP_HAS_SET, JS_PROP_HAS_VALUE, JS_PROP_HAS_WRITABLE, JS_PROP_HAS_CONFIGURABLE, JS_PROP_HAS_ENUMERABLE, JS_EVAL_TYPE_DIRECT, JS_EVAL_FLAG_STRICT, js_meta, js_get_meta, js_new_host_function, js_take_exception, js_call_host_function, js_call_c_function, js_c_function_data_call, JS_GetFunctionData, js_privates, JS_AtomToKey, js_host_exception_to_guest, JS_ATOM_NULL, JS_ATOM_length, JS_ATOM_name, JS_ATOM_prototype, JS_ATOM_constructor, JS_ATOM_callee, JS_ATOM_Symbol_iterator, JS_ATOM_Symbol_unscopables, JS_ATOM_Private_brand, JS_ATOM_brand, JS_ATOM_empty_string, JS_ATOM_next, JS_ATOM_return, JS_ATOM_throw, JS_ATOM_undefined, JS_ATOM_function, JS_ATOM_TYPE_PRIVATE, JS_ATOM_Symbol_toStringTag, hooks, JS_Throw, JS_GetException, JS_ThrowTypeError, JS_ThrowTypeErrorAtom, JS_ThrowTypeErrorNotAnObject, JS_ThrowTypeErrorNotASymbol, JS_ThrowReferenceError, JS_ThrowReferenceErrorNotDefined, JS_ThrowReferenceErrorUninitialized, JS_ThrowReferenceErrorUninitialized2, JS_ThrowSyntaxErrorAtom, JS_ThrowInternalError, JS_ThrowStackOverflow, JS_ThrowTypeErrorReadOnly, JS_IsUncatchableError, JS_SetUncatchableError, build_backtrace, is_strict_mode, JS_NewObject, JS_NewObjectProto, JS_NewObjectProtoClass, JS_NewObjectClass, JS_NewArray, JS_NewSymbolFromAtom, JS_AtomToValue, JS_AtomToString, JS_ValueToAtom, JS_NewCFunctionData, JS_GetProperty, JS_GetPropertyInternal, JS_GetPropertyValue, JS_SetPropertyInternal, JS_SetPropertyValue, JS_HasProperty, JS_DefineProperty, JS_DefinePropertyValue, JS_DefinePropertyValueValue, JS_DefinePropertyValueUint32, JS_DeleteProperty, JS_GetPrototype, JS_SetPrototypeInternal, JS_IsFunction, JS_IsConstructor, JS_CheckGlobalVar, JS_GetGlobalVar, JS_SetGlobalVar, JS_GetGlobalVarRef, JS_DefineGlobalVar, JS_CheckDefineGlobalVar, JS_DefineGlobalFunction, JS_CopyDataProperties, JS_Call, JS_CallFree, JS_CallConstructorInternal, JS_CallConstructor2, js_create_from_ctor, JS_GetOpaque, JS_SetOpaque, JS_ToBoolFree, JS_ToObject, JS_ToPropertyKey, JS_ToNumericFree, js_add_slow, js_binary_arith_slow, js_unary_arith_slow, js_relational_op, js_loose_eq, js_strict_eq2, JS_IsInstanceOf, js_operator_typeof, js_operator_in, JS_GetIterator, JS_IteratorNext, JS_IteratorClose, JS_IteratorGetCompleteValue, build_arg_list, build_for_in_iterator, js_for_in_next, js_create_iterator_result, js_get_fast_array, js_get_length64, async_hooks, JS_ITERATOR_NEXT_DEF, JS_CFUNC_MAGIC_DEF, JS_PROP_STRING_DEF, JS_NewArrayFrom, } from "./quickjs.js";
+import { OP_DEFINE_METHOD_METHOD, OP_DEFINE_METHOD_GETTER, OP_DEFINE_METHOD_ENUMERABLE, JS_DEFINE_CLASS_HAS_HERITAGE, JS_THROW_VAR_RO, JS_THROW_VAR_REDECL, JS_THROW_VAR_UNINITIALIZED, JS_THROW_ERROR_DELETE_SUPER, JS_THROW_ERROR_ITERATOR_THROW, FUNC_RET_AWAIT, FUNC_RET_YIELD, FUNC_RET_YIELD_STAR, FUNC_RET_INITIAL_YIELD, get_i8, get_u16, get_i16, get_u32, get_i32, } from "./opcodes.js";
+import { JS_NewPromiseCapability, js_promise_resolve, perform_promise_then } from "./builtins/promise.js";
+export const ARG_SCOPE_END = -2;
+export const GEN_MAGIC_NEXT = 0;
+export const GEN_MAGIC_RETURN = 1;
+export const GEN_MAGIC_THROW = 2;
+/* ---------------------------------------------------------------------
+   Variable references
+   --------------------------------------------------------------------- */
+export function js_class_has_bytecode(class_id) {
+    return class_id === 13 /* JSClassID.BYTECODE_FUNCTION */ || class_id === 16 /* JSClassID.GENERATOR_FUNCTION */ ||
+        class_id === 48 /* JSClassID.ASYNC_FUNCTION */ || class_id === 52 /* JSClassID.ASYNC_GENERATOR_FUNCTION */;
+}
+export function get_var_ref(ctx, sf, var_idx, is_arg) {
+    for (const vr of sf.var_refs) {
+        if (!vr.is_detached && vr.is_arg === is_arg && vr.var_idx === var_idx)
+            return vr;
+    }
+    const vr = new JSVarRef(sf, is_arg, var_idx);
+    if (sf.var_refs === EMPTY_VAR_REFS)
+        sf.var_refs = [];
+    sf.var_refs.push(vr);
+    return vr;
+}
+export function close_var_refs(rt, sf) {
+    if (sf.var_refs === EMPTY_VAR_REFS)
+        return;
+    for (const vr of sf.var_refs)
+        vr.detach();
+    sf.var_refs.length = 0;
+}
+export function close_lexical_var(ctx, sf, var_idx) {
+    const refs = sf.var_refs;
+    for (let i = refs.length - 1; i >= 0; i--) {
+        const vr = refs[i];
+        if (!vr.is_arg && vr.var_idx === var_idx) {
+            vr.detach();
+            refs.splice(i, 1);
+        }
+    }
+}
+/* ---------------------------------------------------------------------
+   Closures
+   --------------------------------------------------------------------- */
+function func_kind_to_class_id(kind) {
+    switch (kind) {
+        case 1 /* JSFunctionKind.GENERATOR */: return 16 /* JSClassID.GENERATOR_FUNCTION */;
+        case 2 /* JSFunctionKind.ASYNC */: return 48 /* JSClassID.ASYNC_FUNCTION */;
+        case 3 /* JSFunctionKind.ASYNC_GENERATOR */: return 52 /* JSClassID.ASYNC_GENERATOR_FUNCTION */;
+        default: return 13 /* JSClassID.BYTECODE_FUNCTION */;
+    }
+}
+/* collect the variable references of a closure from the current frame */
+function js_build_var_refs(ctx, b, cur_var_refs, sf) {
+    const var_refs = [];
+    for (let i = 0; i < b.closure_var.length; i++) {
+        const cv = b.closure_var[i];
+        if (cv.is_local) {
+            /* reuse the existing variable reference if it already exists */
+            if (!sf) {
+                JS_ThrowInternalError(ctx, 'closure without stack frame');
+                return null;
+            }
+            var_refs.push(get_var_ref(ctx, sf, cv.var_idx, cv.is_arg));
+        }
+        else {
+            if (!cur_var_refs) {
+                JS_ThrowInternalError(ctx, 'closure without parent var refs');
+                return null;
+            }
+            var_refs.push(cur_var_refs[cv.var_idx]);
+        }
+    }
+    return var_refs;
+}
+/* Create the guest function object of a bytecode function with the given
+   variable references. The object is a strict host wrapper whose
+   implementation runs the interpreter (or the compiled code). */
+export function js_closure_from_refs(ctx, b, var_refs, proto, is_ctor) {
+    /* compiled tier: a retargetable wrapper that switches to the compiled body once it exists */
+    if (jit_hooks.make_wrapper !== null && b.func_kind === 0 /* JSFunctionKind.NORMAL */ && !b.no_jit) {
+        const w = jit_hooks.make_wrapper(ctx, b, var_refs, proto, is_ctor);
+        if (w !== null)
+            return w;
+    }
+    let fobj;
+    const impl = (this_val, new_target, args) => {
+        let ret;
+        if (new_target !== undefined)
+            ret = JS_CallInternal(ctx, fobj, new_target, new_target, args, JS_CALL_FLAG_CONSTRUCTOR);
+        else
+            ret = JS_CallInternal(ctx, fobj, this_val, undefined, args, 0);
+        if (ret === JS_EXCEPTION)
+            throw js_take_exception(ctx);
+        return ret;
+    };
+    fobj = js_new_host_function(ctx, impl, is_ctor, '', b.defined_arg_count, proto, func_kind_to_class_id(b.func_kind));
+    const m = js_meta.get(fobj);
+    m.func = new JSFunctionData(b, var_refs);
+    m.realm = b.realm ?? ctx;
+    return fobj;
+}
+export function js_closure2(ctx, b, cur_var_refs, sf, proto, is_ctor) {
+    const var_refs = js_build_var_refs(ctx, b, cur_var_refs, sf);
+    if (!var_refs)
+        return JS_EXCEPTION;
+    return js_closure_from_refs(ctx, b, var_refs, proto, is_ctor);
+}
+function js_instantiate_prototype(ctx, p) {
+    const obj = JS_NewObject(ctx);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_constructor, p, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE) < 0)
+        return JS_EXCEPTION;
+    return obj;
+}
+export function js_function_set_properties(ctx, func_obj, name, len) {
+    JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_length, len, JS_PROP_CONFIGURABLE);
+    JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_name, JS_AtomToString(ctx, name), JS_PROP_CONFIGURABLE);
+}
+export function js_closure(ctx, b, cur_var_refs, sf) {
+    const class_id = func_kind_to_class_id(b.func_kind);
+    const proto = ctx.class_proto[class_id] ?? ctx.function_proto;
+    const func_obj = js_closure2(ctx, b, cur_var_refs, sf, proto, b.has_prototype);
+    if (JS_IsException(func_obj))
+        return JS_EXCEPTION;
+    let name_atom = b.func_name;
+    if (name_atom === JS_ATOM_NULL)
+        name_atom = JS_ATOM_empty_string;
+    js_function_set_properties(ctx, func_obj, name_atom, b.defined_arg_count);
+    if (b.func_kind & 1 /* JSFunctionKind.GENERATOR */) {
+        /* generators have a prototype field which is used as prototype for the generator object */
+        const proto_class_id = (b.func_kind === 3 /* JSFunctionKind.ASYNC_GENERATOR */) ? 53 /* JSClassID.ASYNC_GENERATOR */ : 43 /* JSClassID.GENERATOR */;
+        const gproto = JS_NewObjectProto(ctx, ctx.class_proto[proto_class_id]);
+        if (JS_IsException(gproto))
+            return JS_EXCEPTION;
+        JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_prototype, gproto, JS_PROP_WRITABLE);
+    }
+    else if (b.has_prototype) {
+        const proto_obj = js_instantiate_prototype(ctx, func_obj);
+        if (JS_IsException(proto_obj))
+            return JS_EXCEPTION;
+        JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_prototype, proto_obj, JS_PROP_WRITABLE);
+    }
+    return func_obj;
+}
+/* ---------------------------------------------------------------------
+   Arguments objects
+   --------------------------------------------------------------------- */
+export function js_build_arguments(ctx, argc, argv) {
+    const val = JS_NewObjectProtoClass(ctx, ctx.class_proto[1 /* JSClassID.OBJECT */], 8 /* JSClassID.ARGUMENTS */);
+    if (JS_IsException(val))
+        return val;
+    for (let i = 0; i < argc; i++) {
+        Reflect.defineProperty(val, i, { value: argv[i], writable: true, enumerable: true, configurable: true });
+    }
+    JS_DefinePropertyValue(ctx, val, JS_ATOM_length, argc, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    JS_DefinePropertyValue(ctx, val, JS_ATOM_Symbol_iterator, ctx.array_proto_values, JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
+    /* add callee property to throw a TypeError in strict mode */
+    JS_DefineProperty(ctx, val, JS_ATOM_callee, undefined, ctx.throw_type_error ?? undefined, ctx.throw_type_error ?? undefined, JS_PROP_HAS_GET | JS_PROP_HAS_SET);
+    return val;
+}
+/* legacy arguments object: add references to the function arguments */
+export function js_build_mapped_arguments(ctx, argc, argv, sf, arg_count) {
+    const val = JS_NewObjectProtoClass(ctx, ctx.class_proto[1 /* JSClassID.OBJECT */], 9 /* JSClassID.MAPPED_ARGUMENTS */);
+    if (JS_IsException(val))
+        return val;
+    JS_DefinePropertyValue(ctx, val, JS_ATOM_length, argc, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    /* the mapped arguments alias the variables through accessor properties */
+    for (let i = 0; i < arg_count; i++) {
+        const var_ref = get_var_ref(ctx, sf, i, true);
+        const getter = js_new_host_function(ctx, () => var_ref.get(), false, '', 0, ctx.function_proto, 12 /* JSClassID.C_FUNCTION */);
+        const setter = js_new_host_function(ctx, (_t, _nt, args) => { var_ref.set(args[0]); return undefined; }, false, '', 1, ctx.function_proto, 12 /* JSClassID.C_FUNCTION */);
+        Reflect.defineProperty(val, i, { get: getter, set: setter, enumerable: true, configurable: true });
+    }
+    /* the arguments not mapped to the arguments of the function can be normal properties */
+    for (let i = arg_count; i < argc; i++) {
+        if (JS_DefinePropertyValueUint32(ctx, val, i, argv[i], JS_PROP_C_W_E) < 0)
+            return JS_EXCEPTION;
+    }
+    JS_DefinePropertyValue(ctx, val, JS_ATOM_Symbol_iterator, ctx.array_proto_values, JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
+    /* callee returns this function in non strict mode */
+    JS_DefinePropertyValue(ctx, val, JS_ATOM_callee, sf.cur_func, JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
+    return val;
+}
+function __atom_from_idx(i) { return i + 0x80000000; }
+export function js_build_rest(ctx, first, argc, argv) {
+    return JS_NewArrayFrom(ctx, first < argc ? argv.slice(first, argc) : []);
+}
+/* ---------------------------------------------------------------------
+   Private fields and brands
+   --------------------------------------------------------------------- */
+function JS_ThrowTypeErrorPrivateNotFound(ctx, atom) {
+    return JS_ThrowTypeErrorAtom(ctx, "private class field '%s' does not exist", atom);
+}
+/* private fields and brands live in a side table keyed by the object, so
+   they are invisible to Reflect.ownKeys and proxy traps */
+function js_private_map(obj, create) {
+    let m = js_privates.get(obj);
+    if (!m && create) {
+        m = new Map();
+        js_privates.set(obj, m);
+    }
+    return m;
+}
+function js_private_atom(ctx, name) {
+    return ctx.rt.atoms.symbolToAtom(name);
+}
+export function JS_DefinePrivateField(ctx, obj, name, val) {
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    if (typeof name !== 'symbol') {
+        JS_ThrowTypeErrorNotASymbol(ctx);
+        return -1;
+    }
+    const m = js_private_map(obj, true);
+    if (m.has(name)) {
+        JS_ThrowTypeErrorAtom(ctx, "private class field '%s' already exists", js_private_atom(ctx, name));
+        return -1;
+    }
+    m.set(name, val);
+    return 0;
+}
+export function JS_GetPrivateField(ctx, obj, name) {
+    if (!JS_IsObject(obj))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    if (typeof name !== 'symbol')
+        return JS_ThrowTypeErrorNotASymbol(ctx);
+    const m = js_private_map(obj, false);
+    if (!m || !m.has(name))
+        return JS_ThrowTypeErrorPrivateNotFound(ctx, js_private_atom(ctx, name));
+    return m.get(name);
+}
+export function JS_SetPrivateField(ctx, obj, name, val) {
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    if (typeof name !== 'symbol') {
+        JS_ThrowTypeErrorNotASymbol(ctx);
+        return -1;
+    }
+    const m = js_private_map(obj, false);
+    if (!m || !m.has(name)) {
+        JS_ThrowTypeErrorPrivateNotFound(ctx, js_private_atom(ctx, name));
+        return -1;
+    }
+    m.set(name, val);
+    return 0;
+}
+/* add a private brand field to 'home_obj' if not already present and
+   if obj is != null add a private brand to it */
+export function JS_AddBrand(ctx, obj, home_obj) {
+    if (!JS_IsObject(home_obj)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    const brand_key = ctx.rt.atoms.getSymbol(JS_ATOM_Private_brand);
+    const hm = js_private_map(home_obj, true);
+    let brand = hm.get(brand_key);
+    if (brand === undefined) {
+        /* if the brand is not present, add it */
+        brand = JS_NewSymbolFromAtom(ctx, JS_ATOM_brand, JS_ATOM_TYPE_PRIVATE);
+        hm.set(brand_key, brand);
+    }
+    if (JS_IsObject(obj)) {
+        const m = js_private_map(obj, true);
+        if (m.has(brand)) {
+            JS_ThrowTypeError(ctx, 'private method is already present');
+            return -1;
+        }
+        m.set(brand, undefined);
+    }
+    return 0;
+}
+/* return a boolean telling if the brand of the home object of 'func'
+   is present on 'obj' or -1 in case of exception */
+export function JS_CheckBrand(ctx, obj, func) {
+    const fd = JS_GetFunctionData(func);
+    if (!fd || !fd.home_object) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    const brand_key = ctx.rt.atoms.getSymbol(JS_ATOM_Private_brand);
+    const brand = js_private_map(fd.home_object, false)?.get(brand_key);
+    if (brand === undefined) {
+        JS_ThrowTypeError(ctx, 'expecting <brand> private field');
+        return -1;
+    }
+    if (typeof brand !== 'symbol') {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    return js_private_map(obj, false)?.has(brand) ? 1 : 0;
+}
+/* op1 = object, op2 = field name or method function; returns -1/0/1 */
+export function js_operator_private_in(ctx, op1, op2) {
+    if (!JS_IsObject(op1)) {
+        JS_ThrowTypeError(ctx, "invalid 'in' operand");
+        return -1;
+    }
+    if (JS_IsObject(op2)) {
+        /* method: use the brand */
+        return JS_CheckBrand(ctx, op1, op2);
+    }
+    if (typeof op2 !== 'symbol') {
+        JS_ThrowTypeErrorNotASymbol(ctx);
+        return -1;
+    }
+    return js_private_map(op1, false)?.has(op2) ? 1 : 0;
+}
+/* ---------------------------------------------------------------------
+   Methods, names and classes
+   --------------------------------------------------------------------- */
+export function js_method_set_home_object(ctx, func_obj, home_obj) {
+    const fd = JS_GetFunctionData(func_obj);
+    if (!fd)
+        return;
+    if (fd.function_bytecode.need_home_object) {
+        fd.home_object = JS_IsObject(home_obj) ? home_obj : null;
+    }
+}
+export function js_get_function_name(ctx, name) {
+    const name_str = JS_AtomToString(ctx, name);
+    if (ctx.rt.atoms.isSymbol(name)) {
+        const sym = ctx.rt.atoms.getSymbol(name);
+        if (sym.description !== undefined)
+            return '[' + name_str + ']';
+        return '';
+    }
+    return name_str;
+}
+/* Modify the name of a method according to the atom and 'flags'
+   (bitmask of JS_PROP_HAS_GET and JS_PROP_HAS_SET). Also set the home
+   object of the method. Return < 0 if exception. */
+export function js_method_set_properties(ctx, func_obj, name, flags, home_obj) {
+    let name_str = js_get_function_name(ctx, name);
+    if (flags & JS_PROP_HAS_GET)
+        name_str = 'get ' + name_str;
+    else if (flags & JS_PROP_HAS_SET)
+        name_str = 'set ' + name_str;
+    if (JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_name, name_str, JS_PROP_CONFIGURABLE) < 0)
+        return -1;
+    js_method_set_home_object(ctx, func_obj, home_obj);
+    return 0;
+}
+/* return TRUE if 'obj' has a non empty 'name' string */
+function js_object_has_name(ctx, obj) {
+    let d;
+    try {
+        d = Reflect.getOwnPropertyDescriptor(obj, 'name');
+    }
+    catch {
+        return true;
+    }
+    if (!d)
+        return false;
+    if ('get' in d || 'set' in d)
+        return true;
+    if (typeof d.value !== 'string')
+        return true;
+    return d.value.length !== 0;
+}
+export function JS_DefineObjectName(ctx, obj, name, flags) {
+    if (name !== JS_ATOM_NULL && JS_IsObject(obj) && !js_object_has_name(ctx, obj) &&
+        JS_DefinePropertyValue(ctx, obj, JS_ATOM_name, JS_AtomToString(ctx, name), flags) < 0) {
+        return -1;
+    }
+    return 0;
+}
+export function JS_DefineObjectNameComputed(ctx, obj, str, flags) {
+    if (JS_IsObject(obj) && !js_object_has_name(ctx, obj)) {
+        const prop = JS_ValueToAtom(ctx, str);
+        if (prop === JS_ATOM_NULL)
+            return -1;
+        const name_str = js_get_function_name(ctx, prop);
+        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_name, name_str, flags) < 0)
+            return -1;
+    }
+    return 0;
+}
+/* Define a class: returns [ctor, proto] or null on exception. 'var_refs'
+   are the variable references of the constructor closure (already built;
+   see js_build_var_refs). 'computed_name' is the class name value when
+   the name is computed (class_name is then ignored). */
+export function js_define_class(ctx, class_name, class_flags, parent_class, b, var_refs, is_computed_name, computed_name) {
+    let parent_proto;
+    if (class_flags & JS_DEFINE_CLASS_HAS_HERITAGE) {
+        if (parent_class === null) {
+            parent_proto = null;
+            parent_class = ctx.function_proto;
+        }
+        else {
+            if (!JS_IsConstructor(ctx, parent_class)) {
+                JS_ThrowTypeError(ctx, 'parent class must be constructor');
+                return null;
+            }
+            parent_proto = JS_GetProperty(ctx, parent_class, JS_ATOM_prototype);
+            if (JS_IsException(parent_proto))
+                return null;
+            if (parent_proto !== null && !JS_IsObject(parent_proto)) {
+                JS_ThrowTypeError(ctx, 'parent prototype must be an object or null');
+                return null;
+            }
+        }
+    }
+    else {
+        /* parent_class is JS_UNDEFINED in this case */
+        parent_proto = ctx.class_proto[1 /* JSClassID.OBJECT */];
+        parent_class = ctx.function_proto;
+    }
+    const proto = JS_NewObjectProto(ctx, parent_proto);
+    if (JS_IsException(proto))
+        return null;
+    const ctor = js_closure_from_refs(ctx, b, var_refs, parent_class, true);
+    if (JS_IsException(ctor))
+        return null;
+    js_method_set_home_object(ctx, ctor, proto);
+    const m = js_meta.get(ctor);
+    m.is_constructor = true;
+    m.is_class = true;
+    JS_DefinePropertyValue(ctx, ctor, JS_ATOM_length, b.defined_arg_count, JS_PROP_CONFIGURABLE);
+    if (is_computed_name) {
+        if (JS_DefineObjectNameComputed(ctx, ctor, computed_name, JS_PROP_CONFIGURABLE) < 0)
+            return null;
+    }
+    else {
+        if (JS_DefineObjectName(ctx, ctor, class_name, JS_PROP_CONFIGURABLE) < 0)
+            return null;
+    }
+    /* the constructor property must be first. It can be overriden by computed property names */
+    if (JS_DefinePropertyValue(ctx, proto, JS_ATOM_constructor, ctor, JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE | JS_PROP_THROW) < 0)
+        return null;
+    /* set the prototype property */
+    if (JS_DefinePropertyValue(ctx, ctor, JS_ATOM_prototype, proto, JS_PROP_THROW) < 0)
+        return null;
+    return [ctor, proto];
+}
+/* stack: [name] parent ctor_bytecode -> [name] ctor proto */
+function js_op_define_class(ctx, stack, sp, class_name, class_flags, cur_var_refs, sf, is_computed_name) {
+    const parent_class = stack[sp - 2];
+    const bfunc = stack[sp - 1];
+    const fail = () => { stack[sp - 2] = undefined; stack[sp - 1] = undefined; return -1; };
+    const var_refs = js_build_var_refs(ctx, bfunc, cur_var_refs, sf);
+    if (!var_refs)
+        return fail();
+    const r = js_define_class(ctx, class_name, class_flags, parent_class, bfunc, var_refs, is_computed_name, is_computed_name ? stack[sp - 3] : undefined);
+    if (!r)
+        return fail();
+    stack[sp - 2] = r[0];
+    stack[sp - 1] = r[1];
+    return 0;
+}
+/* ---------------------------------------------------------------------
+   Iteration helpers
+   --------------------------------------------------------------------- */
+/* stack: obj -> iter next  (returns -1 on exception) */
+function js_for_of_start(ctx, stack, sp, is_async) {
+    const op1 = stack[sp - 1];
+    const obj = JS_GetIterator(ctx, op1, is_async);
+    if (JS_IsException(obj))
+        return -1;
+    stack[sp - 1] = obj;
+    const method = JS_GetProperty(ctx, obj, JS_ATOM_next);
+    if (JS_IsException(method))
+        return -1;
+    stack[sp] = method;
+    return 0;
+}
+/* enum_rec [objs] -> enum_rec [objs] value done. There are 'offset'
+   objs. If 'done' is true or in case of exception, 'enum_rec' is set
+   to undefined. If 'done' is true, 'value' is always set to undefined. */
+function js_for_of_next(ctx, stack, sp, offset) {
+    let value = undefined;
+    let done = 1;
+    const iter = stack[sp + offset];
+    if (!JS_IsUndefined(iter)) {
+        const pdone = { done: 0 };
+        value = JS_IteratorNext(ctx, iter, stack[sp + offset + 1], [], pdone);
+        if (JS_IsException(value))
+            done = -1;
+        else
+            done = pdone.done;
+        if (done) {
+            /* replace the iteration object with undefined */
+            stack[sp + offset] = undefined;
+            if (done < 0)
+                return -1;
+            value = undefined;
+        }
+    }
+    stack[sp] = value;
+    stack[sp + 1] = done !== 0;
+    return 0;
+}
+/* stack: iter next catch_offset -> iter next catch_offset obj */
+function js_for_await_of_next(ctx, stack, sp) {
+    stack[sp - 1] = undefined; /* disable the catch offset so that exceptions do not close the iterator */
+    const iter = stack[sp - 3];
+    const next = stack[sp - 2];
+    const obj = JS_Call(ctx, next, iter, []);
+    if (JS_IsException(obj))
+        return -1;
+    stack[sp] = obj;
+    return 0;
+}
+/* stack: catch_offset obj -> catch_offset value done */
+function js_iterator_get_value_done(ctx, stack, sp) {
+    const obj = stack[sp - 1];
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeError(ctx, 'iterator must return an object');
+        return -1;
+    }
+    const pdone = { done: 0 };
+    const value = JS_IteratorGetCompleteValue(ctx, obj, pdone);
+    if (JS_IsException(value))
+        return -1;
+    /* put again the catch offset so that exceptions close the iterator */
+    stack[sp - 2] = JS_NewCatchOffset(0);
+    stack[sp - 1] = value;
+    stack[sp] = pdone.done !== 0;
+    return 0;
+}
+/* stack: array pos enumobj -> array pos enumobj (pos updated) */
+function js_append_enumerate(ctx, stack, sp) {
+    if (typeof stack[sp - 2] !== 'number') {
+        JS_ThrowInternalError(ctx, 'invalid index for append');
+        return -1;
+    }
+    let pos = stack[sp - 2];
+    const src = stack[sp - 1];
+    const target = stack[sp - 3];
+    const iterator = JS_GetProperty(ctx, src, JS_ATOM_Symbol_iterator);
+    if (JS_IsException(iterator))
+        return -1;
+    const is_array_iterator = iterator !== undefined && iterator === ctx.array_proto_values;
+    const enumobj = JS_GetIterator(ctx, src, false);
+    if (JS_IsException(enumobj))
+        return -1;
+    const method = JS_GetProperty(ctx, enumobj, JS_ATOM_next);
+    if (JS_IsException(method))
+        return -1;
+    const fast = js_get_fast_array(ctx, src);
+    let fast_ok = false;
+    if (is_array_iterator && fast && ctx.array_iterator_proto && Reflect.getPrototypeOf(enumobj) === ctx.array_iterator_proto) {
+        const next_d = Reflect.getOwnPropertyDescriptor(ctx.array_iterator_proto, 'next');
+        if (next_d && 'value' in next_d && next_d.value === method) {
+            const len = js_get_length64(ctx, src);
+            if (len < 0) {
+                JS_IteratorClose(ctx, enumobj, true);
+                return -1;
+            }
+            /* if len > count, the elements >= count might be read in the prototypes */
+            if (len === fast.length)
+                fast_ok = true;
+        }
+    }
+    if (fast_ok) {
+        const count = fast.length;
+        for (let i = 0; i < count; i++) {
+            if (JS_DefinePropertyValueUint32(ctx, target, pos++, fast[i], JS_PROP_C_W_E) < 0) {
+                JS_IteratorClose(ctx, enumobj, true);
+                return -1;
+            }
+        }
+    }
+    else {
+        const pdone = { done: 0 };
+        for (;;) {
+            const value = JS_IteratorNext(ctx, enumobj, method, [], pdone);
+            if (JS_IsException(value)) {
+                JS_IteratorClose(ctx, enumobj, true);
+                return -1;
+            }
+            if (pdone.done)
+                break;
+            if (JS_DefinePropertyValueUint32(ctx, target, pos++, value, JS_PROP_C_W_E) < 0) {
+                JS_IteratorClose(ctx, enumobj, true);
+                return -1;
+            }
+        }
+    }
+    stack[sp - 2] = pos;
+    return 0;
+}
+function js_has_unscopable(ctx, obj, atom) {
+    const arr = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_unscopables);
+    if (JS_IsException(arr))
+        return -1;
+    let ret = 0;
+    if (JS_IsObject(arr)) {
+        const val = JS_GetProperty(ctx, arr, atom);
+        if (JS_IsException(val))
+            return -1;
+        ret = JS_ToBoolFree(ctx, val) ? 1 : 0;
+    }
+    return ret;
+}
+/* Function.prototype.apply / Reflect.apply / Reflect.construct helper
+   magic: 0 = apply, 1 = construct (this_arg is new_target), 2 = Reflect.apply (array required) */
+export function js_function_apply(ctx, this_val, argv, magic) {
+    if (!JS_IsFunction(ctx, this_val))
+        return JS_ThrowTypeError(ctx, 'not a function');
+    const this_arg = argv[0];
+    const array_arg = argv[1];
+    if ((array_arg === undefined || array_arg === null) && magic !== 2) {
+        return JS_Call(ctx, this_val, this_arg, []);
+    }
+    const tab = build_arg_list(ctx, array_arg);
+    if (!tab)
+        return JS_EXCEPTION;
+    if (magic & 1)
+        return JS_CallConstructor2(ctx, this_val, this_arg, tab);
+    return JS_Call(ctx, this_val, this_arg, tab);
+}
+function JS_EvalObject(ctx, this_obj, val, flags, scope_idx) {
+    if (typeof val !== 'string')
+        return val;
+    return hooks.JS_EvalInternal(ctx, this_obj, val, '<input>', flags, scope_idx);
+}
+/* interrupt polling: return -1 if an interrupt was requested */
+function js_poll_interrupts(ctx) {
+    if (--ctx.interrupt_counter <= 0) {
+        ctx.interrupt_counter = 10000;
+        const rt = ctx.rt;
+        if (rt.interrupt_handler) {
+            if (rt.interrupt_handler(rt, rt.interrupt_opaque)) {
+                /* XXX: should set a specific flag to avoid catching */
+                JS_ThrowInternalError(ctx, 'interrupted');
+                JS_SetUncatchableError(ctx, rt.current_exception, true);
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+function is_backtrace_needed(ctx, obj) {
+    const m = js_get_meta(obj);
+    return m !== undefined && m.class_id === 3 /* JSClassID.ERROR */ && !m.has_backtrace;
+}
+/* ---------------------------------------------------------------------
+   JS_CallInternal
+   --------------------------------------------------------------------- */
+export function JS_CallInternal(ctx, func_obj, this_obj, new_target, argv, flags) {
+    if (typeof func_obj !== 'function')
+        return JS_ThrowTypeError(ctx, 'not a function');
+    const m = js_meta.get(func_obj);
+    if (m !== undefined) {
+        const fd = m.func;
+        if (fd !== null) {
+            const b = fd.function_bytecode;
+            /* compiled tier (src/jit.ts): compiles hot functions and calls the direct entry */
+            if (jit_hooks.try_call !== null && b.func_kind === 0 /* JSFunctionKind.NORMAL */) {
+                const r = jit_hooks.try_call(ctx, func_obj, fd, b, this_obj, new_target, argv, flags);
+                if (r !== JIT_NOT_COMPILED)
+                    return r;
+            }
+            if (b.compiled === null) {
+                switch (b.func_kind) {
+                    case 0 /* JSFunctionKind.NORMAL */:
+                        return js_call_internal(ctx, func_obj, this_obj, new_target, argv, flags, null, true);
+                    case 1 /* JSFunctionKind.GENERATOR */:
+                        return js_generator_function_call(ctx, func_obj, this_obj, argv, flags);
+                    case 2 /* JSFunctionKind.ASYNC */:
+                        return js_async_function_call(ctx, func_obj, this_obj, argv, flags);
+                    case 3 /* JSFunctionKind.ASYNC_GENERATOR */:
+                        return js_async_generator_function_call(ctx, func_obj, this_obj, argv, flags);
+                }
+            }
+        }
+        else if (m.cfunc !== null) {
+            return js_call_c_function(ctx, func_obj, this_obj, argv, flags);
+        }
+        else if (m.class_id === 15 /* JSClassID.C_FUNCTION_DATA */) {
+            return js_c_function_data_call(ctx, func_obj, this_obj, argv, flags);
+        }
+    }
+    return js_call_host_function(ctx, func_obj, this_obj, new_target, argv, flags);
+}
+/* backward jumps taken in a function's interpreter frames (cumulated over its calls) before the
+   compiled tier is asked to replace the running frame (jit_hooks.osr) */
+export let jit_osr_threshold = 500;
+export function jit_set_osr_threshold(n) { jit_osr_threshold = n; }
+function js_call_internal(caller_ctx, func_obj, this_obj, new_target, argv, flags, gen_state, jit_checked = false) {
+    if (gen_state === null) {
+        /* only interpreted normal bytecode functions are executed here */
+        const m = typeof func_obj === 'function' ? js_meta.get(func_obj) : undefined;
+        if (m === undefined || m.func === null || m.func.function_bytecode.compiled !== null ||
+            m.func.function_bytecode.func_kind !== 0 /* JSFunctionKind.NORMAL */) {
+            return JS_CallInternal(caller_ctx, func_obj, this_obj, new_target, argv, flags);
+        }
+        /* compiled tier: counts the call and compiles the function once it is hot (JS_CallInternal
+           has asked already when it calls here) */
+        if (!jit_checked && jit_hooks.try_call !== null) {
+            const r = jit_hooks.try_call(caller_ctx, func_obj, m.func, m.func.function_bytecode, this_obj, new_target, argv, flags);
+            if (r !== JIT_NOT_COMPILED)
+                return r;
+        }
+        if (flags & JS_CALL_FLAG_CONSTRUCTOR) {
+            /* legacy constructor behavior: create 'this' from new_target */
+            if (m.func.function_bytecode.is_derived_class_constructor) {
+                this_obj = undefined;
+            }
+            else {
+                const obj = js_create_from_ctor(caller_ctx, new_target, 1 /* JSClassID.OBJECT */);
+                if (JS_IsException(obj))
+                    return JS_EXCEPTION;
+                const ret = js_interpret(caller_ctx, func_obj, obj, new_target, argv, flags & ~JS_CALL_FLAG_CONSTRUCTOR, null);
+                if (JS_IsObject(ret) || JS_IsException(ret))
+                    return ret;
+                return obj;
+            }
+        }
+    }
+    return js_interpret(caller_ctx, func_obj, this_obj, new_target, argv, flags, gen_state);
+}
+/* Runs the bytecode of a function in a new interpreter frame, or resumes the frame of a
+   generator. Exactly one host frame of this function exists per interpreter frame: its name
+   identifies interpreter frames on the host stack (src/jit_stack.ts). */
+function js_interpret(caller_ctx, func_obj, this_obj, new_target, argv, flags, gen_state) {
+    const rt = caller_ctx.rt;
+    let ctx;
+    let p;
+    let fd;
+    let b;
+    let sf;
+    let pc;
+    let sp;
+    let argc;
+    let var_refs;
+    let arg_buf;
+    let var_buf;
+    let stack;
+    let ret_val = undefined;
+    let flow = 0 /* Flow.NORMAL */;
+    if (js_poll_interrupts(caller_ctx))
+        return JS_EXCEPTION;
+    if (gen_state !== null) {
+        /* the stack frame is already allocated (generator / async function resume) */
+        const s = gen_state;
+        sf = s.frame;
+        p = sf.cur_func;
+        fd = JS_GetFunctionData(p);
+        b = fd.function_bytecode;
+        ctx = b.realm ?? caller_ctx;
+        var_refs = fd.var_refs;
+        arg_buf = sf.arg_buf;
+        var_buf = sf.var_buf;
+        stack = sf.stack_buf;
+        argc = s.argc;
+        argv = arg_buf;
+        this_obj = s.this_val;
+        new_target = sf.new_target;
+        sp = sf.cur_sp;
+        sf.cur_sp = -1; /* cur_sp is -1 if the function is running */
+        pc = sf.cur_pc;
+        sf.prev_frame = rt.current_stack_frame;
+        rt.current_stack_frame = sf;
+        rt.stack_depth++;
+        if (s.throw_flag)
+            flow = 1 /* Flow.EXCEPTION */;
+    }
+    else {
+        p = func_obj;
+        fd = js_meta.get(p).func;
+        b = fd.function_bytecode;
+        if (rt.stack_depth >= rt.max_stack_depth)
+            return JS_ThrowStackOverflow(caller_ctx);
+        argc = argv.length;
+        sf = new JSStackFrame();
+        sf.js_mode = b.js_mode;
+        sf.arg_count = argc;
+        sf.cur_func = func_obj;
+        var_refs = fd.var_refs;
+        if (argc < b.arg_count || (flags & JS_CALL_FLAG_COPY_ARGV)) {
+            const n = Math.min(argc, b.arg_count);
+            arg_buf = new Array(Math.max(argc, b.arg_count));
+            for (let i = 0; i < argc; i++)
+                arg_buf[i] = argv[i];
+            for (let i = n; i < b.arg_count; i++)
+                arg_buf[i] = undefined;
+            /* keep the extra arguments (for 'arguments' and rest) */
+        }
+        else {
+            arg_buf = argv;
+        }
+        var_buf = new Array(b.var_count);
+        for (let i = 0; i < b.var_count; i++)
+            var_buf[i] = undefined;
+        stack = new Array(b.stack_size);
+        sf.arg_buf = arg_buf;
+        sf.var_buf = var_buf;
+        sf.stack_buf = stack;
+        sf.this_obj = this_obj;
+        sf.new_target = new_target;
+        sp = 0;
+        pc = 0;
+        sf.prev_frame = rt.current_stack_frame;
+        rt.current_stack_frame = sf;
+        rt.stack_depth++;
+        ctx = b.realm ?? caller_ctx; /* set the current realm */
+        argv = arg_buf;
+    }
+    const buf = b.byte_code_buf;
+    const cpool = b.cpool;
+    /* Host exceptions escaping from the engine helpers (host stack overflow
+       while handling an exception, host natives, bugs) are converted to
+       guest exceptions here so that they never leave the interpreter. */
+    outer: for (;;) {
+        try {
+            main: for (;;) {
+                if (flow === 1 /* Flow.EXCEPTION */) {
+                    /* exception handling */
+                    if (is_backtrace_needed(ctx, rt.current_exception)) {
+                        sf.cur_pc = pc;
+                        build_backtrace(ctx, rt.current_exception, null, 0, 0, 0);
+                    }
+                    flow = 0 /* Flow.NORMAL */;
+                    let handled = false;
+                    if (!JS_IsUncatchableError(ctx, rt.current_exception)) {
+                        while (sp > 0) {
+                            const val = stack[--sp];
+                            if (JS_IsCatchOffset(val)) {
+                                const pos = val.v;
+                                if (pos === 0) {
+                                    /* enumerator: close it with a throw */
+                                    sp--; /* drop the next method */
+                                    JS_IteratorClose(ctx, stack[sp - 1], true);
+                                }
+                                else {
+                                    stack[sp++] = rt.current_exception;
+                                    rt.current_exception = JS_UNINITIALIZED;
+                                    rt.exception_pending = false;
+                                    pc = pos;
+                                    handled = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!handled) {
+                        ret_val = JS_EXCEPTION;
+                        flow = b.func_kind !== 0 /* JSFunctionKind.NORMAL */ ? 3 /* Flow.DONE_GENERATOR */ : 2 /* Flow.DONE */;
+                        break main;
+                    }
+                }
+                const opcode = buf[pc++];
+                sw: switch (opcode) {
+                    case 1 /* OP.push_i32 */:
+                        stack[sp++] = get_i32(buf, pc);
+                        pc += 4;
+                        break;
+                    case 180 /* OP.push_bigint_i32 */:
+                        stack[sp++] = BigInt(get_i32(buf, pc));
+                        pc += 4;
+                        break;
+                    case 2 /* OP.push_const */:
+                        stack[sp++] = cpool[get_u32(buf, pc)];
+                        pc += 4;
+                        break;
+                    case 182 /* OP.push_minus1 */:
+                    case 183 /* OP.push_0 */:
+                    case 184 /* OP.push_1 */:
+                    case 185 /* OP.push_2 */:
+                    case 186 /* OP.push_3 */:
+                    case 187 /* OP.push_4 */:
+                    case 188 /* OP.push_5 */:
+                    case 189 /* OP.push_6 */:
+                    case 190 /* OP.push_7 */:
+                        stack[sp++] = opcode - 183 /* OP.push_0 */;
+                        break;
+                    case 191 /* OP.push_i8 */:
+                        stack[sp++] = get_i8(buf, pc);
+                        pc += 1;
+                        break;
+                    case 192 /* OP.push_i16 */:
+                        stack[sp++] = get_i16(buf, pc);
+                        pc += 2;
+                        break;
+                    case 193 /* OP.push_const8 */:
+                        stack[sp++] = cpool[buf[pc++]];
+                        break;
+                    case 194 /* OP.fclosure8 */: {
+                        const v = js_closure(ctx, cpool[buf[pc++]], var_refs, sf);
+                        if (JS_IsException(v)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = v;
+                        break;
+                    }
+                    case 195 /* OP.push_empty_string */:
+                        stack[sp++] = '';
+                        break;
+                    case 235 /* OP.get_length */: {
+                        sf.cur_pc = pc;
+                        const val = JS_GetProperty(ctx, stack[sp - 1], JS_ATOM_length);
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 1] = val;
+                        break;
+                    }
+                    case 4 /* OP.push_atom_value */:
+                        stack[sp++] = JS_AtomToValue(ctx, get_u32(buf, pc));
+                        pc += 4;
+                        break;
+                    case 6 /* OP.undefined */:
+                        stack[sp++] = undefined;
+                        break;
+                    case 7 /* OP.null */:
+                        stack[sp++] = null;
+                        break;
+                    case 8 /* OP.push_this */: {
+                        /* OP_push_this is only called at the start of a function */
+                        let val;
+                        if (!(b.js_mode & JS_MODE_STRICT)) {
+                            if (JS_IsObject(this_obj)) {
+                                val = this_obj;
+                            }
+                            else if (this_obj === null || this_obj === undefined) {
+                                val = ctx.global_obj;
+                            }
+                            else {
+                                val = JS_ToObject(ctx, this_obj);
+                                if (JS_IsException(val)) {
+                                    flow = 1 /* Flow.EXCEPTION */;
+                                    break;
+                                }
+                            }
+                        }
+                        else {
+                            val = this_obj;
+                        }
+                        stack[sp++] = val;
+                        break;
+                    }
+                    case 9 /* OP.push_false */:
+                        stack[sp++] = false;
+                        break;
+                    case 10 /* OP.push_true */:
+                        stack[sp++] = true;
+                        break;
+                    case 11 /* OP.object */: {
+                        const v = JS_NewObject(ctx);
+                        if (JS_IsException(v)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = v;
+                        break;
+                    }
+                    case 12 /* OP.special_object */: {
+                        const arg = buf[pc++];
+                        let v;
+                        switch (arg) {
+                            case 0 /* OPSpecialObject.ARGUMENTS */:
+                                v = js_build_arguments(ctx, argc, argv);
+                                break;
+                            case 1 /* OPSpecialObject.MAPPED_ARGUMENTS */:
+                                v = js_build_mapped_arguments(ctx, argc, argv, sf, Math.min(argc, b.arg_count));
+                                break;
+                            case 2 /* OPSpecialObject.THIS_FUNC */:
+                                v = sf.cur_func;
+                                break;
+                            case 3 /* OPSpecialObject.NEW_TARGET */:
+                                v = new_target;
+                                break;
+                            case 4 /* OPSpecialObject.HOME_OBJECT */:
+                                v = fd.home_object ?? undefined;
+                                break;
+                            case 5 /* OPSpecialObject.VAR_OBJECT */:
+                                v = JS_NewObjectProto(ctx, null);
+                                break;
+                            case 6 /* OPSpecialObject.IMPORT_META */:
+                                v = JS_ThrowTypeError(ctx, 'import.meta is not supported');
+                                break;
+                            default:
+                                v = JS_ThrowInternalError(ctx, 'invalid special object ' + arg);
+                                break;
+                        }
+                        if (JS_IsException(v)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = v;
+                        break;
+                    }
+                    case 13 /* OP.rest */: {
+                        const first = get_u16(buf, pc);
+                        pc += 2;
+                        const v = js_build_rest(ctx, first, argc, argv);
+                        if (JS_IsException(v)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = v;
+                        break;
+                    }
+                    case 14 /* OP.drop */:
+                        sp--;
+                        break;
+                    case 15 /* OP.nip */: /* a b -> b */
+                        stack[sp - 2] = stack[sp - 1];
+                        sp--;
+                        break;
+                    case 16 /* OP.nip1 */: /* a b c -> b c */
+                        stack[sp - 3] = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 1];
+                        sp--;
+                        break;
+                    case 17 /* OP.dup */:
+                        stack[sp] = stack[sp - 1];
+                        sp++;
+                        break;
+                    case 19 /* OP.dup2 */: /* a b -> a b a b */
+                        stack[sp] = stack[sp - 2];
+                        stack[sp + 1] = stack[sp - 1];
+                        sp += 2;
+                        break;
+                    case 20 /* OP.dup3 */: /* a b c -> a b c a b c */
+                        stack[sp] = stack[sp - 3];
+                        stack[sp + 1] = stack[sp - 2];
+                        stack[sp + 2] = stack[sp - 1];
+                        sp += 3;
+                        break;
+                    case 18 /* OP.dup1 */: /* a b -> a a b */
+                        stack[sp] = stack[sp - 1];
+                        stack[sp - 1] = stack[sp - 2];
+                        sp++;
+                        break;
+                    case 21 /* OP.insert2 */: /* obj a -> a obj a (dup_x1) */
+                        stack[sp] = stack[sp - 1];
+                        stack[sp - 1] = stack[sp - 2];
+                        stack[sp - 2] = stack[sp];
+                        sp++;
+                        break;
+                    case 22 /* OP.insert3 */: /* obj prop a -> a obj prop a (dup_x2) */
+                        stack[sp] = stack[sp - 1];
+                        stack[sp - 1] = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 3];
+                        stack[sp - 3] = stack[sp];
+                        sp++;
+                        break;
+                    case 23 /* OP.insert4 */: /* this obj prop a -> a this obj prop a */
+                        stack[sp] = stack[sp - 1];
+                        stack[sp - 1] = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 3];
+                        stack[sp - 3] = stack[sp - 4];
+                        stack[sp - 4] = stack[sp];
+                        sp++;
+                        break;
+                    case 24 /* OP.perm3 */: { /* obj a b -> a obj b (213) */
+                        const tmp = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 3];
+                        stack[sp - 3] = tmp;
+                        break;
+                    }
+                    case 29 /* OP.rot3l */: { /* x a b -> a b x (231) */
+                        const tmp = stack[sp - 3];
+                        stack[sp - 3] = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 1];
+                        stack[sp - 1] = tmp;
+                        break;
+                    }
+                    case 31 /* OP.rot4l */: { /* x a b c -> a b c x */
+                        const tmp = stack[sp - 4];
+                        stack[sp - 4] = stack[sp - 3];
+                        stack[sp - 3] = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 1];
+                        stack[sp - 1] = tmp;
+                        break;
+                    }
+                    case 32 /* OP.rot5l */: { /* x a b c d -> a b c d x */
+                        const tmp = stack[sp - 5];
+                        stack[sp - 5] = stack[sp - 4];
+                        stack[sp - 4] = stack[sp - 3];
+                        stack[sp - 3] = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 1];
+                        stack[sp - 1] = tmp;
+                        break;
+                    }
+                    case 30 /* OP.rot3r */: { /* a b x -> x a b (312) */
+                        const tmp = stack[sp - 1];
+                        stack[sp - 1] = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 3];
+                        stack[sp - 3] = tmp;
+                        break;
+                    }
+                    case 25 /* OP.perm4 */: { /* obj prop a b -> a obj prop b */
+                        const tmp = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 3];
+                        stack[sp - 3] = stack[sp - 4];
+                        stack[sp - 4] = tmp;
+                        break;
+                    }
+                    case 26 /* OP.perm5 */: { /* this obj prop a b -> a this obj prop b */
+                        const tmp = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 3];
+                        stack[sp - 3] = stack[sp - 4];
+                        stack[sp - 4] = stack[sp - 5];
+                        stack[sp - 5] = tmp;
+                        break;
+                    }
+                    case 27 /* OP.swap */: { /* a b -> b a */
+                        const tmp = stack[sp - 2];
+                        stack[sp - 2] = stack[sp - 1];
+                        stack[sp - 1] = tmp;
+                        break;
+                    }
+                    case 28 /* OP.swap2 */: { /* a b c d -> c d a b */
+                        const tmp1 = stack[sp - 4];
+                        const tmp2 = stack[sp - 3];
+                        stack[sp - 4] = stack[sp - 2];
+                        stack[sp - 3] = stack[sp - 1];
+                        stack[sp - 2] = tmp1;
+                        stack[sp - 1] = tmp2;
+                        break;
+                    }
+                    case 3 /* OP.fclosure */: {
+                        const bfunc = cpool[get_u32(buf, pc)];
+                        pc += 4;
+                        const v = js_closure(ctx, bfunc, var_refs, sf);
+                        if (JS_IsException(v)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = v;
+                        break;
+                    }
+                    case 240 /* OP.call0 */:
+                    case 241 /* OP.call1 */:
+                    case 242 /* OP.call2 */:
+                    case 243 /* OP.call3 */:
+                    case 34 /* OP.call */:
+                    case 35 /* OP.tail_call */: {
+                        let call_argc;
+                        if (opcode === 34 /* OP.call */ || opcode === 35 /* OP.tail_call */) {
+                            call_argc = get_u16(buf, pc);
+                            pc += 2;
+                        }
+                        else {
+                            call_argc = opcode - 240 /* OP.call0 */;
+                        }
+                        const call_argv = stack.slice(sp - call_argc, sp);
+                        sf.cur_pc = pc;
+                        ret_val = js_call_internal(ctx, stack[sp - call_argc - 1], undefined, undefined, call_argv, 0, null);
+                        if (JS_IsException(ret_val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        if (opcode === 35 /* OP.tail_call */) {
+                            flow = 2 /* Flow.DONE */;
+                            break main;
+                        }
+                        sp -= call_argc + 1;
+                        stack[sp++] = ret_val;
+                        break;
+                    }
+                    case 33 /* OP.call_constructor */: {
+                        const call_argc = get_u16(buf, pc);
+                        pc += 2;
+                        const call_argv = stack.slice(sp - call_argc, sp);
+                        sf.cur_pc = pc;
+                        ret_val = JS_CallConstructorInternal(ctx, stack[sp - call_argc - 2], stack[sp - call_argc - 1], call_argv, 0);
+                        if (JS_IsException(ret_val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp -= call_argc + 2;
+                        stack[sp++] = ret_val;
+                        break;
+                    }
+                    case 36 /* OP.call_method */:
+                    case 37 /* OP.tail_call_method */: {
+                        const call_argc = get_u16(buf, pc);
+                        pc += 2;
+                        const call_argv = stack.slice(sp - call_argc, sp);
+                        sf.cur_pc = pc;
+                        ret_val = js_call_internal(ctx, stack[sp - call_argc - 1], stack[sp - call_argc - 2], undefined, call_argv, 0, null);
+                        if (JS_IsException(ret_val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        if (opcode === 37 /* OP.tail_call_method */) {
+                            flow = 2 /* Flow.DONE */;
+                            break main;
+                        }
+                        sp -= call_argc + 2;
+                        stack[sp++] = ret_val;
+                        break;
+                    }
+                    case 38 /* OP.array_from */: {
+                        const call_argc = get_u16(buf, pc);
+                        pc += 2;
+                        const arr = JS_NewArray(ctx);
+                        if (JS_IsException(arr)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const base = sp - call_argc;
+                        let err = false;
+                        for (let i = 0; i < call_argc; i++) {
+                            if (JS_DefinePropertyValue(ctx, arr, __atom_from_idx(i), stack[base + i], JS_PROP_C_W_E | JS_PROP_THROW) < 0) {
+                                err = true;
+                                break;
+                            }
+                        }
+                        if (err) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp -= call_argc;
+                        stack[sp++] = arr;
+                        break;
+                    }
+                    case 39 /* OP.apply */: {
+                        const magic = get_u16(buf, pc);
+                        pc += 2;
+                        sf.cur_pc = pc;
+                        ret_val = js_function_apply(ctx, stack[sp - 3], [stack[sp - 2], stack[sp - 1]], magic);
+                        if (JS_IsException(ret_val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp -= 3;
+                        stack[sp++] = ret_val;
+                        break;
+                    }
+                    case 40 /* OP.return */:
+                        ret_val = stack[--sp];
+                        flow = 2 /* Flow.DONE */;
+                        break main;
+                    case 41 /* OP.return_undef */:
+                        ret_val = undefined;
+                        flow = 2 /* Flow.DONE */;
+                        break main;
+                    case 42 /* OP.check_ctor_return */:
+                        /* return TRUE if 'this' should be returned */
+                        if (!JS_IsObject(stack[sp - 1])) {
+                            if (!JS_IsUndefined(stack[sp - 1])) {
+                                JS_ThrowTypeError(caller_ctx, 'derived class constructor must return an object or undefined');
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp] = true;
+                        }
+                        else {
+                            stack[sp] = false;
+                        }
+                        sp++;
+                        break;
+                    case 43 /* OP.check_ctor */:
+                        if (JS_IsUndefined(new_target)) {
+                            JS_ThrowTypeError(ctx, "class constructors must be invoked with 'new'");
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    case 44 /* OP.init_ctor */: {
+                        sf.cur_pc = pc;
+                        if (JS_IsUndefined(new_target)) {
+                            JS_ThrowTypeError(ctx, "class constructors must be invoked with 'new'");
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const sup = JS_GetPrototype(ctx, sf.cur_func);
+                        if (JS_IsException(sup)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const ret = JS_CallConstructor2(ctx, sup, new_target, argv.slice(0, argc));
+                        if (JS_IsException(ret)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = ret;
+                        break;
+                    }
+                    case 45 /* OP.check_brand */: {
+                        const ret = JS_CheckBrand(ctx, stack[sp - 2], stack[sp - 1]);
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        if (!ret) {
+                            JS_ThrowTypeError(ctx, 'invalid brand on object');
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 46 /* OP.add_brand */:
+                        if (JS_AddBrand(ctx, stack[sp - 2], stack[sp - 1]) < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp -= 2;
+                        break;
+                    case 48 /* OP.throw */:
+                        JS_Throw(ctx, stack[--sp]);
+                        flow = 1 /* Flow.EXCEPTION */;
+                        break;
+                    case 49 /* OP.throw_error */: {
+                        const atom = get_u32(buf, pc);
+                        const type = buf[pc + 4];
+                        pc += 5;
+                        if (type === JS_THROW_VAR_RO)
+                            JS_ThrowTypeErrorReadOnly(ctx, JS_PROP_THROW, atom);
+                        else if (type === JS_THROW_VAR_REDECL)
+                            JS_ThrowSyntaxErrorAtom(ctx, "redeclaration of '%s'", atom);
+                        else if (type === JS_THROW_VAR_UNINITIALIZED)
+                            JS_ThrowReferenceErrorUninitialized(ctx, atom);
+                        else if (type === JS_THROW_ERROR_DELETE_SUPER)
+                            JS_ThrowReferenceError(ctx, "unsupported reference to 'super'");
+                        else if (type === JS_THROW_ERROR_ITERATOR_THROW)
+                            JS_ThrowTypeError(ctx, 'iterator does not have a throw method');
+                        else
+                            JS_ThrowInternalError(ctx, 'invalid throw var type ' + type);
+                        flow = 1 /* Flow.EXCEPTION */;
+                        break;
+                    }
+                    case 50 /* OP.eval */: {
+                        const call_argc = get_u16(buf, pc);
+                        const scope_idx = get_u16(buf, pc + 2) + ARG_SCOPE_END;
+                        pc += 4;
+                        const call_argv = stack.slice(sp - call_argc, sp);
+                        sf.cur_pc = pc;
+                        const fn = stack[sp - call_argc - 1];
+                        if (fn !== undefined && fn === ctx.eval_obj) {
+                            const obj = call_argc >= 1 ? call_argv[0] : undefined;
+                            ret_val = JS_EvalObject(ctx, this_obj, obj, JS_EVAL_TYPE_DIRECT | ((sf.js_mode & JS_MODE_STRICT) ? JS_EVAL_FLAG_STRICT : 0), scope_idx);
+                        }
+                        else {
+                            ret_val = js_call_internal(ctx, fn, undefined, undefined, call_argv, 0, null);
+                        }
+                        if (JS_IsException(ret_val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp -= call_argc + 1;
+                        stack[sp++] = ret_val;
+                        break;
+                    }
+                    case 51 /* OP.apply_eval */: {
+                        const scope_idx = get_u16(buf, pc) + ARG_SCOPE_END;
+                        pc += 2;
+                        sf.cur_pc = pc;
+                        const tab = build_arg_list(ctx, stack[sp - 1]);
+                        if (!tab) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const fn = stack[sp - 2];
+                        if (fn !== undefined && fn === ctx.eval_obj) {
+                            const obj = tab.length >= 1 ? tab[0] : undefined;
+                            ret_val = JS_EvalObject(ctx, this_obj, obj, JS_EVAL_TYPE_DIRECT | ((sf.js_mode & JS_MODE_STRICT) ? JS_EVAL_FLAG_STRICT : 0), scope_idx);
+                        }
+                        else {
+                            ret_val = JS_Call(ctx, fn, undefined, tab);
+                        }
+                        if (JS_IsException(ret_val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp -= 2;
+                        stack[sp++] = ret_val;
+                        break;
+                    }
+                    case 52 /* OP.regexp */: {
+                        sf.cur_pc = pc;
+                        if (!hooks.js_regexp_constructor_internal) {
+                            JS_ThrowInternalError(ctx, 'RegExp is not available');
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const v = hooks.js_regexp_constructor_internal(ctx, undefined, stack[sp - 2], stack[sp - 1]);
+                        if (JS_IsException(v)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 2] = v;
+                        sp--;
+                        break;
+                    }
+                    case 53 /* OP.get_super */: {
+                        sf.cur_pc = pc;
+                        const proto = JS_GetPrototype(ctx, stack[sp - 1]);
+                        if (JS_IsException(proto)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 1] = proto;
+                        break;
+                    }
+                    case 54 /* OP.import */:
+                        sf.cur_pc = pc;
+                        JS_ThrowTypeError(ctx, 'dynamic import is not supported');
+                        flow = 1 /* Flow.EXCEPTION */;
+                        break;
+                    case 55 /* OP.check_var */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        const ret = JS_CheckGlobalVar(ctx, atom);
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = ret !== 0;
+                        break;
+                    }
+                    case 56 /* OP.get_var_undef */:
+                    case 57 /* OP.get_var */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        const val = JS_GetGlobalVar(ctx, atom, opcode - 56 /* OP.get_var_undef */);
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = val;
+                        break;
+                    }
+                    case 58 /* OP.put_var */:
+                    case 59 /* OP.put_var_init */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        const ret = JS_SetGlobalVar(ctx, atom, stack[sp - 1], opcode - 58 /* OP.put_var */);
+                        sp--;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 60 /* OP.put_var_strict */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        /* stack[sp-2] is JS_TRUE or JS_FALSE */
+                        if (!stack[sp - 2]) {
+                            JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const ret = JS_SetGlobalVar(ctx, atom, stack[sp - 1], 2);
+                        sp -= 2;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 64 /* OP.check_define_var */: {
+                        const atom = get_u32(buf, pc);
+                        const fl = buf[pc + 4];
+                        pc += 5;
+                        sf.cur_pc = pc;
+                        if (JS_CheckDefineGlobalVar(ctx, atom, fl)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 63 /* OP.define_var */: {
+                        const atom = get_u32(buf, pc);
+                        const fl = buf[pc + 4];
+                        pc += 5;
+                        sf.cur_pc = pc;
+                        if (JS_DefineGlobalVar(ctx, atom, fl) < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 65 /* OP.define_func */: {
+                        const atom = get_u32(buf, pc);
+                        const fl = buf[pc + 4];
+                        pc += 5;
+                        sf.cur_pc = pc;
+                        if (JS_DefineGlobalFunction(ctx, atom, stack[sp - 1], fl) < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp--;
+                        break;
+                    }
+                    case 89 /* OP.get_loc */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        stack[sp++] = var_buf[idx];
+                        break;
+                    }
+                    case 90 /* OP.put_loc */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        var_buf[idx] = stack[--sp];
+                        break;
+                    }
+                    case 91 /* OP.set_loc */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        var_buf[idx] = stack[sp - 1];
+                        break;
+                    }
+                    case 92 /* OP.get_arg */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        stack[sp++] = arg_buf[idx];
+                        break;
+                    }
+                    case 93 /* OP.put_arg */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        arg_buf[idx] = stack[--sp];
+                        break;
+                    }
+                    case 94 /* OP.set_arg */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        arg_buf[idx] = stack[sp - 1];
+                        break;
+                    }
+                    case 196 /* OP.get_loc8 */:
+                        stack[sp++] = var_buf[buf[pc++]];
+                        break;
+                    case 197 /* OP.put_loc8 */:
+                        var_buf[buf[pc++]] = stack[--sp];
+                        break;
+                    case 198 /* OP.set_loc8 */:
+                        var_buf[buf[pc++]] = stack[sp - 1];
+                        break;
+                    case 199 /* OP.get_loc0 */:
+                        stack[sp++] = var_buf[0];
+                        break;
+                    case 200 /* OP.get_loc1 */:
+                        stack[sp++] = var_buf[1];
+                        break;
+                    case 201 /* OP.get_loc2 */:
+                        stack[sp++] = var_buf[2];
+                        break;
+                    case 202 /* OP.get_loc3 */:
+                        stack[sp++] = var_buf[3];
+                        break;
+                    case 203 /* OP.put_loc0 */:
+                        var_buf[0] = stack[--sp];
+                        break;
+                    case 204 /* OP.put_loc1 */:
+                        var_buf[1] = stack[--sp];
+                        break;
+                    case 205 /* OP.put_loc2 */:
+                        var_buf[2] = stack[--sp];
+                        break;
+                    case 206 /* OP.put_loc3 */:
+                        var_buf[3] = stack[--sp];
+                        break;
+                    case 207 /* OP.set_loc0 */:
+                        var_buf[0] = stack[sp - 1];
+                        break;
+                    case 208 /* OP.set_loc1 */:
+                        var_buf[1] = stack[sp - 1];
+                        break;
+                    case 209 /* OP.set_loc2 */:
+                        var_buf[2] = stack[sp - 1];
+                        break;
+                    case 210 /* OP.set_loc3 */:
+                        var_buf[3] = stack[sp - 1];
+                        break;
+                    case 211 /* OP.get_arg0 */:
+                        stack[sp++] = arg_buf[0];
+                        break;
+                    case 212 /* OP.get_arg1 */:
+                        stack[sp++] = arg_buf[1];
+                        break;
+                    case 213 /* OP.get_arg2 */:
+                        stack[sp++] = arg_buf[2];
+                        break;
+                    case 214 /* OP.get_arg3 */:
+                        stack[sp++] = arg_buf[3];
+                        break;
+                    case 215 /* OP.put_arg0 */:
+                        arg_buf[0] = stack[--sp];
+                        break;
+                    case 216 /* OP.put_arg1 */:
+                        arg_buf[1] = stack[--sp];
+                        break;
+                    case 217 /* OP.put_arg2 */:
+                        arg_buf[2] = stack[--sp];
+                        break;
+                    case 218 /* OP.put_arg3 */:
+                        arg_buf[3] = stack[--sp];
+                        break;
+                    case 219 /* OP.set_arg0 */:
+                        arg_buf[0] = stack[sp - 1];
+                        break;
+                    case 220 /* OP.set_arg1 */:
+                        arg_buf[1] = stack[sp - 1];
+                        break;
+                    case 221 /* OP.set_arg2 */:
+                        arg_buf[2] = stack[sp - 1];
+                        break;
+                    case 222 /* OP.set_arg3 */:
+                        arg_buf[3] = stack[sp - 1];
+                        break;
+                    case 223 /* OP.get_var_ref0 */:
+                        stack[sp++] = var_refs[0].get();
+                        break;
+                    case 224 /* OP.get_var_ref1 */:
+                        stack[sp++] = var_refs[1].get();
+                        break;
+                    case 225 /* OP.get_var_ref2 */:
+                        stack[sp++] = var_refs[2].get();
+                        break;
+                    case 226 /* OP.get_var_ref3 */:
+                        stack[sp++] = var_refs[3].get();
+                        break;
+                    case 227 /* OP.put_var_ref0 */:
+                        var_refs[0].set(stack[--sp]);
+                        break;
+                    case 228 /* OP.put_var_ref1 */:
+                        var_refs[1].set(stack[--sp]);
+                        break;
+                    case 229 /* OP.put_var_ref2 */:
+                        var_refs[2].set(stack[--sp]);
+                        break;
+                    case 230 /* OP.put_var_ref3 */:
+                        var_refs[3].set(stack[--sp]);
+                        break;
+                    case 231 /* OP.set_var_ref0 */:
+                        var_refs[0].set(stack[sp - 1]);
+                        break;
+                    case 232 /* OP.set_var_ref1 */:
+                        var_refs[1].set(stack[sp - 1]);
+                        break;
+                    case 233 /* OP.set_var_ref2 */:
+                        var_refs[2].set(stack[sp - 1]);
+                        break;
+                    case 234 /* OP.set_var_ref3 */:
+                        var_refs[3].set(stack[sp - 1]);
+                        break;
+                    case 95 /* OP.get_var_ref */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        stack[sp++] = var_refs[idx].get();
+                        break;
+                    }
+                    case 96 /* OP.put_var_ref */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        var_refs[idx].set(stack[--sp]);
+                        break;
+                    }
+                    case 97 /* OP.set_var_ref */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        var_refs[idx].set(stack[sp - 1]);
+                        break;
+                    }
+                    case 103 /* OP.get_var_ref_check */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        const val = var_refs[idx].get();
+                        if (JS_IsUninitialized(val)) {
+                            JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, true);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = val;
+                        break;
+                    }
+                    case 104 /* OP.put_var_ref_check */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        if (JS_IsUninitialized(var_refs[idx].get())) {
+                            JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, true);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        var_refs[idx].set(stack[--sp]);
+                        break;
+                    }
+                    case 105 /* OP.put_var_ref_check_init */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        if (!JS_IsUninitialized(var_refs[idx].get())) {
+                            JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, true);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        var_refs[idx].set(stack[--sp]);
+                        break;
+                    }
+                    case 98 /* OP.set_loc_uninitialized */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        var_buf[idx] = JS_UNINITIALIZED;
+                        break;
+                    }
+                    case 99 /* OP.get_loc_check */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        if (JS_IsUninitialized(var_buf[idx])) {
+                            JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, false);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = var_buf[idx];
+                        break;
+                    }
+                    case 102 /* OP.get_loc_checkthis */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        if (JS_IsUninitialized(var_buf[idx])) {
+                            JS_ThrowReferenceErrorUninitialized2(caller_ctx, b, idx, false);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = var_buf[idx];
+                        break;
+                    }
+                    case 100 /* OP.put_loc_check */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        if (JS_IsUninitialized(var_buf[idx])) {
+                            JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, false);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        var_buf[idx] = stack[--sp];
+                        break;
+                    }
+                    case 101 /* OP.put_loc_check_init */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        if (!JS_IsUninitialized(var_buf[idx])) {
+                            JS_ThrowReferenceError(ctx, "'this' can be initialized only once");
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        var_buf[idx] = stack[--sp];
+                        break;
+                    }
+                    case 106 /* OP.close_loc */: {
+                        const idx = get_u16(buf, pc);
+                        pc += 2;
+                        close_lexical_var(ctx, sf, idx);
+                        break;
+                    }
+                    case 122 /* OP.make_loc_ref */:
+                    case 123 /* OP.make_arg_ref */:
+                    case 124 /* OP.make_var_ref_ref */: {
+                        const atom = get_u32(buf, pc);
+                        const idx = get_u16(buf, pc + 4);
+                        pc += 6;
+                        /* internal reference object (never visible to guest code): an
+                           accessor property aliasing the variable */
+                        const obj = Object.create(null);
+                        let var_ref;
+                        if (opcode === 124 /* OP.make_var_ref_ref */)
+                            var_ref = var_refs[idx];
+                        else
+                            var_ref = get_var_ref(ctx, sf, idx, opcode === 123 /* OP.make_arg_ref */);
+                        Reflect.defineProperty(obj, JS_AtomToKey(ctx, atom), {
+                            get: () => var_ref.get(), set: (v) => { var_ref.set(v); }, enumerable: true, configurable: true,
+                        });
+                        stack[sp++] = obj;
+                        stack[sp++] = JS_AtomToValue(ctx, atom);
+                        break;
+                    }
+                    case 125 /* OP.make_var_ref */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        const r = JS_GetGlobalVarRef(ctx, atom);
+                        if (!r) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = r[0];
+                        stack[sp++] = r[1];
+                        break;
+                    }
+                    case 109 /* OP.goto */: {
+                        const diff = get_i32(buf, pc);
+                        pc += diff;
+                        if (js_poll_interrupts(ctx)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        if (diff < 0 && jit_hooks.osr !== null && ++b.loop_count >= jit_osr_threshold && gen_state === null) {
+                            const r = jit_hooks.osr(ctx, func_obj, b, sf, pc, sp);
+                            if (r !== JIT_NOT_COMPILED) {
+                                ret_val = r;
+                                flow = 2 /* Flow.DONE */;
+                                break main;
+                            }
+                        }
+                        break;
+                    }
+                    case 239 /* OP.goto16 */: {
+                        const diff = get_i16(buf, pc);
+                        pc += diff;
+                        if (js_poll_interrupts(ctx)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        if (diff < 0 && jit_hooks.osr !== null && ++b.loop_count >= jit_osr_threshold && gen_state === null) {
+                            const r = jit_hooks.osr(ctx, func_obj, b, sf, pc, sp);
+                            if (r !== JIT_NOT_COMPILED) {
+                                ret_val = r;
+                                flow = 2 /* Flow.DONE */;
+                                break main;
+                            }
+                        }
+                        break;
+                    }
+                    case 238 /* OP.goto8 */: {
+                        const diff = get_i8(buf, pc);
+                        pc += diff;
+                        if (js_poll_interrupts(ctx)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        if (diff < 0 && jit_hooks.osr !== null && ++b.loop_count >= jit_osr_threshold && gen_state === null) {
+                            const r = jit_hooks.osr(ctx, func_obj, b, sf, pc, sp);
+                            if (r !== JIT_NOT_COMPILED) {
+                                ret_val = r;
+                                flow = 2 /* Flow.DONE */;
+                                break main;
+                            }
+                        }
+                        break;
+                    }
+                    case 108 /* OP.if_true */: {
+                        const op1 = stack[--sp];
+                        pc += 4;
+                        const res = typeof op1 === 'boolean' ? op1 : JS_ToBoolFree(ctx, op1);
+                        if (res) {
+                            const diff = get_i32(buf, pc - 4) - 4;
+                            pc += diff;
+                            if (diff < 0 && jit_hooks.osr !== null && ++b.loop_count >= jit_osr_threshold && gen_state === null) {
+                                if (js_poll_interrupts(ctx)) {
+                                    flow = 1 /* Flow.EXCEPTION */;
+                                    break;
+                                }
+                                const r = jit_hooks.osr(ctx, func_obj, b, sf, pc, sp);
+                                if (r !== JIT_NOT_COMPILED) {
+                                    ret_val = r;
+                                    flow = 2 /* Flow.DONE */;
+                                    break main;
+                                }
+                            }
+                        }
+                        if (js_poll_interrupts(ctx)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 107 /* OP.if_false */: {
+                        const op1 = stack[--sp];
+                        pc += 4;
+                        const res = typeof op1 === 'boolean' ? op1 : JS_ToBoolFree(ctx, op1);
+                        if (!res) {
+                            const diff = get_i32(buf, pc - 4) - 4;
+                            pc += diff;
+                            if (diff < 0 && jit_hooks.osr !== null && ++b.loop_count >= jit_osr_threshold && gen_state === null) {
+                                if (js_poll_interrupts(ctx)) {
+                                    flow = 1 /* Flow.EXCEPTION */;
+                                    break;
+                                }
+                                const r = jit_hooks.osr(ctx, func_obj, b, sf, pc, sp);
+                                if (r !== JIT_NOT_COMPILED) {
+                                    ret_val = r;
+                                    flow = 2 /* Flow.DONE */;
+                                    break main;
+                                }
+                            }
+                        }
+                        if (js_poll_interrupts(ctx)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 237 /* OP.if_true8 */: {
+                        const op1 = stack[--sp];
+                        pc += 1;
+                        const res = typeof op1 === 'boolean' ? op1 : JS_ToBoolFree(ctx, op1);
+                        if (res) {
+                            const diff = get_i8(buf, pc - 1) - 1;
+                            pc += diff;
+                            if (diff < 0 && jit_hooks.osr !== null && ++b.loop_count >= jit_osr_threshold && gen_state === null) {
+                                if (js_poll_interrupts(ctx)) {
+                                    flow = 1 /* Flow.EXCEPTION */;
+                                    break;
+                                }
+                                const r = jit_hooks.osr(ctx, func_obj, b, sf, pc, sp);
+                                if (r !== JIT_NOT_COMPILED) {
+                                    ret_val = r;
+                                    flow = 2 /* Flow.DONE */;
+                                    break main;
+                                }
+                            }
+                        }
+                        if (js_poll_interrupts(ctx)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 236 /* OP.if_false8 */: {
+                        const op1 = stack[--sp];
+                        pc += 1;
+                        const res = typeof op1 === 'boolean' ? op1 : JS_ToBoolFree(ctx, op1);
+                        if (!res) {
+                            const diff = get_i8(buf, pc - 1) - 1;
+                            pc += diff;
+                            if (diff < 0 && jit_hooks.osr !== null && ++b.loop_count >= jit_osr_threshold && gen_state === null) {
+                                if (js_poll_interrupts(ctx)) {
+                                    flow = 1 /* Flow.EXCEPTION */;
+                                    break;
+                                }
+                                const r = jit_hooks.osr(ctx, func_obj, b, sf, pc, sp);
+                                if (r !== JIT_NOT_COMPILED) {
+                                    ret_val = r;
+                                    flow = 2 /* Flow.DONE */;
+                                    break main;
+                                }
+                            }
+                        }
+                        if (js_poll_interrupts(ctx)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 110 /* OP.catch */: {
+                        const diff = get_i32(buf, pc);
+                        stack[sp++] = JS_NewCatchOffset(pc + diff);
+                        pc += 4;
+                        break;
+                    }
+                    case 111 /* OP.gosub */: {
+                        const diff = get_i32(buf, pc);
+                        stack[sp++] = pc + 4;
+                        pc += diff;
+                        break;
+                    }
+                    case 112 /* OP.ret */: {
+                        const op1 = stack[sp - 1];
+                        if (typeof op1 !== 'number' || !Number.isInteger(op1) || op1 < 0 || op1 >= b.byte_code_len) {
+                            JS_ThrowInternalError(ctx, 'invalid ret value');
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp--;
+                        pc = op1;
+                        break;
+                    }
+                    case 126 /* OP.for_in_start */: {
+                        sf.cur_pc = pc;
+                        const v = build_for_in_iterator(ctx, stack[sp - 1]);
+                        if (JS_IsException(v)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 1] = v;
+                        break;
+                    }
+                    case 129 /* OP.for_in_next */: {
+                        sf.cur_pc = pc;
+                        const pdone = { done: 0 };
+                        const v = js_for_in_next(ctx, stack[sp - 1], pdone);
+                        if (JS_IsException(v)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = v;
+                        stack[sp++] = pdone.done !== 0;
+                        break;
+                    }
+                    case 127 /* OP.for_of_start */:
+                        sf.cur_pc = pc;
+                        if (js_for_of_start(ctx, stack, sp, false)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp += 1;
+                        stack[sp++] = JS_NewCatchOffset(0);
+                        break;
+                    case 130 /* OP.for_of_next */: {
+                        const offset = -3 - buf[pc];
+                        pc += 1;
+                        sf.cur_pc = pc;
+                        if (js_for_of_next(ctx, stack, sp, offset)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp += 2;
+                        break;
+                    }
+                    case 131 /* OP.for_await_of_next */:
+                        sf.cur_pc = pc;
+                        if (js_for_await_of_next(ctx, stack, sp)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp++;
+                        break;
+                    case 128 /* OP.for_await_of_start */:
+                        sf.cur_pc = pc;
+                        if (js_for_of_start(ctx, stack, sp, true)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp += 1;
+                        stack[sp++] = JS_NewCatchOffset(0);
+                        break;
+                    case 133 /* OP.iterator_get_value_done */:
+                        sf.cur_pc = pc;
+                        if (js_iterator_get_value_done(ctx, stack, sp)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp += 1;
+                        break;
+                    case 132 /* OP.iterator_check_object */:
+                        if (!JS_IsObject(stack[sp - 1])) {
+                            JS_ThrowTypeError(ctx, 'iterator must return an object');
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    case 134 /* OP.iterator_close */:
+                        /* iter_obj next catch_offset -> */
+                        sp--; /* drop the catch offset to avoid getting caught by exception */
+                        sp--; /* drop the next method */
+                        if (!JS_IsUndefined(stack[sp - 1])) {
+                            sf.cur_pc = pc;
+                            if (JS_IteratorClose(ctx, stack[sp - 1], false)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                        }
+                        sp--;
+                        break;
+                    case 113 /* OP.nip_catch */: {
+                        /* catch_offset ... ret_val -> ret_eval */
+                        const rv = stack[--sp];
+                        while (sp > 0 && !JS_IsCatchOffset(stack[sp - 1]))
+                            sp--;
+                        if (sp === 0) {
+                            JS_ThrowInternalError(ctx, 'nip_catch');
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 1] = rv;
+                        break;
+                    }
+                    case 135 /* OP.iterator_next */: {
+                        /* stack: iter_obj next catch_offset val */
+                        sf.cur_pc = pc;
+                        const ret = JS_Call(ctx, stack[sp - 3], stack[sp - 4], [stack[sp - 1]]);
+                        if (JS_IsException(ret)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 1] = ret;
+                        break;
+                    }
+                    case 136 /* OP.iterator_call */: {
+                        /* stack: iter_obj next catch_offset val */
+                        const fl = buf[pc++];
+                        sf.cur_pc = pc;
+                        const method = JS_GetProperty(ctx, stack[sp - 4], (fl & 1) ? JS_ATOM_throw : JS_ATOM_return);
+                        if (JS_IsException(method)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        let ret_flag;
+                        if (method === undefined || method === null) {
+                            ret_flag = true;
+                        }
+                        else {
+                            let ret;
+                            if (fl & 2)
+                                ret = JS_CallFree(ctx, method, stack[sp - 4], []);
+                            else
+                                ret = JS_CallFree(ctx, method, stack[sp - 4], [stack[sp - 1]]);
+                            if (JS_IsException(ret)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = ret;
+                            ret_flag = false;
+                        }
+                        stack[sp++] = ret_flag;
+                        break;
+                    }
+                    case 152 /* OP.lnot */: {
+                        const op1 = stack[sp - 1];
+                        const res = typeof op1 === 'boolean' ? op1 : JS_ToBoolFree(ctx, op1);
+                        stack[sp - 1] = !res;
+                        break;
+                    }
+                    case 66 /* OP.get_field */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        const val = JS_GetProperty(ctx, stack[sp - 1], atom);
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 1] = val;
+                        break;
+                    }
+                    case 67 /* OP.get_field2 */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        const val = JS_GetProperty(ctx, stack[sp - 1], atom);
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = val;
+                        break;
+                    }
+                    case 68 /* OP.put_field */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        const ret = JS_SetPropertyInternal(ctx, stack[sp - 2], atom, stack[sp - 1], stack[sp - 2], JS_PROP_THROW_STRICT);
+                        sp -= 2;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 5 /* OP.private_symbol */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        stack[sp++] = JS_NewSymbolFromAtom(ctx, atom, JS_ATOM_TYPE_PRIVATE);
+                        break;
+                    }
+                    case 69 /* OP.get_private_field */: {
+                        const val = JS_GetPrivateField(ctx, stack[sp - 2], stack[sp - 1]);
+                        stack[sp - 2] = val;
+                        sp--;
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 70 /* OP.put_private_field */: {
+                        /* obj value prop -> */
+                        const ret = JS_SetPrivateField(ctx, stack[sp - 3], stack[sp - 1], stack[sp - 2]);
+                        sp -= 3;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 71 /* OP.define_private_field */: {
+                        /* obj prop value -> obj */
+                        const ret = JS_DefinePrivateField(ctx, stack[sp - 3], stack[sp - 2], stack[sp - 1]);
+                        sp -= 2;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 77 /* OP.define_field */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        const ret = JS_DefinePropertyValue(ctx, stack[sp - 2], atom, stack[sp - 1], JS_PROP_C_W_E | JS_PROP_THROW);
+                        sp--;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 78 /* OP.set_name */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        if (JS_DefineObjectName(ctx, stack[sp - 1], atom, JS_PROP_CONFIGURABLE) < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 79 /* OP.set_name_computed */:
+                        if (JS_DefineObjectNameComputed(ctx, stack[sp - 1], stack[sp - 2], JS_PROP_CONFIGURABLE) < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    case 80 /* OP.set_proto */: {
+                        sf.cur_pc = pc;
+                        const proto = stack[sp - 1];
+                        if (JS_IsObject(proto) || proto === null) {
+                            if (JS_SetPrototypeInternal(ctx, stack[sp - 2], proto, true) < 0) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                        }
+                        sp--;
+                        break;
+                    }
+                    case 81 /* OP.set_home_object */:
+                        js_method_set_home_object(ctx, stack[sp - 1], stack[sp - 2]);
+                        break;
+                    case 85 /* OP.define_method */:
+                    case 86 /* OP.define_method_computed */: {
+                        const is_computed = (opcode === 86 /* OP.define_method_computed */);
+                        let atom;
+                        if (is_computed) {
+                            atom = JS_ValueToAtom(ctx, stack[sp - 2]);
+                            if (atom === JS_ATOM_NULL) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                        }
+                        else {
+                            atom = get_u32(buf, pc);
+                            pc += 4;
+                        }
+                        let op_flags = buf[pc++];
+                        const obj = stack[sp - 2 - (is_computed ? 1 : 0)];
+                        let fl = JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE | JS_PROP_HAS_ENUMERABLE | JS_PROP_THROW;
+                        if (op_flags & OP_DEFINE_METHOD_ENUMERABLE)
+                            fl |= JS_PROP_ENUMERABLE;
+                        op_flags &= 3;
+                        let value = undefined, getter = undefined, setter = undefined;
+                        if (op_flags === OP_DEFINE_METHOD_METHOD) {
+                            value = stack[sp - 1];
+                            fl |= JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE;
+                        }
+                        else if (op_flags === OP_DEFINE_METHOD_GETTER) {
+                            getter = stack[sp - 1];
+                            fl |= JS_PROP_HAS_GET;
+                        }
+                        else {
+                            setter = stack[sp - 1];
+                            fl |= JS_PROP_HAS_SET;
+                        }
+                        let ret = js_method_set_properties(ctx, stack[sp - 1], atom, fl, obj);
+                        if (ret >= 0)
+                            ret = JS_DefineProperty(ctx, obj, atom, value, getter, setter, fl);
+                        sp -= 1 + (is_computed ? 1 : 0);
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 87 /* OP.define_class */:
+                    case 88 /* OP.define_class_computed */: {
+                        const atom = get_u32(buf, pc);
+                        const class_flags = buf[pc + 4];
+                        pc += 5;
+                        sf.cur_pc = pc;
+                        if (js_op_define_class(ctx, stack, sp, atom, class_flags, var_refs, sf, opcode === 88 /* OP.define_class_computed */) < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 72 /* OP.get_array_el */: {
+                        sf.cur_pc = pc;
+                        const val = JS_GetPropertyValue(ctx, stack[sp - 2], stack[sp - 1]);
+                        stack[sp - 2] = val;
+                        sp--;
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 73 /* OP.get_array_el2 */: {
+                        sf.cur_pc = pc;
+                        const val = JS_GetPropertyValue(ctx, stack[sp - 2], stack[sp - 1]);
+                        stack[sp - 1] = val;
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 61 /* OP.get_ref_value */: {
+                        sf.cur_pc = pc;
+                        const atom = JS_ValueToAtom(ctx, stack[sp - 1]);
+                        if (atom === JS_ATOM_NULL) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        if (JS_IsUndefined(stack[sp - 2])) {
+                            JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const ret = JS_HasProperty(ctx, stack[sp - 2], atom);
+                        let val;
+                        if (ret <= 0) {
+                            if (ret < 0) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            if (is_strict_mode(ctx)) {
+                                JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            val = undefined;
+                        }
+                        else {
+                            val = JS_GetProperty(ctx, stack[sp - 2], atom);
+                        }
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = val;
+                        break;
+                    }
+                    case 75 /* OP.get_super_value */: {
+                        /* this obj prop -> value */
+                        sf.cur_pc = pc;
+                        const atom = JS_ValueToAtom(ctx, stack[sp - 1]);
+                        if (atom === JS_ATOM_NULL) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const val = JS_GetPropertyInternal(ctx, stack[sp - 2], atom, stack[sp - 3], false);
+                        if (JS_IsException(val)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 3] = val;
+                        sp -= 2;
+                        break;
+                    }
+                    case 74 /* OP.put_array_el */: {
+                        sf.cur_pc = pc;
+                        const ret = JS_SetPropertyValue(ctx, stack[sp - 3], stack[sp - 2], stack[sp - 1], JS_PROP_THROW_STRICT);
+                        sp -= 3;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 62 /* OP.put_ref_value */: {
+                        sf.cur_pc = pc;
+                        const atom = JS_ValueToAtom(ctx, stack[sp - 2]);
+                        if (atom === JS_ATOM_NULL) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        if (JS_IsUndefined(stack[sp - 3])) {
+                            if (is_strict_mode(ctx)) {
+                                JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 3] = ctx.global_obj;
+                        }
+                        const ret = JS_HasProperty(ctx, stack[sp - 3], atom);
+                        if (ret <= 0) {
+                            if (ret < 0) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            if (is_strict_mode(ctx)) {
+                                JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                        }
+                        const r2 = JS_SetPropertyInternal(ctx, stack[sp - 3], atom, stack[sp - 1], stack[sp - 3], JS_PROP_THROW_STRICT);
+                        sp -= 3;
+                        if (r2 < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 76 /* OP.put_super_value */: {
+                        /* this obj prop value -> */
+                        sf.cur_pc = pc;
+                        if (!JS_IsObject(stack[sp - 3])) {
+                            JS_ThrowTypeErrorNotAnObject(ctx);
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const atom = JS_ValueToAtom(ctx, stack[sp - 2]);
+                        if (atom === JS_ATOM_NULL) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const ret = JS_SetPropertyInternal(ctx, stack[sp - 3], atom, stack[sp - 1], stack[sp - 4], JS_PROP_THROW_STRICT);
+                        sp -= 4;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 82 /* OP.define_array_el */: {
+                        const ret = JS_DefinePropertyValueValue(ctx, stack[sp - 3], stack[sp - 2], stack[sp - 1], JS_PROP_C_W_E | JS_PROP_THROW);
+                        sp -= 1;
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 83 /* OP.append */: /* array pos enumobj -- array pos */
+                        sf.cur_pc = pc;
+                        if (js_append_enumerate(ctx, stack, sp)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        sp--;
+                        break;
+                    case 84 /* OP.copy_data_properties */: { /* target source excludeList */
+                        /* stack offsets (-1 based): 2 bits for target, 3 bits for source, 2 bits for exclusionList */
+                        const mask = buf[pc++];
+                        sf.cur_pc = pc;
+                        if (JS_CopyDataProperties(ctx, stack[sp - 1 - (mask & 3)], stack[sp - 1 - ((mask >> 2) & 7)], stack[sp - 1 - ((mask >> 5) & 7)], false)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        break;
+                    }
+                    case 159 /* OP.add */: {
+                        const op1 = stack[sp - 2], op2 = stack[sp - 1];
+                        if (typeof op1 === 'number' && typeof op2 === 'number') {
+                            stack[sp - 2] = op1 + op2;
+                            sp--;
+                        }
+                        else if (typeof op1 === 'string' && typeof op2 === 'string') {
+                            stack[sp - 2] = op1 + op2;
+                            sp--;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            const r = js_add_slow(ctx, op1, op2);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 2] = r;
+                            sp--;
+                        }
+                        break;
+                    }
+                    case 150 /* OP.add_loc */: {
+                        const idx = buf[pc++];
+                        const op2 = stack[sp - 1];
+                        const pv = var_buf[idx];
+                        if (typeof pv === 'number' && typeof op2 === 'number') {
+                            var_buf[idx] = pv + op2;
+                            sp--;
+                        }
+                        else if (typeof pv === 'string' && typeof op2 === 'string') {
+                            var_buf[idx] = pv + op2;
+                            sp--;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            sp--;
+                            const r = js_add_slow(ctx, pv, op2);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            var_buf[idx] = r;
+                        }
+                        break;
+                    }
+                    case 160 /* OP.sub */:
+                    case 156 /* OP.mul */:
+                    case 157 /* OP.div */:
+                    case 158 /* OP.mod */:
+                    case 161 /* OP.pow */: {
+                        const op1 = stack[sp - 2], op2 = stack[sp - 1];
+                        if (typeof op1 === 'number' && typeof op2 === 'number') {
+                            let r;
+                            switch (opcode) {
+                                case 160 /* OP.sub */:
+                                    r = op1 - op2;
+                                    break;
+                                case 156 /* OP.mul */:
+                                    r = op1 * op2;
+                                    break;
+                                case 157 /* OP.div */:
+                                    r = op1 / op2;
+                                    break;
+                                case 158 /* OP.mod */:
+                                    r = op1 % op2;
+                                    break;
+                                default:
+                                    r = Math.pow(op1, op2);
+                                    break;
+                            }
+                            stack[sp - 2] = r;
+                            sp--;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            let aop;
+                            switch (opcode) {
+                                case 160 /* OP.sub */:
+                                    aop = 1 /* JSArithOp.SUB */;
+                                    break;
+                                case 156 /* OP.mul */:
+                                    aop = 2 /* JSArithOp.MUL */;
+                                    break;
+                                case 157 /* OP.div */:
+                                    aop = 3 /* JSArithOp.DIV */;
+                                    break;
+                                case 158 /* OP.mod */:
+                                    aop = 4 /* JSArithOp.MOD */;
+                                    break;
+                                default:
+                                    aop = 5 /* JSArithOp.POW */;
+                                    break;
+                            }
+                            const r = js_binary_arith_slow(ctx, aop, op1, op2);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 2] = r;
+                            sp--;
+                        }
+                        break;
+                    }
+                    case 143 /* OP.plus */: {
+                        const op1 = stack[sp - 1];
+                        if (typeof op1 !== 'number') {
+                            sf.cur_pc = pc;
+                            const r = js_unary_arith_slow(ctx, 1 /* JSUnaryOp.PLUS */, op1);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = r;
+                        }
+                        break;
+                    }
+                    case 142 /* OP.neg */: {
+                        const op1 = stack[sp - 1];
+                        if (typeof op1 === 'number') {
+                            stack[sp - 1] = -op1;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            const r = js_unary_arith_slow(ctx, 0 /* JSUnaryOp.NEG */, op1);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = r;
+                        }
+                        break;
+                    }
+                    case 145 /* OP.inc */: {
+                        const op1 = stack[sp - 1];
+                        if (typeof op1 === 'number') {
+                            stack[sp - 1] = op1 + 1;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            const r = js_unary_arith_slow(ctx, 2 /* JSUnaryOp.INC */, op1);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = r;
+                        }
+                        break;
+                    }
+                    case 144 /* OP.dec */: {
+                        const op1 = stack[sp - 1];
+                        if (typeof op1 === 'number') {
+                            stack[sp - 1] = op1 - 1;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            const r = js_unary_arith_slow(ctx, 3 /* JSUnaryOp.DEC */, op1);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = r;
+                        }
+                        break;
+                    }
+                    case 147 /* OP.post_inc */:
+                    case 146 /* OP.post_dec */: {
+                        sf.cur_pc = pc;
+                        const op1 = JS_ToNumericFree(ctx, stack[sp - 1]);
+                        if (JS_IsException(op1)) {
+                            stack[sp - 1] = undefined;
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 1] = op1;
+                        const r = js_unary_arith_slow(ctx, opcode === 147 /* OP.post_inc */ ? 2 /* JSUnaryOp.INC */ : 3 /* JSUnaryOp.DEC */, op1);
+                        if (JS_IsException(r)) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = r;
+                        break;
+                    }
+                    case 149 /* OP.inc_loc */: {
+                        const idx = buf[pc++];
+                        const op1 = var_buf[idx];
+                        if (typeof op1 === 'number') {
+                            var_buf[idx] = op1 + 1;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            const r = js_unary_arith_slow(ctx, 2 /* JSUnaryOp.INC */, op1);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            var_buf[idx] = r;
+                        }
+                        break;
+                    }
+                    case 148 /* OP.dec_loc */: {
+                        const idx = buf[pc++];
+                        const op1 = var_buf[idx];
+                        if (typeof op1 === 'number') {
+                            var_buf[idx] = op1 - 1;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            const r = js_unary_arith_slow(ctx, 3 /* JSUnaryOp.DEC */, op1);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            var_buf[idx] = r;
+                        }
+                        break;
+                    }
+                    case 151 /* OP.not */: {
+                        const op1 = stack[sp - 1];
+                        if (typeof op1 === 'number') {
+                            stack[sp - 1] = ~op1;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            const r = js_unary_arith_slow(ctx, 4 /* JSUnaryOp.NOT */, op1);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = r;
+                        }
+                        break;
+                    }
+                    case 162 /* OP.shl */:
+                    case 163 /* OP.sar */:
+                    case 164 /* OP.shr */:
+                    case 175 /* OP.and */:
+                    case 177 /* OP.or */:
+                    case 176 /* OP.xor */: {
+                        const op1 = stack[sp - 2], op2 = stack[sp - 1];
+                        if (typeof op1 === 'number' && typeof op2 === 'number') {
+                            let r;
+                            switch (opcode) {
+                                case 162 /* OP.shl */:
+                                    r = op1 << op2;
+                                    break;
+                                case 163 /* OP.sar */:
+                                    r = op1 >> op2;
+                                    break;
+                                case 164 /* OP.shr */:
+                                    r = op1 >>> op2;
+                                    break;
+                                case 175 /* OP.and */:
+                                    r = op1 & op2;
+                                    break;
+                                case 177 /* OP.or */:
+                                    r = op1 | op2;
+                                    break;
+                                default:
+                                    r = op1 ^ op2;
+                                    break;
+                            }
+                            stack[sp - 2] = r;
+                            sp--;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            let aop;
+                            switch (opcode) {
+                                case 162 /* OP.shl */:
+                                    aop = 6 /* JSArithOp.SHL */;
+                                    break;
+                                case 163 /* OP.sar */:
+                                    aop = 7 /* JSArithOp.SAR */;
+                                    break;
+                                case 164 /* OP.shr */:
+                                    aop = 8 /* JSArithOp.SHR */;
+                                    break;
+                                case 175 /* OP.and */:
+                                    aop = 9 /* JSArithOp.AND */;
+                                    break;
+                                case 177 /* OP.or */:
+                                    aop = 10 /* JSArithOp.OR */;
+                                    break;
+                                default:
+                                    aop = 11 /* JSArithOp.XOR */;
+                                    break;
+                            }
+                            const r = js_binary_arith_slow(ctx, aop, op1, op2);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 2] = r;
+                            sp--;
+                        }
+                        break;
+                    }
+                    case 165 /* OP.lt */:
+                    case 166 /* OP.lte */:
+                    case 167 /* OP.gt */:
+                    case 168 /* OP.gte */: {
+                        const op1 = stack[sp - 2], op2 = stack[sp - 1];
+                        if (typeof op1 === 'number' && typeof op2 === 'number') {
+                            let r;
+                            switch (opcode) {
+                                case 165 /* OP.lt */:
+                                    r = op1 < op2;
+                                    break;
+                                case 166 /* OP.lte */:
+                                    r = op1 <= op2;
+                                    break;
+                                case 167 /* OP.gt */:
+                                    r = op1 > op2;
+                                    break;
+                                default:
+                                    r = op1 >= op2;
+                                    break;
+                            }
+                            stack[sp - 2] = r;
+                            sp--;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            let rop;
+                            switch (opcode) {
+                                case 165 /* OP.lt */:
+                                    rop = 0 /* JSRelOp.LT */;
+                                    break;
+                                case 166 /* OP.lte */:
+                                    rop = 1 /* JSRelOp.LTE */;
+                                    break;
+                                case 167 /* OP.gt */:
+                                    rop = 2 /* JSRelOp.GT */;
+                                    break;
+                                default:
+                                    rop = 3 /* JSRelOp.GTE */;
+                                    break;
+                            }
+                            const r = js_relational_op(ctx, rop, op1, op2);
+                            if (r < 0) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 2] = r !== 0;
+                            sp--;
+                        }
+                        break;
+                    }
+                    case 171 /* OP.eq */:
+                    case 172 /* OP.neq */: {
+                        const op1 = stack[sp - 2], op2 = stack[sp - 1];
+                        let r;
+                        if (typeof op1 === typeof op2 && typeof op1 !== 'object') {
+                            r = op1 === op2 ? 1 : 0;
+                        }
+                        else {
+                            sf.cur_pc = pc;
+                            r = js_loose_eq(ctx, op1, op2);
+                            if (r < 0) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                        }
+                        stack[sp - 2] = opcode === 171 /* OP.eq */ ? r !== 0 : r === 0;
+                        sp--;
+                        break;
+                    }
+                    case 173 /* OP.strict_eq */:
+                    case 174 /* OP.strict_neq */: {
+                        const r = js_strict_eq2(ctx, stack[sp - 2], stack[sp - 1], 0 /* JSStrictEqMode.STRICT */);
+                        stack[sp - 2] = opcode === 173 /* OP.strict_eq */ ? r : !r;
+                        sp--;
+                        break;
+                    }
+                    case 170 /* OP.in */: {
+                        sf.cur_pc = pc;
+                        const r = js_operator_in(ctx, stack[sp - 2], stack[sp - 1]);
+                        if (r < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 2] = r !== 0;
+                        sp--;
+                        break;
+                    }
+                    case 179 /* OP.private_in */: {
+                        sf.cur_pc = pc;
+                        const r = js_operator_private_in(ctx, stack[sp - 2], stack[sp - 1]);
+                        if (r < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 2] = r !== 0;
+                        sp--;
+                        break;
+                    }
+                    case 169 /* OP.instanceof */: {
+                        sf.cur_pc = pc;
+                        const r = JS_IsInstanceOf(ctx, stack[sp - 2], stack[sp - 1]);
+                        if (r < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 2] = r !== 0;
+                        sp--;
+                        break;
+                    }
+                    case 153 /* OP.typeof */:
+                        stack[sp - 1] = JS_AtomToString(ctx, js_operator_typeof(ctx, stack[sp - 1]));
+                        break;
+                    case 154 /* OP.delete */: {
+                        sf.cur_pc = pc;
+                        const atom = JS_ValueToAtom(ctx, stack[sp - 1]);
+                        if (atom === JS_ATOM_NULL) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const r = JS_DeleteProperty(ctx, stack[sp - 2], atom, JS_PROP_THROW_STRICT);
+                        if (r < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp - 2] = r !== 0;
+                        sp--;
+                        break;
+                    }
+                    case 155 /* OP.delete_var */: {
+                        const atom = get_u32(buf, pc);
+                        pc += 4;
+                        sf.cur_pc = pc;
+                        const r = JS_DeleteProperty(ctx, ctx.global_obj, atom, 0);
+                        if (r < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        stack[sp++] = r !== 0;
+                        break;
+                    }
+                    case 114 /* OP.to_object */:
+                        if (!JS_IsObject(stack[sp - 1])) {
+                            sf.cur_pc = pc;
+                            const v = JS_ToObject(ctx, stack[sp - 1]);
+                            if (JS_IsException(v)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = v;
+                        }
+                        break;
+                    case 115 /* OP.to_propkey */: {
+                        const v = stack[sp - 1];
+                        if (!(typeof v === 'number' && Number.isInteger(v)) && typeof v !== 'string' && typeof v !== 'symbol') {
+                            sf.cur_pc = pc;
+                            const r = JS_ToPropertyKey(ctx, v);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = r;
+                        }
+                        break;
+                    }
+                    case 116 /* OP.to_propkey2 */: {
+                        /* must be tested first */
+                        if (stack[sp - 2] === undefined || stack[sp - 2] === null) {
+                            JS_ThrowTypeError(ctx, 'value has no property');
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        const v = stack[sp - 1];
+                        if (!(typeof v === 'number' && Number.isInteger(v)) && typeof v !== 'string' && typeof v !== 'symbol') {
+                            sf.cur_pc = pc;
+                            const r = JS_ToPropertyKey(ctx, v);
+                            if (JS_IsException(r)) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            stack[sp - 1] = r;
+                        }
+                        break;
+                    }
+                    case 117 /* OP.with_get_var */:
+                    case 118 /* OP.with_put_var */:
+                    case 119 /* OP.with_delete_var */:
+                    case 120 /* OP.with_make_ref */:
+                    case 121 /* OP.with_get_ref */: {
+                        const atom = get_u32(buf, pc);
+                        const diff = get_i32(buf, pc + 4);
+                        const is_with = buf[pc + 8];
+                        pc += 9;
+                        sf.cur_pc = pc;
+                        const obj = stack[sp - 1];
+                        let ret = JS_HasProperty(ctx, obj, atom);
+                        if (ret < 0) {
+                            flow = 1 /* Flow.EXCEPTION */;
+                            break;
+                        }
+                        let no_with = !ret;
+                        if (ret && is_with) {
+                            ret = js_has_unscopable(ctx, obj, atom);
+                            if (ret < 0) {
+                                flow = 1 /* Flow.EXCEPTION */;
+                                break;
+                            }
+                            if (ret)
+                                no_with = true;
+                        }
+                        if (!no_with) {
+                            switch (opcode) {
+                                case 117 /* OP.with_get_var */: {
+                                    /* in Object Environment Records, GetBindingValue() calls HasProperty() */
+                                    ret = JS_HasProperty(ctx, obj, atom);
+                                    if (ret < 0) {
+                                        flow = 1 /* Flow.EXCEPTION */;
+                                        break sw;
+                                    }
+                                    let val;
+                                    if (!ret) {
+                                        if (is_strict_mode(ctx)) {
+                                            JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                                            flow = 1 /* Flow.EXCEPTION */;
+                                            break sw;
+                                        }
+                                        val = undefined;
+                                    }
+                                    else {
+                                        val = JS_GetProperty(ctx, obj, atom);
+                                        if (JS_IsException(val)) {
+                                            flow = 1 /* Flow.EXCEPTION */;
+                                            break sw;
+                                        }
+                                    }
+                                    stack[sp - 1] = val;
+                                    break;
+                                }
+                                case 118 /* OP.with_put_var */: {
+                                    ret = JS_HasProperty(ctx, obj, atom);
+                                    if (ret < 0) {
+                                        flow = 1 /* Flow.EXCEPTION */;
+                                        break sw;
+                                    }
+                                    if (!ret && is_strict_mode(ctx)) {
+                                        JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                                        flow = 1 /* Flow.EXCEPTION */;
+                                        break sw;
+                                    }
+                                    ret = JS_SetPropertyInternal(ctx, obj, atom, stack[sp - 2], obj, JS_PROP_THROW_STRICT);
+                                    sp -= 2;
+                                    if (ret < 0) {
+                                        flow = 1 /* Flow.EXCEPTION */;
+                                        break sw;
+                                    }
+                                    break;
+                                }
+                                case 119 /* OP.with_delete_var */: {
+                                    ret = JS_DeleteProperty(ctx, obj, atom, 0);
+                                    if (ret < 0) {
+                                        flow = 1 /* Flow.EXCEPTION */;
+                                        break sw;
+                                    }
+                                    stack[sp - 1] = ret !== 0;
+                                    break;
+                                }
+                                case 120 /* OP.with_make_ref */:
+                                    /* produce a pair object/propname on the stack */
+                                    stack[sp++] = JS_AtomToValue(ctx, atom);
+                                    break;
+                                case 121 /* OP.with_get_ref */: {
+                                    /* produce a pair object/method on the stack */
+                                    ret = JS_HasProperty(ctx, obj, atom);
+                                    if (ret < 0) {
+                                        flow = 1 /* Flow.EXCEPTION */;
+                                        break sw;
+                                    }
+                                    let val;
+                                    if (!ret) {
+                                        val = undefined;
+                                    }
+                                    else {
+                                        val = JS_GetProperty(ctx, obj, atom);
+                                        if (JS_IsException(val)) {
+                                            flow = 1 /* Flow.EXCEPTION */;
+                                            break sw;
+                                        }
+                                    }
+                                    stack[sp++] = val;
+                                    break;
+                                }
+                            }
+                            pc += diff - 5;
+                        }
+                        else {
+                            /* if not jumping, drop the object argument */
+                            sp--;
+                        }
+                        break;
+                    }
+                    case 141 /* OP.await */:
+                        ret_val = FUNC_RET_AWAIT;
+                        flow = 3 /* Flow.DONE_GENERATOR */;
+                        break main;
+                    case 138 /* OP.yield */:
+                        ret_val = FUNC_RET_YIELD;
+                        flow = 3 /* Flow.DONE_GENERATOR */;
+                        break main;
+                    case 139 /* OP.yield_star */:
+                    case 140 /* OP.async_yield_star */:
+                        ret_val = FUNC_RET_YIELD_STAR;
+                        flow = 3 /* Flow.DONE_GENERATOR */;
+                        break main;
+                    case 47 /* OP.return_async */:
+                        ret_val = undefined;
+                        flow = 3 /* Flow.DONE_GENERATOR */;
+                        break main;
+                    case 137 /* OP.initial_yield */:
+                        ret_val = FUNC_RET_INITIAL_YIELD;
+                        flow = 3 /* Flow.DONE_GENERATOR */;
+                        break main;
+                    case 181 /* OP.nop */:
+                        break;
+                    case 178 /* OP.is_undefined_or_null */:
+                        stack[sp - 1] = (stack[sp - 1] === undefined || stack[sp - 1] === null);
+                        break;
+                    case 244 /* OP.is_undefined */:
+                        stack[sp - 1] = (stack[sp - 1] === undefined);
+                        break;
+                    case 245 /* OP.is_null */:
+                        stack[sp - 1] = (stack[sp - 1] === null);
+                        break;
+                    case 246 /* OP.typeof_is_undefined */:
+                        /* different from OP_is_undefined because of isHTMLDDA */
+                        stack[sp - 1] = (js_operator_typeof(ctx, stack[sp - 1]) === JS_ATOM_undefined);
+                        break;
+                    case 247 /* OP.typeof_is_function */:
+                        stack[sp - 1] = (js_operator_typeof(ctx, stack[sp - 1]) === JS_ATOM_function);
+                        break;
+                    case 0 /* OP.invalid */:
+                    default:
+                        JS_ThrowInternalError(ctx, `invalid opcode: pc=${pc - 1} opcode=0x${opcode.toString(16).padStart(2, '0')}`);
+                        flow = 1 /* Flow.EXCEPTION */;
+                        break;
+                }
+            }
+            break outer;
+        }
+        catch (e) {
+            js_host_exception_to_guest(ctx, e);
+            flow = 1 /* Flow.EXCEPTION */;
+        }
+    }
+    /* done / done_generator */
+    if (flow === 3 /* Flow.DONE_GENERATOR */ || (flow === 2 /* Flow.DONE */ && b.func_kind !== 0 /* JSFunctionKind.NORMAL */)) {
+        /* the local variables are kept by the generator state */
+        sf.cur_pc = pc;
+        sf.cur_sp = sp;
+    }
+    else {
+        if (sf.var_refs.length !== 0) {
+            /* variable references reference the stack: must close them */
+            close_var_refs(rt, sf);
+        }
+    }
+    rt.current_stack_frame = sf.prev_frame;
+    rt.stack_depth--;
+    return ret_val;
+}
+/* ---------------------------------------------------------------------
+   JSAsyncFunctionState (used by generator and async functions)
+   --------------------------------------------------------------------- */
+export function async_func_init(ctx, func_obj, this_obj, argv) {
+    const s = new JSAsyncFunctionState();
+    const sf = s.frame;
+    const b = JS_GetFunctionData(func_obj).function_bytecode;
+    const argc = argv.length;
+    sf.js_mode = b.js_mode | JS_MODE_ASYNC;
+    sf.cur_pc = 0;
+    const arg_buf_len = Math.max(b.arg_count, argc);
+    sf.arg_buf = new Array(arg_buf_len);
+    for (let i = 0; i < argc; i++)
+        sf.arg_buf[i] = argv[i];
+    for (let i = argc; i < arg_buf_len; i++)
+        sf.arg_buf[i] = undefined;
+    sf.var_buf = new Array(b.var_count);
+    for (let i = 0; i < b.var_count; i++)
+        sf.var_buf[i] = undefined;
+    sf.stack_buf = new Array(b.stack_size);
+    sf.cur_func = func_obj;
+    sf.this_obj = this_obj;
+    sf.new_target = undefined;
+    sf.arg_count = arg_buf_len;
+    sf.cur_sp = 0;
+    s.func_obj = func_obj;
+    s.this_val = this_obj;
+    s.argc = argc;
+    s.resolving_funcs = [undefined, undefined];
+    s.is_completed = false;
+    return s;
+}
+/* resume the execution; returns FUNC_RET_xxx (number) when suspended,
+   the return value when the function completed normally, or JS_EXCEPTION */
+export function async_func_resume(ctx, s) {
+    const rt = ctx.rt;
+    const sf = s.frame;
+    let ret;
+    if (s.is_completed)
+        return JS_ThrowInternalError(ctx, 'async function already completed');
+    if (rt.stack_depth >= rt.max_stack_depth) {
+        ret = JS_ThrowStackOverflow(ctx);
+    }
+    else {
+        ret = js_call_internal(ctx, s.func_obj, s.this_val, undefined, [], JS_CALL_FLAG_GENERATOR, s);
+    }
+    if (JS_IsException(ret) || JS_IsUndefined(ret)) {
+        if (JS_IsUndefined(ret)) {
+            /* OP_return_async: the return value is at the top of the stack */
+            ret = sf.stack_buf[sf.cur_sp - 1];
+            sf.stack_buf[sf.cur_sp - 1] = undefined;
+        }
+        /* end of execution */
+        s.is_completed = true;
+        /* close the closure variables. */
+        close_var_refs(rt, sf);
+        sf.stack_buf = [];
+    }
+    return ret;
+}
+/* ---------------------------------------------------------------------
+   Generators
+   --------------------------------------------------------------------- */
+function free_generator_stack(ctx, s) {
+    if (s.state === 4 /* JSGeneratorState.COMPLETED */)
+        return;
+    s.func_state = null;
+    s.state = 4 /* JSGeneratorState.COMPLETED */;
+}
+export function js_generator_next(ctx, this_val, argv, pdone, magic) {
+    const s = JS_GetOpaque(this_val, 43 /* JSClassID.GENERATOR */);
+    pdone.done = 1;
+    if (!s)
+        return JS_ThrowTypeError(ctx, 'not a generator');
+    let ret;
+    switch (s.state) {
+        default:
+        case 0 /* JSGeneratorState.SUSPENDED_START */:
+            if (magic !== GEN_MAGIC_NEXT) {
+                free_generator_stack(ctx, s);
+                return generator_done(ctx, argv, magic);
+            }
+            s.func_state.throw_flag = false;
+            return generator_exec(ctx, s, pdone);
+        case 2 /* JSGeneratorState.SUSPENDED_YIELD_STAR */:
+        case 1 /* JSGeneratorState.SUSPENDED_YIELD */: {
+            const sf = s.func_state.frame;
+            /* cur_sp[-1] was set to JS_UNDEFINED in the previous call */
+            ret = argv[0];
+            if (magic === GEN_MAGIC_THROW && s.state === 1 /* JSGeneratorState.SUSPENDED_YIELD */) {
+                JS_Throw(ctx, ret);
+                s.func_state.throw_flag = true;
+            }
+            else {
+                sf.stack_buf[sf.cur_sp - 1] = ret;
+                sf.stack_buf[sf.cur_sp] = magic;
+                sf.cur_sp++;
+                s.func_state.throw_flag = false;
+            }
+            return generator_exec(ctx, s, pdone);
+        }
+        case 4 /* JSGeneratorState.COMPLETED */:
+            return generator_done(ctx, argv, magic);
+        case 3 /* JSGeneratorState.EXECUTING */:
+            return JS_ThrowTypeError(ctx, 'cannot invoke a running generator');
+    }
+}
+function generator_done(ctx, argv, magic) {
+    /* execution is finished */
+    switch (magic) {
+        default:
+        case GEN_MAGIC_NEXT: return undefined;
+        case GEN_MAGIC_RETURN: return argv[0];
+        case GEN_MAGIC_THROW: return JS_Throw(ctx, argv[0]);
+    }
+}
+function generator_exec(ctx, s, pdone) {
+    const fs = s.func_state;
+    const sf = fs.frame;
+    s.state = 3 /* JSGeneratorState.EXECUTING */;
+    const func_ret = async_func_resume(ctx, fs);
+    s.state = 1 /* JSGeneratorState.SUSPENDED_YIELD */;
+    if (fs.is_completed) {
+        /* finalize the execution in case of exception or normal return */
+        free_generator_stack(ctx, s);
+        return func_ret;
+    }
+    /* get the returned yield value at the top of the stack */
+    const ret = sf.stack_buf[sf.cur_sp - 1];
+    sf.stack_buf[sf.cur_sp - 1] = undefined;
+    if (func_ret === FUNC_RET_YIELD_STAR) {
+        s.state = 2 /* JSGeneratorState.SUSPENDED_YIELD_STAR */;
+        /* return (value, done) object */
+        pdone.done = 2;
+    }
+    else {
+        pdone.done = 0;
+    }
+    return ret;
+}
+export function js_generator_function_call(ctx, func_obj, this_obj, argv, flags) {
+    const s = new JSGeneratorData();
+    s.state = 0 /* JSGeneratorState.SUSPENDED_START */;
+    s.func_state = async_func_init(ctx, func_obj, this_obj, argv);
+    /* execute the function up to 'OP_initial_yield' */
+    const func_ret = async_func_resume(ctx, s.func_state);
+    if (JS_IsException(func_ret)) {
+        free_generator_stack(ctx, s);
+        return JS_EXCEPTION;
+    }
+    const obj = js_create_from_ctor(ctx, func_obj, 43 /* JSClassID.GENERATOR */);
+    if (JS_IsException(obj)) {
+        free_generator_stack(ctx, s);
+        return JS_EXCEPTION;
+    }
+    JS_SetOpaque(obj, s);
+    return obj;
+}
+export const js_generator_proto_funcs = [
+    JS_ITERATOR_NEXT_DEF('next', 1, js_generator_next, GEN_MAGIC_NEXT),
+    JS_ITERATOR_NEXT_DEF('return', 1, js_generator_next, GEN_MAGIC_RETURN),
+    JS_ITERATOR_NEXT_DEF('throw', 1, js_generator_next, GEN_MAGIC_THROW),
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'Generator', JS_PROP_CONFIGURABLE),
+];
+export const js_generator_function_proto_funcs = [
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'GeneratorFunction', JS_PROP_CONFIGURABLE),
+];
+/* ---------------------------------------------------------------------
+   Async functions
+   --------------------------------------------------------------------- */
+function js_async_function_resolve_create(ctx, s) {
+    const funcs = [undefined, undefined];
+    for (let i = 0; i < 2; i++) {
+        const is_reject = i === 1;
+        const impl = (_this_val, _new_target, args) => {
+            js_async_function_resolve_call(ctx, s, is_reject, args.length > 0 ? args[0] : undefined);
+            return undefined;
+        };
+        const f = js_new_host_function(ctx, impl, false, '', 1, ctx.function_proto, (49 /* JSClassID.ASYNC_FUNCTION_RESOLVE */ + i));
+        js_meta.get(f).u = s;
+        funcs[i] = f;
+    }
+    return funcs;
+}
+function js_async_function_resume(ctx, s) {
+    const func_ret = async_func_resume(ctx, s);
+    if (s.is_completed) {
+        if (JS_IsException(func_ret)) {
+            const error = JS_GetException(ctx);
+            JS_Call(ctx, s.resolving_funcs[1], undefined, [error]); /* XXX: what to do if exception ? */
+        }
+        else {
+            /* normal return */
+            JS_Call(ctx, s.resolving_funcs[0], undefined, [func_ret]);
+        }
+        return;
+    }
+    /* await */
+    const sf = s.frame;
+    const value = sf.stack_buf[sf.cur_sp - 1];
+    sf.stack_buf[sf.cur_sp - 1] = undefined;
+    const fail = () => {
+        const error = JS_GetException(ctx);
+        JS_Call(ctx, s.resolving_funcs[1], undefined, [error]);
+    };
+    const promise = js_promise_resolve(ctx, ctx.promise_ctor ?? undefined, [value], 0);
+    if (JS_IsException(promise)) {
+        fail();
+        return;
+    }
+    const resolving_funcs = js_async_function_resolve_create(ctx, s);
+    if (!resolving_funcs) {
+        fail();
+        return;
+    }
+    /* Note: no need to create 'thrownawayCapability' as in the spec */
+    const res = perform_promise_then(ctx, promise, resolving_funcs, [undefined, undefined]);
+    if (res)
+        fail();
+}
+function js_async_function_resolve_call(ctx, s, is_reject, arg) {
+    s.throw_flag = is_reject;
+    if (is_reject) {
+        JS_Throw(ctx, arg);
+    }
+    else {
+        /* return value of await */
+        s.frame.stack_buf[s.frame.cur_sp - 1] = arg;
+    }
+    js_async_function_resume(ctx, s);
+    return undefined;
+}
+export function js_async_function_call(ctx, func_obj, this_obj, argv, flags) {
+    const s = async_func_init(ctx, func_obj, this_obj, argv);
+    const promise = JS_NewPromiseCapability(ctx, s.resolving_funcs);
+    if (JS_IsException(promise))
+        return JS_EXCEPTION;
+    s.promise = promise;
+    js_async_function_resume(ctx, s);
+    return promise;
+}
+export const js_async_function_proto_funcs = [
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'AsyncFunction', JS_PROP_CONFIGURABLE),
+];
+export class JSAsyncGeneratorRequest {
+    completion_type; /* GEN_MAGIC_x */
+    result;
+    promise;
+    resolving_funcs;
+    constructor(completion_type, result, promise, resolving_funcs) {
+        this.completion_type = completion_type;
+        this.result = result;
+        this.promise = promise;
+        this.resolving_funcs = resolving_funcs;
+    }
+}
+export class JSAsyncGeneratorData {
+    generator = null; /* back pointer to the object */
+    state = 0 /* JSAsyncGeneratorState.SUSPENDED_START */;
+    /* func_state is null in state AWAITING_RETURN and COMPLETED */
+    func_state = null;
+    queue = [];
+}
+function js_async_generator_resolve_function_create(ctx, generator, is_resume_next) {
+    const funcs = [undefined, undefined];
+    for (let i = 0; i < 2; i++) {
+        const func = JS_NewCFunctionData(ctx, js_async_generator_resolve_function, 1, i + (is_resume_next ? 2 : 0), [generator]);
+        if (JS_IsException(func))
+            return null;
+        funcs[i] = func;
+    }
+    return funcs;
+}
+function js_async_generator_await(ctx, s, value) {
+    const promise = js_promise_resolve(ctx, ctx.promise_ctor ?? undefined, [value], 0);
+    if (JS_IsException(promise))
+        return -1;
+    const resolving_funcs = js_async_generator_resolve_function_create(ctx, s.generator, false);
+    if (!resolving_funcs)
+        return -1;
+    /* Note: no need to create 'thrownawayCapability' as in the spec */
+    const res = perform_promise_then(ctx, promise, resolving_funcs, [undefined, undefined]);
+    if (res)
+        return -1;
+    return 0;
+}
+function js_async_generator_resolve_or_reject(ctx, s, result, is_reject) {
+    const next = s.queue.shift();
+    JS_Call(ctx, next.resolving_funcs[is_reject], undefined, [result]);
+}
+function js_async_generator_resolve(ctx, s, value, done) {
+    const result = js_create_iterator_result(ctx, value, done);
+    /* XXX: better exception handling ? */
+    js_async_generator_resolve_or_reject(ctx, s, result, 0);
+}
+function js_async_generator_reject(ctx, s, exception) {
+    js_async_generator_resolve_or_reject(ctx, s, exception, 1);
+}
+function js_async_generator_complete(ctx, s) {
+    if (s.state !== 5 /* JSAsyncGeneratorState.COMPLETED */) {
+        s.state = 5 /* JSAsyncGeneratorState.COMPLETED */;
+        s.func_state = null;
+    }
+}
+function js_async_generator_completed_return(ctx, s, value) {
+    // Can fail looking up JS_ATOM_constructor when is_reject==0.
+    let promise = js_promise_resolve(ctx, ctx.promise_ctor ?? undefined, [value], 0);
+    // A poisoned .constructor property is observable and the resulting
+    // exception should be delivered to the catch handler.
+    if (JS_IsException(promise)) {
+        const err = JS_GetException(ctx);
+        promise = js_promise_resolve(ctx, ctx.promise_ctor ?? undefined, [err], 1);
+        if (JS_IsException(promise))
+            return -1;
+    }
+    const resolving_funcs1 = js_async_generator_resolve_function_create(ctx, s.generator, true);
+    if (!resolving_funcs1)
+        return -1;
+    return perform_promise_then(ctx, promise, resolving_funcs1, [undefined, undefined]);
+}
+function js_async_generator_resume_next(ctx, s) {
+    for (;;) {
+        if (s.queue.length === 0)
+            break;
+        const next = s.queue[0];
+        let resume_exec = false;
+        switch (s.state) {
+            case 3 /* JSAsyncGeneratorState.EXECUTING */:
+                /* only happens when restarting execution after await() */
+                resume_exec = true;
+                break;
+            case 4 /* JSAsyncGeneratorState.AWAITING_RETURN */:
+                return;
+            case 0 /* JSAsyncGeneratorState.SUSPENDED_START */:
+                if (next.completion_type === GEN_MAGIC_NEXT) {
+                    s.func_state.throw_flag = false;
+                    s.state = 3 /* JSAsyncGeneratorState.EXECUTING */;
+                    resume_exec = true;
+                }
+                else {
+                    js_async_generator_complete(ctx, s);
+                }
+                break;
+            case 5 /* JSAsyncGeneratorState.COMPLETED */:
+                if (next.completion_type === GEN_MAGIC_NEXT) {
+                    js_async_generator_resolve(ctx, s, undefined, true);
+                }
+                else if (next.completion_type === GEN_MAGIC_RETURN) {
+                    s.state = 4 /* JSAsyncGeneratorState.AWAITING_RETURN */;
+                    js_async_generator_completed_return(ctx, s, next.result);
+                }
+                else {
+                    js_async_generator_reject(ctx, s, next.result);
+                }
+                return;
+            case 1 /* JSAsyncGeneratorState.SUSPENDED_YIELD */:
+            case 2 /* JSAsyncGeneratorState.SUSPENDED_YIELD_STAR */: {
+                const value = next.result;
+                const sf = s.func_state.frame;
+                if (next.completion_type === GEN_MAGIC_THROW && s.state === 1 /* JSAsyncGeneratorState.SUSPENDED_YIELD */) {
+                    JS_Throw(ctx, value);
+                    s.func_state.throw_flag = true;
+                }
+                else {
+                    /* 'yield' returns a value. 'yield *' also returns a value in case the 'throw' method is called */
+                    sf.stack_buf[sf.cur_sp - 1] = value;
+                    sf.stack_buf[sf.cur_sp] = next.completion_type;
+                    sf.cur_sp++;
+                    s.func_state.throw_flag = false;
+                }
+                s.state = 3 /* JSAsyncGeneratorState.EXECUTING */;
+                resume_exec = true;
+                break;
+            }
+            default:
+                throw new Error('invalid async generator state');
+        }
+        if (!resume_exec)
+            continue;
+        for (;;) {
+            const fs = s.func_state;
+            const func_ret = async_func_resume(ctx, fs);
+            if (fs.is_completed) {
+                if (JS_IsException(func_ret)) {
+                    const value = JS_GetException(ctx);
+                    js_async_generator_complete(ctx, s);
+                    js_async_generator_reject(ctx, s, value);
+                }
+                else {
+                    /* end of function */
+                    js_async_generator_complete(ctx, s);
+                    js_async_generator_resolve(ctx, s, func_ret, true);
+                }
+                break;
+            }
+            const func_ret_code = func_ret;
+            const sf = fs.frame;
+            const value = sf.stack_buf[sf.cur_sp - 1];
+            sf.stack_buf[sf.cur_sp - 1] = undefined;
+            if (func_ret_code === FUNC_RET_YIELD || func_ret_code === FUNC_RET_YIELD_STAR) {
+                s.state = (func_ret_code === FUNC_RET_YIELD_STAR) ? 2 /* JSAsyncGeneratorState.SUSPENDED_YIELD_STAR */ : 1 /* JSAsyncGeneratorState.SUSPENDED_YIELD */;
+                js_async_generator_resolve(ctx, s, value, false);
+                break;
+            }
+            else if (func_ret_code === FUNC_RET_AWAIT) {
+                const ret = js_async_generator_await(ctx, s, value);
+                if (ret < 0) {
+                    /* exception: throw it */
+                    fs.throw_flag = true;
+                    continue; /* resume_exec */
+                }
+                return;
+            }
+            else {
+                throw new Error('invalid async generator return code');
+            }
+        }
+    }
+}
+function js_async_generator_resolve_function(ctx, this_obj, argv, magic, func_data) {
+    const is_reject = (magic & 1) !== 0;
+    const s = JS_GetOpaque(func_data[0], 53 /* JSClassID.ASYNC_GENERATOR */);
+    const arg = argv[0];
+    if (!s)
+        return undefined;
+    if (magic >= 2) {
+        /* resume next case in AWAITING_RETURN state */
+        s.state = 5 /* JSAsyncGeneratorState.COMPLETED */;
+        if (is_reject)
+            js_async_generator_reject(ctx, s, arg);
+        else
+            js_async_generator_resolve(ctx, s, arg, true);
+    }
+    else {
+        /* restart function execution after await() */
+        const fs = s.func_state;
+        fs.throw_flag = is_reject;
+        if (is_reject) {
+            JS_Throw(ctx, arg);
+        }
+        else {
+            /* return value of await */
+            fs.frame.stack_buf[fs.frame.cur_sp - 1] = arg;
+        }
+        js_async_generator_resume_next(ctx, s);
+    }
+    return undefined;
+}
+/* magic = GEN_MAGIC_x */
+export function js_async_generator_next(ctx, this_val, argv, magic) {
+    const s = JS_GetOpaque(this_val, 53 /* JSClassID.ASYNC_GENERATOR */);
+    const resolving_funcs = [undefined, undefined];
+    const promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise))
+        return JS_EXCEPTION;
+    if (!s) {
+        JS_ThrowTypeError(ctx, 'not an AsyncGenerator object');
+        const err = JS_GetException(ctx);
+        JS_Call(ctx, resolving_funcs[1], undefined, [err]);
+        return promise;
+    }
+    s.queue.push(new JSAsyncGeneratorRequest(magic, argv[0], promise, resolving_funcs));
+    if (s.state !== 3 /* JSAsyncGeneratorState.EXECUTING */) {
+        js_async_generator_resume_next(ctx, s);
+    }
+    return promise;
+}
+export function js_async_generator_function_call(ctx, func_obj, this_obj, argv, flags) {
+    const s = new JSAsyncGeneratorData();
+    s.state = 0 /* JSAsyncGeneratorState.SUSPENDED_START */;
+    s.func_state = async_func_init(ctx, func_obj, this_obj, argv);
+    /* execute the function up to 'OP_initial_yield' (no yield nor await are possible) */
+    const func_ret = async_func_resume(ctx, s.func_state);
+    if (JS_IsException(func_ret))
+        return JS_EXCEPTION;
+    const obj = js_create_from_ctor(ctx, func_obj, 53 /* JSClassID.ASYNC_GENERATOR */);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    s.generator = obj;
+    JS_SetOpaque(obj, s);
+    return obj;
+}
+export const js_async_generator_proto_funcs = [
+    JS_CFUNC_MAGIC_DEF('next', 1, js_async_generator_next, GEN_MAGIC_NEXT),
+    JS_CFUNC_MAGIC_DEF('return', 1, js_async_generator_next, GEN_MAGIC_RETURN),
+    JS_CFUNC_MAGIC_DEF('throw', 1, js_async_generator_next, GEN_MAGIC_THROW),
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'AsyncGenerator', JS_PROP_CONFIGURABLE),
+];
+export const js_async_generator_function_proto_funcs = [
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'AsyncGeneratorFunction', JS_PROP_CONFIGURABLE),
+];
+/* ---------------------------------------------------------------------
+   AsyncFromSyncIterator
+   --------------------------------------------------------------------- */
+export class JSAsyncFromSyncIteratorData {
+    sync_iter;
+    next_method;
+    constructor(sync_iter, next_method) { this.sync_iter = sync_iter; this.next_method = next_method; }
+}
+export function JS_CreateAsyncFromSyncIterator(ctx, sync_iter) {
+    const next_method = JS_GetProperty(ctx, sync_iter, JS_ATOM_next);
+    if (JS_IsException(next_method))
+        return JS_EXCEPTION;
+    const async_iter = JS_NewObjectClass(ctx, 51 /* JSClassID.ASYNC_FROM_SYNC_ITERATOR */);
+    if (JS_IsException(async_iter))
+        return async_iter;
+    JS_SetOpaque(async_iter, new JSAsyncFromSyncIteratorData(sync_iter, next_method));
+    return async_iter;
+}
+async_hooks.JS_CreateAsyncFromSyncIterator = JS_CreateAsyncFromSyncIterator;
+function js_async_from_sync_iterator_unwrap(ctx, this_val, argv, magic, func_data) {
+    return js_create_iterator_result(ctx, argv[0], JS_ToBoolFree(ctx, func_data[0]));
+}
+function js_async_from_sync_iterator_unwrap_func_create(ctx, done) {
+    return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_unwrap, 1, 0, [done]);
+}
+function js_async_from_sync_iterator_close_wrap(ctx, this_val, argv, magic, func_data) {
+    JS_Throw(ctx, argv[0]);
+    JS_IteratorClose(ctx, func_data[0], true);
+    return JS_EXCEPTION;
+}
+function js_async_from_sync_iterator_close_wrap_func_create(ctx, sync_iter) {
+    return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_close_wrap, 1, 0, [sync_iter]);
+}
+function js_async_from_sync_iterator_next(ctx, this_val, argv, magic) {
+    const resolving_funcs = [undefined, undefined];
+    const promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise))
+        return JS_EXCEPTION;
+    const reject = () => {
+        const err = JS_GetException(ctx);
+        JS_Call(ctx, resolving_funcs[1], undefined, [err]);
+        return promise;
+    };
+    const s = JS_GetOpaque(this_val, 51 /* JSClassID.ASYNC_FROM_SYNC_ITERATOR */);
+    if (!s) {
+        JS_ThrowTypeError(ctx, 'not an Async-from-Sync Iterator');
+        return reject();
+    }
+    let method;
+    if (magic === GEN_MAGIC_NEXT) {
+        method = s.next_method;
+    }
+    else {
+        method = JS_GetProperty(ctx, s.sync_iter, magic === GEN_MAGIC_RETURN ? JS_ATOM_return : JS_ATOM_throw);
+        if (JS_IsException(method))
+            return reject();
+        if (method === undefined || method === null) {
+            if (magic === GEN_MAGIC_RETURN) {
+                const res = js_create_iterator_result(ctx, argv[0], true);
+                JS_Call(ctx, resolving_funcs[0], undefined, [res]);
+                return promise;
+            }
+            else {
+                if (JS_IteratorClose(ctx, s.sync_iter, false))
+                    return reject();
+                JS_ThrowTypeError(ctx, 'throw is not a method');
+                return reject();
+            }
+        }
+    }
+    const obj = JS_Call(ctx, method, s.sync_iter, argv.length >= 1 ? [argv[0]] : []);
+    if (JS_IsException(obj))
+        return reject();
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeError(ctx, 'iterator must return an object');
+        return reject();
+    }
+    const pdone = { done: 0 };
+    const value = JS_IteratorGetCompleteValue(ctx, obj, pdone);
+    if (JS_IsException(value))
+        return reject();
+    const done = pdone.done !== 0;
+    const value_wrapper_promise = js_promise_resolve(ctx, ctx.promise_ctor ?? undefined, [value], 0);
+    if (JS_IsException(value_wrapper_promise)) {
+        if (magic !== GEN_MAGIC_RETURN && !done)
+            JS_IteratorClose(ctx, s.sync_iter, true);
+        return reject();
+    }
+    const resolve_reject = [undefined, undefined];
+    resolve_reject[0] = js_async_from_sync_iterator_unwrap_func_create(ctx, done);
+    if (JS_IsException(resolve_reject[0]))
+        return JS_EXCEPTION;
+    if (done || magic === GEN_MAGIC_RETURN) {
+        resolve_reject[1] = undefined;
+    }
+    else {
+        resolve_reject[1] = js_async_from_sync_iterator_close_wrap_func_create(ctx, s.sync_iter);
+        if (JS_IsException(resolve_reject[1]))
+            return JS_EXCEPTION;
+    }
+    const res = perform_promise_then(ctx, value_wrapper_promise, resolve_reject, resolving_funcs);
+    if (res)
+        return JS_EXCEPTION;
+    return promise;
+}
+export const js_async_from_sync_iterator_proto_funcs = [
+    JS_CFUNC_MAGIC_DEF('next', 1, js_async_from_sync_iterator_next, GEN_MAGIC_NEXT),
+    JS_CFUNC_MAGIC_DEF('return', 1, js_async_from_sync_iterator_next, GEN_MAGIC_RETURN),
+    JS_CFUNC_MAGIC_DEF('throw', 1, js_async_from_sync_iterator_next, GEN_MAGIC_THROW),
+];
+/* ---------------------------------------------------------------------
+   Runtime / hooks installation
+   --------------------------------------------------------------------- */
+hooks.JS_CallInternal = JS_CallInternal;
+hooks.js_closure = js_closure;
+/* ---------------------------------------------------------------------
+   Value based helpers for the compiled tier (no operand stack)
+   --------------------------------------------------------------------- */
+/* GetIterator + next method: returns [iterator, next] or null on exception */
+export function js_for_of_start_value(ctx, obj, is_async) {
+    const iter = JS_GetIterator(ctx, obj, is_async);
+    if (JS_IsException(iter))
+        return null;
+    const method = JS_GetProperty(ctx, iter, JS_ATOM_next);
+    if (JS_IsException(method))
+        return null;
+    return [iter, method];
+}
+/* IteratorStep: returns {value, done} or null on exception */
+export function js_for_of_next_value(ctx, iter, next) {
+    const pdone = { done: 0 };
+    const value = JS_IteratorNext(ctx, iter, next, [], pdone);
+    if (JS_IsException(value))
+        return null;
+    return { value: pdone.done ? undefined : value, done: pdone.done !== 0 };
+}
+/* spread: append the elements of the iterable 'src' to 'target' starting
+   at index 'pos'; returns the next position or -1 on exception */
+export function js_append_enumerate_value(ctx, target, pos, src) {
+    const stack = [target, pos, src];
+    if (js_append_enumerate(ctx, stack, 3))
+        return -1;
+    return stack[1];
+}
+/* unmapped arguments object from an argument list (compiled functions) */
+export function js_build_arguments_value(ctx, argv) {
+    return js_build_arguments(ctx, argv.length, argv);
+}
+//# sourceMappingURL=interpreter.js.map