@ruby/wasm-wasi 2.3.0 → 2.4.0

package/dist/esm/bindgen/intrinsics.js

@@ -0,0 +1,73 @@
+let DATA_VIEW = new DataView(new ArrayBuffer());
+export function data_view(mem) {
+    if (DATA_VIEW.buffer !== mem.buffer)
+        DATA_VIEW = new DataView(mem.buffer);
+    return DATA_VIEW;
+}
+export function to_uint32(val) {
+    return val >>> 0;
+}
+export const UTF8_DECODER = new TextDecoder('utf-8');
+const UTF8_ENCODER = new TextEncoder('utf-8');
+export function utf8_encode(s, realloc, memory) {
+    if (typeof s !== 'string')
+        throw new TypeError('expected a string');
+    if (s.length === 0) {
+        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);
+    UTF8_ENCODED_LEN = writtenTotal;
+    return ptr;
+}
+export let UTF8_ENCODED_LEN = 0;
+export 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;
+    }
+}
+export function throw_invalid_bool() {
+    throw new RangeError("invalid variant discriminant for bool");
+}

package/dist/esm/bindgen/rb-abi-guest.d.ts

@@ -0,0 +1,140 @@
+export type RbErrno = number;
+export type RbId = number;
+export class RbAbiGuest {
+  
+  /**
+  * The WebAssembly instance that this class is operating with.
+  * This is only available after the `instantiate` method has
+  * been called.
+  */
+  instance: WebAssembly.Instance;
+  
+  /**
+  * Constructs a new instance with internal state necessary to
+  * manage a wasm instance.
+  *
+  * Note that this does not actually instantiate the WebAssembly
+  * instance or module, you'll need to call the `instantiate`
+  * method below to "activate" this class.
+  */
+  constructor();
+  
+  /**
+  * This is a low-level method which can be used to add any
+  * intrinsics necessary for this instance to operate to an
+  * import object.
+  *
+  * The `import` object given here is expected to be used later
+  * to actually instantiate the module this class corresponds to.
+  * If the `instantiate` method below actually does the
+  * instantiation then there's no need to call this method, but
+  * if you're instantiating manually elsewhere then this can be
+  * used to prepare the import object for external instantiation.
+  */
+  addToImports(imports: any): void;
+  
+  /**
+  * Initializes this object with the provided WebAssembly
+  * module/instance.
+  *
+  * This is intended to be a flexible method of instantiating
+  * and completion of the initialization of this class. This
+  * method must be called before interacting with the
+  * WebAssembly object.
+  *
+  * The first argument to this method is where to get the
+  * wasm from. This can be a whole bunch of different types,
+  * for example:
+  *
+  * * A precompiled `WebAssembly.Module`
+  * * A typed array buffer containing the wasm bytecode.
+  * * A `Promise` of a `Response` which is used with
+  *   `instantiateStreaming`
+  * * A `Response` itself used with `instantiateStreaming`.
+  * * An already instantiated `WebAssembly.Instance`
+  *
+  * If necessary the module is compiled, and if necessary the
+  * module is instantiated. Whether or not it's necessary
+  * depends on the type of argument provided to
+  * instantiation.
+  *
+  * If instantiation is performed then the `imports` object
+  * passed here is the list of imports used to instantiate
+  * the instance. This method may add its own intrinsics to
+  * this `imports` object too.
+  */
+  instantiate(
+  module: WebAssembly.Module | BufferSource | Promise<Response> | Response | WebAssembly.Instance,
+  imports?: any,
+  ): Promise<void>;
+  rubyShowVersion(): void;
+  rubyInit(): void;
+  rubySysinit(args: string[]): void;
+  rubyOptions(args: string[]): RbIseq;
+  rubyScript(name: string): void;
+  rubyInitLoadpath(): void;
+  rbEvalStringProtect(str: string): [RbAbiValue, number];
+  rbFuncallvProtect(recv: RbAbiValue, mid: RbId, args: RbAbiValue[]): [RbAbiValue, number];
+  rbIntern(name: string): RbId;
+  rbErrinfo(): RbAbiValue;
+  rbClearErrinfo(): void;
+  rstringPtr(value: RbAbiValue): string;
+  rbVmBugreport(): void;
+  rbGcEnable(): boolean;
+  rbGcDisable(): boolean;
+  rbSetShouldProhibitRewind(newValue: boolean): boolean;
+}
+
+export class RbIseq {
+  // Creates a new strong reference count as a new
+  // object.  This is only required if you're also
+  // calling `drop` below and want to manually manage
+  // the reference count from JS.
+  //
+  // If you don't call `drop`, you don't need to call
+  // this and can simply use the object from JS.
+  clone(): RbIseq;
+  
+  // Explicitly indicate that this JS object will no
+  // longer be used. If the internal reference count
+  // reaches zero then this will deterministically
+  // destroy the underlying wasm object.
+  //
+  // This is not required to be called from JS. Wasm
+  // destructors will be automatically called for you
+  // if this is not called using the JS
+  // `FinalizationRegistry`.
+  //
+  // Calling this method does not guarantee that the
+  // underlying wasm object is deallocated. Something
+  // else (including wasm) may be holding onto a
+  // strong reference count.
+  drop(): void;
+}
+
+export class RbAbiValue {
+  // Creates a new strong reference count as a new
+  // object.  This is only required if you're also
+  // calling `drop` below and want to manually manage
+  // the reference count from JS.
+  //
+  // If you don't call `drop`, you don't need to call
+  // this and can simply use the object from JS.
+  clone(): RbAbiValue;
+  
+  // Explicitly indicate that this JS object will no
+  // longer be used. If the internal reference count
+  // reaches zero then this will deterministically
+  // destroy the underlying wasm object.
+  //
+  // This is not required to be called from JS. Wasm
+  // destructors will be automatically called for you
+  // if this is not called using the JS
+  // `FinalizationRegistry`.
+  //
+  // Calling this method does not guarantee that the
+  // underlying wasm object is deallocated. Something
+  // else (including wasm) may be holding onto a
+  // strong reference count.
+  drop(): void;
+}

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

