jseption 0.0.0-stage → 0.0.2

package/dist/quickjs.js

@@ -0,0 +1,3408 @@
+/*
+ * jseption: TypeScript port of QuickJS
+ *
+ * Copyright (c) 2017-2025 Fabrice Bellard (original C implementation)
+ * Copyright (c) 2017-2025 Charlie Gordon (original C implementation)
+ *
+ * This file is the port of the "core" part of quickjs.c: runtime and
+ * context management, atoms, exceptions, the object model (property
+ * lookup, definition, deletion), value conversions and the abstract
+ * operators used by the interpreter and the builtins.
+ *
+ * Host-values model (docs/HOST_VALUES.md): guest objects are host objects
+ * with guest-owned prototype chains, properties are the host object's own
+ * properties (accessed through Reflect), and engine metadata lives in a
+ * WeakMap. Guest functions are strict host wrapper functions.
+ */
+import { jit_hooks } from "./jit_hook.js";
+import { AtomTable, JS_ATOM_NULL, JS_ATOM_TYPE_STRING, JS_ATOM_TYPE_SYMBOL, __JS_AtomIsTaggedInt, __JS_AtomFromUInt32, __JS_AtomToUInt32, JS_ATOM_MAX_INT, JS_ATOM_length, JS_ATOM_prototype, JS_ATOM_constructor, JS_ATOM_message, JS_ATOM_stack, JS_ATOM_toString, JS_ATOM_valueOf, JS_ATOM_Symbol_toPrimitive, JS_ATOM_Symbol_iterator, JS_ATOM_Symbol_hasInstance, JS_ATOM_done, JS_ATOM_value, JS_ATOM_return, JS_ATOM_get, JS_ATOM_set, JS_ATOM_configurable, JS_ATOM_writable, JS_ATOM_enumerable, JS_ATOM_undefined, JS_ATOM_object, JS_ATOM_boolean, JS_ATOM_number, JS_ATOM_string, JS_ATOM_symbol, JS_ATOM_bigint, JS_ATOM_function, JS_ATOM_lineNumber, JS_ATOM_fileName, JS_ATOM_columnNumber, JS_ATOM_Error, JS_ATOM___proto__, JS_ATOM_Symbol_asyncIterator, JS_ATOM_null, JS_ATOM_false, JS_ATOM_true, JS_ATOM_Object, JS_ATOM_Function, JS_ATOM_Array, JS_ATOM_Number, JS_ATOM_String, JS_ATOM_Boolean, JS_ATOM_Symbol, JS_ATOM_Arguments, JS_ATOM_BigInt, JS_ATOM_Date, JS_ATOM_RegExp, JS_ATOM_Map, JS_ATOM_Set, JS_ATOM_WeakMap, JS_ATOM_WeakSet, JS_ATOM_Generator, JS_ATOM_Proxy, JS_ATOM_Promise, JS_ATOM_AsyncFunction, JS_ATOM_AsyncGenerator, JS_ATOM_GeneratorFunction, JS_ATOM_AsyncGeneratorFunction, JS_ATOM_ForInIterator, JS_ATOM_Map_Iterator, JS_ATOM_Set_Iterator, JS_ATOM_Array_Iterator, JS_ATOM_String_Iterator, JS_ATOM_RegExp_String_Iterator, JS_ATOM_PromiseResolveFunction, JS_ATOM_PromiseRejectFunction, JS_ATOM_AsyncFunctionResolve, JS_ATOM_AsyncFunctionReject, JS_ATOM_ArrayBuffer, JS_ATOM_SharedArrayBuffer, JS_ATOM_Uint8ClampedArray, JS_ATOM_Int8Array, JS_ATOM_Uint8Array, JS_ATOM_Int16Array, JS_ATOM_Uint16Array, JS_ATOM_Int32Array, JS_ATOM_Uint32Array, JS_ATOM_BigInt64Array, JS_ATOM_BigUint64Array, JS_ATOM_Float32Array, JS_ATOM_Float64Array, JS_ATOM_DataView, JS_ATOM_WeakRef, JS_ATOM_FinalizationRegistry, JS_ATOM_Module, } from "./atoms.js";
+import { JSSpecial, JS_EXCEPTION, JS_UNINITIALIZED, JS_MODE_BACKTRACE_BARRIER, JS_PROP_CONFIGURABLE, JS_PROP_WRITABLE, JS_PROP_ENUMERABLE, JS_PROP_C_W_E, JS_PROP_TMASK, JS_PROP_GETSET, JS_PROP_HAS_CONFIGURABLE, JS_PROP_HAS_WRITABLE, JS_PROP_HAS_ENUMERABLE, JS_PROP_HAS_GET, JS_PROP_HAS_SET, JS_PROP_HAS_VALUE, JS_PROP_THROW, JS_PROP_THROW_STRICT, JS_PROP_NO_ADD, JS_GPN_STRING_MASK, JS_GPN_SYMBOL_MASK, JS_GPN_ENUM_ONLY, JS_GPN_SET_ENUM, JS_IsException, JS_IsObject, JS_IsUndefined, JSCFunctionRecord, JSCFunctionDataRecord, JSStackFrame, JS_CALL_FLAG_CONSTRUCTOR, JS_CALL_FLAG_COPY_ARGV, JSForInState, JSObjectMeta, JS_MODE_STRICT, } from "./values.js";
+export * from "./values.js";
+export * from "./atoms.js";
+export class JSClass {
+    class_id;
+    class_name;
+    constructor(class_id, def) {
+        this.class_id = class_id;
+        this.class_name = def.class_name;
+    }
+}
+/* engine metadata of guest objects (class id, internal slots, bytecode).
+   Objects belong to a single runtime, so one table is shared. */
+export const js_meta = new WeakMap();
+/* private fields and brands: object -> (private symbol -> value) */
+export const js_privates = new WeakMap();
+/* direct call entries for the compiled tier: guest function object ->
+   (this_val, new_target, ...args) => result, using the host exception
+   convention. Borrowed natives register their host function here. */
+export const js_direct = new WeakMap();
+export function js_get_meta(obj) {
+    if (typeof obj === 'object' || typeof obj === 'function') {
+        if (obj === null)
+            return undefined;
+        return js_meta.get(obj);
+    }
+    return undefined;
+}
+export function js_ensure_meta(obj, class_id = 1 /* JSClassID.OBJECT */) {
+    let m = js_meta.get(obj);
+    if (!m) {
+        m = new JSObjectMeta(class_id);
+        js_meta.set(obj, m);
+    }
+    return m;
+}
+/* bytecode function data of a function object, or null */
+export function JS_GetFunctionData(func) {
+    const m = js_get_meta(func);
+    return m ? m.func : null;
+}
+export class JSRuntime {
+    atoms = new AtomTable();
+    class_array = [];
+    class_count = 0;
+    current_exception = undefined;
+    exception_pending = false;
+    current_stack_frame = null;
+    interrupt_handler = null;
+    interrupt_opaque = null;
+    host_promise_rejection_tracker = null;
+    host_promise_rejection_tracker_opaque = null;
+    job_list = [];
+    module_normalize_func = null;
+    module_loader_func = null;
+    module_loader_opaque = null;
+    stack_depth = 0;
+    max_stack_depth = 2000;
+    user_opaque = null;
+    /* symbols registered with Symbol.for() */
+    global_symbol_registry = new Map();
+    can_block = false;
+    context_list = [];
+    interrupt_counter = 0;
+}
+export class JSContext {
+    rt;
+    class_proto = [];
+    function_proto = null;
+    function_ctor = null;
+    array_ctor = null;
+    regexp_ctor = null;
+    promise_ctor = null;
+    native_error_proto = [];
+    error_ctor = null;
+    error_prepare_stack = undefined;
+    error_stack_trace_limit = 10;
+    iterator_proto = null;
+    async_iterator_proto = null;
+    array_proto_values = undefined;
+    throw_type_error = null;
+    eval_obj = undefined;
+    /* the global object (an ordinary guest object) */
+    global_obj;
+    /* compiled tier: true while Object.prototype has no accessor and no read-only data
+       property (other than __proto__), so that the fields of an object literal can be
+       assigned instead of defined. Cleared by JS_DefineProperty. */
+    plain_object_proto = { ok: true };
+    /* global lexical bindings (let/const/class at the top level): an engine
+       internal object with a null prototype, never visible to guest code */
+    global_var_obj;
+    user_opaque = null;
+    loaded_modules = new Map();
+    interrupt_counter = 0;
+    array_iterator_proto = null;
+    generator_proto = null;
+    async_generator_proto = null;
+    constructor(rt) {
+        this.rt = rt;
+        for (let i = 0; i < rt.class_count; i++)
+            this.class_proto.push(null);
+        for (let i = 0; i < 8 /* JSErrorEnum.NATIVE_ERROR_COUNT */; i++)
+            this.native_error_proto.push(null);
+    }
+}
+export const hooks = {
+    JS_CallInternal: () => { throw new Error('interpreter not loaded'); },
+    JS_EvalInternal: () => { throw new Error('parser not loaded'); },
+    JS_AddIntrinsicBaseObjects: () => { throw new Error('builtins not loaded'); },
+    js_closure: () => { throw new Error('interpreter not loaded'); },
+    js_regexp_constructor_internal: null,
+    js_borrow_native: () => { throw new Error('native builtins not loaded'); },
+    init_runtime: [],
+};
+export function JS_NewClass1(rt, class_id, def) {
+    while (rt.class_array.length <= class_id)
+        rt.class_array.push(null);
+    rt.class_array[class_id] = new JSClass(class_id, def);
+    if (class_id >= rt.class_count)
+        rt.class_count = class_id + 1;
+    for (const ctx of rt.context_list) {
+        while (ctx.class_proto.length < rt.class_count)
+            ctx.class_proto.push(null);
+    }
+}
+export function JS_NewClass(rt, class_id, def) {
+    JS_NewClass1(rt, class_id, def);
+    return 0;
+}
+let next_class_id = 56 /* JSClassID.INIT_COUNT */;
+export function JS_NewClassID() {
+    return next_class_id++;
+}
+export function JS_IsRegisteredClass(rt, class_id) {
+    return class_id < rt.class_array.length && rt.class_array[class_id] !== null;
+}
+/* class definitions of the predefined classes */
+const js_std_class_def = [
+    [1 /* JSClassID.OBJECT */, JS_ATOM_Object],
+    [2 /* JSClassID.ARRAY */, JS_ATOM_Array],
+    [3 /* JSClassID.ERROR */, JS_ATOM_Error],
+    [4 /* JSClassID.NUMBER */, JS_ATOM_Number],
+    [5 /* JSClassID.STRING */, JS_ATOM_String],
+    [6 /* JSClassID.BOOLEAN */, JS_ATOM_Boolean],
+    [7 /* JSClassID.SYMBOL */, JS_ATOM_Symbol],
+    [8 /* JSClassID.ARGUMENTS */, JS_ATOM_Arguments],
+    [9 /* JSClassID.MAPPED_ARGUMENTS */, JS_ATOM_Arguments],
+    [10 /* JSClassID.DATE */, JS_ATOM_Date],
+    [11 /* JSClassID.MODULE_NS */, JS_ATOM_Module],
+    [12 /* JSClassID.C_FUNCTION */, JS_ATOM_Function],
+    [13 /* JSClassID.BYTECODE_FUNCTION */, JS_ATOM_Function],
+    [14 /* JSClassID.BOUND_FUNCTION */, JS_ATOM_Function],
+    [15 /* JSClassID.C_FUNCTION_DATA */, JS_ATOM_Function],
+    [16 /* JSClassID.GENERATOR_FUNCTION */, JS_ATOM_GeneratorFunction],
+    [17 /* JSClassID.FOR_IN_ITERATOR */, JS_ATOM_ForInIterator],
+    [18 /* JSClassID.REGEXP */, JS_ATOM_RegExp],
+    [19 /* JSClassID.ARRAY_BUFFER */, JS_ATOM_ArrayBuffer],
+    [20 /* JSClassID.SHARED_ARRAY_BUFFER */, JS_ATOM_SharedArrayBuffer],
+    [21 /* JSClassID.UINT8C_ARRAY */, JS_ATOM_Uint8ClampedArray],
+    [22 /* JSClassID.INT8_ARRAY */, JS_ATOM_Int8Array],
+    [23 /* JSClassID.UINT8_ARRAY */, JS_ATOM_Uint8Array],
+    [24 /* JSClassID.INT16_ARRAY */, JS_ATOM_Int16Array],
+    [25 /* JSClassID.UINT16_ARRAY */, JS_ATOM_Uint16Array],
+    [26 /* JSClassID.INT32_ARRAY */, JS_ATOM_Int32Array],
+    [27 /* JSClassID.UINT32_ARRAY */, JS_ATOM_Uint32Array],
+    [28 /* JSClassID.BIG_INT64_ARRAY */, JS_ATOM_BigInt64Array],
+    [29 /* JSClassID.BIG_UINT64_ARRAY */, JS_ATOM_BigUint64Array],
+    [30 /* JSClassID.FLOAT32_ARRAY */, JS_ATOM_Float32Array],
+    [31 /* JSClassID.FLOAT64_ARRAY */, JS_ATOM_Float64Array],
+    [32 /* JSClassID.DATAVIEW */, JS_ATOM_DataView],
+    [33 /* JSClassID.BIG_INT */, JS_ATOM_BigInt],
+    [34 /* JSClassID.MAP */, JS_ATOM_Map],
+    [35 /* JSClassID.SET */, JS_ATOM_Set],
+    [36 /* JSClassID.WEAKMAP */, JS_ATOM_WeakMap],
+    [37 /* JSClassID.WEAKSET */, JS_ATOM_WeakSet],
+    [38 /* JSClassID.MAP_ITERATOR */, JS_ATOM_Map_Iterator],
+    [39 /* JSClassID.SET_ITERATOR */, JS_ATOM_Set_Iterator],
+    [40 /* JSClassID.ARRAY_ITERATOR */, JS_ATOM_Array_Iterator],
+    [41 /* JSClassID.STRING_ITERATOR */, JS_ATOM_String_Iterator],
+    [42 /* JSClassID.REGEXP_STRING_ITERATOR */, JS_ATOM_RegExp_String_Iterator],
+    [43 /* JSClassID.GENERATOR */, JS_ATOM_Generator],
+    [44 /* JSClassID.PROXY */, JS_ATOM_Proxy],
+    [45 /* JSClassID.PROMISE */, JS_ATOM_Promise],
+    [46 /* JSClassID.PROMISE_RESOLVE_FUNCTION */, JS_ATOM_PromiseResolveFunction],
+    [47 /* JSClassID.PROMISE_REJECT_FUNCTION */, JS_ATOM_PromiseRejectFunction],
+    [48 /* JSClassID.ASYNC_FUNCTION */, JS_ATOM_AsyncFunction],
+    [49 /* JSClassID.ASYNC_FUNCTION_RESOLVE */, JS_ATOM_AsyncFunctionResolve],
+    [50 /* JSClassID.ASYNC_FUNCTION_REJECT */, JS_ATOM_AsyncFunctionReject],
+    [51 /* JSClassID.ASYNC_FROM_SYNC_ITERATOR */, JS_ATOM_Object],
+    [52 /* JSClassID.ASYNC_GENERATOR_FUNCTION */, JS_ATOM_AsyncGeneratorFunction],
+    [53 /* JSClassID.ASYNC_GENERATOR */, JS_ATOM_AsyncGenerator],
+    [54 /* JSClassID.WEAK_REF */, JS_ATOM_WeakRef],
+    [55 /* JSClassID.FINALIZATION_REGISTRY */, JS_ATOM_FinalizationRegistry],
+];
+export function JS_NewRuntime() {
+    const rt = new JSRuntime();
+    for (const [id, name] of js_std_class_def) {
+        JS_NewClass1(rt, id, { class_name: name });
+    }
+    for (const f of hooks.init_runtime)
+        f(rt);
+    return rt;
+}
+export function JS_FreeRuntime(rt) {
+    rt.job_list.length = 0;
+    rt.context_list.length = 0;
+}
+export function JS_SetRuntimeOpaque(rt, opaque) { rt.user_opaque = opaque; }
+export function JS_GetRuntimeOpaque(rt) { return rt.user_opaque; }
+export function JS_SetContextOpaque(ctx, opaque) { ctx.user_opaque = opaque; }
+export function JS_GetContextOpaque(ctx) { return ctx.user_opaque; }
+export function JS_GetRuntime(ctx) { return ctx.rt; }
+export function JS_SetMaxStackSize(rt, depth) { rt.max_stack_depth = depth; }
+export function JS_SetInterruptHandler(rt, cb, opaque) {
+    rt.interrupt_handler = cb;
+    rt.interrupt_opaque = opaque;
+}
+export function JS_SetHostPromiseRejectionTracker(rt, cb, opaque) {
+    rt.host_promise_rejection_tracker = cb;
+    rt.host_promise_rejection_tracker_opaque = opaque;
+}
+export function JS_NewContextRaw(rt) {
+    const ctx = new JSContext(rt);
+    rt.context_list.push(ctx);
+    ctx.class_proto[1 /* JSClassID.OBJECT */] = JS_NewObjectProto(ctx, null);
+    /* placeholder replaced by the builtins (Function.prototype is a function) */
+    ctx.function_proto = JS_NewObjectProtoClass(ctx, ctx.class_proto[1 /* JSClassID.OBJECT */], 1 /* JSClassID.OBJECT */);
+    ctx.global_obj = JS_NewObject(ctx);
+    ctx.global_var_obj = Object.create(null);
+    return ctx;
+}
+export function JS_NewContext(rt) {
+    const ctx = JS_NewContextRaw(rt);
+    hooks.JS_AddIntrinsicBaseObjects(ctx);
+    return ctx;
+}
+export function JS_FreeContext(ctx) {
+    const i = ctx.rt.context_list.indexOf(ctx);
+    if (i >= 0)
+        ctx.rt.context_list.splice(i, 1);
+}
+export function JS_GetClassProto(ctx, class_id) {
+    return ctx.class_proto[class_id] ?? undefined;
+}
+export function JS_SetClassProto(ctx, class_id, obj) {
+    ctx.class_proto[class_id] = obj;
+}
+export function JS_GetGlobalObject(ctx) { return ctx.global_obj; }
+/* ---------------------------------------------------------------------
+   Atoms
+   --------------------------------------------------------------------- */
+export function JS_NewAtom(ctx, str) { return ctx.rt.atoms.newAtomStr(str); }
+export function JS_NewAtomStr(ctx, str) { return ctx.rt.atoms.newAtomStr(str); }
+export function JS_NewAtomUInt32(ctx, n) { return ctx.rt.atoms.newAtomUInt32(n); }
+export function JS_NewAtomInt64(ctx, n) {
+    if (n >= 0 && n <= JS_ATOM_MAX_INT)
+        return __JS_AtomFromUInt32(n);
+    return ctx.rt.atoms.newAtomStr(String(n));
+}
+export function JS_DupAtom(_ctx, v) { return v; }
+export function JS_FreeAtom(_ctx, _v) { }
+export function JS_FreeValue(_ctx, _v) { }
+export function JS_DupValue(_ctx, v) { return v; }
+export function JS_AtomIsString(ctx, atom) { return ctx.rt.atoms.isString(atom); }
+export function JS_AtomIsSymbol(ctx, atom) { return ctx.rt.atoms.isSymbol(atom); }
+export function JS_AtomGetStr(ctx, atom) { return ctx.rt.atoms.toDisplayStr(atom); }
+export function JS_AtomGetStrRT(rt, atom) { return rt.atoms.toDisplayStr(atom); }
+export function JS_AtomToKey(ctx, atom) {
+    return ctx.rt.atoms.toKey(atom);
+}
+/* atom from a host property key (as returned by Reflect.ownKeys) */
+export function JS_KeyToAtom(ctx, key) {
+    switch (typeof key) {
+        case 'string': return ctx.rt.atoms.newAtomStr(key);
+        case 'number': return ctx.rt.atoms.newAtomUInt32(key);
+        default: return ctx.rt.atoms.symbolToAtom(key);
+    }
+}
+/* atom to JS value: string or symbol */
+export function JS_AtomToValue(ctx, atom) {
+    const atoms = ctx.rt.atoms;
+    if (atoms.isSymbol(atom))
+        return atoms.getSymbol(atom);
+    return atoms.toStr(atom);
+}
+/* atom to string (symbols are converted to their description) */
+export function JS_AtomToString(ctx, atom) {
+    return ctx.rt.atoms.toStr(atom);
+}
+/* return the array index (0 .. 2^32-2) or -1 if the atom is not an array index */
+export function JS_AtomIsArrayIndex(ctx, atom) {
+    if (__JS_AtomIsTaggedInt(atom))
+        return __JS_AtomToUInt32(atom);
+    const atoms = ctx.rt.atoms;
+    if (atoms.getType(atom) !== JS_ATOM_TYPE_STRING)
+        return -1;
+    const str = atoms.toStr(atom);
+    /* canonical uint32 string larger than JS_ATOM_MAX_INT */
+    if (str.length !== 10)
+        return -1;
+    if (!/^[1-9][0-9]{9}$/.test(str))
+        return -1;
+    const n = Number(str);
+    if (n > 0xfffffffe)
+        return -1;
+    return n;
+}
+/* return TRUE if the atom is a numeric index (canonical numeric string) */
+export function JS_AtomIsNumericIndex1(ctx, atom) {
+    if (__JS_AtomIsTaggedInt(atom))
+        return __JS_AtomToUInt32(atom);
+    if (!ctx.rt.atoms.isString(atom))
+        return undefined;
+    const str = ctx.rt.atoms.toStr(atom);
+    if (str === '-0')
+        return -0;
+    if (str === 'Infinity')
+        return Infinity;
+    if (str === '-Infinity')
+        return -Infinity;
+    if (str === 'NaN')
+        return NaN;
+    const n = Number(str);
+    if (Number.isNaN(n) || str.trim() !== str || str === '')
+        return undefined;
+    if (js_number_to_string(n, 10) !== str)
+        return undefined;
+    return n;
+}
+export function JS_AtomIsNumericIndex(ctx, atom) {
+    return JS_AtomIsNumericIndex1(ctx, atom) !== undefined;
+}
+/* ToPropertyKey */
+export function JS_ValueToAtom(ctx, val) {
+    switch (typeof val) {
+        case 'number':
+            if (Number.isInteger(val) && val >= 0 && val <= JS_ATOM_MAX_INT)
+                return __JS_AtomFromUInt32(val);
+            return ctx.rt.atoms.newAtomStr(js_number_to_string(val, 10));
+        case 'string':
+            return ctx.rt.atoms.newAtomStr(val);
+        case 'symbol':
+            return ctx.rt.atoms.symbolToAtom(val);
+        case 'boolean':
+            return val ? JS_ATOM_true : JS_ATOM_false;
+        case 'undefined':
+            return JS_ATOM_undefined;
+        case 'bigint':
+            return ctx.rt.atoms.newAtomStr(val.toString());
+        case 'object':
+        case 'function':
+            if (val === null)
+                return JS_ATOM_null;
+            if (JS_IsObject(val)) {
+                const prim = JS_ToPrimitive(ctx, val, HINT_STRING);
+                if (JS_IsException(prim))
+                    return JS_ATOM_NULL;
+                return JS_ValueToAtom(ctx, prim);
+            }
+            break;
+    }
+    JS_ThrowTypeError(ctx, 'invalid property key');
+    return JS_ATOM_NULL;
+}
+export function JS_NewSymbol(ctx, description, atom_type = JS_ATOM_TYPE_SYMBOL) {
+    return ctx.rt.atoms.newSymbol(description, atom_type);
+}
+export function JS_NewSymbolFromAtom(ctx, descr, atom_type) {
+    return ctx.rt.atoms.newSymbol(ctx.rt.atoms.toStr(descr), atom_type);
+}
+/* ---------------------------------------------------------------------
+   Exceptions
+   --------------------------------------------------------------------- */
+export function JS_Throw(ctx, obj) {
+    const rt = ctx.rt;
+    rt.current_exception = obj;
+    rt.exception_pending = true;
+    return JS_EXCEPTION;
+}
+export function JS_GetException(ctx) {
+    const rt = ctx.rt;
+    const val = rt.current_exception;
+    rt.current_exception = undefined;
+    rt.exception_pending = false;
+    return val;
+}
+export function JS_HasException(ctx) { return ctx.rt.exception_pending; }
+/* take the pending exception to throw it as a host exception (used by the
+   function wrappers at the engine/host boundary) */
+export function js_take_exception(ctx) {
+    return JS_GetException(ctx);
+}
+/* Convert a value thrown by host code into the engine convention. Guest
+   values pass through; host intrinsic errors (their prototype chain reaches
+   the host Error.prototype, which no guest object has) become guest errors.
+   Always returns JS_EXCEPTION. */
+/* Host error messages quote the expression that failed ("$s1 is not a function. (In
+   '$s1(...)', ...)"): map the common ones to the QuickJS wording so that generated code
+   never shows through, and drop the quoted source otherwise. */
+export function js_normalize_host_message(e) {
+    let msg = String(e.message);
+    if (e instanceof TypeError) {
+        if (/ is not a function\b/.test(msg))
+            return 'not a function';
+        if (/ is not a constructor\b/.test(msg))
+            return 'not a constructor';
+        const m = /^(null|undefined) is not an object \(evaluating '([^']*)'\)$/.exec(msg);
+        if (m) {
+            const expr = m[2];
+            const eq = expr.indexOf(' = ');
+            const lhs = eq >= 0 ? expr.slice(0, eq) : expr;
+            const name = /\.([A-Za-z_$][\w$]*)$/.exec(lhs);
+            const what = eq >= 0 ? 'cannot set property' : 'cannot read property';
+            return name ? `${what} '${name[1]}' of ${m[1]}` : `${what} of ${m[1]}`;
+        }
+    }
+    msg = msg.replace(/\s*\((?:evaluating|In) '.*$/, '');
+    return msg;
+}
+export function js_host_exception_to_guest(ctx, e) {
+    if (e === JS_EXCEPTION)
+        return JS_EXCEPTION; /* already pending */
+    if (e instanceof Error) {
+        let msg = js_normalize_host_message(e);
+        let num;
+        if (e instanceof RangeError) {
+            if (/call stack|stack size|recursion|stack overflow/i.test(msg))
+                return JS_ThrowStackOverflow(ctx);
+            num = 1 /* JSErrorEnum.RANGE_ERROR */;
+        }
+        else if (e instanceof TypeError)
+            num = 4 /* JSErrorEnum.TYPE_ERROR */;
+        else if (e instanceof SyntaxError)
+            num = 3 /* JSErrorEnum.SYNTAX_ERROR */;
+        else if (e instanceof ReferenceError)
+            num = 2 /* JSErrorEnum.REFERENCE_ERROR */;
+        else if (e instanceof URIError)
+            num = 5 /* JSErrorEnum.URI_ERROR */;
+        else if (e instanceof EvalError)
+            num = 0 /* JSErrorEnum.EVAL_ERROR */;
+        else {
+            num = 6 /* JSErrorEnum.INTERNAL_ERROR */;
+            msg = 'internal error: ' + msg;
+        }
+        /* the host captured the stack where the error was raised: compiled guest frames are
+           located from it (see build_backtrace) */
+        return JS_ThrowError2(ctx, num, msg, true, typeof e.stack === 'string' ? e.stack : null);
+    }
+    return JS_Throw(ctx, e);
+}
+export function JS_IsError(ctx, val) {
+    const m = js_get_meta(val);
+    return m !== undefined && m.class_id === 3 /* JSClassID.ERROR */;
+}
+export function JS_IsUncatchableError(ctx, val) {
+    const m = js_get_meta(val);
+    return m !== undefined && m.class_id === 3 /* JSClassID.ERROR */ && m.is_uncatchable_error;
+}
+export function JS_SetUncatchableError(ctx, val, flag) {
+    const m = js_get_meta(val);
+    if (m && m.class_id === 3 /* JSClassID.ERROR */)
+        m.is_uncatchable_error = flag;
+}
+export function JS_NewError(ctx) {
+    return JS_NewObjectProtoClass(ctx, ctx.class_proto[3 /* JSClassID.ERROR */], 3 /* JSClassID.ERROR */);
+}
+export function JS_NewErrorNative(ctx, error_num, message) {
+    let proto;
+    if (error_num === 8 /* JSErrorEnum.PLAIN_ERROR */)
+        proto = ctx.class_proto[3 /* JSClassID.ERROR */];
+    else
+        proto = ctx.native_error_proto[error_num];
+    const obj = JS_NewObjectProtoClass(ctx, proto, 3 /* JSClassID.ERROR */);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_message, message, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    return obj;
+}
+export const JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL = 1 << 0;
+/* Build the 'stack' property of an error from the current call stack.
+
+   Interpreter and C function frames are the `JSStackFrame` chain. Compiled
+   functions (src/jit.ts) have no such frame: when the compiled tier is on,
+   the host stack (`host_stack`, or the current one) is mapped to guest frames
+   by src/jit_stack.ts and the engine frames found in it consume the chain in
+   order, so both kinds appear interleaved as they were called. Frames of
+   host builtins called by guest code appear as `(native)`.
+
+   `fileName`/`lineNumber`/`columnNumber` are set from the given position or,
+   when none is given, from the innermost frame with a position. */
+export function build_backtrace(ctx, error_obj, filename, line_num, col_num, backtrace_flags, host_stack = null) {
+    let str = '';
+    const is_obj = JS_IsObject(error_obj);
+    let has_pos = false;
+    const set_pos = (file, line, col) => {
+        has_pos = true;
+        if (!is_obj)
+            return;
+        /* Note: SpiderMonkey does that, could update once there is a standard */
+        JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_fileName, file, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+        JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_lineNumber, line, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+        JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_columnNumber, col, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    };
+    if (filename) {
+        str += `    at ${filename}`;
+        if (line_num !== -1)
+            str += `:${line_num}:${col_num}`;
+        str += '\n';
+        set_pos(filename, line_num, col_num);
+    }
+    /* one line for an engine frame */
+    const frame_line = (sf) => {
+        const f = sf.cur_func;
+        let func_name = '';
+        if (JS_IsObject(f))
+            func_name = get_func_name(ctx, f);
+        let s = `    at ${func_name || '<anonymous>'}`;
+        const fd = JS_GetFunctionData(f);
+        if (fd) {
+            const b = fd.function_bytecode;
+            if (b.has_debug) {
+                const fname = ctx.rt.atoms.toStr(b.debug.filename);
+                const [line1, col1] = find_line_num(ctx, b, sf.cur_pc - 1);
+                s += ` (${fname}`;
+                if (line1 > 0) {
+                    s += `:${line1}:${col1}`;
+                    if (!has_pos)
+                        set_pos(fname, line1, col1);
+                }
+                s += ')';
+            }
+        }
+        else {
+            s += ' (native)';
+        }
+        return s + '\n';
+    };
+    let skip = (backtrace_flags & JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL) !== 0;
+    let sf = ctx.rt.current_stack_frame;
+    const hooks = jit_hooks.stack;
+    if (hooks !== null) {
+        const frames = hooks.frames(host_stack ?? hooks.capture());
+        let stop = false;
+        for (let i = 0; i < frames.length && !stop; i++) {
+            const hf = frames[i];
+            switch (hf.kind) {
+                case 'compiled':
+                    if (skip) {
+                        skip = false;
+                        break;
+                    }
+                    str += `    at ${hf.name || '<anonymous>'} (${hf.file}`;
+                    if (hf.line > 0) {
+                        str += `:${hf.line}:${hf.col}`;
+                        if (!has_pos)
+                            set_pos(hf.file, hf.line, hf.col);
+                    }
+                    str += ')\n';
+                    break;
+                case 'native':
+                    if (skip) {
+                        skip = false;
+                        break;
+                    }
+                    str += `    at ${hf.name || '<anonymous>'} (native)\n`;
+                    break;
+                default: {
+                    /* the next engine frame, when of the matching kind (the frame of a C function that
+                       raised a host exception is already unwound when the exception is converted) */
+                    if (sf === null)
+                        break;
+                    if ((JS_GetFunctionData(sf.cur_func) !== null) !== (hf.kind === 'interp'))
+                        break;
+                    if (sf.js_mode & JS_MODE_BACKTRACE_BARRIER) {
+                        sf = null;
+                        stop = true;
+                        break;
+                    }
+                    const cur = sf;
+                    sf = sf.prev_frame;
+                    /* a frame replaced by compiled code (on-stack replacement) is shown by its compiled
+                       frame, which precedes it on the host stack */
+                    if (cur.osr)
+                        break;
+                    if (skip) {
+                        skip = false;
+                        break;
+                    }
+                    str += frame_line(cur);
+                    break;
+                }
+            }
+        }
+        /* engine frames the host stack did not show (its depth limit) follow */
+    }
+    for (; sf !== null; sf = sf.prev_frame) {
+        if (sf.js_mode & JS_MODE_BACKTRACE_BARRIER)
+            break;
+        if (sf.osr)
+            continue;
+        if (skip) {
+            skip = false;
+            continue;
+        }
+        str += frame_line(sf);
+    }
+    if (is_obj) {
+        JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_stack, str, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+        const m = js_get_meta(error_obj);
+        if (m)
+            m.has_backtrace = true;
+    }
+}
+export function get_func_name(ctx, func) {
+    try {
+        const d = Reflect.getOwnPropertyDescriptor(func, 'name');
+        if (d && 'value' in d && typeof d.value === 'string')
+            return d.value;
+    }
+    catch { /* proxy trap failures are ignored here */ }
+    const fd = JS_GetFunctionData(func);
+    if (fd)
+        return ctx.rt.atoms.toStr(fd.function_bytecode.func_name);
+    return '';
+}
+/* decode the pc2line table: returns [line, col] of the last entry whose
+   pc is <= pc_value. pc_value < 0 returns the function start position. */
+export function find_line_num(ctx, b, pc_value) {
+    const buf = b.debug.pc2line;
+    if (!buf || buf.length === 0)
+        return [-1, -1];
+    /* encoding: sequence of (pc_delta: leb128, line_delta: sleb128, col_delta: sleb128);
+       the first entry gives the function start position */
+    let pos = 0, pc = 0, line = 0, col = 0;
+    let last_line = -1, last_col = -1;
+    let first = true;
+    while (pos < buf.length) {
+        const r1 = get_leb128(buf, pos);
+        pos = r1[1];
+        const r2 = get_sleb128(buf, pos);
+        pos = r2[1];
+        const r3 = get_sleb128(buf, pos);
+        pos = r3[1];
+        pc += r1[0];
+        line += r2[0];
+        col += r3[0];
+        if (first) {
+            first = false;
+            last_line = line;
+            last_col = col;
+            if (pc_value < 0)
+                break;
+            continue;
+        }
+        if (pc > pc_value)
+            break;
+        last_line = line;
+        last_col = col;
+    }
+    return [last_line, last_col];
+}
+export function get_leb128(buf, pos) {
+    let v = 0, shift = 0;
+    for (;;) {
+        const a = buf[pos++];
+        v += (a & 0x7f) * Math.pow(2, shift);
+        if (!(a & 0x80))
+            break;
+        shift += 7;
+    }
+    return [v, pos];
+}
+export function get_sleb128(buf, pos) {
+    const [v, p] = get_leb128(buf, pos);
+    /* zigzag */
+    return [(v % 2 === 1) ? -((v + 1) / 2) : v / 2, p];
+}
+export function JS_ThrowError2(ctx, error_num, message, add_backtrace, host_stack = null) {
+    const obj = JS_NewErrorNative(ctx, error_num, message);
+    if (add_backtrace)
+        build_backtrace(ctx, obj, null, 0, 0, 0, host_stack);
+    return JS_Throw(ctx, obj);
+}
+export function JS_ThrowError(ctx, error_num, message) {
+    /* the backtrace is added later (with the exact position) if called
+       from a bytecode function */
+    const sf = ctx.rt.current_stack_frame;
+    if (!sf || JS_GetFunctionData(sf.cur_func) === null)
+        return JS_ThrowError2(ctx, error_num, message, true);
+    const hooks = jit_hooks.stack;
+    if (hooks !== null) {
+        /* a compiled function has no interpreter frame: when it is the thrower, its position is
+           on the host stack now and gone once the exception has propagated */
+        const stack = hooks.capture();
+        if (hooks.compiled_on_top(stack))
+            return JS_ThrowError2(ctx, error_num, message, true, stack);
+    }
+    return JS_ThrowError2(ctx, error_num, message, false);
+}
+export function JS_ThrowSyntaxError(ctx, msg) { return JS_ThrowError(ctx, 3 /* JSErrorEnum.SYNTAX_ERROR */, msg); }
+export function JS_ThrowTypeError(ctx, msg) { return JS_ThrowError(ctx, 4 /* JSErrorEnum.TYPE_ERROR */, msg); }
+export function JS_ThrowReferenceError(ctx, msg) { return JS_ThrowError(ctx, 2 /* JSErrorEnum.REFERENCE_ERROR */, msg); }
+export function JS_ThrowRangeError(ctx, msg) { return JS_ThrowError(ctx, 1 /* JSErrorEnum.RANGE_ERROR */, msg); }
+export function JS_ThrowInternalError(ctx, msg) { return JS_ThrowError(ctx, 6 /* JSErrorEnum.INTERNAL_ERROR */, msg); }
+export function JS_ThrowURIError(ctx, msg) { return JS_ThrowError(ctx, 5 /* JSErrorEnum.URI_ERROR */, msg); }
+export function JS_ThrowEvalError(ctx, msg) { return JS_ThrowError(ctx, 0 /* JSErrorEnum.EVAL_ERROR */, msg); }
+export function JS_ThrowOutOfMemory(ctx) { return JS_ThrowInternalError(ctx, 'out of memory'); }
+export function JS_ThrowStackOverflow(ctx) { return JS_ThrowInternalError(ctx, 'stack overflow'); }
+export function JS_ThrowTypeErrorAtom(ctx, fmt, atom) {
+    return JS_ThrowTypeError(ctx, fmt.replace('%s', JS_AtomGetStr(ctx, atom)));
+}
+export function JS_ThrowSyntaxErrorAtom(ctx, fmt, atom) {
+    return JS_ThrowSyntaxError(ctx, fmt.replace('%s', JS_AtomGetStr(ctx, atom)));
+}
+export function JS_ThrowReferenceErrorNotDefined(ctx, name) {
+    return JS_ThrowReferenceError(ctx, `'${JS_AtomGetStr(ctx, name)}' is not defined`);
+}
+export function JS_ThrowReferenceErrorUninitialized(ctx, name) {
+    return JS_ThrowReferenceError(ctx, `${name === JS_ATOM_NULL ? 'lexical variable' : "'" + JS_AtomGetStr(ctx, name) + "'"} is not initialized`);
+}
+export function JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, is_ref) {
+    let atom = JS_ATOM_NULL;
+    if (is_ref)
+        atom = b.closure_var[idx].var_name;
+    else
+        atom = b.vardefs[b.arg_count + idx]?.var_name ?? JS_ATOM_NULL;
+    return JS_ThrowReferenceErrorUninitialized(ctx, atom);
+}
+export function JS_ThrowTypeErrorReadOnly(ctx, flags, atom) {
+    if ((flags & JS_PROP_THROW) || ((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
+        JS_ThrowTypeErrorAtom(ctx, "'%s' is read-only", atom);
+        return -1;
+    }
+    return 0;
+}
+export function JS_ThrowTypeErrorNotAnObject(ctx) { return JS_ThrowTypeError(ctx, 'not an object'); }
+export function JS_ThrowTypeErrorNotASymbol(ctx) { return JS_ThrowTypeError(ctx, 'not a symbol'); }
+export function JS_ThrowTypeErrorInvalidClass(ctx, class_id) {
+    const name = ctx.rt.class_array[class_id]?.class_name ?? JS_ATOM_Object;
+    return JS_ThrowTypeErrorAtom(ctx, '%s object expected', name);
+}
+export function JS_ThrowTypeErrorNotAFunction(ctx) { return JS_ThrowTypeError(ctx, 'not a function'); }
+export function is_strict_mode(ctx) {
+    const sf = ctx.rt.current_stack_frame;
+    return !!sf && (sf.js_mode & JS_MODE_STRICT) !== 0;
+}
+/* host-side error class used only to signal fatal interpreter bugs */
+export class JSInternalError extends Error {
+}
+/* ---------------------------------------------------------------------
+   Object creation
+   --------------------------------------------------------------------- */
+function js_is_function_class(class_id) {
+    switch (class_id) {
+        case 12 /* JSClassID.C_FUNCTION */:
+        case 15 /* JSClassID.C_FUNCTION_DATA */:
+        case 13 /* JSClassID.BYTECODE_FUNCTION */:
+        case 14 /* JSClassID.BOUND_FUNCTION */:
+        case 16 /* JSClassID.GENERATOR_FUNCTION */:
+        case 48 /* JSClassID.ASYNC_FUNCTION */:
+        case 52 /* JSClassID.ASYNC_GENERATOR_FUNCTION */:
+        case 46 /* JSClassID.PROMISE_RESOLVE_FUNCTION */:
+        case 47 /* JSClassID.PROMISE_REJECT_FUNCTION */:
+        case 49 /* JSClassID.ASYNC_FUNCTION_RESOLVE */:
+        case 50 /* JSClassID.ASYNC_FUNCTION_REJECT */:
+            return true;
+        default:
+            return false;
+    }
+}
+/* Create a guest object with the given prototype and class. Arrays are
+   host arrays re-prototyped to the guest prototype; the other classes are
+   ordinary objects with metadata when class_id != JS_CLASS_OBJECT.
+   Function classes must be created with JS_NewCFunction* or js_closure. */
+export function JS_NewObjectProtoClass(ctx, proto, class_id) {
+    const p = JS_IsObject(proto) ? proto : null;
+    let obj;
+    if (class_id === 2 /* JSClassID.ARRAY */) {
+        obj = [];
+        Object.setPrototypeOf(obj, p);
+    }
+    else {
+        if (js_is_function_class(class_id))
+            throw new JSInternalError('function objects must be created with js_new_host_function');
+        obj = Object.create(p);
+    }
+    if (class_id !== 1 /* JSClassID.OBJECT */)
+        js_meta.set(obj, new JSObjectMeta(class_id));
+    return obj;
+}
+export function JS_NewObjectClass(ctx, class_id) {
+    return JS_NewObjectProtoClass(ctx, ctx.class_proto[class_id], class_id);
+}
+export function JS_NewObjectProto(ctx, proto) {
+    return Object.create(JS_IsObject(proto) ? proto : null);
+}
+export function JS_NewObject(ctx) {
+    return Object.create(ctx.class_proto[1 /* JSClassID.OBJECT */]);
+}
+export function JS_NewArray(ctx) {
+    const a = [];
+    Object.setPrototypeOf(a, ctx.class_proto[2 /* JSClassID.ARRAY */]);
+    return a;
+}
+/* create an array from a list of values (the list is copied) */
+export function js_create_array(ctx, values) {
+    const a = values.slice();
+    Object.setPrototypeOf(a, ctx.class_proto[2 /* JSClassID.ARRAY */]);
+    return a;
+}
+/* create an array from a list of values (takes ownership of the list) */
+export function JS_NewArrayFrom(ctx, values) {
+    Object.setPrototypeOf(values, ctx.class_proto[2 /* JSClassID.ARRAY */]);
+    return values;
+}
+/* return the host array backing a guest array (not a proxy) when it is
+   dense (no holes), or null. QuickJS fast arrays never have holes, so the
+   fast paths of the builtins may assume that every element is present. */
+export function js_get_fast_array(ctx, obj) {
+    /* host arrays may contain holes: callers must use 'i in arr' where the
+       spec requires HasProperty (a scan here would make every call O(n)) */
+    if (!Array.isArray(obj) || js_meta.get(obj) !== undefined)
+        return null;
+    return obj;
+}
+export function JS_SetOpaque(obj, opaque) {
+    if (!JS_IsObject(obj))
+        return -1;
+    js_ensure_meta(obj).u = opaque;
+    return 0;
+}
+export function JS_GetOpaque(obj, class_id) {
+    const m = js_get_meta(obj);
+    if (m && m.class_id === class_id)
+        return m.u;
+    return null;
+}
+export function JS_GetOpaque2(ctx, obj, class_id) {
+    const p = JS_GetOpaque(obj, class_id);
+    if (p === null || p === undefined)
+        JS_ThrowTypeErrorInvalidClass(ctx, class_id);
+    return p;
+}
+export function JS_GetAnyOpaque(obj) {
+    const m = js_get_meta(obj);
+    return m ? m.u : null;
+}
+/* class id of a value: 0 for non objects */
+export function JS_GetClassID(v) {
+    if (!JS_IsObject(v))
+        return 0;
+    const m = js_meta.get(v);
+    if (m)
+        return m.class_id;
+    if (Array.isArray(v))
+        return 2 /* JSClassID.ARRAY */;
+    if (typeof v === 'function')
+        return 12 /* JSClassID.C_FUNCTION */;
+    return 1 /* JSClassID.OBJECT */;
+}
+/* (plain module code: ES modules are strict, and no code generation from
+   strings is needed, so the runtime loads under a CSP without 'unsafe-eval'
+   and on platforms such as Cloudflare Workers) */
+const host_fn_factory = {
+    mk_method(impl) {
+        const o = { m(...args) { return impl(this, undefined, args); } };
+        return o.m;
+    },
+    mk_function(impl) {
+        const f = function (...args) { return impl(this, new.target, args); };
+        f.prototype = undefined; /* replaced by the engine; never a host object */
+        return f;
+    },
+};
+/* create a guest function object calling 'impl' (which uses the host
+   exception convention) */
+export function js_new_host_function(ctx, impl, is_ctor, name, length, proto, class_id) {
+    const f = is_ctor ? host_fn_factory.mk_function(impl) : host_fn_factory.mk_method(impl);
+    js_direct.set(f, (t, nt, ...args) => impl(t, nt, args));
+    js_init_host_function(ctx, f, is_ctor, name, length, proto, class_id);
+    return f;
+}
+/* make a freshly created strict host function `f` a guest function object (prototype, length,
+   name, metadata). A `function` must have had its host `prototype` property replaced already. */
+export function js_init_host_function(ctx, f, is_ctor, name, length, proto, class_id) {
+    Object.setPrototypeOf(f, JS_IsObject(proto) ? proto : null);
+    Reflect.defineProperty(f, 'length', { value: length, writable: false, enumerable: false, configurable: true });
+    Reflect.defineProperty(f, 'name', { value: name, writable: false, enumerable: false, configurable: true });
+    const m = new JSObjectMeta(class_id);
+    m.is_constructor = is_ctor;
+    m.realm = ctx;
+    js_meta.set(f, m);
+    return m;
+}
+export function JS_IsFunction(ctx, val) {
+    return typeof val === 'function';
+}
+/* IsConstructor for host functions without metadata (bound functions
+   created by the host, borrowed natives): Reflect.construct validates its
+   new.target argument without calling it */
+function js_is_host_constructor(f) {
+    try {
+        Reflect.construct(String, [], f);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function JS_IsConstructor(ctx, val) {
+    if (typeof val !== 'function')
+        return false;
+    const m = js_meta.get(val);
+    if (m)
+        return m.is_constructor;
+    return js_is_host_constructor(val);
+}
+export function JS_SetConstructorBit(ctx, func_obj, val) {
+    if (typeof func_obj !== 'function')
+        return false;
+    js_ensure_meta(func_obj, 12 /* JSClassID.C_FUNCTION */).is_constructor = val;
+    return true;
+}
+/* IsArray: -1 on exception (revoked proxy) */
+export function JS_IsArray(ctx, val) {
+    const m = js_get_meta(val);
+    if (m && m.class_id === 44 /* JSClassID.PROXY */) {
+        const s = m.u;
+        if (s.is_revoked) {
+            JS_ThrowTypeError(ctx, 'revoked proxy');
+            return -1;
+        }
+        return JS_IsArray(ctx, s.target);
+    }
+    try {
+        return Array.isArray(val) ? 1 : 0;
+    }
+    catch (e) {
+        JS_ThrowTypeError(ctx, 'revoked proxy');
+        return -1;
+    }
+}
+function js_cfunc_is_ctor(cproto) {
+    return cproto === 2 /* JSCFunctionEnum.constructor */ ||
+        cproto === 3 /* JSCFunctionEnum.constructor_magic */ ||
+        cproto === 4 /* JSCFunctionEnum.constructor_or_func */ ||
+        cproto === 5 /* JSCFunctionEnum.constructor_or_func_magic */;
+}
+export function JS_NewCFunction3(ctx, func, name, length, cproto, magic, proto_val) {
+    const rec = new JSCFunctionRecord(func, length, cproto, magic);
+    let fobj;
+    const impl = (this_val, new_target, args) => {
+        let ret;
+        if (new_target !== undefined)
+            ret = js_call_c_function(ctx, fobj, new_target, args, JS_CALL_FLAG_CONSTRUCTOR);
+        else
+            ret = js_call_c_function(ctx, fobj, this_val, args, 0);
+        if (ret === JS_EXCEPTION)
+            throw js_take_exception(ctx);
+        return ret;
+    };
+    fobj = js_new_host_function(ctx, impl, js_cfunc_is_ctor(cproto), name, length, proto_val, 12 /* JSClassID.C_FUNCTION */);
+    js_meta.get(fobj).cfunc = rec;
+    return fobj;
+}
+export function JS_NewCFunction2(ctx, func, name, length, cproto, magic) {
+    return JS_NewCFunction3(ctx, func, name, length, cproto, magic, ctx.function_proto);
+}
+export function JS_NewCFunction(ctx, func, name, length) {
+    return JS_NewCFunction2(ctx, func, name, length, 0 /* JSCFunctionEnum.generic */, 0);
+}
+export function JS_NewCFunctionMagic(ctx, func, name, length, cproto, magic) {
+    return JS_NewCFunction2(ctx, func, name, length, cproto, magic);
+}
+export function JS_NewCFunctionData(ctx, func, length, magic, data) {
+    const s = new JSCFunctionDataRecord(func, length, magic, data.slice());
+    let fobj;
+    const impl = (this_val, new_target, args) => {
+        const ret = js_c_function_data_call(ctx, fobj, this_val, args, 0);
+        if (ret === JS_EXCEPTION)
+            throw js_take_exception(ctx);
+        return ret;
+    };
+    fobj = js_new_host_function(ctx, impl, false, '', length, ctx.function_proto, 15 /* JSClassID.C_FUNCTION_DATA */);
+    js_meta.get(fobj).u = s;
+    return fobj;
+}
+export function js_c_function_data_call(ctx, func_obj, this_val, argv, flags) {
+    const s = js_meta.get(func_obj).u;
+    const rt = ctx.rt;
+    if (rt.stack_depth >= rt.max_stack_depth)
+        return JS_ThrowStackOverflow(ctx);
+    const sf = new JSStackFrame();
+    sf.cur_func = func_obj;
+    sf.arg_buf = argv;
+    sf.arg_count = argv.length;
+    sf.prev_frame = rt.current_stack_frame;
+    rt.current_stack_frame = sf;
+    rt.stack_depth++;
+    try {
+        return s.func(ctx, this_val, argv, s.magic, s.data);
+    }
+    finally {
+        rt.current_stack_frame = sf.prev_frame;
+        rt.stack_depth--;
+    }
+}
+/* call a C function. In the constructor case, 'this_obj' is new_target. */
+export function js_call_c_function(ctx, func_obj, this_obj, argv, flags) {
+    const meta = js_meta.get(func_obj);
+    const rec = meta.cfunc;
+    const rt = ctx.rt;
+    const realm = meta.realm;
+    if (rt.stack_depth >= rt.max_stack_depth)
+        return JS_ThrowStackOverflow(ctx);
+    const sf = new JSStackFrame();
+    sf.cur_func = func_obj;
+    sf.arg_buf = argv;
+    sf.arg_count = argv.length;
+    sf.prev_frame = rt.current_stack_frame;
+    rt.current_stack_frame = sf;
+    rt.stack_depth++;
+    /* argv is not padded: argv.length is argc and missing arguments read as undefined */
+    const args = argv;
+    let ret;
+    const f = rec.func;
+    try {
+        switch (rec.cproto) {
+            case 2 /* JSCFunctionEnum.constructor */:
+            case 4 /* JSCFunctionEnum.constructor_or_func */:
+                if (!(flags & JS_CALL_FLAG_CONSTRUCTOR)) {
+                    if (rec.cproto === 2 /* JSCFunctionEnum.constructor */) {
+                        ret = JS_ThrowTypeError(realm, 'must be called with new');
+                        break;
+                    }
+                    this_obj = undefined;
+                }
+                ret = f(realm, this_obj, args);
+                break;
+            case 3 /* JSCFunctionEnum.constructor_magic */:
+            case 5 /* JSCFunctionEnum.constructor_or_func_magic */:
+                if (!(flags & JS_CALL_FLAG_CONSTRUCTOR)) {
+                    if (rec.cproto === 3 /* JSCFunctionEnum.constructor_magic */) {
+                        ret = JS_ThrowTypeError(realm, 'must be called with new');
+                        break;
+                    }
+                    this_obj = undefined;
+                }
+                ret = f(realm, this_obj, args, rec.magic);
+                break;
+            case 0 /* JSCFunctionEnum.generic */:
+                ret = f(realm, this_obj, args);
+                break;
+            case 1 /* JSCFunctionEnum.generic_magic */:
+                ret = f(realm, this_obj, args, rec.magic);
+                break;
+            case 8 /* JSCFunctionEnum.getter */:
+                ret = f(realm, this_obj);
+                break;
+            case 9 /* JSCFunctionEnum.setter */:
+                ret = f(realm, this_obj, args[0]);
+                break;
+            case 10 /* JSCFunctionEnum.getter_magic */:
+                ret = f(realm, this_obj, rec.magic);
+                break;
+            case 11 /* JSCFunctionEnum.setter_magic */:
+                ret = f(realm, this_obj, args[0], rec.magic);
+                break;
+            case 6 /* JSCFunctionEnum.f_f */: {
+                const d1 = JS_ToFloat64(realm, args[0]);
+                if (JS_IsException(d1)) {
+                    ret = JS_EXCEPTION;
+                    break;
+                }
+                ret = f(d1);
+                break;
+            }
+            case 7 /* JSCFunctionEnum.f_f_f */: {
+                const d1 = JS_ToFloat64(realm, args[0]);
+                if (JS_IsException(d1)) {
+                    ret = JS_EXCEPTION;
+                    break;
+                }
+                const d2 = JS_ToFloat64(realm, args[1]);
+                if (JS_IsException(d2)) {
+                    ret = JS_EXCEPTION;
+                    break;
+                }
+                ret = f(d1, d2);
+                break;
+            }
+            case 12 /* JSCFunctionEnum.iterator_next */: {
+                const pdone = { done: 0 };
+                ret = f(realm, this_obj, args, pdone, rec.magic);
+                if (!JS_IsException(ret) && pdone.done !== 2) {
+                    ret = js_create_iterator_result(realm, ret, pdone.done !== 0);
+                }
+                break;
+            }
+            default:
+                throw new JSInternalError('unknown cproto ' + rec.cproto);
+        }
+    }
+    finally {
+        rt.current_stack_frame = sf.prev_frame;
+        rt.stack_depth--;
+    }
+    return ret;
+}
+/* call a host function (bound function, generated code, borrowed native,
+   guest wrapper) with the host exception convention */
+export function js_call_host_function(ctx, func_obj, this_obj, new_target, argv, flags) {
+    const rt = ctx.rt;
+    if (rt.stack_depth >= rt.max_stack_depth)
+        return JS_ThrowStackOverflow(ctx);
+    rt.stack_depth++;
+    try {
+        if (flags & JS_CALL_FLAG_CONSTRUCTOR) {
+            return Reflect.construct(func_obj, argv, (new_target === undefined ? func_obj : new_target));
+        }
+        return Reflect.apply(func_obj, this_obj, argv);
+    }
+    catch (e) {
+        return js_host_exception_to_guest(ctx, e);
+    }
+    finally {
+        rt.stack_depth--;
+    }
+}
+export function JS_Call(ctx, func_obj, this_obj, argv) {
+    return hooks.JS_CallInternal(ctx, func_obj, this_obj, undefined, argv, JS_CALL_FLAG_COPY_ARGV);
+}
+export function JS_CallFree(ctx, func_obj, this_obj, argv) {
+    return hooks.JS_CallInternal(ctx, func_obj, this_obj, undefined, argv, JS_CALL_FLAG_COPY_ARGV);
+}
+export function JS_CallConstructorInternal(ctx, func_obj, new_target, argv, flags) {
+    flags |= JS_CALL_FLAG_CONSTRUCTOR;
+    if (typeof func_obj !== 'function')
+        return JS_ThrowTypeError(ctx, 'not a function');
+    if (!JS_IsConstructor(ctx, func_obj))
+        return JS_ThrowTypeError(ctx, 'not a constructor');
+    /* bytecode functions, C functions and proxies: the 'this' value is
+       created by the callee from new_target */
+    return hooks.JS_CallInternal(ctx, func_obj, new_target, new_target, argv, flags);
+}
+export function JS_CallConstructor2(ctx, func_obj, new_target, argv) {
+    return JS_CallConstructorInternal(ctx, func_obj, new_target, argv, JS_CALL_FLAG_COPY_ARGV);
+}
+export function JS_CallConstructor(ctx, func_obj, argv) {
+    return JS_CallConstructorInternal(ctx, func_obj, func_obj, argv, JS_CALL_FLAG_COPY_ARGV);
+}
+export function JS_Invoke(ctx, this_val, atom, argv) {
+    const func = JS_GetProperty(ctx, this_val, atom);
+    if (JS_IsException(func))
+        return func;
+    return JS_CallFree(ctx, func, this_val, argv);
+}
+/* get the function realm: used for the default prototype of new objects */
+export function JS_GetFunctionRealm(ctx, func_obj) {
+    const m = js_get_meta(func_obj);
+    if (!m)
+        return ctx;
+    switch (m.class_id) {
+        case 12 /* JSClassID.C_FUNCTION */:
+        case 15 /* JSClassID.C_FUNCTION_DATA */:
+            return m.realm ?? ctx;
+        case 13 /* JSClassID.BYTECODE_FUNCTION */:
+        case 16 /* JSClassID.GENERATOR_FUNCTION */:
+        case 48 /* JSClassID.ASYNC_FUNCTION */:
+        case 52 /* JSClassID.ASYNC_GENERATOR_FUNCTION */:
+            return m.func?.function_bytecode.realm ?? m.realm ?? ctx;
+        case 14 /* JSClassID.BOUND_FUNCTION */:
+            return JS_GetFunctionRealm(ctx, m.u.func_obj);
+        case 44 /* JSClassID.PROXY */: {
+            const s = m.u;
+            if (s.is_revoked) {
+                JS_ThrowTypeError(ctx, 'revoked proxy');
+                return ctx;
+            }
+            return JS_GetFunctionRealm(ctx, s.target);
+        }
+        default:
+            return ctx;
+    }
+}
+/* GetPrototypeFromConstructor: create an object with the prototype taken
+   from the 'prototype' property of 'ctor' or the default class proto */
+export function js_create_from_ctor(ctx, ctor, class_id) {
+    const proto = js_proto_from_ctor(ctx, ctor, class_id);
+    if (JS_IsException(proto))
+        return proto;
+    return JS_NewObjectProtoClass(ctx, proto, class_id);
+}
+/* GetPrototypeFromConstructor: the prototype to use for an object created
+   by 'ctor' (undefined: the default class prototype) */
+export function js_proto_from_ctor(ctx, ctor, class_id) {
+    if (JS_IsUndefined(ctor))
+        return ctx.class_proto[class_id];
+    const proto = JS_GetProperty(ctx, ctor, JS_ATOM_prototype);
+    if (JS_IsException(proto))
+        return proto;
+    if (!JS_IsObject(proto)) {
+        const realm = JS_GetFunctionRealm(ctx, ctor);
+        return realm.class_proto[class_id];
+    }
+    return proto;
+}
+/* Primitive wrapper objects (Number, String, Boolean, Symbol and BigInt
+   instances) are host wrapper objects re-prototyped to the guest prototype,
+   so that host natives (JSON.stringify, String.prototype.valueOf, ...) see
+   the internal slot. The engine reads the value from the metadata. */
+export function js_new_primitive_wrapper(ctx, proto, class_id, value) {
+    const obj = Object(value);
+    Object.setPrototypeOf(obj, JS_IsObject(proto) ? proto : null);
+    const m = new JSObjectMeta(class_id);
+    m.u = value;
+    js_meta.set(obj, m);
+    return obj;
+}
+export function js_create_wrapper_from_ctor(ctx, ctor, class_id, value) {
+    const proto = js_proto_from_ctor(ctx, ctor, class_id);
+    if (JS_IsException(proto))
+        return proto;
+    return js_new_primitive_wrapper(ctx, proto, class_id, value);
+}
+export function JS_SetConstructor2(ctx, func_obj, proto, proto_flags, ctor_flags) {
+    JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_prototype, proto, proto_flags);
+    JS_DefinePropertyValue(ctx, proto, JS_ATOM_constructor, func_obj, ctor_flags);
+    if (typeof func_obj === 'function')
+        js_ensure_meta(func_obj, 12 /* JSClassID.C_FUNCTION */).is_constructor = true;
+}
+export function JS_SetConstructor(ctx, func_obj, proto) {
+    JS_SetConstructor2(ctx, func_obj, proto, 0, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+}
+export function JS_NewGlobalCConstructor2(ctx, func_obj, name, proto) {
+    JS_DefinePropertyValueStr(ctx, ctx.global_obj, name, func_obj, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    JS_SetConstructor(ctx, func_obj, proto);
+    return func_obj;
+}
+export function JS_NewGlobalCConstructor(ctx, name, func, length, proto) {
+    const func_obj = JS_NewCFunction2(ctx, func, name, length, 4 /* JSCFunctionEnum.constructor_or_func */, 0);
+    return JS_NewGlobalCConstructor2(ctx, func_obj, name, proto);
+}
+export function JS_NewGlobalCConstructorOnly(ctx, name, func, length, proto) {
+    const func_obj = JS_NewCFunction2(ctx, func, name, length, 2 /* JSCFunctionEnum.constructor */, 0);
+    return JS_NewGlobalCConstructor2(ctx, func_obj, name, proto);
+}
+export function JS_NATIVE_DEF(name, length, host, fix = null) {
+    return { name, prop_flags: JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, def_type: 10 /* JSDefKind.NATIVE */, magic: 0,
+        u: { length, host, fix } };
+}
+export function JS_NATIVE_GETSET_DEF(name, get, set, fix = null) {
+    return { name, prop_flags: JS_PROP_CONFIGURABLE, def_type: 11 /* JSDefKind.NATIVE_GETSET */, magic: 0, u: { get, set, fix } };
+}
+export function JS_CFUNC_DEF(name, length, func) {
+    return { name, prop_flags: JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, def_type: 0 /* JSDefKind.CFUNC */, magic: 0,
+        u: { length, cproto: 0 /* JSCFunctionEnum.generic */, func } };
+}
+export function JS_CFUNC_MAGIC_DEF(name, length, func, magic) {
+    return { name, prop_flags: JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, def_type: 0 /* JSDefKind.CFUNC */, magic,
+        u: { length, cproto: 1 /* JSCFunctionEnum.generic_magic */, func } };
+}
+export function JS_CFUNC_SPECIAL_DEF(name, length, cproto, func) {
+    return { name, prop_flags: JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, def_type: 0 /* JSDefKind.CFUNC */, magic: 0,
+        u: { length, cproto, func } };
+}
+export function JS_ITERATOR_NEXT_DEF(name, length, func, magic) {
+    return { name, prop_flags: JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, def_type: 0 /* JSDefKind.CFUNC */, magic,
+        u: { length, cproto: 12 /* JSCFunctionEnum.iterator_next */, func } };
+}
+export function JS_CGETSET_DEF(name, fgetter, fsetter) {
+    return { name, prop_flags: JS_PROP_CONFIGURABLE, def_type: 1 /* JSDefKind.CGETSET */, magic: 0, u: { get: fgetter, set: fsetter } };
+}
+export function JS_CGETSET_MAGIC_DEF(name, fgetter, fsetter, magic) {
+    return { name, prop_flags: JS_PROP_CONFIGURABLE, def_type: 2 /* JSDefKind.CGETSET_MAGIC */, magic, u: { get: fgetter, set: fsetter } };
+}
+export function JS_CGETSET_ENUMERABLE_DEF(name, fgetter, fsetter) {
+    return { name, prop_flags: JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE, def_type: 1 /* JSDefKind.CGETSET */, magic: 0, u: { get: fgetter, set: fsetter } };
+}
+export function JS_PROP_STRING_DEF(name, cstr, prop_flags) {
+    return { name, prop_flags, def_type: 3 /* JSDefKind.PROP_STRING */, magic: 0, u: cstr };
+}
+export function JS_PROP_INT32_DEF(name, val, prop_flags) {
+    return { name, prop_flags, def_type: 4 /* JSDefKind.PROP_INT32 */, magic: 0, u: val };
+}
+export function JS_PROP_INT64_DEF(name, val, prop_flags) {
+    return { name, prop_flags, def_type: 5 /* JSDefKind.PROP_INT64 */, magic: 0, u: val };
+}
+export function JS_PROP_DOUBLE_DEF(name, val, prop_flags) {
+    return { name, prop_flags, def_type: 6 /* JSDefKind.PROP_DOUBLE */, magic: 0, u: val };
+}
+export function JS_PROP_UNDEFINED_DEF(name, prop_flags) {
+    return { name, prop_flags, def_type: 7 /* JSDefKind.PROP_UNDEFINED */, magic: 0, u: undefined };
+}
+export function JS_OBJECT_DEF(name, tab, prop_flags) {
+    return { name, prop_flags, def_type: 8 /* JSDefKind.OBJECT */, magic: 0, u: tab };
+}
+export function JS_ALIAS_DEF(name, from) {
+    return { name, prop_flags: JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, def_type: 9 /* JSDefKind.ALIAS */, magic: 0, u: { name: from, base: -1 } };
+}
+export function JS_ALIAS_BASE_DEF(name, from, base) {
+    return { name, prop_flags: JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, def_type: 9 /* JSDefKind.ALIAS */, magic: 0, u: { name: from, base } };
+}
+function entry_name_atom(ctx, name) {
+    if (typeof name === 'number')
+        return name;
+    return JS_NewAtom(ctx, name);
+}
+function entry_display_name(ctx, atom) {
+    if (ctx.rt.atoms.isSymbol(atom))
+        return '[' + ctx.rt.atoms.toStr(atom) + ']';
+    return ctx.rt.atoms.toStr(atom);
+}
+export function JS_InstantiateFunctionListItem(ctx, obj, atom, e) {
+    let val;
+    let prop_flags = e.prop_flags;
+    switch (e.def_type) {
+        case 9 /* JSDefKind.ALIAS */: {
+            /* base: -1 = same object, 0 = global object, 1 = Array.prototype (as in C) */
+            let base_obj = obj;
+            if (e.u.base === 0)
+                base_obj = ctx.global_obj;
+            else if (e.u.base === 1)
+                base_obj = ctx.class_proto[2 /* JSClassID.ARRAY */];
+            const atom1 = JS_NewAtom(ctx, e.u.name);
+            val = JS_GetProperty(ctx, base_obj, atom1);
+            break;
+        }
+        case 0 /* JSDefKind.CFUNC */: {
+            const name = entry_display_name(ctx, atom);
+            val = JS_NewCFunction3(ctx, e.u.func, name, e.u.length, e.u.cproto, e.magic, ctx.function_proto);
+            break;
+        }
+        case 1 /* JSDefKind.CGETSET */:
+        case 2 /* JSDefKind.CGETSET_MAGIC */: {
+            let getter = undefined, setter = undefined;
+            const name = entry_display_name(ctx, atom);
+            if (e.u.get) {
+                getter = JS_NewCFunction3(ctx, e.u.get, 'get ' + name, 0, e.def_type === 2 /* JSDefKind.CGETSET_MAGIC */ ? 10 /* JSCFunctionEnum.getter_magic */ : 8 /* JSCFunctionEnum.getter */, e.magic, ctx.function_proto);
+            }
+            if (e.u.set) {
+                setter = JS_NewCFunction3(ctx, e.u.set, 'set ' + name, 1, e.def_type === 2 /* JSDefKind.CGETSET_MAGIC */ ? 11 /* JSCFunctionEnum.setter_magic */ : 9 /* JSCFunctionEnum.setter */, e.magic, ctx.function_proto);
+            }
+            JS_DefinePropertyGetSet(ctx, obj, atom, getter, setter, prop_flags);
+            return 0;
+        }
+        case 10 /* JSDefKind.NATIVE */: {
+            const name = entry_display_name(ctx, atom);
+            val = hooks.js_borrow_native(ctx, e.u.host, name, e.u.length, e.u.fix);
+            break;
+        }
+        case 11 /* JSDefKind.NATIVE_GETSET */: {
+            const name = entry_display_name(ctx, atom);
+            const getter = e.u.get ? hooks.js_borrow_native(ctx, e.u.get, 'get ' + name, 0, e.u.fix) : undefined;
+            const setter = e.u.set ? hooks.js_borrow_native(ctx, e.u.set, 'set ' + name, 1, null) : undefined;
+            JS_DefinePropertyGetSet(ctx, obj, atom, getter, setter, prop_flags);
+            return 0;
+        }
+        case 3 /* JSDefKind.PROP_STRING */:
+            val = e.u;
+            break;
+        case 4 /* JSDefKind.PROP_INT32 */:
+        case 5 /* JSDefKind.PROP_INT64 */:
+        case 6 /* JSDefKind.PROP_DOUBLE */:
+            val = e.u;
+            break;
+        case 7 /* JSDefKind.PROP_UNDEFINED */:
+            val = undefined;
+            break;
+        case 8 /* JSDefKind.OBJECT */:
+            val = JS_NewObject(ctx);
+            JS_SetPropertyFunctionList(ctx, val, e.u);
+            break;
+        default:
+            throw new JSInternalError('bad def_type');
+    }
+    JS_DefinePropertyValue(ctx, obj, atom, val, prop_flags);
+    return 0;
+}
+export function JS_SetPropertyFunctionList(ctx, obj, tab) {
+    for (const e of tab) {
+        const atom = entry_name_atom(ctx, e.name);
+        JS_InstantiateFunctionListItem(ctx, obj, atom, e);
+    }
+}
+/* ---------------------------------------------------------------------
+   Properties
+   --------------------------------------------------------------------- */
+export function is_typed_array(class_id) {
+    return class_id >= 21 /* JSClassID.UINT8C_ARRAY */ && class_id <= 31 /* JSClassID.FLOAT64_ARRAY */;
+}
+export function JS_ThrowTypeErrorOrFalse(ctx, flags, msg) {
+    if ((flags & JS_PROP_THROW) || ((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
+        JS_ThrowTypeError(ctx, msg);
+        return -1;
+    }
+    return 0;
+}
+/* return 1 if the flags are compatible (ValidateAndApplyPropertyDescriptor
+   for non configurable properties when there is no value change) */
+export function check_define_prop_flags(prop_flags, flags) {
+    const has_accessor = (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) !== 0;
+    if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
+        if ((flags & (JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE)) === (JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE))
+            return false;
+        if ((flags & JS_PROP_HAS_ENUMERABLE) && (flags & JS_PROP_ENUMERABLE) !== (prop_flags & JS_PROP_ENUMERABLE))
+            return false;
+    }
+    if (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE | JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
+        if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
+            const has_value = (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE)) !== 0;
+            const is_getset = (prop_flags & JS_PROP_TMASK) === JS_PROP_GETSET;
+            if (has_accessor && !is_getset)
+                return false;
+            if (has_value && is_getset)
+                return false;
+            if (!is_getset && !(prop_flags & JS_PROP_WRITABLE)) {
+                if ((flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) === (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+/* fill 'desc' from a host property descriptor */
+function js_desc_from_host(d, desc) {
+    let flags = 0;
+    if (d.configurable)
+        flags |= JS_PROP_CONFIGURABLE;
+    if (d.enumerable)
+        flags |= JS_PROP_ENUMERABLE;
+    if ('get' in d || 'set' in d) {
+        flags |= JS_PROP_GETSET;
+        desc.getter = d.get;
+        desc.setter = d.set;
+        desc.value = undefined;
+    }
+    else {
+        if (d.writable)
+            flags |= JS_PROP_WRITABLE;
+        desc.value = d.value;
+        desc.getter = undefined;
+        desc.setter = undefined;
+    }
+    desc.flags = flags;
+}
+/* own property lookup: -1 exception, 0 not found, 1 found (desc filled if != null) */
+export function JS_GetOwnPropertyInternal(ctx, desc, p, prop) {
+    const key = JS_AtomToKey(ctx, prop);
+    if (desc === null && js_meta.get(p) === undefined) {
+        /* existence only: Object.hasOwn is ~40x cheaper than building a descriptor */
+        try {
+            return Object.hasOwn(p, key) ? 1 : 0;
+        }
+        catch (e) {
+            js_host_exception_to_guest(ctx, e);
+            return -1;
+        }
+    }
+    let d;
+    try {
+        d = Reflect.getOwnPropertyDescriptor(p, key);
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+    if (d === undefined)
+        return 0;
+    if (desc)
+        js_desc_from_host(d, desc);
+    return 1;
+}
+export function JS_GetOwnProperty(ctx, desc, obj, prop) {
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    return JS_GetOwnPropertyInternal(ctx, desc, obj, prop);
+}
+export function new_desc() {
+    return { flags: 0, value: undefined, getter: undefined, setter: undefined };
+}
+/* prototype of a primitive value (null for undefined/null) */
+export function JS_GetPrototypePrimitive(ctx, val) {
+    switch (typeof val) {
+        case 'bigint': return ctx.class_proto[33 /* JSClassID.BIG_INT */];
+        case 'number': return ctx.class_proto[4 /* JSClassID.NUMBER */];
+        case 'boolean': return ctx.class_proto[6 /* JSClassID.BOOLEAN */];
+        case 'string': return ctx.class_proto[5 /* JSClassID.STRING */];
+        case 'symbol': return ctx.class_proto[7 /* JSClassID.SYMBOL */];
+        default: return null;
+    }
+}
+/* return the prototype (object or null) or JS_EXCEPTION */
+export function JS_GetPrototype(ctx, obj) {
+    if (JS_IsObject(obj)) {
+        try {
+            return Reflect.getPrototypeOf(obj);
+        }
+        catch (e) {
+            return js_host_exception_to_guest(ctx, e);
+        }
+    }
+    return JS_GetPrototypePrimitive(ctx, obj);
+}
+export function JS_GetPrototypeFree(ctx, obj) { return JS_GetPrototype(ctx, obj); }
+function js_string_own_property(ctx, str, prop) {
+    if (__JS_AtomIsTaggedInt(prop)) {
+        const idx = __JS_AtomToUInt32(prop);
+        if (idx < str.length)
+            return str[idx];
+        return undefined;
+    }
+    if (prop === JS_ATOM_length)
+        return str.length;
+    return undefined;
+}
+/* GetProperty. 'this_obj' is the receiver. */
+export function JS_GetPropertyInternal(ctx, obj, prop, this_obj, throw_ref_error) {
+    let base;
+    switch (typeof obj) {
+        case 'object':
+        case 'function':
+            if (obj === null)
+                return JS_ThrowTypeErrorAtom(ctx, "cannot read property '%s' of null", prop);
+            base = obj;
+            break;
+        case 'undefined':
+            return JS_ThrowTypeErrorAtom(ctx, "cannot read property '%s' of undefined", prop);
+        case 'string': {
+            const v = js_string_own_property(ctx, obj, prop);
+            if (v !== undefined)
+                return v;
+            base = ctx.class_proto[5 /* JSClassID.STRING */];
+            break;
+        }
+        default:
+            base = JS_GetPrototypePrimitive(ctx, obj);
+            break;
+    }
+    const key = JS_AtomToKey(ctx, prop);
+    try {
+        if (throw_ref_error && !Reflect.has(base, key))
+            return JS_ThrowReferenceErrorNotDefined(ctx, prop);
+        if (this_obj === obj && base === obj)
+            return base[key];
+        /* primitive base or explicit receiver: the receiver is the original value */
+        return Reflect.get(base, key, this_obj);
+    }
+    catch (e) {
+        return js_host_exception_to_guest(ctx, e);
+    }
+}
+export function JS_GetProperty(ctx, this_obj, prop) {
+    return JS_GetPropertyInternal(ctx, this_obj, prop, this_obj, false);
+}
+export function JS_GetPropertyStr(ctx, this_obj, prop) {
+    return JS_GetPropertyInternal(ctx, this_obj, JS_NewAtom(ctx, prop), this_obj, false);
+}
+export function JS_GetPropertyUint32(ctx, this_obj, idx) {
+    return JS_GetPropertyInternal(ctx, this_obj, JS_NewAtomUInt32(ctx, idx), this_obj, false);
+}
+export function JS_GetPropertyInt64(ctx, this_obj, idx) {
+    return JS_GetPropertyInternal(ctx, this_obj, JS_NewAtomInt64(ctx, idx), this_obj, false);
+}
+/* obj[prop] with a JS value as property key */
+export function JS_GetPropertyValue(ctx, this_obj, prop) {
+    if (JS_IsObject(this_obj) && !JS_IsObject(prop) && typeof prop !== 'undefined') {
+        /* the host performs ToPropertyKey on primitives */
+        try {
+            return this_obj[prop];
+        }
+        catch (e) {
+            return js_host_exception_to_guest(ctx, e);
+        }
+    }
+    const atom = JS_ValueToAtom(ctx, prop);
+    if (atom === JS_ATOM_NULL)
+        return JS_EXCEPTION;
+    return JS_GetPropertyInternal(ctx, this_obj, atom, this_obj, false);
+}
+/* HasProperty: -1 exception */
+export function JS_HasProperty(ctx, obj, prop) {
+    if (!JS_IsObject(obj))
+        return 0;
+    try {
+        return Reflect.has(obj, JS_AtomToKey(ctx, prop)) ? 1 : 0;
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+}
+export function JS_IsExtensible(ctx, obj) {
+    if (!JS_IsObject(obj))
+        return 0;
+    try {
+        return Reflect.isExtensible(obj) ? 1 : 0;
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+}
+export function JS_PreventExtensions(ctx, obj) {
+    if (!JS_IsObject(obj))
+        return 1;
+    try {
+        return Reflect.preventExtensions(obj) ? 1 : 0;
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+}
+/* SetPrototypeOf: -1 exception, 0 failed (throw_flag false), 1 ok */
+export function JS_SetPrototypeInternal(ctx, obj, proto_val, throw_flag) {
+    if (!(proto_val === null || JS_IsObject(proto_val))) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    if (!JS_IsObject(obj)) {
+        if (obj === undefined || obj === null) {
+            JS_ThrowTypeErrorNotAnObject(ctx);
+            return -1;
+        }
+        return 1;
+    }
+    let ok;
+    try {
+        ok = Reflect.setPrototypeOf(obj, proto_val);
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+    if (!ok) {
+        if (throw_flag) {
+            let ext = true;
+            try {
+                ext = Reflect.isExtensible(obj);
+            }
+            catch { /* ignore */ }
+            if (JS_GetClassID(obj) === 44 /* JSClassID.PROXY */)
+                JS_ThrowTypeError(ctx, 'proxy: bad prototype');
+            else if (!ext)
+                JS_ThrowTypeError(ctx, 'object is not extensible');
+            else
+                JS_ThrowTypeError(ctx, 'circular prototype chain');
+            return -1;
+        }
+        return 0;
+    }
+    return 1;
+}
+export function JS_SetPrototype(ctx, obj, proto_val) {
+    return JS_SetPrototypeInternal(ctx, obj, proto_val, true);
+}
+function js_strict_store(o, k, v) {
+    o[k] = v; /* module code is strict: throws a host TypeError on failure */
+}
+/* after a strict store threw a host TypeError: true if the failure is one
+   that a sloppy store would ignore (read-only data property, accessor
+   without setter, or non-extensible receiver), false if the error came
+   from elsewhere (e.g. a typed array element conversion) */
+function js_store_failed_silently(obj, key) {
+    let o = obj;
+    while (o !== null) {
+        const d = Reflect.getOwnPropertyDescriptor(o, key);
+        if (d !== undefined) {
+            if ('value' in d)
+                return !d.writable;
+            return d.set === undefined;
+        }
+        o = Reflect.getPrototypeOf(o);
+    }
+    return !Reflect.isExtensible(obj);
+}
+/* true if 'e' is an error raised by the host engine itself (its prototype
+   chain reaches the host Error.prototype), as opposed to a guest value */
+export function js_is_host_error(e) {
+    return e instanceof Error;
+}
+function js_set_failed(ctx, obj, key, prop, flags) {
+    if ((flags & JS_PROP_THROW) || ((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
+        if (JS_GetClassID(obj) === 44 /* JSClassID.PROXY */) {
+            JS_ThrowTypeError(ctx, 'proxy: cannot set property');
+        }
+        else {
+            let has = false;
+            try {
+                has = Reflect.has(obj, key);
+            }
+            catch { /* ignore */ }
+            if (has)
+                JS_ThrowTypeErrorAtom(ctx, "'%s' is read-only", prop);
+            else
+                JS_ThrowTypeError(ctx, 'object is not extensible');
+        }
+        return -1;
+    }
+    return 0;
+}
+/* SetProperty: -1 exception, 0 failed silently, 1 ok. 'this_obj' is the receiver. */
+export function JS_SetPropertyInternal(ctx, obj, prop, val, this_obj, flags) {
+    const key = JS_AtomToKey(ctx, prop);
+    if (JS_IsObject(obj)) {
+        if (this_obj === obj && js_meta.get(obj)?.class_id !== 44 /* JSClassID.PROXY */) {
+            /* plain assignment (proxies use Reflect.set below, which tells a refused
+               trap from an invariant violation): Reflect.set is ~50x slower than an inline-cached
+               store in JSC (and ~600 ns when appending to an array). A strict
+               store throws a host TypeError on failure, which we diagnose with the
+               QuickJS message; guest setters throw guest values, which propagate. */
+            try {
+                js_strict_store(obj, key, val);
+                return 1;
+            }
+            catch (e) {
+                if (js_is_host_error(e) && js_store_failed_silently(obj, key)) {
+                    return js_set_failed(ctx, obj, key, prop, flags);
+                }
+                js_host_exception_to_guest(ctx, e);
+                return -1;
+            }
+        }
+        let ok;
+        try {
+            ok = Reflect.set(obj, key, val, this_obj);
+        }
+        catch (e) {
+            js_host_exception_to_guest(ctx, e);
+            return -1;
+        }
+        if (ok)
+            return 1;
+        return js_set_failed(ctx, obj, key, prop, flags);
+    }
+    if (obj === undefined || obj === null) {
+        JS_ThrowTypeErrorAtom(ctx, obj === null ? "cannot set property '%s' of null" : "cannot set property '%s' of undefined", prop);
+        return -1;
+    }
+    /* primitive: look for a setter in the prototype chain of the primitive */
+    const proto = JS_GetPrototypePrimitive(ctx, obj);
+    let ok;
+    try {
+        ok = Reflect.set(proto, key, val, this_obj);
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+    if (ok)
+        return 1;
+    return JS_ThrowTypeErrorOrFalse(ctx, flags, 'cannot set property on a primitive value');
+}
+export function JS_SetProperty(ctx, this_obj, prop, val) {
+    return JS_SetPropertyInternal(ctx, this_obj, prop, val, this_obj, JS_PROP_THROW);
+}
+export function JS_SetPropertyStr(ctx, this_obj, prop, val) {
+    return JS_SetProperty(ctx, this_obj, JS_NewAtom(ctx, prop), val);
+}
+export function JS_SetPropertyUint32(ctx, this_obj, idx, val) {
+    return JS_SetProperty(ctx, this_obj, JS_NewAtomUInt32(ctx, idx), val);
+}
+export function JS_SetPropertyInt64(ctx, this_obj, idx, val) {
+    return JS_SetProperty(ctx, this_obj, JS_NewAtomInt64(ctx, idx), val);
+}
+/* obj[prop] = val with a JS value as property key */
+export function JS_SetPropertyValue(ctx, this_obj, prop, val, flags) {
+    if (JS_IsObject(this_obj) && !JS_IsObject(prop) && typeof prop !== 'undefined') {
+        let ok;
+        try {
+            ok = Reflect.set(this_obj, prop, val);
+        }
+        catch (e) {
+            js_host_exception_to_guest(ctx, e);
+            return -1;
+        }
+        if (ok)
+            return 1;
+        const atom = JS_ValueToAtom(ctx, prop);
+        if (atom === JS_ATOM_NULL)
+            return -1;
+        return js_set_failed(ctx, this_obj, JS_AtomToKey(ctx, atom), atom, flags);
+    }
+    const atom = JS_ValueToAtom(ctx, prop);
+    if (atom === JS_ATOM_NULL)
+        return -1;
+    return JS_SetPropertyInternal(ctx, this_obj, atom, val, this_obj, flags);
+}
+export function JS_CreateDataPropertyUint32(ctx, this_obj, index, val, flags) {
+    return JS_DefinePropertyValue(ctx, this_obj, JS_NewAtomInt64(ctx, index), val, flags | JS_PROP_C_W_E);
+}
+/* build a host property descriptor from the JS_PROP_HAS_* flags */
+function js_host_desc(val, getter, setter, flags) {
+    const d = {};
+    if (flags & JS_PROP_HAS_VALUE)
+        d.value = val;
+    if (flags & JS_PROP_HAS_GET)
+        d.get = getter;
+    if (flags & JS_PROP_HAS_SET)
+        d.set = setter;
+    if (flags & JS_PROP_HAS_WRITABLE)
+        d.writable = (flags & JS_PROP_WRITABLE) !== 0;
+    if (flags & JS_PROP_HAS_CONFIGURABLE)
+        d.configurable = (flags & JS_PROP_CONFIGURABLE) !== 0;
+    if (flags & JS_PROP_HAS_ENUMERABLE)
+        d.enumerable = (flags & JS_PROP_ENUMERABLE) !== 0;
+    return d;
+}
+/* DefineOwnProperty: -1 exception, 0 failed, 1 ok */
+export function JS_DefineProperty(ctx, this_obj, prop, val, getter, setter, flags) {
+    if (!JS_IsObject(this_obj)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    let ok;
+    if (this_obj === ctx.class_proto[1 /* JSClassID.OBJECT */] && prop !== JS_ATOM___proto__ &&
+        ((flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) || ((flags & JS_PROP_HAS_WRITABLE) && !(flags & JS_PROP_WRITABLE)))) {
+        ctx.plain_object_proto.ok = false;
+    }
+    try {
+        ok = Reflect.defineProperty(this_obj, JS_AtomToKey(ctx, prop), js_host_desc(val, getter, setter, flags));
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+    if (ok)
+        return 1;
+    if (JS_GetClassID(this_obj) === 44 /* JSClassID.PROXY */)
+        return JS_ThrowTypeErrorOrFalse(ctx, flags, 'proxy: inconsistent defineProperty');
+    return JS_ThrowTypeErrorOrFalse(ctx, flags, 'property is not configurable');
+}
+export function JS_DefinePropertyValue(ctx, this_obj, prop, val, flags) {
+    return JS_DefineProperty(ctx, this_obj, prop, val, undefined, undefined, flags | JS_PROP_HAS_VALUE | JS_PROP_HAS_CONFIGURABLE | JS_PROP_HAS_WRITABLE | JS_PROP_HAS_ENUMERABLE);
+}
+export function JS_DefinePropertyValueValue(ctx, this_obj, prop, val, flags) {
+    const atom = JS_ValueToAtom(ctx, prop);
+    if (atom === JS_ATOM_NULL)
+        return -1;
+    return JS_DefinePropertyValue(ctx, this_obj, atom, val, flags);
+}
+export function JS_DefinePropertyValueUint32(ctx, this_obj, idx, val, flags) {
+    return JS_DefinePropertyValue(ctx, this_obj, JS_NewAtomUInt32(ctx, idx), val, flags);
+}
+export function JS_DefinePropertyValueInt64(ctx, this_obj, idx, val, flags) {
+    return JS_DefinePropertyValue(ctx, this_obj, JS_NewAtomInt64(ctx, idx), val, flags);
+}
+export function JS_DefinePropertyValueStr(ctx, this_obj, prop, val, flags) {
+    return JS_DefinePropertyValue(ctx, this_obj, JS_NewAtom(ctx, prop), val, flags);
+}
+export function JS_DefinePropertyGetSet(ctx, this_obj, prop, getter, setter, flags) {
+    return JS_DefineProperty(ctx, this_obj, prop, undefined, getter, setter, flags | JS_PROP_HAS_GET | JS_PROP_HAS_SET | JS_PROP_HAS_CONFIGURABLE | JS_PROP_HAS_ENUMERABLE);
+}
+/* delete an own property: -1 exception, 0 not deleted, 1 deleted (or absent) */
+export function delete_property(ctx, p, atom) {
+    try {
+        return Reflect.deleteProperty(p, JS_AtomToKey(ctx, atom)) ? 1 : 0;
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+}
+export function JS_DeleteProperty(ctx, obj, prop, flags) {
+    const obj1 = JS_ToObject(ctx, obj);
+    if (JS_IsException(obj1))
+        return -1;
+    const res = delete_property(ctx, obj1, prop);
+    if (res !== 0)
+        return res;
+    if ((flags & JS_PROP_THROW) || ((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
+        JS_ThrowTypeError(ctx, 'could not delete property');
+        return -1;
+    }
+    return 0;
+}
+export function JS_DeletePropertyInt64(ctx, obj, idx, flags) {
+    return JS_DeleteProperty(ctx, obj, JS_NewAtomInt64(ctx, idx), flags);
+}
+/* own property keys of 'p' filtered by the JS_GPN_* flags */
+export function JS_GetOwnPropertyNamesInternal(ctx, p, flags) {
+    let keys;
+    try {
+        keys = Reflect.ownKeys(p);
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return null;
+    }
+    const need_enum = (flags & (JS_GPN_ENUM_ONLY | JS_GPN_SET_ENUM)) !== 0;
+    const tab = [];
+    for (const k of keys) {
+        if (typeof k === 'symbol') {
+            if (!(flags & JS_GPN_SYMBOL_MASK))
+                continue;
+        }
+        else {
+            if (!(flags & JS_GPN_STRING_MASK))
+                continue;
+        }
+        let is_enumerable = true;
+        if (need_enum) {
+            let d;
+            try {
+                d = Reflect.getOwnPropertyDescriptor(p, k);
+            }
+            catch (e) {
+                js_host_exception_to_guest(ctx, e);
+                return null;
+            }
+            if (d === undefined)
+                continue; /* deleted by a proxy trap */
+            is_enumerable = !!d.enumerable;
+            if ((flags & JS_GPN_ENUM_ONLY) && !is_enumerable)
+                continue;
+        }
+        tab.push({ atom: JS_KeyToAtom(ctx, k), is_enumerable });
+    }
+    return tab;
+}
+export function JS_GetOwnPropertyNames(ctx, obj, flags) {
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return null;
+    }
+    return JS_GetOwnPropertyNamesInternal(ctx, obj, flags);
+}
+/* FromPropertyDescriptor */
+export function JS_FromPropertyDescriptor(ctx, d) {
+    const obj = JS_NewObject(ctx);
+    if ((d.flags & JS_PROP_TMASK) === JS_PROP_GETSET) {
+        JS_DefinePropertyValue(ctx, obj, JS_ATOM_get, d.getter, JS_PROP_C_W_E);
+        JS_DefinePropertyValue(ctx, obj, JS_ATOM_set, d.setter, JS_PROP_C_W_E);
+    }
+    else {
+        JS_DefinePropertyValue(ctx, obj, JS_ATOM_value, d.value, JS_PROP_C_W_E);
+        JS_DefinePropertyValue(ctx, obj, JS_ATOM_writable, (d.flags & JS_PROP_WRITABLE) !== 0, JS_PROP_C_W_E);
+    }
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_enumerable, (d.flags & JS_PROP_ENUMERABLE) !== 0, JS_PROP_C_W_E);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_configurable, (d.flags & JS_PROP_CONFIGURABLE) !== 0, JS_PROP_C_W_E);
+    return obj;
+}
+/* ToPropertyDescriptor: fill d.flags with the JS_PROP_HAS_* flags; -1 on exception */
+export function js_obj_to_desc(ctx, d, desc) {
+    if (!JS_IsObject(desc)) {
+        JS_ThrowTypeError(ctx, 'property descriptor must be an object');
+        return -1;
+    }
+    let flags = 0;
+    let val = undefined, getter = undefined, setter = undefined;
+    const get_field = (atom) => {
+        const present = JS_HasProperty(ctx, desc, atom);
+        if (present <= 0)
+            return [present, undefined];
+        const v = JS_GetProperty(ctx, desc, atom);
+        if (JS_IsException(v))
+            return [-1, undefined];
+        return [1, v];
+    };
+    let r;
+    r = get_field(JS_ATOM_configurable);
+    if (r[0] < 0)
+        return -1;
+    if (r[0]) {
+        flags |= JS_PROP_HAS_CONFIGURABLE;
+        if (JS_ToBoolFree(ctx, r[1]))
+            flags |= JS_PROP_CONFIGURABLE;
+    }
+    r = get_field(JS_ATOM_enumerable);
+    if (r[0] < 0)
+        return -1;
+    if (r[0]) {
+        flags |= JS_PROP_HAS_ENUMERABLE;
+        if (JS_ToBoolFree(ctx, r[1]))
+            flags |= JS_PROP_ENUMERABLE;
+    }
+    r = get_field(JS_ATOM_value);
+    if (r[0] < 0)
+        return -1;
+    if (r[0]) {
+        flags |= JS_PROP_HAS_VALUE;
+        val = r[1];
+    }
+    r = get_field(JS_ATOM_writable);
+    if (r[0] < 0)
+        return -1;
+    if (r[0]) {
+        flags |= JS_PROP_HAS_WRITABLE;
+        if (JS_ToBoolFree(ctx, r[1]))
+            flags |= JS_PROP_WRITABLE;
+    }
+    r = get_field(JS_ATOM_get);
+    if (r[0] < 0)
+        return -1;
+    if (r[0]) {
+        flags |= JS_PROP_HAS_GET;
+        if (!(JS_IsUndefined(r[1]) || JS_IsFunction(ctx, r[1]))) {
+            JS_ThrowTypeError(ctx, 'invalid getter');
+            return -1;
+        }
+        getter = r[1];
+    }
+    r = get_field(JS_ATOM_set);
+    if (r[0] < 0)
+        return -1;
+    if (r[0]) {
+        flags |= JS_PROP_HAS_SET;
+        if (!(JS_IsUndefined(r[1]) || JS_IsFunction(ctx, r[1]))) {
+            JS_ThrowTypeError(ctx, 'invalid setter');
+            return -1;
+        }
+        setter = r[1];
+    }
+    if ((flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) && (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE))) {
+        JS_ThrowTypeError(ctx, 'cannot have setter/getter and value or writable');
+        return -1;
+    }
+    d.flags = flags;
+    d.value = val;
+    d.getter = getter;
+    d.setter = setter;
+    return 0;
+}
+/* 'length' property of an array-like: -1 on exception */
+export function js_get_length64(ctx, obj) {
+    const len = JS_GetProperty(ctx, obj, JS_ATOM_length);
+    if (JS_IsException(len))
+        return -1;
+    return JS_ToLengthFree(ctx, len);
+}
+export const js_get_length32 = js_get_length64;
+export function js_set_length64(ctx, obj, len) {
+    return JS_SetProperty(ctx, obj, JS_ATOM_length, len);
+}
+/* ---------------------------------------------------------------------
+   Global variables
+   --------------------------------------------------------------------- */
+export const DEFINE_GLOBAL_LEX_VAR = 1 << 7;
+export const DEFINE_GLOBAL_FUNC_VAR = 1 << 6;
+function js_global_own_desc(ctx, key) {
+    try {
+        return Reflect.getOwnPropertyDescriptor(ctx.global_obj, key);
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return null;
+    }
+}
+export function JS_CheckDefineGlobalVar(ctx, prop, flags) {
+    const key = JS_AtomToKey(ctx, prop);
+    const d = js_global_own_desc(ctx, key);
+    if (d === null)
+        return -1;
+    if (flags & DEFINE_GLOBAL_LEX_VAR) {
+        if (d && !d.configurable) {
+            JS_ThrowSyntaxErrorAtom(ctx, "redeclaration of '%s'", prop);
+            return -1;
+        }
+    }
+    else {
+        if (!d && !Reflect.isExtensible(ctx.global_obj)) {
+            JS_ThrowTypeErrorAtom(ctx, "cannot define variable '%s'", prop);
+            return -1;
+        }
+        if (flags & DEFINE_GLOBAL_FUNC_VAR) {
+            if (d && !d.configurable &&
+                (('get' in d || 'set' in d) || !(d.writable && d.enumerable))) {
+                JS_ThrowTypeErrorAtom(ctx, "cannot define variable '%s'", prop);
+                return -1;
+            }
+        }
+    }
+    /* check if there already is a lexical declaration */
+    if (key in ctx.global_var_obj) {
+        JS_ThrowSyntaxErrorAtom(ctx, "redeclaration of '%s'", prop);
+        return -1;
+    }
+    return 0;
+}
+/* def_flags is (0, DEFINE_GLOBAL_LEX_VAR) | JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE */
+export function JS_DefineGlobalVar(ctx, prop, def_flags) {
+    const key = JS_AtomToKey(ctx, prop);
+    if (def_flags & DEFINE_GLOBAL_LEX_VAR) {
+        const gvo = ctx.global_var_obj;
+        if (key in gvo)
+            return 0;
+        Reflect.defineProperty(gvo, key, {
+            value: JS_UNINITIALIZED, writable: (def_flags & JS_PROP_WRITABLE) !== 0,
+            enumerable: true, configurable: true,
+        });
+        return 0;
+    }
+    const d = js_global_own_desc(ctx, key);
+    if (d === null)
+        return -1;
+    if (d)
+        return 0;
+    if (!Reflect.isExtensible(ctx.global_obj))
+        return 0;
+    try {
+        Reflect.defineProperty(ctx.global_obj, key, {
+            value: undefined, writable: true, enumerable: true,
+            configurable: (def_flags & JS_PROP_CONFIGURABLE) !== 0,
+        });
+    }
+    catch (e) {
+        js_host_exception_to_guest(ctx, e);
+        return -1;
+    }
+    return 0;
+}
+/* 'def_flags' is 0 or JS_PROP_CONFIGURABLE. */
+export function JS_DefineGlobalFunction(ctx, prop, func, def_flags) {
+    const d = js_global_own_desc(ctx, JS_AtomToKey(ctx, prop));
+    if (d === null)
+        return -1;
+    let flags = JS_PROP_HAS_VALUE | JS_PROP_THROW;
+    if (!d || d.configurable) {
+        flags |= JS_PROP_ENUMERABLE | JS_PROP_WRITABLE | def_flags | JS_PROP_HAS_CONFIGURABLE | JS_PROP_HAS_WRITABLE | JS_PROP_HAS_ENUMERABLE;
+    }
+    if (JS_DefineProperty(ctx, ctx.global_obj, prop, func, undefined, undefined, flags) < 0)
+        return -1;
+    return 0;
+}
+export function JS_GetGlobalVar(ctx, prop, throw_ref_error) {
+    const key = JS_AtomToKey(ctx, prop);
+    const gvo = ctx.global_var_obj;
+    if (key in gvo) {
+        const v = gvo[key];
+        if (v === JS_UNINITIALIZED)
+            return JS_ThrowReferenceErrorUninitialized(ctx, prop);
+        return v;
+    }
+    const g = ctx.global_obj;
+    try {
+        if (!Reflect.has(g, key)) {
+            if (throw_ref_error)
+                return JS_ThrowReferenceErrorNotDefined(ctx, prop);
+            return undefined;
+        }
+        return g[key];
+    }
+    catch (e) {
+        return js_host_exception_to_guest(ctx, e);
+    }
+}
+/* construct a reference to a global variable: returns [obj, prop] or null on exception */
+export function JS_GetGlobalVarRef(ctx, prop) {
+    const key = JS_AtomToKey(ctx, prop);
+    const gvo = ctx.global_var_obj;
+    let obj;
+    if (key in gvo) {
+        const d = Reflect.getOwnPropertyDescriptor(gvo, key);
+        if (d.value === JS_UNINITIALIZED) {
+            JS_ThrowReferenceErrorUninitialized(ctx, prop);
+            return null;
+        }
+        if (!d.writable) {
+            JS_ThrowTypeErrorReadOnly(ctx, JS_PROP_THROW, prop);
+            return null;
+        }
+        obj = gvo;
+    }
+    else {
+        const ret = JS_HasProperty(ctx, ctx.global_obj, prop);
+        if (ret < 0)
+            return null;
+        obj = ret ? ctx.global_obj : undefined;
+    }
+    return [obj, JS_AtomToValue(ctx, prop)];
+}
+/* use for strict variable access: test if the variable exists */
+export function JS_CheckGlobalVar(ctx, prop) {
+    if (JS_AtomToKey(ctx, prop) in ctx.global_var_obj)
+        return 1;
+    return JS_HasProperty(ctx, ctx.global_obj, prop);
+}
+/* flag = 0: normal variable write
+   flag = 1: initialize lexical variable
+   flag = 2: normal variable write, strict check was done before */
+export function JS_SetGlobalVar(ctx, prop, val, flag) {
+    const key = JS_AtomToKey(ctx, prop);
+    const gvo = ctx.global_var_obj;
+    if (key in gvo) {
+        if (flag !== 1) {
+            const d = Reflect.getOwnPropertyDescriptor(gvo, key);
+            if (d.value === JS_UNINITIALIZED) {
+                JS_ThrowReferenceErrorUninitialized(ctx, prop);
+                return -1;
+            }
+            if (!d.writable)
+                return JS_ThrowTypeErrorReadOnly(ctx, JS_PROP_THROW, prop);
+        }
+        Reflect.defineProperty(gvo, key, { value: val });
+        return 0;
+    }
+    let flags = JS_PROP_THROW_STRICT;
+    if (is_strict_mode(ctx))
+        flags |= JS_PROP_NO_ADD;
+    if (flag === 2 || (flags & JS_PROP_NO_ADD)) {
+        /* strict mode: the variable must exist */
+        const ret = JS_HasProperty(ctx, ctx.global_obj, prop);
+        if (ret < 0)
+            return -1;
+        if (!ret) {
+            if (flag !== 2) {
+                JS_ThrowReferenceErrorNotDefined(ctx, prop);
+                return -1;
+            }
+        }
+    }
+    return JS_SetPropertyInternal(ctx, ctx.global_obj, prop, val, ctx.global_obj, flags);
+}
+/* ---------------------------------------------------------------------
+   Conversions
+   --------------------------------------------------------------------- */
+export const HINT_STRING = 0;
+export const HINT_NUMBER = 1;
+export const HINT_NONE = 2;
+export const HINT_FORCE_ORDINARY = 1 << 4; /* don't try Symbol.toPrimitive */
+export function JS_ToPrimitiveFree(ctx, val, hint) {
+    if (!JS_IsObject(val))
+        return val;
+    if (!(hint & HINT_FORCE_ORDINARY)) {
+        const method = JS_GetProperty(ctx, val, JS_ATOM_Symbol_toPrimitive);
+        if (JS_IsException(method))
+            return JS_EXCEPTION;
+        if (!(method === undefined || method === null)) {
+            let atom;
+            switch (hint) {
+                case HINT_STRING:
+                    atom = JS_ATOM_string;
+                    break;
+                case HINT_NUMBER:
+                    atom = JS_ATOM_number;
+                    break;
+                default:
+                    atom = JS_ATOM_default;
+                    break;
+            }
+            const arg = JS_AtomToString(ctx, atom);
+            const ret = JS_CallFree(ctx, method, val, [arg]);
+            if (JS_IsException(ret))
+                return ret;
+            if (JS_IsObject(ret))
+                return JS_ThrowTypeError(ctx, 'toPrimitive');
+            return ret;
+        }
+    }
+    hint &= ~HINT_FORCE_ORDINARY;
+    if (hint !== HINT_STRING)
+        hint = HINT_NUMBER;
+    for (let i = 0; i < 2; i++) {
+        const name = ((i ^ hint) === 0) ? JS_ATOM_toString : JS_ATOM_valueOf;
+        const method = JS_GetProperty(ctx, val, name);
+        if (JS_IsException(method))
+            return JS_EXCEPTION;
+        if (JS_IsFunction(ctx, method)) {
+            const ret = JS_CallFree(ctx, method, val, []);
+            if (JS_IsException(ret))
+                return ret;
+            if (!JS_IsObject(ret))
+                return ret;
+        }
+    }
+    return JS_ThrowTypeError(ctx, 'toPrimitive');
+}
+const JS_ATOM_default = 22; /* 'default' keyword atom */
+export function JS_ToPrimitive(ctx, val, hint) {
+    return JS_ToPrimitiveFree(ctx, val, hint);
+}
+export function JS_ToBoolFree(ctx, val) {
+    switch (typeof val) {
+        case 'boolean': return val;
+        case 'number': return !(val === 0 || Number.isNaN(val));
+        case 'string': return val.length > 0;
+        case 'bigint': return val !== 0n;
+        case 'undefined': return false;
+        case 'object':
+            if (val === null)
+                return false;
+            if (JS_IsObject(val))
+                return true;
+            return true;
+    }
+    return true;
+}
+export const JS_ToBool = JS_ToBoolFree;
+/* StringToNumber */
+export function js_atof(ctx, str) {
+    return Number(str);
+}
+/* ToNumber: returns JS_EXCEPTION on error */
+/* ToNumber: returns JS_EXCEPTION on error */
+export function JS_ToNumberFree(ctx, val) {
+    switch (typeof val) {
+        case 'number': return val;
+        case 'boolean': return val ? 1 : 0;
+        case 'undefined': return NaN;
+        case 'string': return js_atof(ctx, val);
+        case 'bigint': return JS_ThrowTypeError(ctx, 'cannot convert bigint to number');
+        case 'symbol': return JS_ThrowTypeError(ctx, 'cannot convert symbol to number');
+        case 'object':
+        case 'function':
+            if (val === null)
+                return 0;
+            if (JS_IsObject(val)) {
+                const prim = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
+                if (JS_IsException(prim))
+                    return prim;
+                return JS_ToNumberFree(ctx, prim);
+            }
+            break;
+    }
+    return JS_ThrowTypeError(ctx, 'cannot convert to number');
+}
+export const JS_ToNumber = JS_ToNumberFree;
+/* ToNumeric: number or bigint */
+export function JS_ToNumericFree(ctx, val) {
+    if (typeof val === 'bigint')
+        return val;
+    if (JS_IsObject(val)) {
+        const prim = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
+        if (JS_IsException(prim))
+            return prim;
+        if (typeof prim === 'bigint')
+            return prim;
+        return JS_ToNumberFree(ctx, prim);
+    }
+    return JS_ToNumberFree(ctx, val);
+}
+export const JS_ToNumeric = JS_ToNumericFree;
+/* return a number or JS_EXCEPTION */
+export function JS_ToFloat64(ctx, val) {
+    if (typeof val === 'number')
+        return val;
+    const r = JS_ToNumberFree(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    return r;
+}
+/* return the int32 value or throws; on exception returns JS_EXCEPTION */
+export function JS_ToInt32Free(ctx, val) {
+    if (typeof val === 'number')
+        return val | 0;
+    const r = JS_ToNumberFree(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    return r | 0;
+}
+export const JS_ToInt32 = JS_ToInt32Free;
+export function JS_ToUint32Free(ctx, val) {
+    if (typeof val === 'number')
+        return val >>> 0;
+    const r = JS_ToNumberFree(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    return r >>> 0;
+}
+export const JS_ToUint32 = JS_ToUint32Free;
+/* ToInt32 with clamping (used by typed arrays / string functions) */
+export function JS_ToInt32Clamp(ctx, val, min_val, max_val, neg_offset) {
+    const r = JS_ToFloat64(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    let d = r;
+    if (Number.isNaN(d))
+        return min_val < 0 ? 0 : min_val;
+    d = Math.trunc(d);
+    if (d < 0) {
+        d += neg_offset;
+        if (d < min_val)
+            d = min_val;
+    }
+    else if (d > max_val)
+        d = max_val;
+    return d;
+}
+/* ToInt32 with saturation */
+export function JS_ToInt32Sat(ctx, val) {
+    const r = JS_ToFloat64(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    const d = r;
+    if (Number.isNaN(d))
+        return 0;
+    if (d < -2147483648)
+        return -2147483648;
+    if (d > 2147483647)
+        return 2147483647;
+    return Math.trunc(d);
+}
+export function JS_ToInt64Sat(ctx, val) {
+    const r = JS_ToFloat64(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    const d = r;
+    if (Number.isNaN(d))
+        return 0;
+    if (d < -9223372036854775808)
+        return -9223372036854775808;
+    if (d >= 9223372036854775807)
+        return 9223372036854775807;
+    return Math.trunc(d);
+}
+export function JS_ToInt64Clamp(ctx, val, min_val, max_val, neg_offset) {
+    const r = JS_ToFloat64(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    let d = r;
+    if (Number.isNaN(d))
+        return min_val < 0 ? 0 : min_val;
+    d = Math.trunc(d);
+    if (d < 0) {
+        d += neg_offset;
+        if (d < min_val)
+            d = min_val;
+    }
+    else if (d > max_val)
+        d = max_val;
+    return d;
+}
+/* ToInteger (truncation); returns JS_EXCEPTION on error */
+export function JS_ToInt64Free(ctx, val) {
+    const r = JS_ToFloat64(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    const d = r;
+    if (Number.isNaN(d))
+        return 0;
+    if (!Number.isFinite(d))
+        return d > 0 ? 9223372036854775807 : -9223372036854775808;
+    return Math.trunc(d);
+}
+export const JS_ToInt64 = JS_ToInt64Free;
+/* ToIndex: returns -1 and throws on error */
+export function JS_ToIndex(ctx, val) {
+    if (val === undefined)
+        return 0;
+    const r = JS_ToFloat64(ctx, val);
+    if (JS_IsException(r))
+        return -1;
+    let d = r;
+    if (Number.isNaN(d))
+        d = 0;
+    d = Math.trunc(d);
+    if (d < 0 || d > 9007199254740991) {
+        JS_ThrowRangeError(ctx, 'invalid array index');
+        return -1;
+    }
+    return d === 0 ? 0 : d;
+}
+/* ToLength: returns -1 on exception */
+export function JS_ToLengthFree(ctx, val) {
+    const r = JS_ToFloat64(ctx, val);
+    if (JS_IsException(r))
+        return -1;
+    let d = r;
+    if (Number.isNaN(d) || d <= 0)
+        return 0;
+    d = Math.trunc(d);
+    if (d > 9007199254740991)
+        d = 9007199254740991;
+    return d;
+}
+/* ToUint32 with RangeError if not a valid array length (ArraySetLength
+   semantics: ToUint32 and ToNumber are both evaluated). Return -1 on exception */
+export function JS_ToArrayLengthFree(ctx, val, is_array_ctor) {
+    let d;
+    if (typeof val === 'number') {
+        d = val;
+    }
+    else {
+        const r = JS_ToNumberFree(ctx, val);
+        if (JS_IsException(r))
+            return -1;
+        d = r;
+        if (!is_array_ctor) {
+            /* the spec evaluates ToNumber a second time */
+            const r2 = JS_ToNumberFree(ctx, val);
+            if (JS_IsException(r2))
+                return -1;
+            if (r2 !== d && !(Number.isNaN(r2) && Number.isNaN(d))) {
+                JS_ThrowRangeError(ctx, 'invalid array length');
+                return -1;
+            }
+        }
+    }
+    const len = d >>> 0;
+    if (len !== d) {
+        JS_ThrowRangeError(ctx, 'invalid array length');
+        return -1;
+    }
+    return len;
+}
+export function JS_ToUint8ClampFree(ctx, val) {
+    const r = JS_ToFloat64(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    const d = r;
+    if (Number.isNaN(d) || d <= 0)
+        return 0;
+    if (d >= 255)
+        return 255;
+    /* round half to even */
+    const f = Math.floor(d);
+    const diff = d - f;
+    if (diff > 0.5)
+        return f + 1;
+    if (diff < 0.5)
+        return f;
+    return (f % 2 === 0) ? f : f + 1;
+}
+/* ToBigInt */
+/* ToBigInt */
+export function JS_ToBigIntFree(ctx, val) {
+    switch (typeof val) {
+        case 'bigint': return val;
+        case 'boolean': return val ? 1n : 0n;
+        case 'string': {
+            const r = js_string_to_bigint(val);
+            if (r === null)
+                return JS_ThrowSyntaxError(ctx, 'invalid bigint literal');
+            return r;
+        }
+        case 'number':
+            return JS_ThrowTypeError(ctx, 'cannot convert number to bigint');
+        case 'undefined':
+            return JS_ThrowTypeError(ctx, 'cannot convert undefined to bigint');
+        case 'symbol':
+            return JS_ThrowTypeError(ctx, 'cannot convert symbol to bigint');
+        case 'object':
+        case 'function':
+            if (val === null)
+                return JS_ThrowTypeError(ctx, 'cannot convert null to bigint');
+            if (JS_IsObject(val)) {
+                const prim = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
+                if (JS_IsException(prim))
+                    return prim;
+                return JS_ToBigIntFree(ctx, prim);
+            }
+            break;
+    }
+    return JS_ThrowTypeError(ctx, 'cannot convert to bigint');
+}
+export const JS_ToBigInt = JS_ToBigIntFree;
+export function js_string_to_bigint(str) {
+    const s = str.trim();
+    if (s === '')
+        return 0n;
+    try {
+        if (/^[+-]?\d+$/.test(s) || /^0[xX][0-9a-fA-F]+$/.test(s) || /^0[oO][0-7]+$/.test(s) || /^0[bB][01]+$/.test(s)) {
+            return BigInt(s);
+        }
+    }
+    catch { /* fallthrough */ }
+    return null;
+}
+export function JS_NewBigInt64(ctx, v) { return BigInt.asIntN(64, BigInt(v)); }
+export function JS_NewBigUint64(ctx, v) { return BigInt.asUintN(64, BigInt(v)); }
+export function JS_ToBigInt64(ctx, val) {
+    const r = JS_ToBigIntFree(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    return BigInt.asIntN(64, r);
+}
+/* number to string with a radix */
+export function js_number_to_string(d, radix) {
+    if (radix === 10)
+        return String(d);
+    return d.toString(radix);
+}
+export function js_dtoa(d) { return String(d); }
+/* ToString */
+export function JS_ToStringInternal(ctx, val, is_ToPropertyKey) {
+    switch (typeof val) {
+        case 'string': return val;
+        case 'number': return js_number_to_string(val, 10);
+        case 'boolean': return val ? 'true' : 'false';
+        case 'undefined': return 'undefined';
+        case 'bigint': return val.toString();
+        case 'symbol':
+            if (is_ToPropertyKey)
+                return val;
+            return JS_ThrowTypeError(ctx, 'cannot convert symbol to string');
+        case 'object':
+        case 'function':
+            if (val === null)
+                return 'null';
+            if (JS_IsObject(val)) {
+                const prim = JS_ToPrimitiveFree(ctx, val, HINT_STRING);
+                if (JS_IsException(prim))
+                    return prim;
+                return JS_ToStringInternal(ctx, prim, is_ToPropertyKey);
+            }
+            if (val === JS_EXCEPTION)
+                return '[exception]';
+            if (val === JS_UNINITIALIZED)
+                return '[uninitialized]';
+            return '[catch offset]';
+    }
+    return JS_ThrowTypeError(ctx, 'cannot convert to string');
+}
+export function JS_ToString(ctx, val) {
+    return JS_ToStringInternal(ctx, val, false);
+}
+export const JS_ToStringFree = JS_ToString;
+export function JS_ToCString(ctx, val) {
+    const r = JS_ToString(ctx, val);
+    if (JS_IsException(r))
+        return null;
+    return r;
+}
+export function JS_ToPropertyKey(ctx, val) {
+    return JS_ToStringInternal(ctx, val, true);
+}
+/* return a quoted string with JSON-like escapes */
+export function JS_ToQuotedString(ctx, val) {
+    const r = JS_ToString(ctx, val);
+    if (JS_IsException(r))
+        return r;
+    return js_quote_string(r);
+}
+export function js_quote_string(s) {
+    let out = '"';
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        switch (c) {
+            case 0x09:
+                out += '\\t';
+                break;
+            case 0x0a:
+                out += '\\n';
+                break;
+            case 0x0d:
+                out += '\\r';
+                break;
+            case 0x08:
+                out += '\\b';
+                break;
+            case 0x0c:
+                out += '\\f';
+                break;
+            case 0x5c:
+                out += '\\\\';
+                break;
+            case 0x22:
+                out += '\\"';
+                break;
+            default:
+                if (c < 32 || (c >= 0xd800 && c <= 0xdfff && !is_paired_surrogate(s, i))) {
+                    out += '\\u' + c.toString(16).padStart(4, '0');
+                }
+                else {
+                    out += s[i];
+                }
+        }
+    }
+    return out + '"';
+}
+function is_paired_surrogate(s, i) {
+    const c = s.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff) {
+        const c2 = s.charCodeAt(i + 1);
+        return c2 >= 0xdc00 && c2 <= 0xdfff;
+    }
+    if (c >= 0xdc00 && c <= 0xdfff) {
+        if (i === 0)
+            return false;
+        const c1 = s.charCodeAt(i - 1);
+        return c1 >= 0xd800 && c1 <= 0xdbff;
+    }
+    return true;
+}
+/* string wrapper objects expose 'length' and the character indices as own
+   properties (the string exotic object of the specification) */
+/* ToObject */
+export function JS_ToObject(ctx, val) {
+    switch (typeof val) {
+        case 'object':
+        case 'function':
+            if (JS_IsObject(val))
+                return val;
+            return JS_ThrowTypeError(ctx, 'cannot convert to object');
+        case 'undefined':
+            return JS_ThrowTypeError(ctx, 'cannot convert to object');
+        case 'symbol': return js_new_primitive_wrapper(ctx, ctx.class_proto[7 /* JSClassID.SYMBOL */], 7 /* JSClassID.SYMBOL */, val);
+        case 'number': return js_new_primitive_wrapper(ctx, ctx.class_proto[4 /* JSClassID.NUMBER */], 4 /* JSClassID.NUMBER */, val);
+        case 'boolean': return js_new_primitive_wrapper(ctx, ctx.class_proto[6 /* JSClassID.BOOLEAN */], 6 /* JSClassID.BOOLEAN */, val);
+        case 'bigint': return js_new_primitive_wrapper(ctx, ctx.class_proto[33 /* JSClassID.BIG_INT */], 33 /* JSClassID.BIG_INT */, val);
+        case 'string': return js_new_primitive_wrapper(ctx, ctx.class_proto[5 /* JSClassID.STRING */], 5 /* JSClassID.STRING */, val);
+    }
+    return JS_ThrowTypeError(ctx, 'cannot convert to object');
+}
+export const JS_ToObjectFree = JS_ToObject;
+/* "this" value of a primitive wrapper: the primitive, JS_EXCEPTION if the
+   object is not a wrapper of the given class */
+export function JS_ThisObjectData(ctx, this_val, class_id) {
+    if (JS_IsObject(this_val)) {
+        const m = js_meta.get(this_val);
+        if (m && m.class_id === class_id)
+            return m.u;
+        return JS_EXCEPTION;
+    }
+    return this_val;
+}
+/* ---------------------------------------------------------------------
+   Comparisons and operators
+   --------------------------------------------------------------------- */
+export function js_same_value(ctx, op1, op2) {
+    return Object.is(op1, op2);
+}
+export function js_same_value_zero(ctx, op1, op2) {
+    if (typeof op1 === 'number' && typeof op2 === 'number')
+        return op1 === op2 || (Number.isNaN(op1) && Number.isNaN(op2));
+    return op1 === op2;
+}
+export function js_strict_eq2(ctx, op1, op2, eq_mode) {
+    switch (eq_mode) {
+        case 0 /* JSStrictEqMode.STRICT */: return op1 === op2; /* host semantics match (NaN !== NaN, +0 === -0) */
+        case 1 /* JSStrictEqMode.SAME_VALUE */: return Object.is(op1, op2);
+        case 2 /* JSStrictEqMode.SAME_VALUE_ZERO */: return js_same_value_zero(ctx, op1, op2);
+    }
+}
+export function js_strict_eq(ctx, op1, op2) { return op1 === op2; }
+/* abstract equality: returns -1 on exception */
+export function js_loose_eq(ctx, op1, op2) {
+    for (;;) {
+        const o1 = JS_IsObject(op1), o2 = JS_IsObject(op2);
+        if (o1 && o2)
+            return op1 === op2 ? 1 : 0;
+        if (!o1 && !o2 && typeof op1 === typeof op2)
+            return op1 === op2 ? 1 : 0;
+        const n1 = (op1 === undefined || op1 === null), n2 = (op2 === undefined || op2 === null);
+        /* undefined == null */
+        if (n1 && n2)
+            return 1;
+        if (n1 || n2)
+            return 0;
+        const t1 = typeof op1, t2 = typeof op2;
+        if (t1 === 'number' && t2 === 'string') {
+            op2 = js_atof(ctx, op2);
+            continue;
+        }
+        if (t1 === 'string' && t2 === 'number') {
+            op1 = js_atof(ctx, op1);
+            continue;
+        }
+        if (t1 === 'bigint' && t2 === 'string') {
+            const b = js_string_to_bigint(op2);
+            if (b === null)
+                return 0;
+            return op1 === b ? 1 : 0;
+        }
+        if (t1 === 'string' && t2 === 'bigint') {
+            const b = js_string_to_bigint(op1);
+            if (b === null)
+                return 0;
+            return op2 === b ? 1 : 0;
+        }
+        if (t1 === 'boolean') {
+            op1 = op1 ? 1 : 0;
+            continue;
+        }
+        if (t2 === 'boolean') {
+            op2 = op2 ? 1 : 0;
+            continue;
+        }
+        if (o1 && !o2) {
+            const p = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
+            if (JS_IsException(p))
+                return -1;
+            op1 = p;
+            continue;
+        }
+        if (o2 && !o1) {
+            const p = JS_ToPrimitiveFree(ctx, op2, HINT_NONE);
+            if (JS_IsException(p))
+                return -1;
+            op2 = p;
+            continue;
+        }
+        if (t1 === 'bigint' && t2 === 'number')
+            return bigint_num_eq(op1, op2) ? 1 : 0;
+        if (t1 === 'number' && t2 === 'bigint')
+            return bigint_num_eq(op2, op1) ? 1 : 0;
+        return 0;
+    }
+}
+function bigint_num_eq(a, b) {
+    if (!Number.isFinite(b) || !Number.isInteger(b))
+        return false;
+    return a === BigInt(b);
+}
+/* relational comparison: returns -1 on exception, else 0/1 */
+export function js_relational_op(ctx, op, op1, op2) {
+    if (JS_IsObject(op1)) {
+        op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NUMBER);
+        if (JS_IsException(op1))
+            return -1;
+    }
+    if (JS_IsObject(op2)) {
+        op2 = JS_ToPrimitiveFree(ctx, op2, HINT_NUMBER);
+        if (JS_IsException(op2))
+            return -1;
+    }
+    let res;
+    if (typeof op1 === 'string' && typeof op2 === 'string') {
+        switch (op) {
+            case 0 /* JSRelOp.LT */:
+                res = op1 < op2;
+                break;
+            case 1 /* JSRelOp.LTE */:
+                res = op1 <= op2;
+                break;
+            case 2 /* JSRelOp.GT */:
+                res = op1 > op2;
+                break;
+            default:
+                res = op1 >= op2;
+                break;
+        }
+        return res ? 1 : 0;
+    }
+    if (typeof op1 === 'symbol' || typeof op2 === 'symbol') {
+        JS_ThrowTypeError(ctx, 'cannot convert symbol to number');
+        return -1;
+    }
+    let n1, n2;
+    if (typeof op1 === 'bigint' && typeof op2 === 'string') {
+        const b = js_string_to_bigint(op2);
+        if (b === null)
+            return 0;
+        n1 = op1;
+        n2 = b;
+    }
+    else if (typeof op1 === 'string' && typeof op2 === 'bigint') {
+        const b = js_string_to_bigint(op1);
+        if (b === null)
+            return 0;
+        n1 = b;
+        n2 = op2;
+    }
+    else {
+        n1 = JS_ToNumericFree(ctx, op1);
+        if (JS_IsException(n1))
+            return -1;
+        n2 = JS_ToNumericFree(ctx, op2);
+        if (JS_IsException(n2))
+            return -1;
+    }
+    /* host relational ops handle number/bigint mixes correctly */
+    const a = n1, b = n2;
+    switch (op) {
+        case 0 /* JSRelOp.LT */:
+            res = a < b;
+            break;
+        case 1 /* JSRelOp.LTE */:
+            res = a <= b;
+            break;
+        case 2 /* JSRelOp.GT */:
+            res = a > b;
+            break;
+        default:
+            res = a >= b;
+            break;
+    }
+    return res ? 1 : 0;
+}
+/* return -1 if exception, else 0/1 */
+export function JS_OrdinaryIsInstanceOf(ctx, val, obj) {
+    if (!JS_IsFunction(ctx, obj))
+        return 0;
+    const m = js_get_meta(obj);
+    if (m && m.class_id === 14 /* JSClassID.BOUND_FUNCTION */) {
+        return JS_IsInstanceOf(ctx, val, m.u.func_obj);
+    }
+    if (!JS_IsObject(val))
+        return 0;
+    const proto = JS_GetProperty(ctx, obj, JS_ATOM_prototype);
+    if (JS_IsException(proto))
+        return -1;
+    if (!JS_IsObject(proto)) {
+        JS_ThrowTypeError(ctx, 'operand \'prototype\' property is not an object');
+        return -1;
+    }
+    let obj1 = val;
+    let depth = 0;
+    for (;;) {
+        const proto1 = JS_GetPrototype(ctx, obj1);
+        if (JS_IsException(proto1))
+            return -1;
+        if (proto1 === null || proto1 === undefined)
+            return 0;
+        if (proto1 === proto)
+            return 1;
+        obj1 = proto1;
+        if (++depth > 100000) {
+            JS_ThrowInternalError(ctx, 'prototype chain too deep');
+            return -1;
+        }
+    }
+}
+export function JS_IsInstanceOf(ctx, val, obj) {
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeError(ctx, 'invalid \'instanceof\' right operand');
+        return -1;
+    }
+    const method = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_hasInstance);
+    if (JS_IsException(method))
+        return -1;
+    if (!(method === undefined || method === null)) {
+        const ret = JS_CallFree(ctx, method, obj, [val]);
+        if (JS_IsException(ret))
+            return -1;
+        return JS_ToBoolFree(ctx, ret) ? 1 : 0;
+    }
+    if (!JS_IsFunction(ctx, obj)) {
+        JS_ThrowTypeError(ctx, 'invalid \'instanceof\' right operand');
+        return -1;
+    }
+    return JS_OrdinaryIsInstanceOf(ctx, val, obj);
+}
+export function js_operator_typeof(ctx, op1) {
+    switch (typeof op1) {
+        case 'bigint': return JS_ATOM_bigint;
+        case 'number': return JS_ATOM_number;
+        case 'undefined': return JS_ATOM_undefined;
+        case 'boolean': return JS_ATOM_boolean;
+        case 'string': return JS_ATOM_string;
+        case 'symbol': return JS_ATOM_symbol;
+        case 'function': return JS_ATOM_function;
+        case 'object':
+            if (op1 instanceof JSSpecial)
+                return JS_ATOM_undefined;
+            return JS_ATOM_object;
+    }
+    return JS_ATOM_undefined;
+}
+/* 'in' operator: -1 on exception */
+export function js_operator_in(ctx, op1, op2) {
+    if (!JS_IsObject(op2)) {
+        JS_ThrowTypeError(ctx, 'invalid \'in\' operand');
+        return -1;
+    }
+    const atom = JS_ValueToAtom(ctx, op1);
+    if (atom === JS_ATOM_NULL)
+        return -1;
+    return JS_HasProperty(ctx, op2, atom);
+}
+export function js_binary_arith_slow(ctx, op, op1, op2) {
+    const n1 = JS_ToNumericFree(ctx, op1);
+    if (JS_IsException(n1))
+        return n1;
+    const n2 = JS_ToNumericFree(ctx, op2);
+    if (JS_IsException(n2))
+        return n2;
+    const b1 = typeof n1 === 'bigint', b2 = typeof n2 === 'bigint';
+    if (b1 !== b2)
+        return JS_ThrowTypeError(ctx, 'both operands must be bigint');
+    if (b1) {
+        const a = n1, b = n2;
+        try {
+            switch (op) {
+                case 0 /* JSArithOp.ADD */: return a + b;
+                case 1 /* JSArithOp.SUB */: return a - b;
+                case 2 /* JSArithOp.MUL */: return a * b;
+                case 3 /* JSArithOp.DIV */:
+                    if (b === 0n)
+                        return JS_ThrowRangeError(ctx, 'division by zero');
+                    return a / b;
+                case 4 /* JSArithOp.MOD */:
+                    if (b === 0n)
+                        return JS_ThrowRangeError(ctx, 'division by zero');
+                    return a % b;
+                case 5 /* JSArithOp.POW */:
+                    if (b < 0n)
+                        return JS_ThrowRangeError(ctx, 'invalid bigint exponent');
+                    return a ** b;
+                case 6 /* JSArithOp.SHL */: return a << b;
+                case 7 /* JSArithOp.SAR */: return a >> b;
+                case 8 /* JSArithOp.SHR */: return JS_ThrowTypeError(ctx, 'BigInts have no unsigned right shift, use >> instead');
+                case 9 /* JSArithOp.AND */: return a & b;
+                case 10 /* JSArithOp.OR */: return a | b;
+                case 11 /* JSArithOp.XOR */: return a ^ b;
+            }
+        }
+        catch (e) {
+            return JS_ThrowRangeError(ctx, String(e.message));
+        }
+    }
+    const a = n1, b = n2;
+    switch (op) {
+        case 0 /* JSArithOp.ADD */: return a + b;
+        case 1 /* JSArithOp.SUB */: return a - b;
+        case 2 /* JSArithOp.MUL */: return a * b;
+        case 3 /* JSArithOp.DIV */: return a / b;
+        case 4 /* JSArithOp.MOD */: return a % b;
+        case 5 /* JSArithOp.POW */: return js_pow(a, b);
+        case 6 /* JSArithOp.SHL */: return a << (b & 31);
+        case 7 /* JSArithOp.SAR */: return a >> (b & 31);
+        case 8 /* JSArithOp.SHR */: return a >>> (b & 31);
+        case 9 /* JSArithOp.AND */: return a & b;
+        case 10 /* JSArithOp.OR */: return a | b;
+        case 11 /* JSArithOp.XOR */: return a ^ b;
+    }
+    return undefined;
+}
+export function js_pow(a, b) {
+    /* Math.pow follows the spec */
+    return Math.pow(a, b);
+}
+/* '+' operator with string concatenation */
+export function js_add_slow(ctx, op1, op2) {
+    if (JS_IsObject(op1)) {
+        op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
+        if (JS_IsException(op1))
+            return op1;
+    }
+    if (JS_IsObject(op2)) {
+        op2 = JS_ToPrimitiveFree(ctx, op2, HINT_NONE);
+        if (JS_IsException(op2))
+            return op2;
+    }
+    if (typeof op1 === 'string' || typeof op2 === 'string') {
+        const s1 = JS_ToString(ctx, op1);
+        if (JS_IsException(s1))
+            return s1;
+        const s2 = JS_ToString(ctx, op2);
+        if (JS_IsException(s2))
+            return s2;
+        return s1 + s2;
+    }
+    return js_binary_arith_slow(ctx, 0 /* JSArithOp.ADD */, op1, op2);
+}
+export function js_unary_arith_slow(ctx, op, op1) {
+    if (op === 1 /* JSUnaryOp.PLUS */)
+        return JS_ToNumberFree(ctx, op1);
+    const n = JS_ToNumericFree(ctx, op1);
+    if (JS_IsException(n))
+        return n;
+    if (typeof n === 'bigint') {
+        switch (op) {
+            case 0 /* JSUnaryOp.NEG */: return -n;
+            case 2 /* JSUnaryOp.INC */: return n + 1n;
+            case 3 /* JSUnaryOp.DEC */: return n - 1n;
+            case 4 /* JSUnaryOp.NOT */: return ~n;
+        }
+    }
+    const a = n;
+    switch (op) {
+        case 0 /* JSUnaryOp.NEG */: return -a;
+        case 2 /* JSUnaryOp.INC */: return a + 1;
+        case 3 /* JSUnaryOp.DEC */: return a - 1;
+        case 4 /* JSUnaryOp.NOT */: return ~a;
+    }
+    return undefined;
+}
+/* ---------------------------------------------------------------------
+   Iterators
+   --------------------------------------------------------------------- */
+export function js_create_iterator_result(ctx, val, done) {
+    const obj = JS_NewObject(ctx);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_value, val, JS_PROP_C_W_E);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_done, done, JS_PROP_C_W_E);
+    return obj;
+}
+export const JS_CreateIterResultObject = js_create_iterator_result;
+export function JS_GetIterator2(ctx, obj, method) {
+    const enum_obj = JS_Call(ctx, method, obj, []);
+    if (JS_IsException(enum_obj))
+        return enum_obj;
+    if (!JS_IsObject(enum_obj))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    return enum_obj;
+}
+/* hook set by the async builtins: create an AsyncFromSyncIterator */
+export const async_hooks = { JS_CreateAsyncFromSyncIterator: null };
+export function JS_GetIterator(ctx, obj, is_async) {
+    let method;
+    if (is_async) {
+        method = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_asyncIterator);
+        if (JS_IsException(method))
+            return method;
+        if (method === undefined || method === null) {
+            method = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_iterator);
+            if (JS_IsException(method))
+                return method;
+            const sync_iter = JS_GetIterator2(ctx, obj, method);
+            if (JS_IsException(sync_iter))
+                return sync_iter;
+            return async_hooks.JS_CreateAsyncFromSyncIterator(ctx, sync_iter);
+        }
+    }
+    else {
+        method = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_iterator);
+        if (JS_IsException(method))
+            return method;
+    }
+    if (!JS_IsFunction(ctx, method))
+        return JS_ThrowTypeError(ctx, 'value is not iterable');
+    return JS_GetIterator2(ctx, obj, method);
+}
+/* return the result object of the next() call or JS_EXCEPTION */
+export function JS_IteratorNext2(ctx, enum_obj, method, argv, pdone) {
+    const obj = JS_Call(ctx, method, enum_obj, argv);
+    if (JS_IsException(obj)) {
+        pdone.done = 0;
+        return obj;
+    }
+    if (!JS_IsObject(obj)) {
+        pdone.done = 0;
+        return JS_ThrowTypeError(ctx, 'iterator must return an object');
+    }
+    const done_val = JS_GetProperty(ctx, obj, JS_ATOM_done);
+    if (JS_IsException(done_val)) {
+        pdone.done = 0;
+        return done_val;
+    }
+    pdone.done = JS_ToBoolFree(ctx, done_val) ? 1 : 0;
+    return obj;
+}
+/* return the 'value' of the next() call; pdone.done is set */
+export function JS_IteratorNext(ctx, enum_obj, method, argv, pdone) {
+    const obj = JS_IteratorNext2(ctx, enum_obj, method, argv, pdone);
+    if (JS_IsException(obj))
+        return obj;
+    if (pdone.done)
+        return undefined;
+    const value = JS_GetProperty(ctx, obj, JS_ATOM_value);
+    if (JS_IsException(value)) {
+        pdone.done = 0;
+        return value;
+    }
+    return value;
+}
+/* return < 0 in case of exception */
+export function JS_IteratorClose(ctx, enum_obj, is_exception_pending) {
+    let ex_obj = undefined;
+    if (is_exception_pending)
+        ex_obj = JS_GetException(ctx);
+    let res = 0;
+    const method = JS_GetProperty(ctx, enum_obj, JS_ATOM_return);
+    if (JS_IsException(method)) {
+        res = -1;
+    }
+    else if (!(method === undefined || method === null)) {
+        const ret = JS_CallFree(ctx, method, enum_obj, []);
+        if (!is_exception_pending) {
+            if (JS_IsException(ret))
+                res = -1;
+            else if (!JS_IsObject(ret)) {
+                JS_ThrowTypeErrorNotAnObject(ctx);
+                res = -1;
+            }
+        }
+    }
+    if (is_exception_pending) {
+        JS_Throw(ctx, ex_obj);
+        return -1;
+    }
+    return res;
+}
+/* obtain the next element of the iterator 'enum_obj' (used by the interpreter) */
+export function JS_IteratorGetCompleteValue(ctx, obj, pdone) {
+    const done_val = JS_GetProperty(ctx, obj, JS_ATOM_done);
+    if (JS_IsException(done_val))
+        return done_val;
+    const done = JS_ToBoolFree(ctx, done_val);
+    const value = JS_GetProperty(ctx, obj, JS_ATOM_value);
+    if (JS_IsException(value))
+        return value;
+    pdone.done = done ? 1 : 0;
+    return value;
+}
+/* build an array from an iterable or array-like (used by apply/spread) */
+/* build an argument list from an iterable or array-like (used by apply/spread) */
+export function build_arg_list(ctx, array_arg) {
+    if (!JS_IsObject(array_arg)) {
+        JS_ThrowTypeError(ctx, 'not a object');
+        return null;
+    }
+    const len = js_get_length64(ctx, array_arg);
+    if (len < 0)
+        return null;
+    if (len > 65536 * 16) {
+        JS_ThrowRangeError(ctx, 'too many arguments');
+        return null;
+    }
+    const tab = new Array(len);
+    const fast = js_get_fast_array(ctx, array_arg);
+    if (fast && fast.length === len) {
+        /* holes read as undefined, like the generic path */
+        for (let i = 0; i < len; i++)
+            tab[i] = fast[i];
+        return tab;
+    }
+    for (let i = 0; i < len; i++) {
+        const v = JS_GetPropertyUint32(ctx, array_arg, i);
+        if (JS_IsException(v))
+            return null;
+        tab[i] = v;
+    }
+    return tab;
+}
+/* for-in enumeration: snapshot of the enumerable string keys (own keys
+   first, then the prototype chain), as EnumerateObjectProperties */
+export function build_for_in_iterator(ctx, obj) {
+    const it = new JSForInState();
+    if (!JS_IsObject(obj)) {
+        if (obj === undefined || obj === null) {
+            it.obj = undefined;
+            return it;
+        }
+        obj = JS_ToObject(ctx, obj);
+        if (JS_IsException(obj))
+            return obj;
+    }
+    it.obj = obj;
+    try {
+        /* the host for-in implements the specification algorithm, including
+           proxy traps and shadowing */
+        let own = 0;
+        const own_keys = new Set(Object.keys(obj));
+        for (const k in obj) {
+            it.keys.push(k);
+            if (own_keys.has(k))
+                own++;
+        }
+        it.own_count = own;
+    }
+    catch (e) {
+        return js_host_exception_to_guest(ctx, e);
+    }
+    return it;
+}
+/* return the next key or undefined when done. pdone.done = 1 when finished. -1 exception */
+export function js_for_in_next(ctx, enum_obj, pdone) {
+    const it = enum_obj;
+    const obj = it.obj;
+    for (;;) {
+        if (it.idx >= it.keys.length || obj === undefined) {
+            pdone.done = 1;
+            return undefined;
+        }
+        const idx = it.idx++;
+        const key = it.keys[idx];
+        /* check if the property was deleted (own keys: own property lookup,
+           prototype keys: prototype chain lookup, as in C) */
+        let ret;
+        try {
+            if (idx < it.own_count)
+                ret = Reflect.getOwnPropertyDescriptor(obj, key) !== undefined ? 1 : 0;
+            else
+                ret = Reflect.has(obj, key) ? 1 : 0;
+        }
+        catch (e) {
+            js_host_exception_to_guest(ctx, e);
+            return JS_EXCEPTION;
+        }
+        if (!ret)
+            continue;
+        pdone.done = 0;
+        return key;
+    }
+}
+/* ---------------------------------------------------------------------
+   Jobs (Promises)
+   --------------------------------------------------------------------- */
+export function JS_EnqueueJob(ctx, job_func, argv) {
+    ctx.rt.job_list.push({ job_func, ctx, argv: argv.slice() });
+    return 0;
+}
+export function JS_IsJobPending(rt) { return rt.job_list.length > 0; }
+/* return < 0 if exception, 0 if no job pending, 1 if a job was executed
+   successfully. The context of the job is returned in pctx */
+export function JS_ExecutePendingJob(rt, pctx) {
+    if (rt.job_list.length === 0) {
+        pctx.ctx = null;
+        return 0;
+    }
+    const e = rt.job_list.shift();
+    pctx.ctx = e.ctx;
+    const res = e.job_func(e.ctx, e.argv);
+    if (JS_IsException(res))
+        return -1;
+    return 1;
+}
+/* ---------------------------------------------------------------------
+   Eval
+   --------------------------------------------------------------------- */
+export function JS_EvalThis(ctx, this_obj, input, filename, eval_flags) {
+    return hooks.JS_EvalInternal(ctx, this_obj, input, filename, eval_flags, -1);
+}
+export function JS_Eval(ctx, input, filename, eval_flags) {
+    return JS_EvalThis(ctx, ctx.global_obj, input, filename, eval_flags);
+}
+/* run the function object produced by JS_EVAL_FLAG_COMPILE_ONLY */
+export function JS_EvalFunction(ctx, fun_obj) {
+    return JS_Call(ctx, fun_obj, ctx.global_obj, []);
+}
+export function JS_RunGC(_rt) { }
+/* ---------------------------------------------------------------------
+   Misc helpers
+   --------------------------------------------------------------------- */
+export function JS_NewString(ctx, s) { return s; }
+export function JS_NewStringLen(ctx, s) { return s; }
+export function JS_NewAtomString(ctx, s) { return s; }
+export function JS_NewBool(ctx, v) { return v; }
+export function JS_NewInt32(ctx, v) { return v | 0; }
+export function JS_NewUint32(ctx, v) { return v >>> 0; }
+export function JS_NewInt64(ctx, v) { return v; }
+export function JS_NewFloat64(ctx, v) { return v; }
+export function JS_NewCatchOffsetValue(v) { return v; }
+export function JS_IsLiveObject(_rt, obj) { return JS_IsObject(obj); }
+/* used by the interpreter: name of a class id */
+export function JS_GetClassName(ctx, class_id) {
+    return ctx.rt.atoms.toStr(ctx.rt.class_array[class_id]?.class_name ?? JS_ATOM_Object);
+}
+/* Object.prototype.toString tag helper */
+export function js_object_class_name(ctx, obj) {
+    switch (JS_GetClassID(obj)) {
+        case 2 /* JSClassID.ARRAY */: return 'Array';
+        case 3 /* JSClassID.ERROR */: return 'Error';
+        case 8 /* JSClassID.ARGUMENTS */:
+        case 9 /* JSClassID.MAPPED_ARGUMENTS */: return 'Arguments';
+        case 6 /* JSClassID.BOOLEAN */: return 'Boolean';
+        case 4 /* JSClassID.NUMBER */: return 'Number';
+        case 5 /* JSClassID.STRING */: return 'String';
+        case 10 /* JSClassID.DATE */: return 'Date';
+        case 18 /* JSClassID.REGEXP */: return 'RegExp';
+        default:
+            if (JS_IsFunction(ctx, obj))
+                return 'Function';
+            return 'Object';
+    }
+}
+/* copy the enumerable own properties of 'source' into 'target' (object spread) */
+export function JS_CopyDataProperties(ctx, target, source, excluded, setprop) {
+    if (!JS_IsObject(source))
+        return 0;
+    const tab = JS_GetOwnPropertyNamesInternal(ctx, source, JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK);
+    if (!tab)
+        return -1;
+    for (const e of tab) {
+        if (JS_IsObject(excluded)) {
+            const ret = JS_GetOwnPropertyInternal(ctx, null, excluded, e.atom);
+            if (ret < 0)
+                return -1;
+            if (ret)
+                continue;
+        }
+        /* check enumerability (proxies may change it) */
+        const desc = new_desc();
+        const ret = JS_GetOwnPropertyInternal(ctx, desc, source, e.atom);
+        if (ret < 0)
+            return -1;
+        if (!ret || !(desc.flags & JS_PROP_ENUMERABLE))
+            continue;
+        const val = JS_GetProperty(ctx, source, e.atom);
+        if (JS_IsException(val))
+            return -1;
+        let r;
+        if (setprop)
+            r = JS_SetProperty(ctx, target, e.atom, val);
+        else
+            r = JS_DefinePropertyValue(ctx, target, e.atom, val, JS_PROP_C_W_E);
+        if (r < 0)
+            return -1;
+    }
+    return 0;
+}
+/* JSON-less value dump for debugging / qjs print */
+export function JS_DumpValue(ctx, val) {
+    const s = JS_ToString(ctx, val);
+    if (JS_IsException(s)) {
+        JS_GetException(ctx);
+        return '[exception]';
+    }
+    return s;
+}
+/* mark an error object as already carrying its backtrace (the interpreter
+   adds the backtrace of errors created without one at throw time) */
+export function JS_SetErrorBacktraceDone(obj) {
+    const m = js_get_meta(obj);
+    if (m)
+        m.has_backtrace = true;
+}
+//# sourceMappingURL=quickjs.js.map