@ruby/wasm-wasi 2.3.0 → 2.4.0

package/dist/cjs/bindgen/intrinsics.d.ts

@@ -0,0 +1,13 @@
+export function data_view(mem: any): DataView;
+export function to_uint32(val: any): number;
+export function utf8_encode(s: any, realloc: any, memory: any): number;
+export function throw_invalid_bool(): void;
+export const UTF8_DECODER: TextDecoder;
+export let UTF8_ENCODED_LEN: number;
+export class Slab {
+    list: any[];
+    head: number;
+    insert(val: any): number;
+    get(idx: any): any;
+    remove(idx: any): any;
+}

package/dist/cjs/bindgen/intrinsics.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throw_invalid_bool = exports.Slab = exports.UTF8_ENCODED_LEN = exports.utf8_encode = exports.UTF8_DECODER = exports.to_uint32 = exports.data_view = void 0;
+let DATA_VIEW = new DataView(new ArrayBuffer());
+function data_view(mem) {
+    if (DATA_VIEW.buffer !== mem.buffer)
+        DATA_VIEW = new DataView(mem.buffer);
+    return DATA_VIEW;
+}
+exports.data_view = data_view;
+function to_uint32(val) {
+    return val >>> 0;
+}
+exports.to_uint32 = to_uint32;
+exports.UTF8_DECODER = new TextDecoder('utf-8');
+const UTF8_ENCODER = new TextEncoder('utf-8');
+function utf8_encode(s, realloc, memory) {
+    if (typeof s !== 'string')
+        throw new TypeError('expected a string');
+    if (s.length === 0) {
+        exports.UTF8_ENCODED_LEN = 0;
+        return 1;
+    }
+    let alloc_len = 0;
+    let ptr = 0;
+    let writtenTotal = 0;
+    while (s.length > 0) {
+        ptr = realloc(ptr, alloc_len, 1, alloc_len + s.length);
+        alloc_len += s.length;
+        const { read, written } = UTF8_ENCODER.encodeInto(s, new Uint8Array(memory.buffer, ptr + writtenTotal, alloc_len - writtenTotal));
+        writtenTotal += written;
+        s = s.slice(read);
+    }
+    if (alloc_len > writtenTotal)
+        ptr = realloc(ptr, alloc_len, 1, writtenTotal);
+    exports.UTF8_ENCODED_LEN = writtenTotal;
+    return ptr;
+}
+exports.utf8_encode = utf8_encode;
+exports.UTF8_ENCODED_LEN = 0;
+class Slab {
+    constructor() {
+        this.list = [];
+        this.head = 0;
+    }
+    insert(val) {
+        if (this.head >= this.list.length) {
+            this.list.push({
+                next: this.list.length + 1,
+                val: undefined,
+            });
+        }
+        const ret = this.head;
+        const slot = this.list[ret];
+        this.head = slot.next;
+        slot.next = -1;
+        slot.val = val;
+        return ret;
+    }
+    get(idx) {
+        if (idx >= this.list.length)
+            throw new RangeError('handle index not valid');
+        const slot = this.list[idx];
+        if (slot.next === -1)
+            return slot.val;
+        throw new RangeError('handle index not valid');
+    }
+    remove(idx) {
+        const ret = this.get(idx); // validate the slot
+        const slot = this.list[idx];
+        slot.val = undefined;
+        slot.next = this.head;
+        this.head = idx;
+        return ret;
+    }
+}
+exports.Slab = Slab;
+function throw_invalid_bool() {
+    throw new RangeError("invalid variant discriminant for bool");
+}
+exports.throw_invalid_bool = throw_invalid_bool;

