jseption 0.0.2 → 0.0.4

package/dist/bytecode.js

@@ -0,0 +1,1071 @@
+/*
+ * Bytecode serialization: JS_WriteObject / JS_ReadObject.
+ *
+ * Writes the function tree produced by JS_EVAL_FLAG_COMPILE_ONLY to bytes and
+ * reads it back into any runtime of the same jseption version, so that a
+ * script can be compiled ahead of time and loaded without parsing. The design
+ * follows quickjs.c (bc_write_* / bc_read_*): atoms are runtime specific, so
+ * the writer emits an atom table and renumbers every atom (in the function
+ * fields and in the atom operands of the byte code, found by walking the
+ * opcodes by their format), and the reader interns the strings in its own
+ * runtime and patches the operands back.
+ *
+ * Only load bytecode you produced yourself: like in QuickJS, the reader checks
+ * the format (header, bounds, tags, indices, opcode boundaries, checksum), not
+ * the semantics of the byte code, and hand-made byte code can reach states the
+ * parser never emits.
+ *
+ * Format (all integers are unsigned LEB128 unless stated otherwise):
+ *
+ *   magic        4 bytes "JSBC"
+ *   format       u8 (BC_FORMAT)
+ *   version      length + ASCII bytes: the jseption package version
+ *   flags        BC_FLAG_*
+ *   strings      count, then per string (length << 1 | wide), then the
+ *                byte length and bytes of the Latin-1 blob, then the
+ *                byte length and bytes of the UTF-16LE blob
+ *   atoms        count, then the string index of each atom
+ *   root         a tagged value (BC_TAG_FUNCTION_BYTECODE)
+ *   checksum     8 bytes: two 32-bit little-endian sums (Fletcher style, over
+ *                little-endian 32-bit words) of everything before them
+ *
+ * Atom references (function fields and byte code operands) use the encoding of
+ * bc_atom_to_idx: predefined atoms (< JS_ATOM_END) and tagged integer atoms are
+ * kept, other atoms become JS_ATOM_END + their index in the atom table.
+ */
+import { JS_ATOM_END, JS_ATOM_raw, JS_ATOM_TAG_INT, JS_ATOM_TYPE_STRING, __JS_AtomIsTaggedInt } from "./atoms.js";
+import { JS_GetFunctionData, JS_ThrowSyntaxError, JS_ThrowTypeError, JS_NewArray, JS_DefinePropertyValue, JS_DefinePropertyValueUint32, JS_IsException, JS_PROP_ENUMERABLE, hooks } from "./quickjs.js";
+import { JSClosureVar, JSFunctionBytecode, JSVarDef, JSModuleDef, JSReqModuleEntry, JSExportEntry, JSStarExportEntry, JSImportEntry } from "./values.js";
+import { js_module_set_function, hooks_bytecode } from "./module.js";
+import { short_opcode_info } from "./opcodes.js";
+import { JSEPTION_VERSION } from "./version.js";
+/* keep each function's source text (Function.prototype.toString); off by default */
+export const JS_WRITE_OBJ_SOURCE = 1 << 0;
+export const BC_MAGIC = [0x4a, 0x53, 0x42, 0x43]; /* "JSBC" */
+export const BC_FORMAT = 1;
+const BC_FLAG_SOURCE = 1 << 0;
+/* JSFunctionBytecode flags */
+const F_HAS_PROTOTYPE = 1 << 0;
+const F_SIMPLE_PARAMS = 1 << 1;
+const F_DERIVED_CTOR = 1 << 2;
+const F_HOME_OBJECT = 1 << 3;
+const F_NEW_TARGET = 1 << 4;
+const F_SUPER_CALL = 1 << 5;
+const F_SUPER = 1 << 6;
+const F_ARGUMENTS = 1 << 7;
+const F_HAS_DEBUG = 1 << 8;
+const F_EVAL = 1 << 9;
+const F_HAS_SOURCE = 1 << 10;
+/* JSVarDef / JSClosureVar flags */
+const V_CONST = 1 << 0;
+const V_LEXICAL = 1 << 1;
+const V_CAPTURED = 1 << 2;
+const V_STATIC_PRIVATE = 1 << 3;
+const V_LOCAL = 1 << 4;
+const V_ARG = 1 << 5;
+const VAR_KIND_MAX = 9 /* JSVarKind.PRIVATE_GETTER_SETTER */;
+/* the size of each opcode of the final byte code (0: not an opcode) and what its operand
+   holds, indexed by the opcode byte, so that walking the byte code costs a few array reads
+   per instruction */
+const OPK_ATOM = 1, OPK_CONST = 2, OPK_CONST8 = 3, OPK_FCLOSURE = 4, OPK_FCLOSURE8 = 5;
+const OP_SIZE = new Uint8Array(256);
+const OP_KIND = new Uint8Array(256);
+for (let op = 0; op < 256; op++) {
+    const info = short_opcode_info(op);
+    if (info === undefined)
+        continue;
+    OP_SIZE[op] = info.size;
+    switch (info.fmt) {
+        case 23 /* OpFmt.atom */:
+        case 24 /* OpFmt.atom_u8 */:
+        case 25 /* OpFmt.atom_u16 */:
+        case 26 /* OpFmt.atom_label_u8 */:
+        case 27 /* OpFmt.atom_label_u16 */:
+            OP_KIND[op] = OPK_ATOM;
+            break;
+        case 21 /* OpFmt.const */:
+            OP_KIND[op] = OPK_CONST;
+            break;
+        case 8 /* OpFmt.const8 */:
+            OP_KIND[op] = OPK_CONST8;
+            break;
+    }
+}
+OP_KIND[3 /* OP.fclosure */] = OPK_FCLOSURE;
+OP_KIND[194 /* OP.fclosure8 */] = OPK_FCLOSURE8;
+/* ---------------------------------------------------------------------
+   Writer
+   --------------------------------------------------------------------- */
+class BCWriteError extends Error {
+}
+class ByteBuf {
+    buf = new Uint8Array(4096);
+    len = 0;
+    f64 = new Float64Array(1);
+    f64b = new Uint8Array(this.f64.buffer);
+    grow(n) {
+        let size = this.buf.length * 2;
+        while (size < this.len + n)
+            size *= 2;
+        const b = new Uint8Array(size);
+        b.set(this.buf.subarray(0, this.len));
+        this.buf = b;
+    }
+    u8(v) {
+        if (this.len >= this.buf.length)
+            this.grow(1);
+        this.buf[this.len++] = v;
+    }
+    leb(v) {
+        if (this.len + 5 > this.buf.length)
+            this.grow(5);
+        const buf = this.buf;
+        while (v >= 0x80) {
+            buf[this.len++] = (v % 0x80) | 0x80;
+            v = Math.floor(v / 0x80);
+        }
+        buf[this.len++] = v;
+    }
+    sleb(v) {
+        this.leb(v < 0 ? -2 * v - 1 : 2 * v);
+    }
+    f64v(v) {
+        if (this.len + 8 > this.buf.length)
+            this.grow(8);
+        this.f64[0] = v;
+        const b = this.f64b;
+        /* little endian on the wire */
+        if (LITTLE_ENDIAN)
+            for (let i = 0; i < 8; i++)
+                this.buf[this.len++] = b[i];
+        else
+            for (let i = 7; i >= 0; i--)
+                this.buf[this.len++] = b[i];
+    }
+    bytes(src) {
+        if (this.len + src.length > this.buf.length)
+            this.grow(src.length);
+        this.buf.set(src, this.len);
+        this.len += src.length;
+    }
+    result() { return this.buf.slice(0, this.len); }
+}
+const LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+class BCWriter {
+    ctx;
+    flags;
+    out = new ByteBuf();
+    strings = [];
+    string_idx = new Map();
+    atoms = []; /* string index of each atom table entry */
+    atom_idx = new Map();
+    constructor(ctx, flags) {
+        this.ctx = ctx;
+        this.flags = flags;
+    }
+    string_ref(s) {
+        let i = this.string_idx.get(s);
+        if (i === undefined) {
+            i = this.strings.length;
+            this.strings.push(s);
+            this.string_idx.set(s, i);
+        }
+        return i;
+    }
+    /* bc_atom_to_idx */
+    atom_to_idx(atom) {
+        if (atom < JS_ATOM_END || __JS_AtomIsTaggedInt(atom))
+            return atom;
+        let i = this.atom_idx.get(atom);
+        if (i === undefined) {
+            const atoms = this.ctx.rt.atoms;
+            if (atoms.getType(atom) !== JS_ATOM_TYPE_STRING)
+                throw new BCWriteError('cannot serialize a symbol atom: ' + atoms.toDisplayStr(atom));
+            i = this.atoms.length;
+            this.atoms.push(this.string_ref(atoms.toStr(atom)));
+            this.atom_idx.set(atom, i);
+        }
+        return JS_ATOM_END + i;
+    }
+    atom(atom) { this.out.leb(this.atom_to_idx(atom)); }
+    value(v) {
+        const out = this.out;
+        switch (typeof v) {
+            case 'undefined':
+                out.u8(2 /* BCTag.UNDEFINED */);
+                return;
+            case 'boolean':
+                out.u8(v ? 4 /* BCTag.TRUE */ : 3 /* BCTag.FALSE */);
+                return;
+            case 'number':
+                if ((v | 0) === v && !(v === 0 && 1 / v < 0)) {
+                    out.u8(5 /* BCTag.INT32 */);
+                    out.sleb(v);
+                }
+                else {
+                    out.u8(6 /* BCTag.FLOAT64 */);
+                    out.f64v(v);
+                }
+                return;
+            case 'string':
+                out.u8(7 /* BCTag.STRING */);
+                out.leb(this.string_ref(v));
+                return;
+            case 'bigint':
+                out.u8(8 /* BCTag.BIG_INT */);
+                out.leb(this.string_ref(v.toString()));
+                return;
+            case 'object':
+                if (v === null) {
+                    out.u8(1 /* BCTag.NULL */);
+                    return;
+                }
+                if (v instanceof JSFunctionBytecode) {
+                    this.function(v);
+                    return;
+                }
+                if (Array.isArray(v) && Object.isFrozen(v) && Object.prototype.hasOwnProperty.call(v, 'raw')) {
+                    this.template(v);
+                    return;
+                }
+                break;
+        }
+        throw new BCWriteError('unsupported constant in the function tree: ' + describe(v));
+    }
+    /* a template object (js_parse_template): frozen array of cooked strings with a frozen
+       'raw' array of raw strings */
+    template(arr) {
+        const out = this.out;
+        const raw = arr.raw;
+        if (!Array.isArray(raw) || raw.length !== arr.length)
+            throw new BCWriteError('malformed template object');
+        out.u8(10 /* BCTag.TEMPLATE_OBJECT */);
+        out.leb(arr.length);
+        for (let i = 0; i < arr.length; i++) {
+            const c = arr[i], r = raw[i];
+            if ((c !== undefined && typeof c !== 'string') || typeof r !== 'string')
+                throw new BCWriteError('malformed template object');
+            out.leb(c === undefined ? 0 : this.string_ref(c) + 1);
+            out.leb(this.string_ref(r));
+        }
+    }
+    function(b) {
+        const out = this.out;
+        const keep_source = (this.flags & JS_WRITE_OBJ_SOURCE) !== 0 && b.has_debug && b.debug.source !== null;
+        let flags = 0;
+        if (b.has_prototype)
+            flags |= F_HAS_PROTOTYPE;
+        if (b.has_simple_parameter_list)
+            flags |= F_SIMPLE_PARAMS;
+        if (b.is_derived_class_constructor)
+            flags |= F_DERIVED_CTOR;
+        if (b.need_home_object)
+            flags |= F_HOME_OBJECT;
+        if (b.new_target_allowed)
+            flags |= F_NEW_TARGET;
+        if (b.super_call_allowed)
+            flags |= F_SUPER_CALL;
+        if (b.super_allowed)
+            flags |= F_SUPER;
+        if (b.arguments_allowed)
+            flags |= F_ARGUMENTS;
+        if (b.has_debug)
+            flags |= F_HAS_DEBUG;
+        if (b.is_direct_or_indirect_eval)
+            flags |= F_EVAL;
+        if (keep_source)
+            flags |= F_HAS_SOURCE;
+        if (b.vardefs.length !== b.arg_count + b.var_count)
+            throw new BCWriteError('inconsistent variable count');
+        out.u8(9 /* BCTag.FUNCTION_BYTECODE */);
+        out.leb(flags);
+        out.u8(b.js_mode);
+        out.u8(b.func_kind);
+        this.atom(b.func_name);
+        out.leb(b.arg_count);
+        out.leb(b.var_count);
+        out.leb(b.defined_arg_count);
+        out.leb(b.stack_size);
+        out.leb(b.closure_var.length);
+        out.leb(b.cpool.length);
+        out.leb(b.byte_code_len);
+        for (const vd of b.vardefs) {
+            this.atom(vd.var_name);
+            out.leb(vd.scope_level);
+            out.sleb(vd.scope_next);
+            out.u8((vd.is_const ? V_CONST : 0) | (vd.is_lexical ? V_LEXICAL : 0) | (vd.is_captured ? V_CAPTURED : 0) |
+                (vd.is_static_private ? V_STATIC_PRIVATE : 0));
+            out.u8(vd.var_kind);
+            out.sleb(vd.func_pool_idx);
+        }
+        for (const cv of b.closure_var) {
+            this.atom(cv.var_name);
+            out.leb(cv.var_idx);
+            out.u8((cv.is_const ? V_CONST : 0) | (cv.is_lexical ? V_LEXICAL : 0) | (cv.is_local ? V_LOCAL : 0) |
+                (cv.is_arg ? V_ARG : 0));
+            out.u8(cv.var_kind);
+        }
+        out.bytes(this.byte_code(b));
+        if (b.has_debug) {
+            this.atom(b.debug.filename);
+            const pc2line = b.debug.pc2line;
+            if (pc2line === null)
+                out.leb(0);
+            else {
+                out.leb(pc2line.length);
+                out.bytes(pc2line);
+            }
+            if (keep_source)
+                out.leb(this.string_ref(b.debug.source));
+        }
+        for (const v of b.cpool)
+            this.value(v);
+    }
+    /* a compiled module (JS_WriteModule): its requests, entries and body function */
+    module(m) {
+        const out = this.out;
+        out.u8(11 /* BCTag.MODULE */);
+        this.atom(m.module_name);
+        out.leb(m.req_module_entries.length);
+        for (const rme of m.req_module_entries) {
+            this.atom(rme.module_name);
+            if (rme.attributes === null) {
+                out.leb(0);
+            }
+            else {
+                const keys = Object.keys(rme.attributes);
+                out.leb(keys.length + 1);
+                for (const k of keys) {
+                    out.leb(this.string_ref(k));
+                    out.leb(this.string_ref(rme.attributes[k]));
+                }
+            }
+        }
+        out.leb(m.export_entries.length);
+        for (const me of m.export_entries) {
+            out.u8(me.export_type);
+            if (me.export_type === 0 /* JSExportType.LOCAL */) {
+                out.leb(me.var_idx);
+            }
+            else {
+                out.leb(me.req_module_idx);
+                this.atom(me.local_name);
+            }
+            this.atom(me.export_name);
+        }
+        out.leb(m.star_export_entries.length);
+        for (const se of m.star_export_entries)
+            out.leb(se.req_module_idx);
+        out.leb(m.import_entries.length);
+        for (const mi of m.import_entries) {
+            out.leb(mi.var_idx);
+            out.u8(mi.is_star ? 1 : 0);
+            this.atom(mi.import_name);
+            out.leb(mi.req_module_idx);
+        }
+        out.u8(m.has_tla ? 1 : 0);
+        this.function(m.func_bytecode);
+    }
+    /* the byte code with its atom operands renumbered (JS_WriteFunctionBytecode) */
+    byte_code(b) {
+        const len = b.byte_code_len;
+        const bc = b.byte_code_buf.slice(0, len);
+        let pos = 0;
+        while (pos < len) {
+            const op = bc[pos], size = OP_SIZE[op];
+            if (size === 0)
+                throw new BCWriteError(`invalid opcode ${op} at pc ${pos}`);
+            if (OP_KIND[op] === OPK_ATOM && pos + 5 <= len) {
+                const atom = (bc[pos + 1] | (bc[pos + 2] << 8) | (bc[pos + 3] << 16) | (bc[pos + 4] << 24)) >>> 0;
+                const v = this.atom_to_idx(atom);
+                bc[pos + 1] = v;
+                bc[pos + 2] = v >>> 8;
+                bc[pos + 3] = v >>> 16;
+                bc[pos + 4] = v >>> 24;
+            }
+            pos += size;
+        }
+        if (pos !== len)
+            throw new BCWriteError('truncated instruction at the end of the byte code');
+        return bc;
+    }
+    finish(body) {
+        const out = new ByteBuf();
+        for (const c of BC_MAGIC)
+            out.u8(c);
+        out.u8(BC_FORMAT);
+        out.leb(JSEPTION_VERSION.length);
+        for (let i = 0; i < JSEPTION_VERSION.length; i++)
+            out.u8(JSEPTION_VERSION.charCodeAt(i));
+        out.leb(this.flags & JS_WRITE_OBJ_SOURCE ? BC_FLAG_SOURCE : 0);
+        /* string table */
+        const strings = this.strings;
+        out.leb(strings.length);
+        let narrow_len = 0, wide_len = 0;
+        const wide = [];
+        for (const s of strings) {
+            let w = false;
+            for (let i = 0; i < s.length; i++)
+                if (s.charCodeAt(i) > 0xff) {
+                    w = true;
+                    break;
+                }
+            wide.push(w);
+            out.leb(s.length * 2 + (w ? 1 : 0));
+            if (w)
+                wide_len += s.length;
+            else
+                narrow_len += s.length;
+        }
+        out.leb(narrow_len);
+        const narrow = new Uint8Array(narrow_len);
+        let p = 0;
+        for (let k = 0; k < strings.length; k++) {
+            if (wide[k])
+                continue;
+            const s = strings[k];
+            for (let i = 0; i < s.length; i++)
+                narrow[p++] = s.charCodeAt(i);
+        }
+        out.bytes(narrow);
+        out.leb(wide_len * 2);
+        const wbuf = new Uint8Array(wide_len * 2);
+        p = 0;
+        for (let k = 0; k < strings.length; k++) {
+            if (!wide[k])
+                continue;
+            const s = strings[k];
+            for (let i = 0; i < s.length; i++) {
+                const c = s.charCodeAt(i);
+                wbuf[p++] = c;
+                wbuf[p++] = c >>> 8;
+            }
+        }
+        out.bytes(wbuf);
+        /* atom table */
+        out.leb(this.atoms.length);
+        for (const i of this.atoms)
+            out.leb(i);
+        out.bytes(body.buf.subarray(0, body.len));
+        const [a, b] = checksum(out.buf, out.len);
+        for (const v of [a, b]) {
+            out.u8(v & 0xff);
+            out.u8((v >>> 8) & 0xff);
+            out.u8((v >>> 16) & 0xff);
+            out.u8(v >>> 24);
+        }
+        return out.result();
+    }
+}
+function describe(v) {
+    if (typeof v === 'function')
+        return 'function object';
+    if (Array.isArray(v))
+        return 'array';
+    if (typeof v === 'object' && v !== null)
+        return 'object';
+    return typeof v;
+}
+const CHECKSUM_SIZE = 8;
+/* Fletcher-style sums of buf[0, end) taken as little-endian 32-bit words (the tail bytewise):
+   detects truncation and corrupted bytes, at a quarter of the cost of a bytewise checksum
+   (it is not a defence against deliberate tampering) */
+function checksum(buf, end) {
+    const n = end >>> 2;
+    let a = 1, b = 0;
+    if (LITTLE_ENDIAN) {
+        if (buf.byteOffset & 3)
+            buf = buf.slice(0, end);
+        const w = new Int32Array(buf.buffer, buf.byteOffset, n);
+        for (let i = 0; i < n; i++) {
+            a = (a + w[i]) | 0;
+            b = (b + a) | 0;
+        }
+    }
+    else {
+        for (let i = 0; i < n; i++) {
+            const p = i * 4;
+            a = (a + (buf[p] | (buf[p + 1] << 8) | (buf[p + 2] << 16) | (buf[p + 3] << 24))) | 0;
+            b = (b + a) | 0;
+        }
+    }
+    for (let i = n * 4; i < end; i++) {
+        a = (a + buf[i]) | 0;
+        b = (b + a) | 0;
+    }
+    return [a >>> 0, b >>> 0];
+}
+/* Serialize the function returned by JS_Eval(..., JS_EVAL_FLAG_COMPILE_ONLY) (or any
+   bytecode function that does not close over variables). Returns null with a pending
+   exception on failure. */
+export function JS_WriteObject(ctx, obj, flags = 0) {
+    if (obj instanceof JSModuleDef) {
+        /* a module compiled with JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY */
+        if (obj.kind !== 0 /* JSModuleKind.JS */ || obj.func_bytecode === null) {
+            JS_ThrowTypeError(ctx, 'JS_WriteObject: only JavaScript modules can be written');
+            return null;
+        }
+        const w = new BCWriter(ctx, flags);
+        try {
+            w.module(obj);
+            return w.finish(w.out);
+        }
+        catch (e) {
+            if (e instanceof BCWriteError) {
+                JS_ThrowTypeError(ctx, 'JS_WriteObject: ' + e.message);
+                return null;
+            }
+            throw e;
+        }
+    }
+    const fd = JS_GetFunctionData(obj);
+    if (fd === null) {
+        JS_ThrowTypeError(ctx, 'JS_WriteObject: not a bytecode function (expected the result of JS_EVAL_FLAG_COMPILE_ONLY)');
+        return null;
+    }
+    const b = fd.function_bytecode;
+    if (b.closure_var.length !== 0) {
+        JS_ThrowTypeError(ctx, 'JS_WriteObject: the function closes over variables of an enclosing scope');
+        return null;
+    }
+    const w = new BCWriter(ctx, flags);
+    try {
+        w.function(b);
+        const body = w.out;
+        return w.finish(body);
+    }
+    catch (e) {
+        if (e instanceof BCWriteError) {
+            JS_ThrowTypeError(ctx, 'JS_WriteObject: ' + e.message);
+            return null;
+        }
+        throw e;
+    }
+}
+/* ---------------------------------------------------------------------
+   Reader
+   --------------------------------------------------------------------- */
+class BCReadError extends Error {
+}
+const MAX_DEPTH = 2000;
+/* parser limits (define_var / add_arg: at most 65534 each; compute_stack_size: JS_STACK_SIZE_MAX) */
+const MAX_LOCALS = 65535;
+const MAX_STACK_SIZE = 65534;
+class BCReader {
+    ctx;
+    pos = 0;
+    end;
+    strings = [];
+    atoms = [];
+    keep_source = false;
+    depth = 0;
+    f64 = new Float64Array(1);
+    f64b = new Uint8Array(this.f64.buffer);
+    buf;
+    /* the reader works on a private copy of the input: the byte code is patched in place and
+       the functions keep views of it (one copy instead of two per function) */
+    constructor(ctx, input) {
+        this.ctx = ctx;
+        this.buf = input.slice();
+        this.end = this.buf.length;
+    }
+    fail(msg) { throw new BCReadError(msg); }
+    truncated() { throw new BCReadError('read after the end of the buffer'); }
+    u8() {
+        if (this.pos >= this.end)
+            this.truncated();
+        return this.buf[this.pos++];
+    }
+    leb() {
+        const buf = this.buf;
+        let pos = this.pos;
+        if (pos >= this.end)
+            this.truncated();
+        let a = buf[pos++];
+        if (a < 0x80) {
+            this.pos = pos;
+            return a;
+        }
+        let v = a & 0x7f, mul = 0x80;
+        for (let i = 1;; i++) {
+            if (pos >= this.end)
+                this.truncated();
+            if (i >= 5)
+                this.fail('invalid LEB128 number');
+            a = buf[pos++];
+            v += (a & 0x7f) * mul;
+            if (a < 0x80)
+                break;
+            mul *= 0x80;
+        }
+        if (v > 0xffffffff)
+            this.fail('invalid LEB128 number');
+        this.pos = pos;
+        return v;
+    }
+    sleb() {
+        const v = this.leb();
+        return (v % 2 === 1) ? -((v + 1) / 2) : v / 2;
+    }
+    f64v() {
+        if (this.pos + 8 > this.end)
+            this.truncated();
+        const b = this.f64b, buf = this.buf;
+        if (LITTLE_ENDIAN)
+            for (let i = 0; i < 8; i++)
+                b[i] = buf[this.pos++];
+        else
+            for (let i = 7; i >= 0; i--)
+                b[i] = buf[this.pos++];
+        return this.f64[0];
+    }
+    /* a count whose items each take at least one byte */
+    count() {
+        const n = this.leb();
+        if (n > this.end - this.pos)
+            this.truncated();
+        return n;
+    }
+    bytes(n) {
+        if (n > this.end - this.pos)
+            this.truncated();
+        const r = this.buf.subarray(this.pos, this.pos + n);
+        this.pos += n;
+        return r;
+    }
+    string() {
+        const i = this.leb();
+        if (i >= this.strings.length)
+            this.fail(`invalid string index ${i}`);
+        return this.strings[i];
+    }
+    /* bc_idx_to_atom */
+    idx_to_atom(v) {
+        if (v < JS_ATOM_END || v >= JS_ATOM_TAG_INT)
+            return v;
+        const i = v - JS_ATOM_END;
+        if (i >= this.atoms.length)
+            this.fail(`invalid atom index ${v}`);
+        return this.atoms[i];
+    }
+    atom() { return this.idx_to_atom(this.leb()); }
+    header() {
+        const buf = this.buf;
+        if (buf.length < BC_MAGIC.length + 2 + CHECKSUM_SIZE)
+            this.truncated();
+        for (let i = 0; i < BC_MAGIC.length; i++)
+            if (buf[i] !== BC_MAGIC[i])
+                this.fail('not jseption bytecode (bad magic number)');
+        this.pos = BC_MAGIC.length;
+        const format = this.u8();
+        const vlen = this.leb();
+        if (vlen > 64)
+            this.fail('not jseption bytecode (bad header)');
+        if (vlen > this.end - this.pos)
+            this.truncated();
+        let version = '';
+        for (let i = 0; i < vlen; i++)
+            version += String.fromCharCode(buf[this.pos++]);
+        if (format !== BC_FORMAT || version !== JSEPTION_VERSION)
+            this.fail(`bytecode version mismatch: written by jseption ${version} (format ${format}), ` +
+                `this is jseption ${JSEPTION_VERSION} (format ${BC_FORMAT})`);
+        /* everything after the version is covered by the checksum */
+        if (buf.length - CHECKSUM_SIZE < this.pos)
+            this.truncated();
+        this.end = buf.length - CHECKSUM_SIZE;
+        const [a, b] = checksum(buf, this.end);
+        const u32 = (p) => (buf[p] | (buf[p + 1] << 8) | (buf[p + 2] << 16) | (buf[p + 3] << 24)) >>> 0;
+        if (u32(this.end) !== a || u32(this.end + 4) !== b)
+            this.fail('checksum mismatch (truncated or corrupted bytecode)');
+        const flags = this.leb();
+        if (flags & ~BC_FLAG_SOURCE)
+            this.fail('unknown flags');
+        this.keep_source = (flags & BC_FLAG_SOURCE) !== 0;
+    }
+    string_table() {
+        const n = this.count();
+        const lens = new Array(n);
+        let narrow_len = 0, wide_len = 0;
+        for (let i = 0; i < n; i++) {
+            const v = this.leb();
+            lens[i] = v;
+            if (v & 1)
+                wide_len += (v - 1) / 2;
+            else
+                narrow_len += v / 2;
+        }
+        if (this.leb() !== narrow_len)
+            this.fail('inconsistent string table');
+        if (narrow_len > this.end - this.pos)
+            this.truncated();
+        const narrow = latin1_decode(this.buf, this.pos, this.pos + narrow_len);
+        this.pos += narrow_len;
+        if (this.leb() !== wide_len * 2)
+            this.fail('inconsistent string table');
+        if (wide_len * 2 > this.end - this.pos)
+            this.truncated();
+        const wide = utf16_decode(this.buf, this.pos, wide_len);
+        this.pos += wide_len * 2;
+        const strings = this.strings = new Array(n);
+        let np = 0, wp = 0;
+        for (let i = 0; i < n; i++) {
+            const v = lens[i];
+            if (v & 1) {
+                const l = (v - 1) / 2;
+                strings[i] = wide.slice(wp, wp + l);
+                wp += l;
+            }
+            else {
+                const l = v / 2;
+                strings[i] = narrow.slice(np, np + l);
+                np += l;
+            }
+        }
+    }
+    atom_table() {
+        const n = this.count();
+        const atoms = this.atoms = new Array(n);
+        const table = this.ctx.rt.atoms;
+        for (let i = 0; i < n; i++)
+            atoms[i] = table.newAtomStr(this.string());
+    }
+    value() {
+        const tag = this.u8();
+        switch (tag) {
+            case 1 /* BCTag.NULL */: return null;
+            case 2 /* BCTag.UNDEFINED */: return undefined;
+            case 3 /* BCTag.FALSE */: return false;
+            case 4 /* BCTag.TRUE */: return true;
+            case 5 /* BCTag.INT32 */: {
+                const v = this.sleb();
+                if ((v | 0) !== v)
+                    this.fail('invalid int32');
+                return v;
+            }
+            case 6 /* BCTag.FLOAT64 */: return this.f64v();
+            case 7 /* BCTag.STRING */: return this.string();
+            case 8 /* BCTag.BIG_INT */: {
+                const s = this.string();
+                if (!/^-?[0-9]+$/.test(s))
+                    this.fail('invalid BigInt');
+                return BigInt(s);
+            }
+            case 9 /* BCTag.FUNCTION_BYTECODE */: return this.function();
+            case 10 /* BCTag.TEMPLATE_OBJECT */: return this.template();
+        }
+        return this.fail(`invalid tag ${tag} at offset ${this.pos - 1}`);
+    }
+    template() {
+        const ctx = this.ctx;
+        const n = this.count();
+        const arr = JS_NewArray(ctx), raw = JS_NewArray(ctx);
+        if (JS_IsException(arr) || JS_IsException(raw))
+            this.fail('out of memory');
+        for (let i = 0; i < n; i++) {
+            const c = this.leb();
+            let cooked;
+            if (c !== 0) {
+                if (c > this.strings.length)
+                    this.fail(`invalid string index ${c - 1}`);
+                cooked = this.strings[c - 1];
+            }
+            JS_DefinePropertyValueUint32(ctx, raw, i, this.string(), JS_PROP_ENUMERABLE);
+            JS_DefinePropertyValueUint32(ctx, arr, i, cooked, JS_PROP_ENUMERABLE);
+        }
+        JS_DefinePropertyValue(ctx, arr, JS_ATOM_raw, raw, 0);
+        Object.freeze(raw);
+        Object.freeze(arr);
+        return arr;
+    }
+    function() {
+        if (++this.depth > MAX_DEPTH)
+            this.fail('functions nested too deeply');
+        const b = new JSFunctionBytecode();
+        const flags = this.leb();
+        if (flags >= F_HAS_SOURCE << 1)
+            this.fail('invalid function flags');
+        b.has_prototype = (flags & F_HAS_PROTOTYPE) !== 0;
+        b.has_simple_parameter_list = (flags & F_SIMPLE_PARAMS) !== 0;
+        b.is_derived_class_constructor = (flags & F_DERIVED_CTOR) !== 0;
+        b.need_home_object = (flags & F_HOME_OBJECT) !== 0;
+        b.new_target_allowed = (flags & F_NEW_TARGET) !== 0;
+        b.super_call_allowed = (flags & F_SUPER_CALL) !== 0;
+        b.super_allowed = (flags & F_SUPER) !== 0;
+        b.arguments_allowed = (flags & F_ARGUMENTS) !== 0;
+        b.has_debug = (flags & F_HAS_DEBUG) !== 0;
+        b.is_direct_or_indirect_eval = (flags & F_EVAL) !== 0;
+        b.js_mode = this.u8();
+        const kind = this.u8();
+        if (kind > 3 /* JSFunctionKind.ASYNC_GENERATOR */)
+            this.fail('invalid function kind');
+        b.func_kind = kind;
+        b.func_name = this.atom();
+        b.arg_count = this.count();
+        b.var_count = this.count();
+        b.defined_arg_count = this.leb();
+        b.stack_size = this.leb();
+        /* the parser's limits: the interpreter sizes each frame from these, so an out-of-range
+           value would make it allocate a huge frame instead of failing here */
+        if (b.arg_count >= MAX_LOCALS || b.var_count >= MAX_LOCALS)
+            this.fail('too many variables');
+        if (b.defined_arg_count > b.arg_count)
+            this.fail('invalid defined argument count');
+        if (b.stack_size > MAX_STACK_SIZE)
+            this.fail(`invalid stack size ${b.stack_size}`);
+        const closure_count = this.count();
+        const cpool_count = this.count();
+        const bc_len = this.count();
+        const nvars = b.arg_count + b.var_count;
+        const vardefs = b.vardefs = new Array(nvars);
+        for (let i = 0; i < nvars; i++) {
+            const vd = new JSVarDef(this.atom());
+            vd.scope_level = this.leb();
+            vd.scope_next = this.sleb();
+            const f = this.u8();
+            vd.is_const = (f & V_CONST) !== 0;
+            vd.is_lexical = (f & V_LEXICAL) !== 0;
+            vd.is_captured = (f & V_CAPTURED) !== 0;
+            vd.is_static_private = (f & V_STATIC_PRIVATE) !== 0;
+            const k = this.u8();
+            if (k > VAR_KIND_MAX)
+                this.fail('invalid variable kind');
+            vd.var_kind = k;
+            vd.func_pool_idx = this.sleb();
+            vardefs[i] = vd;
+        }
+        const closure_var = b.closure_var = new Array(closure_count);
+        for (let i = 0; i < closure_count; i++) {
+            const cv = new JSClosureVar();
+            cv.var_name = this.atom();
+            cv.var_idx = this.leb();
+            const f = this.u8();
+            cv.is_const = (f & V_CONST) !== 0;
+            cv.is_lexical = (f & V_LEXICAL) !== 0;
+            cv.is_local = (f & V_LOCAL) !== 0;
+            cv.is_arg = (f & V_ARG) !== 0;
+            const k = this.u8();
+            if (k > VAR_KIND_MAX)
+                this.fail('invalid variable kind');
+            cv.var_kind = k;
+            closure_var[i] = cv;
+        }
+        const bc = this.bytes(bc_len);
+        b.byte_code_buf = bc;
+        b.byte_code_len = bc_len;
+        if (b.has_debug) {
+            b.debug.filename = this.atom();
+            const n = this.leb();
+            b.debug.pc2line = this.bytes(n);
+            if (flags & F_HAS_SOURCE) {
+                if (!this.keep_source)
+                    this.fail('invalid function flags');
+                const src = this.string();
+                b.debug.source = src;
+                b.debug.source_len = src.length;
+            }
+        }
+        else if (flags & F_HAS_SOURCE) {
+            this.fail('invalid function flags');
+        }
+        const cpool = b.cpool = new Array(cpool_count);
+        for (let i = 0; i < cpool_count; i++)
+            cpool[i] = this.value();
+        this.fixup_byte_code(b);
+        b.realm = this.ctx;
+        this.depth--;
+        return b;
+    }
+    /* a compiled module (JS_ReadModule) */
+    module() {
+        const m = new JSModuleDef(this.atom());
+        m.realm = this.ctx;
+        const nreq = this.count();
+        for (let i = 0; i < nreq; i++) {
+            const name = this.atom();
+            const n = this.leb();
+            let attrs = null;
+            if (n > 0) {
+                if (n - 1 > this.end - this.pos)
+                    this.truncated();
+                attrs = Object.create(null);
+                for (let j = 0; j < n - 1; j++) {
+                    const k = this.string();
+                    attrs[k] = this.string();
+                }
+            }
+            m.req_module_entries.push(new JSReqModuleEntry(name, attrs));
+        }
+        const req_idx = () => {
+            const i = this.leb();
+            if (i >= nreq)
+                this.fail(`invalid module request index ${i}`);
+            return i;
+        };
+        const nexp = this.count();
+        const local_exports = [];
+        for (let i = 0; i < nexp; i++) {
+            const type = this.u8();
+            let me;
+            if (type === 0 /* JSExportType.LOCAL */) {
+                const var_idx = this.leb();
+                local_exports.push(var_idx);
+                me = new JSExportEntry(0, this.atom(), 0 /* JSExportType.LOCAL */);
+                me.var_idx = var_idx;
+                me.local_name = me.export_name;
+            }
+            else if (type === 1 /* JSExportType.INDIRECT */) {
+                const idx = req_idx();
+                const local_name = this.atom();
+                me = new JSExportEntry(local_name, this.atom(), 1 /* JSExportType.INDIRECT */);
+                me.req_module_idx = idx;
+            }
+            else {
+                this.fail('invalid export entry');
+            }
+            m.export_entries.push(me);
+        }
+        const nstar = this.count();
+        for (let i = 0; i < nstar; i++)
+            m.star_export_entries.push(new JSStarExportEntry(req_idx()));
+        const nimp = this.count();
+        const imports = [];
+        for (let i = 0; i < nimp; i++) {
+            const var_idx = this.leb();
+            const is_star = this.u8();
+            if (is_star > 1)
+                this.fail('invalid import entry');
+            const mi = new JSImportEntry(var_idx, is_star === 1, this.atom());
+            mi.req_module_idx = req_idx();
+            m.import_entries.push(mi);
+            imports.push({ var_idx, is_star: is_star === 1 });
+        }
+        const tla = this.u8();
+        if (tla > 1)
+            this.fail('invalid module flags');
+        m.has_tla = tla === 1;
+        if (this.u8() !== 9 /* BCTag.FUNCTION_BYTECODE */)
+            this.fail('the module body is not a function');
+        const b = this.function();
+        if (b.func_kind !== 2 /* JSFunctionKind.ASYNC */)
+            this.fail('the module body is not an async function');
+        /* the entries index the closure variables of the body */
+        const ncv = b.closure_var.length;
+        for (const v of local_exports)
+            if (v >= ncv)
+                this.fail(`invalid export variable index ${v}`);
+        for (const { var_idx, is_star } of imports) {
+            if (var_idx >= ncv)
+                this.fail(`invalid import variable index ${var_idx}`);
+            if (b.closure_var[var_idx].is_local !== is_star)
+                this.fail('invalid import variable');
+        }
+        js_module_set_function(m, b);
+        return m;
+    }
+    /* patch the atom operands and check the instruction boundaries and the constant pool
+       indices (JS_ReadFunctionBytecode) */
+    fixup_byte_code(b) {
+        const bc = b.byte_code_buf, len = b.byte_code_len, cpool = b.cpool;
+        let pos = 0;
+        const natoms = this.atoms.length, atoms = this.atoms;
+        while (pos < len) {
+            const op = bc[pos], size = OP_SIZE[op];
+            if (size === 0)
+                this.fail(`invalid opcode ${op} at pc ${pos}`);
+            if (pos + size > len)
+                this.fail(`truncated instruction at pc ${pos}`);
+            const kind = OP_KIND[op];
+            if (kind !== 0) {
+                if (kind === OPK_ATOM) {
+                    const v = (bc[pos + 1] | (bc[pos + 2] << 8) | (bc[pos + 3] << 16) | (bc[pos + 4] << 24)) >>> 0;
+                    if (v >= JS_ATOM_END && v < JS_ATOM_TAG_INT) {
+                        const i = v - JS_ATOM_END;
+                        if (i >= natoms)
+                            this.fail(`invalid atom index ${v} at pc ${pos}`);
+                        const atom = atoms[i];
+                        bc[pos + 1] = atom;
+                        bc[pos + 2] = atom >>> 8;
+                        bc[pos + 3] = atom >>> 16;
+                        bc[pos + 4] = atom >>> 24;
+                    }
+                }
+                else {
+                    const idx = (kind === OPK_CONST8 || kind === OPK_FCLOSURE8) ? bc[pos + 1]
+                        : (bc[pos + 1] | (bc[pos + 2] << 8) | (bc[pos + 3] << 16) | (bc[pos + 4] << 24)) >>> 0;
+                    if (idx >= cpool.length)
+                        this.fail(`invalid constant pool index ${idx} at pc ${pos}`);
+                    if (kind >= OPK_FCLOSURE && !(cpool[idx] instanceof JSFunctionBytecode))
+                        this.fail(`closure of a constant that is not a function at pc ${pos}`);
+                }
+            }
+            pos += size;
+        }
+    }
+}
+/* buf[start, end) as a Latin-1 string */
+function latin1_decode(buf, start, end) {
+    const CHUNK = 8192;
+    if (end - start <= CHUNK)
+        return String.fromCharCode.apply(null, buf.subarray(start, end));
+    const parts = [];
+    for (let i = start; i < end; i += CHUNK)
+        parts.push(String.fromCharCode.apply(null, buf.subarray(i, Math.min(end, i + CHUNK))));
+    return parts.join('');
+}
+/* n UTF-16LE code units at buf[start] as a string (lone surrogates preserved) */
+function utf16_decode(buf, start, n) {
+    if (n === 0)
+        return '';
+    let units;
+    if (LITTLE_ENDIAN) {
+        units = new Uint16Array(buf.slice(start, start + 2 * n).buffer);
+    }
+    else {
+        units = new Uint16Array(n);
+        for (let i = 0; i < n; i++)
+            units[i] = buf[start + 2 * i] | (buf[start + 2 * i + 1] << 8);
+    }
+    const CHUNK = 8192;
+    const parts = [];
+    for (let i = 0; i < n; i += CHUNK)
+        parts.push(String.fromCharCode.apply(null, units.subarray(i, Math.min(n, i + CHUNK))));
+    return parts.join('');
+}
+/* Read bytes produced by JS_WriteObject into this context. Returns a function object to
+   run with JS_EvalFunction, or JS_EXCEPTION with a SyntaxError pending when the input is
+   not valid bytecode of this jseption version. */
+export function JS_ReadObject(ctx, buf) {
+    if (!(buf instanceof Uint8Array))
+        return JS_ThrowTypeError(ctx, 'JS_ReadObject: expected a Uint8Array');
+    const r = new BCReader(ctx, buf);
+    let b;
+    try {
+        r.header();
+        r.string_table();
+        r.atom_table();
+        const tag = r.u8();
+        if (tag === 11 /* BCTag.MODULE */) {
+            const m = r.module();
+            if (r.pos !== r.end)
+                r.fail('trailing bytes after the root value');
+            return m;
+        }
+        if (tag !== 9 /* BCTag.FUNCTION_BYTECODE */)
+            r.fail('the root value is not a function');
+        b = r.function();
+        if (r.pos !== r.end)
+            r.fail('trailing bytes after the root value');
+    }
+    catch (e) {
+        if (e instanceof BCReadError)
+            return JS_ThrowSyntaxError(ctx, 'JS_ReadObject: ' + e.message);
+        if (e instanceof RangeError)
+            return JS_ThrowSyntaxError(ctx, 'JS_ReadObject: ' + e.message);
+        throw e;
+    }
+    if (b.closure_var.length !== 0)
+        return JS_ThrowSyntaxError(ctx, 'JS_ReadObject: the root function has closure variables');
+    return hooks.js_closure(ctx, b, null, null);
+}
+hooks_bytecode.read = (ctx, bytes) => JS_ReadObject(ctx, bytes);
+//# sourceMappingURL=bytecode.js.map