@@ -0,0 +1,230 @@
+import { data_view, to_uint32, UTF8_DECODER, utf8_encode, UTF8_ENCODED_LEN, Slab, throw_invalid_bool } from './intrinsics.js';
+export class RbAbiGuest {
+    constructor() {
+        this._resource0_slab = new Slab();
+        this._resource1_slab = new 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 = utf8_encode(e, realloc, memory);
+            const len0 = UTF8_ENCODED_LEN;
+            data_view(memory).setInt32(base + 4, len0, true);
+            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 = utf8_encode(e, realloc, memory);
+            const len0 = UTF8_ENCODED_LEN;
+            data_view(memory).setInt32(base + 4, len0, true);
+            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 = utf8_encode(arg0, realloc, memory);
+        const len0 = 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 = utf8_encode(arg0, realloc, memory);
+        const len0 = 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(data_view(memory).getInt32(ret + 0, true)), 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');
+            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()), to_uint32(arg1), result2, len2);
+        return [this._resource1_slab.remove(data_view(memory).getInt32(ret + 0, true)), data_view(memory).getInt32(ret + 4, true)];
+    }
+    rbIntern(arg0) {
+        const memory = this._exports.memory;
+        const realloc = this._exports["cabi_realloc"];
+        const ptr0 = utf8_encode(arg0, realloc, memory);
+        const len0 = 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 = data_view(memory).getInt32(ret + 0, true);
+        const len1 = data_view(memory).getInt32(ret + 4, true);
+        const result1 = 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 : throw_invalid_bool());
+    }
+    rbGcDisable() {
+        const ret = this._exports['rb-gc-disable: func() -> bool']();
+        const bool0 = ret;
+        return bool0 == 0 ? false : (bool0 == 1 ? true : 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 : throw_invalid_bool());
+    }
+}
+export 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);
+    }
+}
+export 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);
+    }
+}

package/dist/esm/bindgen/rb-js-abi-host.d.ts

@@ -0,0 +1,53 @@
+export type JsAbiResult = JsAbiResultSuccess | JsAbiResultFailure;
+export interface JsAbiResultSuccess {
+  tag: "success",
+  val: JsAbiValue,
+}
+export interface JsAbiResultFailure {
+  tag: "failure",
+  val: JsAbiValue,
+}
+export type RawInteger = RawIntegerF64 | RawIntegerBignum;
+export interface RawIntegerF64 {
+  tag: "f64",
+  val: number,
+}
+export interface RawIntegerBignum {
+  tag: "bignum",
+  val: string,
+}
+export function addRbJsAbiHostToImports(imports: any, obj: RbJsAbiHost, get_export: (name: string) => WebAssembly.ExportValue): void;
+export interface RbJsAbiHost {
+  evalJs(code: string): JsAbiResult;
+  isJs(value: JsAbiValue): boolean;
+  instanceOf(value: JsAbiValue, klass: JsAbiValue): boolean;
+  globalThis(): JsAbiValue;
+  intToJsNumber(value: number): JsAbiValue;
+  floatToJsNumber(value: number): JsAbiValue;
+  stringToJsString(value: string): JsAbiValue;
+  boolToJsBool(value: boolean): JsAbiValue;
+  procToJsFunction(value: number): JsAbiValue;
+  rbObjectToJsRbValue(rawRbAbiValue: number): JsAbiValue;
+  jsValueToString(value: JsAbiValue): string;
+  jsValueToInteger(value: JsAbiValue): RawInteger;
+  exportJsValueToHost(value: JsAbiValue): void;
+  importJsValueFromHost(): JsAbiValue;
+  jsValueTypeof(value: JsAbiValue): string;
+  jsValueEqual(lhs: JsAbiValue, rhs: JsAbiValue): boolean;
+  jsValueStrictlyEqual(lhs: JsAbiValue, rhs: JsAbiValue): boolean;
+  reflectApply(target: JsAbiValue, thisArgument: JsAbiValue, arguments: JsAbiValue[]): JsAbiResult;
+  reflectConstruct(target: JsAbiValue, arguments: JsAbiValue[]): JsAbiValue;
+  reflectDeleteProperty(target: JsAbiValue, propertyKey: string): boolean;
+  reflectGet(target: JsAbiValue, propertyKey: string): JsAbiResult;
+  reflectGetOwnPropertyDescriptor(target: JsAbiValue, propertyKey: string): JsAbiValue;
+  reflectGetPrototypeOf(target: JsAbiValue): JsAbiValue;
+  reflectHas(target: JsAbiValue, propertyKey: string): boolean;
+  reflectIsExtensible(target: JsAbiValue): boolean;
+  reflectOwnKeys(target: JsAbiValue): JsAbiValue[];
+  reflectPreventExtensions(target: JsAbiValue): boolean;
+  reflectSet(target: JsAbiValue, propertyKey: string, value: JsAbiValue): JsAbiResult;
+  reflectSetPrototypeOf(target: JsAbiValue, prototype: JsAbiValue): boolean;
+  dropJsAbiValue?: (val: JsAbiValue) => void;
+}
+export interface JsAbiValue {
+}