package/dist/cjs/bindgen/rb-abi-guest.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RbAbiValue = exports.RbIseq = exports.RbAbiGuest = void 0;
+const intrinsics_js_1 = require("./intrinsics.js");
+class RbAbiGuest {
+    constructor() {
+        this._resource0_slab = new intrinsics_js_1.Slab();
+        this._resource1_slab = new intrinsics_js_1.Slab();
+    }
+    addToImports(imports) {
+        if (!("canonical_abi" in imports))
+            imports["canonical_abi"] = {};
+        imports.canonical_abi['resource_drop_rb-iseq'] = i => {
+            this._resource0_slab.remove(i).drop();
+        };
+        imports.canonical_abi['resource_clone_rb-iseq'] = i => {
+            const obj = this._resource0_slab.get(i);
+            return this._resource0_slab.insert(obj.clone());
+        };
+        imports.canonical_abi['resource_get_rb-iseq'] = i => {
+            return this._resource0_slab.get(i)._wasm_val;
+        };
+        imports.canonical_abi['resource_new_rb-iseq'] = i => {
+            const registry = this._registry0;
+            return this._resource0_slab.insert(new RbIseq(i, this));
+        };
+        imports.canonical_abi['resource_drop_rb-abi-value'] = i => {
+            this._resource1_slab.remove(i).drop();
+        };
+        imports.canonical_abi['resource_clone_rb-abi-value'] = i => {
+            const obj = this._resource1_slab.get(i);
+            return this._resource1_slab.insert(obj.clone());
+        };
+        imports.canonical_abi['resource_get_rb-abi-value'] = i => {
+            return this._resource1_slab.get(i)._wasm_val;
+        };
+        imports.canonical_abi['resource_new_rb-abi-value'] = i => {
+            const registry = this._registry1;
+            return this._resource1_slab.insert(new RbAbiValue(i, this));
+        };
+    }
+    async instantiate(module, imports) {
+        imports = imports || {};
+        this.addToImports(imports);
+        if (module instanceof WebAssembly.Instance) {
+            this.instance = module;
+        }
+        else if (module instanceof WebAssembly.Module) {
+            this.instance = await WebAssembly.instantiate(module, imports);
+        }
+        else if (module instanceof ArrayBuffer || module instanceof Uint8Array) {
+            const { instance } = await WebAssembly.instantiate(module, imports);
+            this.instance = instance;
+        }
+        else {
+            const { instance } = await WebAssembly.instantiateStreaming(module, imports);
+            this.instance = instance;
+        }
+        this._exports = this.instance.exports;
+        this._registry0 = new FinalizationRegistry(this._exports['canonical_abi_drop_rb-iseq']);
+        this._registry1 = new FinalizationRegistry(this._exports['canonical_abi_drop_rb-abi-value']);
+    }
+    rubyShowVersion() {
+        this._exports['ruby-show-version: func() -> ()']();
+    }
+    rubyInit() {
+        this._exports['ruby-init: func() -> ()']();
+    }
+    rubySysinit(arg0) {
+        const memory = this._exports.memory;
+        const realloc = this._exports["cabi_realloc"];
+        const vec1 = arg0;
+        const len1 = vec1.length;
+        const result1 = realloc(0, 0, 4, len1 * 8);
+        for (let i = 0; i < vec1.length; i++) {
+            const e = vec1[i];
+            const base = result1 + i * 8;
+            const ptr0 = (0, intrinsics_js_1.utf8_encode)(e, realloc, memory);
+            const len0 = intrinsics_js_1.UTF8_ENCODED_LEN;
+            (0, intrinsics_js_1.data_view)(memory).setInt32(base + 4, len0, true);
+            (0, intrinsics_js_1.data_view)(memory).setInt32(base + 0, ptr0, true);
+        }
+        this._exports['ruby-sysinit: func(args: list<string>) -> ()'](result1, len1);
+    }
+    rubyOptions(arg0) {
+        const memory = this._exports.memory;
+        const realloc = this._exports["cabi_realloc"];
+        const vec1 = arg0;
+        const len1 = vec1.length;
+        const result1 = realloc(0, 0, 4, len1 * 8);
+        for (let i = 0; i < vec1.length; i++) {
+            const e = vec1[i];
+            const base = result1 + i * 8;
+            const ptr0 = (0, intrinsics_js_1.utf8_encode)(e, realloc, memory);
+            const len0 = intrinsics_js_1.UTF8_ENCODED_LEN;
+            (0, intrinsics_js_1.data_view)(memory).setInt32(base + 4, len0, true);
+            (0, intrinsics_js_1.data_view)(memory).setInt32(base + 0, ptr0, true);
+        }
+        const ret = this._exports['ruby-options: func(args: list<string>) -> handle<rb-iseq>'](result1, len1);
+        return this._resource0_slab.remove(ret);
+    }
+    rubyScript(arg0) {
+        const memory = this._exports.memory;
+        const realloc = this._exports["cabi_realloc"];
+        const ptr0 = (0, intrinsics_js_1.utf8_encode)(arg0, realloc, memory);
+        const len0 = intrinsics_js_1.UTF8_ENCODED_LEN;
+        this._exports['ruby-script: func(name: string) -> ()'](ptr0, len0);
+    }
+    rubyInitLoadpath() {
+        this._exports['ruby-init-loadpath: func() -> ()']();
+    }
+    rbEvalStringProtect(arg0) {
+        const memory = this._exports.memory;
+        const realloc = this._exports["cabi_realloc"];
+        const ptr0 = (0, intrinsics_js_1.utf8_encode)(arg0, realloc, memory);
+        const len0 = intrinsics_js_1.UTF8_ENCODED_LEN;
+        const ret = this._exports['rb-eval-string-protect: func(str: string) -> tuple<handle<rb-abi-value>, s32>'](ptr0, len0);
+        return [this._resource1_slab.remove((0, intrinsics_js_1.data_view)(memory).getInt32(ret + 0, true)), (0, intrinsics_js_1.data_view)(memory).getInt32(ret + 4, true)];
+    }
+    rbFuncallvProtect(arg0, arg1, arg2) {
+        const memory = this._exports.memory;
+        const realloc = this._exports["cabi_realloc"];
+        const obj0 = arg0;
+        if (!(obj0 instanceof RbAbiValue))
+            throw new TypeError('expected instance of RbAbiValue');
+        const vec2 = arg2;
+        const len2 = vec2.length;
+        const result2 = realloc(0, 0, 4, len2 * 4);
+        for (let i = 0; i < vec2.length; i++) {
+            const e = vec2[i];
+            const base = result2 + i * 4;
+            const obj1 = e;
+            if (!(obj1 instanceof RbAbiValue))
+                throw new TypeError('expected instance of RbAbiValue');
+            (0, intrinsics_js_1.data_view)(memory).setInt32(base + 0, this._resource1_slab.insert(obj1.clone()), true);
+        }
+        const ret = this._exports['rb-funcallv-protect: func(recv: handle<rb-abi-value>, mid: u32, args: list<handle<rb-abi-value>>) -> tuple<handle<rb-abi-value>, s32>'](this._resource1_slab.insert(obj0.clone()), (0, intrinsics_js_1.to_uint32)(arg1), result2, len2);
+        return [this._resource1_slab.remove((0, intrinsics_js_1.data_view)(memory).getInt32(ret + 0, true)), (0, intrinsics_js_1.data_view)(memory).getInt32(ret + 4, true)];
+    }
+    rbIntern(arg0) {
+        const memory = this._exports.memory;
+        const realloc = this._exports["cabi_realloc"];
+        const ptr0 = (0, intrinsics_js_1.utf8_encode)(arg0, realloc, memory);
+        const len0 = intrinsics_js_1.UTF8_ENCODED_LEN;
+        const ret = this._exports['rb-intern: func(name: string) -> u32'](ptr0, len0);
+        return ret >>> 0;
+    }
+    rbErrinfo() {
+        const ret = this._exports['rb-errinfo: func() -> handle<rb-abi-value>']();
+        return this._resource1_slab.remove(ret);
+    }
+    rbClearErrinfo() {
+        this._exports['rb-clear-errinfo: func() -> ()']();
+    }
+    rstringPtr(arg0) {
+        const memory = this._exports.memory;
+        const obj0 = arg0;
+        if (!(obj0 instanceof RbAbiValue))
+            throw new TypeError('expected instance of RbAbiValue');
+        const ret = this._exports['rstring-ptr: func(value: handle<rb-abi-value>) -> string'](this._resource1_slab.insert(obj0.clone()));
+        const ptr1 = (0, intrinsics_js_1.data_view)(memory).getInt32(ret + 0, true);
+        const len1 = (0, intrinsics_js_1.data_view)(memory).getInt32(ret + 4, true);
+        const result1 = intrinsics_js_1.UTF8_DECODER.decode(new Uint8Array(memory.buffer, ptr1, len1));
+        this._exports["cabi_post_rstring-ptr"](ret);
+        return result1;
+    }
+    rbVmBugreport() {
+        this._exports['rb-vm-bugreport: func() -> ()']();
+    }
+    rbGcEnable() {
+        const ret = this._exports['rb-gc-enable: func() -> bool']();
+        const bool0 = ret;
+        return bool0 == 0 ? false : (bool0 == 1 ? true : (0, intrinsics_js_1.throw_invalid_bool)());
+    }
+    rbGcDisable() {
+        const ret = this._exports['rb-gc-disable: func() -> bool']();
+        const bool0 = ret;
+        return bool0 == 0 ? false : (bool0 == 1 ? true : (0, intrinsics_js_1.throw_invalid_bool)());
+    }
+    rbSetShouldProhibitRewind(arg0) {
+        const ret = this._exports['rb-set-should-prohibit-rewind: func(new-value: bool) -> bool'](arg0 ? 1 : 0);
+        const bool0 = ret;
+        return bool0 == 0 ? false : (bool0 == 1 ? true : (0, intrinsics_js_1.throw_invalid_bool)());
+    }
+}
+exports.RbAbiGuest = RbAbiGuest;
+class RbIseq {
+    constructor(wasm_val, obj) {
+        this._wasm_val = wasm_val;
+        this._obj = obj;
+        this._refcnt = 1;
+        obj._registry0.register(this, wasm_val, this);
+    }
+    clone() {
+        this._refcnt += 1;
+        return this;
+    }
+    drop() {
+        this._refcnt -= 1;
+        if (this._refcnt !== 0)
+            return;
+        this._obj._registry0.unregister(this);
+        const dtor = this._obj._exports['canonical_abi_drop_rb-iseq'];
+        const wasm_val = this._wasm_val;
+        delete this._obj;
+        delete this._refcnt;
+        delete this._wasm_val;
+        dtor(wasm_val);
+    }
+}
+exports.RbIseq = RbIseq;
+class RbAbiValue {
+    constructor(wasm_val, obj) {
+        this._wasm_val = wasm_val;
+        this._obj = obj;
+        this._refcnt = 1;
+        obj._registry1.register(this, wasm_val, this);
+    }
+    clone() {
+        this._refcnt += 1;
+        return this;
+    }
+    drop() {
+        this._refcnt -= 1;
+        if (this._refcnt !== 0)
+            return;
+        this._obj._registry1.unregister(this);
+        const dtor = this._obj._exports['canonical_abi_drop_rb-abi-value'];
+        const wasm_val = this._wasm_val;
+        delete this._obj;
+        delete this._refcnt;
+        delete this._wasm_val;
+        dtor(wasm_val);
+    }
+}
+exports.RbAbiValue = RbAbiValue;

