jseption 0.0.0-stage → 0.0.2

package/dist/jit_runtime.js

@@ -0,0 +1,721 @@
+/*
+ * Runtime adapter for the compiled tier (src/jit.ts).
+ *
+ * This is the ONLY module that generated code talks to, and the only
+ * place where the compiled tier touches engine internals. Generated code
+ * receives one `JitRuntime` instance per context as `$RT`, plus a few
+ * host intrinsics and engine tables as factory parameters (see
+ * JIT_FACTORY_PARAMS).
+ *
+ * Conventions:
+ *  - every helper either returns a guest value or `throw`s a guest value
+ *    (the engine's JS_EXCEPTION/current_exception convention is converted
+ *    here by `check()`/`throw_pending()`);
+ *  - `DONE` is a sentinel returned by the iteration helpers;
+ *  - the direct entry of a guest function (js_direct) uses the explicit
+ *    convention `direct($this, $new_target, ...args)`; compiled code calls
+ *    it when it has an explicit `this` or new.target, and calls guest
+ *    functions natively otherwise.
+ */
+import { JS_EXCEPTION, JS_UNINITIALIZED, JS_IsException, JS_IsObject, JS_GetException, js_take_exception, js_host_exception_to_guest, JS_ThrowTypeError, JS_ThrowReferenceError, JS_ThrowInternalError, JS_ThrowStackOverflow, JS_ThrowTypeErrorReadOnly, JS_ThrowSyntaxErrorAtom, JS_ThrowReferenceErrorUninitialized, JS_ThrowReferenceErrorNotDefined, JS_ThrowReferenceErrorUninitialized2, JS_ThrowTypeErrorNotAnObject, JS_GetProperty, JS_GetPropertyInternal, JS_GetPropertyValue, JS_SetPropertyInternal, JS_SetPropertyValue, JS_DefinePropertyValue, JS_DefinePropertyValueValue, JS_DefinePropertyValueUint32, JS_DefineProperty, JS_DeleteProperty, JS_HasProperty, JS_GetPrototype, JS_SetPrototypeInternal, JS_NewObject, JS_NewObjectProto, JS_NewObjectProtoClass, JS_NewArrayFrom, JS_ValueToAtom, JS_AtomToValue, JS_AtomToKey, JS_NewSymbolFromAtom, JS_ToObject, JS_ToPropertyKey, JS_ToNumericFree, JS_IsInstanceOf, js_operator_in, js_unary_arith_slow, JS_GetIterator, JS_IteratorClose, build_for_in_iterator, js_for_in_next, JS_CopyDataProperties, JS_Call, JS_CallConstructorInternal, JS_CallConstructor2, js_create_from_ctor, JS_CheckGlobalVar, JS_GetGlobalVar, JS_SetGlobalVar, JS_CheckDefineGlobalVar, JS_DefineGlobalVar, JS_DefineGlobalFunction, JS_GetGlobalVarRef, hooks, js_meta, js_direct, JS_GetFunctionData, js_new_host_function, js_init_host_function, JS_ATOM_NULL, JS_ATOM_return, JS_ATOM_throw, JS_ATOM_length, JS_ATOM_prototype, JS_ATOM_callee, JS_ATOM_Symbol_iterator, JS_ATOM_empty_string, JS_ATOM_TYPE_PRIVATE, JS_ATOM_constructor, JS_IsUncatchableError, JS_SetUncatchableError, } from "./quickjs.js";
+import { JSFunctionData, JSObjectMeta, new_var_ref_cell, JS_PROP_C_W_E, JS_PROP_THROW, JS_PROP_CONFIGURABLE, JS_PROP_WRITABLE, JS_PROP_ENUMERABLE, JS_PROP_HAS_CONFIGURABLE, JS_PROP_HAS_ENUMERABLE, JS_PROP_HAS_VALUE, JS_PROP_HAS_WRITABLE, JS_PROP_HAS_GET, JS_PROP_HAS_SET, JS_CALL_FLAG_CONSTRUCTOR, } from "./values.js";
+import { JS_CallInternal, js_closure_from_refs, js_function_set_properties, js_define_class, js_build_arguments_value, js_build_rest, JS_DefinePrivateField, JS_GetPrivateField, JS_SetPrivateField, JS_AddBrand, JS_CheckBrand, js_operator_private_in, js_method_set_home_object, js_method_set_properties, JS_DefineObjectName, JS_DefineObjectNameComputed, js_function_apply, js_for_of_start_value, js_for_of_next_value, js_append_enumerate_value, } from "./interpreter.js";
+import { short_opcode_info } from "./opcodes.js";
+import { OP_DEFINE_METHOD_ENUMERABLE, OP_DEFINE_METHOD_METHOD, OP_DEFINE_METHOD_GETTER, JS_THROW_VAR_RO, JS_THROW_VAR_REDECL, JS_THROW_VAR_UNINITIALIZED, JS_THROW_ERROR_DELETE_SUPER, JS_THROW_ERROR_ITERATOR_THROW } from "./opcodes.js";
+/* parameters of the generated factory function, in order */
+export const JIT_FACTORY_PARAMS = ['$RT', '$cpool', '$b', '$U', '$D', '$Obj', '$set', '$del', '$getproto', '$DIRECT', '$P', '$G', '$GV',
+    '$CALL', '$CONSTRUCT', '$C'];
+export function jit_runtime_factory_args(RT, b) {
+    return [RT, b.cpool, b, JS_UNINITIALIZED, RT.DONE, RT.Obj, Reflect.set, Reflect.deleteProperty, Object.getPrototypeOf,
+        js_direct, RT.ctx.plain_object_proto, RT.ctx.global_obj, RT.ctx.global_var_obj, Function.prototype.call, Reflect.construct,
+        RT.ctx];
+}
+const runtimes = new WeakMap();
+/* `compile(b)` returns the compiled form of `b` if it is (or should now be) compiled, else null */
+export function make_jit_runtime(ctx, compile) {
+    let rt = runtimes.get(ctx);
+    if (!rt) {
+        rt = new JitRuntime(ctx, compile);
+        runtimes.set(ctx, rt);
+    }
+    return rt;
+}
+/* Call a compiled body through its private host-convention copy (`fd.priv`): the engine's
+   ordinary (non-construct) calls of compiled functions. */
+export function jit_runtime_call_priv(ctx, priv, this_obj, argv) {
+    const rt = ctx.rt;
+    if (rt.stack_depth >= rt.max_stack_depth)
+        return JS_ThrowStackOverflow(ctx);
+    rt.stack_depth++;
+    const sf = rt.current_stack_frame;
+    try {
+        return priv.apply(this_obj, argv);
+    }
+    catch (e) {
+        return js_host_exception_to_guest(ctx, e);
+    }
+    finally {
+        rt.current_stack_frame = sf;
+        rt.stack_depth--;
+    }
+}
+/* ---------------------------------------------------------------------
+   Retargetable wrappers
+
+   The function object of a closure created by the interpreter (or by compiled code before the
+   function's bytecode is compiled) is a wrapper that calls the compiled body as soon as one
+   exists for the closure (JSFunctionData.priv for calls, .ctor for construct calls) and the
+   engine otherwise, so its identity survives tier-up. The wrappers are generated once per
+   (kind, arity) without rest parameters: a call is `fd.priv.call(this, a0, a1)`, which the host
+   inlines (measured: the same cost as calling the compiled function directly, also for `new`).
+   --------------------------------------------------------------------- */
+/* the body reads `arguments` (or a rest parameter, or init_ctor's arguments): its wrapper must
+   forward the exact argument list. Cached on the bytecode. */
+export function jit_bytecode_uses_args(b) {
+    if (b.uses_args >= 0)
+        return b.uses_args === 1;
+    const buf = b.byte_code_buf, len = b.byte_code_len;
+    let r = 0;
+    for (let pos = 0; pos < len;) {
+        const op = buf[pos];
+        if (op === 13 /* OP.rest */ || op === 44 /* OP.init_ctor */) {
+            r = 1;
+            break;
+        }
+        if (op === 12 /* OP.special_object */) {
+            const k = buf[pos + 1];
+            if (k === 0 /* OPSpecialObject.ARGUMENTS */ || k === 1 /* OPSpecialObject.MAPPED_ARGUMENTS */) {
+                r = 1;
+                break;
+            }
+        }
+        const oi = short_opcode_info(op);
+        if (!oi || oi.size <= 0) {
+            r = 1;
+            break;
+        }
+        pos += oi.size;
+    }
+    b.uses_args = r;
+    return r === 1;
+}
+const MAX_WRAPPER_ARITY = 12;
+/* The wrapper code is generated once per function (bytecode), not once per arity: the call
+   `p.call(this, a0)` inside a wrapper shared by many functions sees many targets and the host
+   stops inlining it (measured in Bun: 1.75x the cost of a direct call, against 1x for a
+   per-function wrapper). Closures of the same function share their wrapper's code. */
+function wrapper_factory(b, is_ctor) {
+    /* cached per kind (constructible or not): a function is normally wrapped as one kind only */
+    const slot = is_ctor ? 'f' : 'm';
+    if (b.wrapper_factory === null)
+        b.wrapper_factory = { f: undefined, m: undefined };
+    const cached = b.wrapper_factory[slot];
+    if (cached !== undefined)
+        return cached;
+    const arity = b.arg_count;
+    let use_args = jit_bytecode_uses_args(b);
+    if (arity > MAX_WRAPPER_ARITY)
+        use_args = true;
+    let f;
+    const params = use_args ? '' : Array.from({ length: arity }, (_, i) => `a${i}`).join(', ');
+    const call_p = use_args ? 'p.apply(this, arguments)' : `p.call(this${params ? ', ' + params : ''})`;
+    const call_c = use_args ? 'c(t, new.target, ...arguments)' : `c(t, new.target${params ? ', ' + params : ''})`;
+    const src = is_ctor
+        ? `"use strict"; return function (fd, slow) { return function $w(${params}) {
+  if (new.target === undefined) { const p = fd.priv; if (p !== null) return ${call_p}; }
+  else { const c = fd.ctor; if (c !== null) { const xp = new.target.prototype; const t = (typeof xp === 'object' ? xp !== null : typeof xp === 'function') ? this : undefined; return ${call_c}; } }
+  return slow($w, this, new.target, arguments);
+}; };`
+        : `"use strict"; return function (fd, slow) { let w; const o = { $w(${params}) {
+  const p = fd.priv; if (p !== null) return ${call_p};
+  return slow(w, this, undefined, arguments);
+} }; w = o.$w; return w; };`;
+    try {
+        f = new Function(src)();
+    }
+    catch {
+        f = null; /* code generation unavailable */
+    }
+    b.wrapper_factory[slot] = f;
+    return f;
+}
+const slow_calls = new WeakMap();
+function slow_call(ctx) {
+    let s = slow_calls.get(ctx);
+    if (s === undefined) {
+        s = (w, t, nt, args) => {
+            const argv = new Array(args.length);
+            for (let i = 0; i < args.length; i++)
+                argv[i] = args[i];
+            const ret = nt !== undefined ? JS_CallInternal(ctx, w, nt, nt, argv, JS_CALL_FLAG_CONSTRUCTOR)
+                : JS_CallInternal(ctx, w, t, undefined, argv, 0);
+            if (ret === JS_EXCEPTION)
+                throw js_take_exception(ctx);
+            return ret;
+        };
+        slow_calls.set(ctx, s);
+    }
+    return s;
+}
+/* the function object of a closure of a normal function: a retargetable wrapper, or null when
+   wrappers cannot be generated (the engine then uses its generic wrapper) */
+export function jit_runtime_make_wrapper(ctx, b, var_refs, proto, is_ctor) {
+    const fac = wrapper_factory(b, is_ctor);
+    if (fac === null)
+        return null;
+    const fd = new JSFunctionData(b, var_refs);
+    const slow = slow_call(ctx);
+    const w = fac(fd, slow);
+    /* a host `function` has an own `prototype` object with a host prototype chain */
+    if (is_ctor)
+        w.prototype = undefined;
+    const m = js_init_host_function(ctx, w, is_ctor, '', b.defined_arg_count, proto, func_kind_to_class_id(b.func_kind));
+    m.func = fd;
+    m.realm = b.realm ?? ctx;
+    js_direct.set(w, (t, nt, ...args) => {
+        if (nt === undefined) {
+            const p = fd.priv;
+            if (p !== null)
+                return p.apply(t, args);
+        }
+        return slow(w, t, nt, args);
+    });
+    return w;
+}
+/* Call the direct entry of a compiled function from the engine (JS_CallInternal). */
+export function jit_runtime_call_compiled(ctx, direct, 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++;
+    const sf = rt.current_stack_frame;
+    try {
+        /* construct call (JS_CallConstructorInternal passes new_target as this_obj, like C): the
+           callee creates `this`. The interpreter's legacy constructor path calls back with the flag
+           cleared, new_target set and `this` already created: the compiled prologue keeps it. */
+        if (flags & JS_CALL_FLAG_CONSTRUCTOR)
+            return direct(undefined, new_target, ...argv);
+        return direct(this_obj, new_target, ...argv);
+    }
+    catch (e) {
+        return js_host_exception_to_guest(ctx, e);
+    }
+    finally {
+        rt.current_stack_frame = sf;
+        rt.stack_depth--;
+    }
+}
+function func_kind_to_class_id(kind) {
+    switch (kind) {
+        case 1 /* JSFunctionKind.GENERATOR */: return 16 /* JSClassID.GENERATOR_FUNCTION */;
+        case 2 /* JSFunctionKind.ASYNC */: return 48 /* JSClassID.ASYNC_FUNCTION */;
+        case 3 /* JSFunctionKind.ASYNC_GENERATOR */: return 52 /* JSClassID.ASYNC_GENERATOR_FUNCTION */;
+        default: return 13 /* JSClassID.BYTECODE_FUNCTION */;
+    }
+}
+export class JitRuntime {
+    ctx;
+    compile;
+    /* sentinel returned by iteration helpers */
+    DONE = Symbol('jit.done');
+    /* host constructor whose .prototype is the guest Object.prototype: `new $Obj()` creates an
+       object literal (measured ~0.7 ns vs ~27 ns for `{__proto__: proto}`) */
+    Obj;
+    constructor(ctx, compile) {
+        this.ctx = ctx;
+        this.compile = compile;
+        const Obj = function () { };
+        Obj.prototype = ctx.class_proto[1 /* JSClassID.OBJECT */];
+        this.Obj = Obj;
+    }
+    /* --- exception plumbing --- */
+    throw_pending() {
+        throw js_take_exception(this.ctx);
+    }
+    check(v) {
+        if (v === JS_EXCEPTION)
+            this.throw_pending();
+        return v;
+    }
+    checkn(r) {
+        if (r < 0)
+            this.throw_pending();
+    }
+    /* host exception -> guest exception value (guest values pass through) */
+    to_guest_exception(e) {
+        if (!(e instanceof Error) && e !== JS_EXCEPTION)
+            return e;
+        js_host_exception_to_guest(this.ctx, e);
+        return js_take_exception(this.ctx);
+    }
+    /* a guest `catch` (or the handler that runs `finally`, or closes an iterator) takes the
+       exception, unless it is uncatchable (an interrupt): that one goes on unwinding, without
+       running handlers, as in the interpreter */
+    catchable(e) {
+        const v = this.to_guest_exception(e);
+        if (JS_IsUncatchableError(this.ctx, v))
+            throw v;
+        return v;
+    }
+    /* --- interrupts --- */
+    /* compiled code polls at every function entry and loop head, as the interpreter polls at
+       its jumps. Generated code decrements `ctx.interrupt_counter` inline and calls
+       poll_handler() when it runs out; poll() is the same check as a call. Every 10000 polls
+       the runtime's interrupt handler is asked, and a request to stop throws an uncatchable
+       InternalError */
+    poll() {
+        if (--this.ctx.interrupt_counter > 0)
+            return;
+        this.poll_handler();
+    }
+    poll_handler() {
+        const ctx = this.ctx;
+        ctx.interrupt_counter = 10000;
+        const rt = ctx.rt;
+        if (rt.interrupt_handler === null || !rt.interrupt_handler(rt, rt.interrupt_opaque))
+            return;
+        JS_ThrowInternalError(ctx, 'interrupted');
+        JS_SetUncatchableError(ctx, rt.current_exception, true);
+        this.throw_pending();
+    }
+    throw_type_error(msg) { JS_ThrowTypeError(this.ctx, msg); this.throw_pending(); }
+    throw_reference_error(msg) { JS_ThrowReferenceError(this.ctx, msg); this.throw_pending(); }
+    throw_internal_error(msg) { JS_ThrowInternalError(this.ctx, msg); this.throw_pending(); }
+    throw_not_a_constructor(_f) { this.throw_type_error('not a constructor'); }
+    throw_uninitialized(b, idx, is_ref) {
+        JS_ThrowReferenceErrorUninitialized2(this.ctx, b, idx, is_ref);
+        this.throw_pending();
+    }
+    throw_error(atom, type) {
+        const ctx = this.ctx;
+        if (type === JS_THROW_VAR_RO)
+            JS_ThrowTypeErrorReadOnly(ctx, JS_PROP_THROW, atom);
+        else if (type === JS_THROW_VAR_REDECL)
+            JS_ThrowSyntaxErrorAtom(ctx, "redeclaration of '%s'", atom);
+        else if (type === JS_THROW_VAR_UNINITIALIZED)
+            JS_ThrowReferenceErrorUninitialized(ctx, atom);
+        else if (type === JS_THROW_ERROR_DELETE_SUPER)
+            JS_ThrowReferenceError(ctx, "unsupported reference to 'super'");
+        else if (type === JS_THROW_ERROR_ITERATOR_THROW)
+            JS_ThrowTypeError(ctx, 'iterator does not have a throw method');
+        else
+            JS_ThrowInternalError(ctx, 'invalid throw var type ' + type);
+        this.throw_pending();
+    }
+    /* --- values --- */
+    new_cell(v) { return new_var_ref_cell(v); }
+    new_object() { return this.check(JS_NewObject(this.ctx)); }
+    new_object_null() { return this.check(JS_NewObjectProto(this.ctx, null)); }
+    /* array literal: takes ownership of the host array and re-prototypes it */
+    array(elems) { return JS_NewArrayFrom(this.ctx, elems); }
+    atom_value(atom) { return JS_AtomToValue(this.ctx, atom); }
+    private_symbol(atom) { return JS_NewSymbolFromAtom(this.ctx, atom, JS_ATOM_TYPE_PRIVATE); }
+    sloppy_this(t) {
+        if (JS_IsObject(t))
+            return t;
+        if (t === undefined || t === null)
+            return this.ctx.global_obj;
+        return this.check(JS_ToObject(this.ctx, t));
+    }
+    regexp(pattern, flags) {
+        if (!hooks.js_regexp_constructor_internal)
+            this.throw_internal_error('RegExp is not available');
+        return this.check(hooks.js_regexp_constructor_internal(this.ctx, undefined, pattern, flags));
+    }
+    to_object(v) { return this.check(JS_ToObject(this.ctx, v)); }
+    to_propkey(v) { return this.check(JS_ToPropertyKey(this.ctx, v)); }
+    to_numeric(v) { return this.check(JS_ToNumericFree(this.ctx, v)); }
+    inc(v) { return this.check(js_unary_arith_slow(this.ctx, 2 /* JSUnaryOp.INC */, v)); }
+    dec(v) { return this.check(js_unary_arith_slow(this.ctx, 3 /* JSUnaryOp.DEC */, v)); }
+    in(k, o) {
+        const r = js_operator_in(this.ctx, k, o);
+        if (r < 0)
+            this.throw_pending();
+        return r !== 0;
+    }
+    instanceof(v, c) {
+        const r = JS_IsInstanceOf(this.ctx, v, c);
+        if (r < 0)
+            this.throw_pending();
+        return r !== 0;
+    }
+    get_prototype(o) { return this.check(JS_GetPrototype(this.ctx, o)); }
+    /* --- calls --- */
+    /* call with an explicit this when the callee has no direct entry (not a guest function) */
+    call_slow(f, thisv, args) {
+        return this.check(JS_CallInternal(this.ctx, f, thisv, undefined, args, 0));
+    }
+    construct_slow(f, new_target, args) {
+        return this.check(JS_CallConstructorInternal(this.ctx, f, new_target, args, 0));
+    }
+    /* method call on a primitive receiver (looked up on the guest prototype of its type) */
+    call_method_prim(o, atom, args) {
+        const f = this.check(JS_GetProperty(this.ctx, o, atom));
+        return this.check(JS_CallInternal(this.ctx, f, o, undefined, args, 0));
+    }
+    call_method_prim_key(o, key, args) {
+        const f = this.check(JS_GetPropertyValue(this.ctx, o, key));
+        return this.check(JS_CallInternal(this.ctx, f, o, undefined, args, 0));
+    }
+    apply(f, thisv, arr, magic) {
+        return this.check(js_function_apply(this.ctx, f, [thisv, arr], magic));
+    }
+    create_this(new_target) {
+        /* fast path: an ordinary guest function with an object `prototype` (the property read is
+           native, as the host does for `new`) */
+        if (typeof new_target === 'function' && js_meta.get(new_target)?.class_id !== 44 /* JSClassID.PROXY */) {
+            const p = new_target.prototype;
+            if (typeof p === 'object' && p !== null)
+                return Object.create(p);
+        }
+        return this.check(js_create_from_ctor(this.ctx, new_target, 1 /* JSClassID.OBJECT */));
+    }
+    /* `off` is the index of the first guest argument in the host `arguments` object (2 for the
+       direct convention, 0 for the natural one) */
+    init_ctor(self, new_target, args, off) {
+        if (new_target === undefined)
+            this.throw_type_error("class constructors must be invoked with 'new'");
+        const sup = this.check(JS_GetPrototype(this.ctx, self));
+        return this.check(JS_CallConstructor2(this.ctx, sup, new_target, Array.prototype.slice.call(args, off)));
+    }
+    arguments(args, off) {
+        return this.check(js_build_arguments_value(this.ctx, Array.prototype.slice.call(args, off)));
+    }
+    /* legacy arguments object aliasing the argument cells through accessor properties */
+    mapped_arguments(args, off, cells, self) {
+        const ctx = this.ctx;
+        const argv = Array.prototype.slice.call(args, off);
+        const argc = argv.length;
+        const val = this.check(JS_NewObjectProtoClass(ctx, ctx.class_proto[1 /* JSClassID.OBJECT */], 9 /* JSClassID.MAPPED_ARGUMENTS */));
+        JS_DefinePropertyValue(ctx, val, JS_ATOM_length, argc, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+        const n = Math.min(argc, cells.length);
+        for (let i = 0; i < n; i++) {
+            const cell = cells[i];
+            const getter = js_new_host_function(ctx, () => cell.get(), false, '', 0, ctx.function_proto, 12 /* JSClassID.C_FUNCTION */);
+            const setter = js_new_host_function(ctx, (_t, _nt, a) => { cell.set(a[0]); return undefined; }, false, '', 1, ctx.function_proto, 12 /* JSClassID.C_FUNCTION */);
+            Reflect.defineProperty(val, i, { get: getter, set: setter, enumerable: true, configurable: true });
+        }
+        for (let i = n; i < argc; i++)
+            this.checkn(JS_DefinePropertyValueUint32(ctx, val, i, argv[i], JS_PROP_C_W_E));
+        JS_DefinePropertyValue(ctx, val, JS_ATOM_Symbol_iterator, ctx.array_proto_values, JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
+        JS_DefinePropertyValue(ctx, val, JS_ATOM_callee, self, JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
+        return val;
+    }
+    rest(args, off, first) {
+        const argv = Array.prototype.slice.call(args, off);
+        return this.check(js_build_rest(this.ctx, first, argv.length, argv));
+    }
+    home_object(self) {
+        return JS_GetFunctionData(self)?.home_object ?? undefined;
+    }
+    /* --- closures and classes --- */
+    /* guest function object for bytecode `b` with the given variable references (fclosure).
+       When `b` is compiled the object is the generated forwarder, else an interpreter wrapper
+       that the call hook tiers up later. */
+    closure(b, var_refs, _parent) {
+        const ctx = this.ctx;
+        const class_id = func_kind_to_class_id(b.func_kind);
+        const proto = ctx.class_proto[class_id] ?? ctx.function_proto;
+        let fo = null;
+        if (b.func_kind === 0 /* JSFunctionKind.NORMAL */ && !b.no_jit) {
+            const c = this.compile(b);
+            if (c) {
+                const [f, direct, mkpriv] = c.make(var_refs);
+                const m = new JSObjectMeta(13 /* JSClassID.BYTECODE_FUNCTION */);
+                m.func = new JSFunctionData(b, var_refs);
+                m.func.compiled = direct;
+                m.func.mkpriv = mkpriv;
+                m.is_constructor = b.has_prototype;
+                m.realm = b.realm ?? ctx;
+                js_meta.set(f, m);
+                js_direct.set(f, direct);
+                Object.setPrototypeOf(f, proto);
+                /* a host `function` has an own `prototype` object with a host prototype chain */
+                if (Object.prototype.hasOwnProperty.call(f, 'prototype'))
+                    f.prototype = undefined;
+                fo = f;
+            }
+        }
+        if (fo === null)
+            fo = this.check(js_closure_from_refs(ctx, b, var_refs, proto, b.has_prototype));
+        let name_atom = b.func_name;
+        if (name_atom === JS_ATOM_NULL)
+            name_atom = JS_ATOM_empty_string;
+        js_function_set_properties(ctx, fo, name_atom, b.defined_arg_count);
+        if (b.func_kind & 1 /* JSFunctionKind.GENERATOR */) {
+            const proto_class_id = (b.func_kind === 3 /* JSFunctionKind.ASYNC_GENERATOR */) ? 53 /* JSClassID.ASYNC_GENERATOR */ : 43 /* JSClassID.GENERATOR */;
+            const gproto = this.check(JS_NewObjectProto(ctx, ctx.class_proto[proto_class_id]));
+            JS_DefinePropertyValue(ctx, fo, JS_ATOM_prototype, gproto, JS_PROP_WRITABLE);
+        }
+        else if (b.has_prototype) {
+            const pobj = this.check(JS_NewObject(ctx));
+            this.checkn(JS_DefinePropertyValue(ctx, pobj, JS_ATOM_constructor, fo, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE));
+            this.checkn(JS_DefinePropertyValue(ctx, fo, JS_ATOM_prototype, pobj, JS_PROP_WRITABLE));
+        }
+        return fo;
+    }
+    define_class(name, parent_class, b, class_flags, var_refs, is_computed_name) {
+        const r = js_define_class(this.ctx, is_computed_name ? JS_ATOM_NULL : name, class_flags, parent_class, b, var_refs, is_computed_name, is_computed_name ? name : undefined);
+        if (r === null)
+            this.throw_pending();
+        return r;
+    }
+    set_home_object(f, home) { js_method_set_home_object(this.ctx, f, home); }
+    set_name(f, atom) { this.checkn(JS_DefineObjectName(this.ctx, f, atom, JS_PROP_CONFIGURABLE)); }
+    set_name_computed(f, name) { this.checkn(JS_DefineObjectNameComputed(this.ctx, f, name, JS_PROP_CONFIGURABLE)); }
+    define_method(obj, key, fn, op_flags, computed) {
+        const ctx = this.ctx;
+        let atom;
+        if (computed) {
+            atom = JS_ValueToAtom(ctx, key);
+            if (atom === JS_ATOM_NULL)
+                this.throw_pending();
+        }
+        else {
+            atom = key;
+        }
+        let fl = JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE | JS_PROP_HAS_ENUMERABLE | JS_PROP_THROW;
+        if (op_flags & OP_DEFINE_METHOD_ENUMERABLE)
+            fl |= JS_PROP_ENUMERABLE;
+        op_flags &= 3;
+        let value = undefined, getter = undefined, setter = undefined;
+        if (op_flags === OP_DEFINE_METHOD_METHOD) {
+            value = fn;
+            fl |= JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE;
+        }
+        else if (op_flags === OP_DEFINE_METHOD_GETTER) {
+            getter = fn;
+            fl |= JS_PROP_HAS_GET;
+        }
+        else {
+            setter = fn;
+            fl |= JS_PROP_HAS_SET;
+        }
+        this.checkn(js_method_set_properties(ctx, fn, atom, fl, obj));
+        this.checkn(JS_DefineProperty(ctx, obj, atom, value, getter, setter, fl));
+    }
+    set_proto(o, proto) {
+        if (JS_IsObject(proto) || proto === null)
+            this.checkn(JS_SetPrototypeInternal(this.ctx, o, proto, true));
+    }
+    check_brand(o, f) {
+        const r = JS_CheckBrand(this.ctx, o, f);
+        if (r < 0)
+            this.throw_pending();
+        if (!r)
+            this.throw_type_error('invalid brand on object');
+    }
+    add_brand(o, f) { this.checkn(JS_AddBrand(this.ctx, o, f)); }
+    get_private_field(o, name) { return this.check(JS_GetPrivateField(this.ctx, o, name)); }
+    put_private_field(o, name, v) { this.checkn(JS_SetPrivateField(this.ctx, o, name, v)); }
+    define_private_field(o, name, v) { this.checkn(JS_DefinePrivateField(this.ctx, o, name, v)); }
+    private_in(o, name) {
+        const r = js_operator_private_in(this.ctx, o, name);
+        if (r < 0)
+            this.throw_pending();
+        return r !== 0;
+    }
+    /* --- globals --- */
+    check_var(atom) {
+        const r = JS_CheckGlobalVar(this.ctx, atom);
+        if (r < 0)
+            this.throw_pending();
+        return r !== 0;
+    }
+    get_global(atom, throw_ref_error) {
+        return this.check(JS_GetGlobalVar(this.ctx, atom, throw_ref_error ? 1 : 0));
+    }
+    /* JS_SetGlobalVar with an explicit strict flag (the engine's version reads the strictness
+       from the current interpreter frame, which does not exist for compiled code) */
+    put_global(atom, v, flag, strict) {
+        const ctx = this.ctx;
+        if (flag === 1 || !strict || (JS_AtomToKey(ctx, atom) in ctx.global_var_obj)) {
+            this.checkn(JS_SetGlobalVar(ctx, atom, v, flag));
+            return;
+        }
+        const ret = JS_HasProperty(ctx, ctx.global_obj, atom);
+        if (ret < 0)
+            this.throw_pending();
+        if (!ret) {
+            JS_ThrowReferenceErrorNotDefined(ctx, atom);
+            this.throw_pending();
+        }
+        this.checkn(JS_SetPropertyInternal(ctx, ctx.global_obj, atom, v, ctx.global_obj, JS_PROP_THROW));
+    }
+    put_global_strict(atom, defined, v) {
+        const ctx = this.ctx;
+        if (!defined) {
+            JS_ThrowReferenceErrorNotDefined(ctx, atom);
+            this.throw_pending();
+        }
+        if (JS_AtomToKey(ctx, atom) in ctx.global_var_obj) {
+            this.checkn(JS_SetGlobalVar(ctx, atom, v, 2));
+            return;
+        }
+        this.checkn(JS_SetPropertyInternal(ctx, ctx.global_obj, atom, v, ctx.global_obj, JS_PROP_THROW));
+    }
+    check_define_var(atom, flags) { if (JS_CheckDefineGlobalVar(this.ctx, atom, flags))
+        this.throw_pending(); }
+    define_var(atom, flags) { this.checkn(JS_DefineGlobalVar(this.ctx, atom, flags)); }
+    define_func(atom, v, flags) { this.checkn(JS_DefineGlobalFunction(this.ctx, atom, v, flags)); }
+    get_global_ref(atom) {
+        const r = JS_GetGlobalVarRef(this.ctx, atom);
+        if (!r)
+            this.throw_pending();
+        return r;
+    }
+    delete_global(atom) {
+        const r = JS_DeleteProperty(this.ctx, this.ctx.global_obj, atom, 0);
+        if (r < 0)
+            this.throw_pending();
+        return r !== 0;
+    }
+    /* --- properties (slow paths: primitive bases and runtime-dependent semantics) --- */
+    get_field(o, atom) { return this.check(JS_GetProperty(this.ctx, o, atom)); }
+    get_field_str(o, name) {
+        return this.check(JS_GetProperty(this.ctx, o, this.ctx.rt.atoms.newAtomStr(name)));
+    }
+    get_length(o) { return this.check(JS_GetProperty(this.ctx, o, JS_ATOM_length)); }
+    get_el(o, k) { return this.check(JS_GetPropertyValue(this.ctx, o, k)); }
+    put_field(o, atom, v, strict) {
+        this.checkn(JS_SetPropertyInternal(this.ctx, o, atom, v, o, strict ? JS_PROP_THROW : 0));
+    }
+    put_el(o, k, v, strict) {
+        this.checkn(JS_SetPropertyValue(this.ctx, o, k, v, strict ? JS_PROP_THROW : 0));
+    }
+    delete(o, k, strict) {
+        const atom = JS_ValueToAtom(this.ctx, k);
+        if (atom === JS_ATOM_NULL)
+            this.throw_pending();
+        const r = JS_DeleteProperty(this.ctx, o, atom, strict ? JS_PROP_THROW : 0);
+        if (r < 0)
+            this.throw_pending();
+        return r !== 0;
+    }
+    define_field(o, atom, v) {
+        this.checkn(JS_DefinePropertyValue(this.ctx, o, atom, v, JS_PROP_C_W_E | JS_PROP_THROW));
+    }
+    define_array_el(arr, pos, v) {
+        this.checkn(JS_DefinePropertyValueValue(this.ctx, arr, pos, v, JS_PROP_C_W_E | JS_PROP_THROW));
+    }
+    append(arr, pos, src) {
+        if (typeof pos !== 'number')
+            this.throw_internal_error('invalid index for append');
+        const r = js_append_enumerate_value(this.ctx, arr, pos, src);
+        if (r < 0)
+            this.throw_pending();
+        return r;
+    }
+    copy_data_properties(target, source, excluded) {
+        if (JS_CopyDataProperties(this.ctx, target, source, excluded, false))
+            this.throw_pending();
+    }
+    get_ref_value(o, k, strict) {
+        const ctx = this.ctx;
+        const atom = JS_ValueToAtom(ctx, k);
+        if (atom === JS_ATOM_NULL)
+            this.throw_pending();
+        if (o === undefined) {
+            JS_ThrowReferenceErrorNotDefined(ctx, atom);
+            this.throw_pending();
+        }
+        const r = JS_HasProperty(ctx, o, atom);
+        if (r < 0)
+            this.throw_pending();
+        if (!r) {
+            if (strict) {
+                JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                this.throw_pending();
+            }
+            return undefined;
+        }
+        return this.check(JS_GetProperty(ctx, o, atom));
+    }
+    put_ref_value(o, k, v, strict) {
+        const ctx = this.ctx;
+        const atom = JS_ValueToAtom(ctx, k);
+        if (atom === JS_ATOM_NULL)
+            this.throw_pending();
+        if (o === undefined) {
+            if (strict) {
+                JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                this.throw_pending();
+            }
+            o = ctx.global_obj;
+        }
+        const r = JS_HasProperty(ctx, o, atom);
+        if (r < 0)
+            this.throw_pending();
+        if (!r && strict) {
+            JS_ThrowReferenceErrorNotDefined(ctx, atom);
+            this.throw_pending();
+        }
+        this.checkn(JS_SetPropertyInternal(ctx, o, atom, v, o, strict ? JS_PROP_THROW : 0));
+    }
+    get_super_value(thisv, o, k) {
+        const atom = JS_ValueToAtom(this.ctx, k);
+        if (atom === JS_ATOM_NULL)
+            this.throw_pending();
+        return this.check(JS_GetPropertyInternal(this.ctx, o, atom, thisv, false));
+    }
+    put_super_value(thisv, o, k, v) {
+        if (!JS_IsObject(o)) {
+            JS_ThrowTypeErrorNotAnObject(this.ctx);
+            this.throw_pending();
+        }
+        const atom = JS_ValueToAtom(this.ctx, k);
+        if (atom === JS_ATOM_NULL)
+            this.throw_pending();
+        this.checkn(JS_SetPropertyInternal(this.ctx, o, atom, v, thisv, JS_PROP_THROW));
+    }
+    /* --- iteration --- */
+    for_in_start(o) { return this.check(build_for_in_iterator(this.ctx, o)); }
+    for_in_next(it) {
+        const pdone = { done: 0 };
+        const v = this.check(js_for_in_next(this.ctx, it, pdone));
+        return pdone.done ? this.DONE : v;
+    }
+    get_iterator(o) { return this.check(JS_GetIterator(this.ctx, o, false)); }
+    for_of_start(o) {
+        const r = js_for_of_start_value(this.ctx, o, false);
+        if (r === null)
+            this.throw_pending();
+        return r;
+    }
+    for_of_next(iter, next) {
+        if (iter === undefined)
+            return this.DONE;
+        const r = js_for_of_next_value(this.ctx, iter, next);
+        if (r === null)
+            this.throw_pending();
+        return r.done ? this.DONE : r.value;
+    }
+    iterator_close(iter) {
+        if (JS_IteratorClose(this.ctx, iter, false) < 0)
+            this.throw_pending();
+    }
+    /* close an iterator while an exception is propagating: errors from return() are ignored */
+    iterator_close_exc(iter) {
+        if (iter === undefined)
+            return;
+        const ctx = this.ctx;
+        const method = JS_GetProperty(ctx, iter, JS_ATOM_return);
+        if (JS_IsException(method)) {
+            JS_GetException(ctx);
+            return;
+        }
+        if (method === undefined || method === null)
+            return;
+        const r = JS_Call(ctx, method, iter, []);
+        if (JS_IsException(r))
+            JS_GetException(ctx);
+    }
+    iterator_call(iter, val, flags) {
+        const ctx = this.ctx;
+        const method = this.check(JS_GetProperty(ctx, iter, (flags & 1) ? JS_ATOM_throw : JS_ATOM_return));
+        if (method === undefined || method === null)
+            return this.DONE;
+        return this.check(JS_Call(ctx, method, iter, (flags & 2) ? [] : [val]));
+    }
+}
+//# sourceMappingURL=jit_runtime.js.map