package/dist/cjs/bindgen/rb-js-abi-host.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRbJsAbiHostToImports = void 0;
+const intrinsics_js_1 = require("./intrinsics.js");
+function addRbJsAbiHostToImports(imports, obj, get_export) {
+    if (!("rb-js-abi-host" in imports))
+        imports["rb-js-abi-host"] = {};
+    imports["rb-js-abi-host"]["eval-js: func(code: string) -> variant { success(handle<js-abi-value>), failure(handle<js-abi-value>) }"] = function (arg0, arg1, arg2) {
+        const memory = get_export("memory");
+        const ptr0 = arg0;
+        const len0 = arg1;
+        const result0 = intrinsics_js_1.UTF8_DECODER.decode(new Uint8Array(memory.buffer, ptr0, len0));
+        const ret0 = obj.evalJs(result0);
+        const variant1 = ret0;
+        switch (variant1.tag) {
+            case "success": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg2 + 0, 0, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg2 + 4, resources0.insert(e), true);
+                break;
+            }
+            case "failure": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg2 + 0, 1, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg2 + 4, resources0.insert(e), true);
+                break;
+            }
+            default:
+                throw new RangeError("invalid variant specified for JsAbiResult");
+        }
+    };
+    imports["rb-js-abi-host"]["is-js: func(value: handle<js-abi-value>) -> bool"] = function (arg0) {
+        const ret0 = obj.isJs(resources0.get(arg0));
+        return ret0 ? 1 : 0;
+    };
+    imports["rb-js-abi-host"]["instance-of: func(value: handle<js-abi-value>, klass: handle<js-abi-value>) -> bool"] = function (arg0, arg1) {
+        const ret0 = obj.instanceOf(resources0.get(arg0), resources0.get(arg1));
+        return ret0 ? 1 : 0;
+    };
+    imports["rb-js-abi-host"]["global-this: func() -> handle<js-abi-value>"] = function () {
+        const ret0 = obj.globalThis();
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["int-to-js-number: func(value: s32) -> handle<js-abi-value>"] = function (arg0) {
+        const ret0 = obj.intToJsNumber(arg0);
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["float-to-js-number: func(value: float64) -> handle<js-abi-value>"] = function (arg0) {
+        const ret0 = obj.floatToJsNumber(arg0);
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["string-to-js-string: func(value: string) -> handle<js-abi-value>"] = function (arg0, arg1) {
+        const memory = get_export("memory");
+        const ptr0 = arg0;
+        const len0 = arg1;
+        const result0 = intrinsics_js_1.UTF8_DECODER.decode(new Uint8Array(memory.buffer, ptr0, len0));
+        const ret0 = obj.stringToJsString(result0);
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["bool-to-js-bool: func(value: bool) -> handle<js-abi-value>"] = function (arg0) {
+        const bool0 = arg0;
+        const ret0 = obj.boolToJsBool(bool0 == 0 ? false : (bool0 == 1 ? true : (0, intrinsics_js_1.throw_invalid_bool)()));
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["proc-to-js-function: func(value: u32) -> handle<js-abi-value>"] = function (arg0) {
+        const ret0 = obj.procToJsFunction(arg0 >>> 0);
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["rb-object-to-js-rb-value: func(raw-rb-abi-value: u32) -> handle<js-abi-value>"] = function (arg0) {
+        const ret0 = obj.rbObjectToJsRbValue(arg0 >>> 0);
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["js-value-to-string: func(value: handle<js-abi-value>) -> string"] = function (arg0, arg1) {
+        const memory = get_export("memory");
+        const realloc = get_export("cabi_realloc");
+        const ret0 = obj.jsValueToString(resources0.get(arg0));
+        const ptr0 = (0, intrinsics_js_1.utf8_encode)(ret0, realloc, memory);
+        const len0 = intrinsics_js_1.UTF8_ENCODED_LEN;
+        (0, intrinsics_js_1.data_view)(memory).setInt32(arg1 + 4, len0, true);
+        (0, intrinsics_js_1.data_view)(memory).setInt32(arg1 + 0, ptr0, true);
+    };
+    imports["rb-js-abi-host"]["js-value-to-integer: func(value: handle<js-abi-value>) -> variant { f64(float64), bignum(string) }"] = function (arg0, arg1) {
+        const memory = get_export("memory");
+        const realloc = get_export("cabi_realloc");
+        const ret0 = obj.jsValueToInteger(resources0.get(arg0));
+        const variant1 = ret0;
+        switch (variant1.tag) {
+            case "f64": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg1 + 0, 0, true);
+                (0, intrinsics_js_1.data_view)(memory).setFloat64(arg1 + 8, +e, true);
+                break;
+            }
+            case "bignum": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg1 + 0, 1, true);
+                const ptr0 = (0, intrinsics_js_1.utf8_encode)(e, realloc, memory);
+                const len0 = intrinsics_js_1.UTF8_ENCODED_LEN;
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg1 + 12, len0, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg1 + 8, ptr0, true);
+                break;
+            }
+            default:
+                throw new RangeError("invalid variant specified for RawInteger");
+        }
+    };
+    imports["rb-js-abi-host"]["export-js-value-to-host: func(value: handle<js-abi-value>) -> ()"] = function (arg0) {
+        obj.exportJsValueToHost(resources0.get(arg0));
+    };
+    imports["rb-js-abi-host"]["import-js-value-from-host: func() -> handle<js-abi-value>"] = function () {
+        const ret0 = obj.importJsValueFromHost();
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["js-value-typeof: func(value: handle<js-abi-value>) -> string"] = function (arg0, arg1) {
+        const memory = get_export("memory");
+        const realloc = get_export("cabi_realloc");
+        const ret0 = obj.jsValueTypeof(resources0.get(arg0));
+        const ptr0 = (0, intrinsics_js_1.utf8_encode)(ret0, realloc, memory);
+        const len0 = intrinsics_js_1.UTF8_ENCODED_LEN;
+        (0, intrinsics_js_1.data_view)(memory).setInt32(arg1 + 4, len0, true);
+        (0, intrinsics_js_1.data_view)(memory).setInt32(arg1 + 0, ptr0, true);
+    };
+    imports["rb-js-abi-host"]["js-value-equal: func(lhs: handle<js-abi-value>, rhs: handle<js-abi-value>) -> bool"] = function (arg0, arg1) {
+        const ret0 = obj.jsValueEqual(resources0.get(arg0), resources0.get(arg1));
+        return ret0 ? 1 : 0;
+    };
+    imports["rb-js-abi-host"]["js-value-strictly-equal: func(lhs: handle<js-abi-value>, rhs: handle<js-abi-value>) -> bool"] = function (arg0, arg1) {
+        const ret0 = obj.jsValueStrictlyEqual(resources0.get(arg0), resources0.get(arg1));
+        return ret0 ? 1 : 0;
+    };
+    imports["rb-js-abi-host"]["reflect-apply: func(target: handle<js-abi-value>, this-argument: handle<js-abi-value>, arguments: list<handle<js-abi-value>>) -> variant { success(handle<js-abi-value>), failure(handle<js-abi-value>) }"] = function (arg0, arg1, arg2, arg3, arg4) {
+        const memory = get_export("memory");
+        const len0 = arg3;
+        const base0 = arg2;
+        const result0 = [];
+        for (let i = 0; i < len0; i++) {
+            const base = base0 + i * 4;
+            result0.push(resources0.get((0, intrinsics_js_1.data_view)(memory).getInt32(base + 0, true)));
+        }
+        const ret0 = obj.reflectApply(resources0.get(arg0), resources0.get(arg1), result0);
+        const variant1 = ret0;
+        switch (variant1.tag) {
+            case "success": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg4 + 0, 0, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg4 + 4, resources0.insert(e), true);
+                break;
+            }
+            case "failure": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg4 + 0, 1, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg4 + 4, resources0.insert(e), true);
+                break;
+            }
+            default:
+                throw new RangeError("invalid variant specified for JsAbiResult");
+        }
+    };
+    imports["rb-js-abi-host"]["reflect-construct: func(target: handle<js-abi-value>, arguments: list<handle<js-abi-value>>) -> handle<js-abi-value>"] = function (arg0, arg1, arg2) {
+        const memory = get_export("memory");
+        const len0 = arg2;
+        const base0 = arg1;
+        const result0 = [];
+        for (let i = 0; i < len0; i++) {
+            const base = base0 + i * 4;
+            result0.push(resources0.get((0, intrinsics_js_1.data_view)(memory).getInt32(base + 0, true)));
+        }
+        const ret0 = obj.reflectConstruct(resources0.get(arg0), result0);
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["reflect-delete-property: func(target: handle<js-abi-value>, property-key: string) -> bool"] = function (arg0, arg1, arg2) {
+        const memory = get_export("memory");
+        const ptr0 = arg1;
+        const len0 = arg2;
+        const result0 = intrinsics_js_1.UTF8_DECODER.decode(new Uint8Array(memory.buffer, ptr0, len0));
+        const ret0 = obj.reflectDeleteProperty(resources0.get(arg0), result0);
+        return ret0 ? 1 : 0;
+    };
+    imports["rb-js-abi-host"]["reflect-get: func(target: handle<js-abi-value>, property-key: string) -> variant { success(handle<js-abi-value>), failure(handle<js-abi-value>) }"] = function (arg0, arg1, arg2, arg3) {
+        const memory = get_export("memory");
+        const ptr0 = arg1;
+        const len0 = arg2;
+        const result0 = intrinsics_js_1.UTF8_DECODER.decode(new Uint8Array(memory.buffer, ptr0, len0));
+        const ret0 = obj.reflectGet(resources0.get(arg0), result0);
+        const variant1 = ret0;
+        switch (variant1.tag) {
+            case "success": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg3 + 0, 0, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg3 + 4, resources0.insert(e), true);
+                break;
+            }
+            case "failure": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg3 + 0, 1, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg3 + 4, resources0.insert(e), true);
+                break;
+            }
+            default:
+                throw new RangeError("invalid variant specified for JsAbiResult");
+        }
+    };
+    imports["rb-js-abi-host"]["reflect-get-own-property-descriptor: func(target: handle<js-abi-value>, property-key: string) -> handle<js-abi-value>"] = function (arg0, arg1, arg2) {
+        const memory = get_export("memory");
+        const ptr0 = arg1;
+        const len0 = arg2;
+        const result0 = intrinsics_js_1.UTF8_DECODER.decode(new Uint8Array(memory.buffer, ptr0, len0));
+        const ret0 = obj.reflectGetOwnPropertyDescriptor(resources0.get(arg0), result0);
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["reflect-get-prototype-of: func(target: handle<js-abi-value>) -> handle<js-abi-value>"] = function (arg0) {
+        const ret0 = obj.reflectGetPrototypeOf(resources0.get(arg0));
+        return resources0.insert(ret0);
+    };
+    imports["rb-js-abi-host"]["reflect-has: func(target: handle<js-abi-value>, property-key: string) -> bool"] = function (arg0, arg1, arg2) {
+        const memory = get_export("memory");
+        const ptr0 = arg1;
+        const len0 = arg2;
+        const result0 = intrinsics_js_1.UTF8_DECODER.decode(new Uint8Array(memory.buffer, ptr0, len0));
+        const ret0 = obj.reflectHas(resources0.get(arg0), result0);
+        return ret0 ? 1 : 0;
+    };
+    imports["rb-js-abi-host"]["reflect-is-extensible: func(target: handle<js-abi-value>) -> bool"] = function (arg0) {
+        const ret0 = obj.reflectIsExtensible(resources0.get(arg0));
+        return ret0 ? 1 : 0;
+    };
+    imports["rb-js-abi-host"]["reflect-own-keys: func(target: handle<js-abi-value>) -> list<handle<js-abi-value>>"] = function (arg0, arg1) {
+        const memory = get_export("memory");
+        const realloc = get_export("cabi_realloc");
+        const ret0 = obj.reflectOwnKeys(resources0.get(arg0));
+        const vec0 = ret0;
+        const len0 = vec0.length;
+        const result0 = realloc(0, 0, 4, len0 * 4);
+        for (let i = 0; i < vec0.length; i++) {
+            const e = vec0[i];
+            const base = result0 + i * 4;
+            (0, intrinsics_js_1.data_view)(memory).setInt32(base + 0, resources0.insert(e), true);
+        }
+        (0, intrinsics_js_1.data_view)(memory).setInt32(arg1 + 4, len0, true);
+        (0, intrinsics_js_1.data_view)(memory).setInt32(arg1 + 0, result0, true);
+    };
+    imports["rb-js-abi-host"]["reflect-prevent-extensions: func(target: handle<js-abi-value>) -> bool"] = function (arg0) {
+        const ret0 = obj.reflectPreventExtensions(resources0.get(arg0));
+        return ret0 ? 1 : 0;
+    };
+    imports["rb-js-abi-host"]["reflect-set: func(target: handle<js-abi-value>, property-key: string, value: handle<js-abi-value>) -> variant { success(handle<js-abi-value>), failure(handle<js-abi-value>) }"] = function (arg0, arg1, arg2, arg3, arg4) {
+        const memory = get_export("memory");
+        const ptr0 = arg1;
+        const len0 = arg2;
+        const result0 = intrinsics_js_1.UTF8_DECODER.decode(new Uint8Array(memory.buffer, ptr0, len0));
+        const ret0 = obj.reflectSet(resources0.get(arg0), result0, resources0.get(arg3));
+        const variant1 = ret0;
+        switch (variant1.tag) {
+            case "success": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg4 + 0, 0, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg4 + 4, resources0.insert(e), true);
+                break;
+            }
+            case "failure": {
+                const e = variant1.val;
+                (0, intrinsics_js_1.data_view)(memory).setInt8(arg4 + 0, 1, true);
+                (0, intrinsics_js_1.data_view)(memory).setInt32(arg4 + 4, resources0.insert(e), true);
+                break;
+            }
+            default:
+                throw new RangeError("invalid variant specified for JsAbiResult");
+        }
+    };
+    imports["rb-js-abi-host"]["reflect-set-prototype-of: func(target: handle<js-abi-value>, prototype: handle<js-abi-value>) -> bool"] = function (arg0, arg1) {
+        const ret0 = obj.reflectSetPrototypeOf(resources0.get(arg0), resources0.get(arg1));
+        return ret0 ? 1 : 0;
+    };
+    if (!("canonical_abi" in imports))
+        imports["canonical_abi"] = {};
+    const resources0 = new intrinsics_js_1.Slab();
+    imports.canonical_abi["resource_drop_js-abi-value"] = (i) => {
+        const val = resources0.remove(i);
+        if (obj.dropJsAbiValue)
+            obj.dropJsAbiValue(val);
+    };
+}
+exports.addRbJsAbiHostToImports = addRbJsAbiHostToImports;

package/dist/{browser.d.ts → cjs/browser.d.ts}

@@ -1,5 +1,5 @@
-import { WASI } from "@wasmer/wasi";
-import { RubyVM } from "./index";
+import { WASI } from "@bjorn3/browser_wasi_shim";
+import { RubyVM } from "./index.js";
 export declare const DefaultRubyVM: (rubyModule: WebAssembly.Module, options?: {
     consolePrint?: boolean;
     env?: Record<string, string> | undefined;

package/dist/cjs/browser.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultRubyVM = void 0;
+const browser_wasi_shim_1 = require("@bjorn3/browser_wasi_shim");
+const index_js_1 = require("./index.js");
+const DefaultRubyVM = async (rubyModule, options = {}) => {
+    var _a, _b;
+    const args = [];
+    const env = Object.entries((_a = options.env) !== null && _a !== void 0 ? _a : {}).map(([k, v]) => `${k}=${v}`);
+    const fds = [];
+    const wasi = new browser_wasi_shim_1.WASI(args, env, fds, { debug: false });
+    const vm = new index_js_1.RubyVM();
+    const imports = {
+        wasi_snapshot_preview1: wasi.wasiImport,
+    };
+    vm.addToImports(imports);
+    const printer = ((_b = options.consolePrint) !== null && _b !== void 0 ? _b : true) ? (0, index_js_1.consolePrinter)() : undefined;
+    printer === null || printer === void 0 ? void 0 : printer.addToImports(imports);
+    const instance = await WebAssembly.instantiate(rubyModule, imports);
+    await vm.setInstance(instance);
+    printer === null || printer === void 0 ? void 0 : printer.setMemory(instance.exports.memory);
+    wasi.initialize(instance);
+    vm.initialize();
+    return {
+        vm,
+        wasi,
+        instance,
+    };
+};
+exports.DefaultRubyVM = DefaultRubyVM;

package/dist/{browser.script.d.ts → cjs/browser.script.d.ts}

@@ -1,4 +1,4 @@
-import { DefaultRubyVM } from "./browser";
+import { DefaultRubyVM } from "./browser.js";
 export declare const main: (pkg: {
     name: string;
     version: string;