@scalable-vector-audio/sva-wasm 0.3.2 → 0.5.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@scalable-vector-audio/sva-wasm",
   "type": "module",
   "description": "JS bindings: a composition a page fills node by node, rendered in the browser",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/sva_wasm.d.ts

@@ -1,6 +1,13 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class Checkpoint {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly position: number;
+}
+
 export class Composition {
     free(): void;
     [Symbol.dispose](): void;
@@ -9,6 +16,7 @@ export class Composition {
      * Empties the memory tier only: a persistent pack outlives it by design.
      */
     clear_cache(): void;
+    clear_volatile(): void;
     insert(path: string, text: string): void;
     constructor(name?: string | null);
     /**
@@ -17,9 +25,18 @@ export class Composition {
      */
     static persistent(name: string | null | undefined, cache: string, max_bytes?: number | null): Promise<Composition>;
     /**
-     * Unset, `target` is `master`; `seconds` is the horizon and `rate` the observation rate.
+     * Unset, `target` is `master`; `until` is the horizon in seconds, or `"silent"` to end
+     * where every later sample is provably under `2^-bits` (default the profile's own), by
+     * `max_secs` at the latest. `rate` is the observation rate. What reads a `volatile`
+     * parameter is kept in a slot, never in either store.
+     */
+    render(target: string | null | undefined, rate: number | null | undefined, until: any, volatile?: string[] | null, bits?: number | null, max_secs?: number | null): Rendering;
+    /**
+     * A stream of `target` (`master` unset) at `rate`, `block` samples a block, each key of
+     * `bindings` a named argument on the target. `until: "silent"` ends it at the first block
+     * whose end proves every later sample under `2^-bits`, throwing past `max_secs`.
      */
-    render(target?: string | null, rate?: number | null, seconds?: number | null): Rendering;
+    stream(target: string | null | undefined, rate: number | null | undefined, block: number, bindings: any, until: any, bits?: number | null, max_secs?: number | null): Stream;
     /**
      * The memory tier's, as `cache_max_bytes` is; `persistent_bytes` is the pack's.
      */
@@ -31,6 +48,8 @@ export class Composition {
      */
     readonly persistent_bytes: number;
     readonly persistent_max_bytes: number;
+    volatile_max_bytes: number;
+    readonly volatile_bytes: number;
 }
 
 export class Rendering {
@@ -52,23 +71,64 @@ export class Rendering {
     readonly target: string;
 }
 
+/**
+ * A target block by block, for a player that cannot know how long a note is held.
+ */
+export class Stream {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    checkpoint(): Checkpoint;
+    /**
+     * Writes the next block into `out`, component `c` from `c * block`, and returns the
+     * samples each component took: `block`, fewer where silence ends inside it, `0` after.
+     */
+    next(out: Float32Array): number;
+    /**
+     * `until` as `stream` takes it, `max_secs` counted from the checkpoint.
+     */
+    resume(checkpoint: Checkpoint, bindings: any, until: any, bits?: number | null, max_secs?: number | null): Stream;
+    readonly block: number;
+    readonly channels: number;
+    readonly end: number | undefined;
+    readonly position: number;
+    readonly sample_rate: number;
+}
+
+export function builtins(): any;
+
+/**
+ * `sva-cli outline`'s `data`.
+ */
+export function outline(text: string): any;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __wbg_checkpoint_free: (a: number, b: number) => void;
     readonly __wbg_composition_free: (a: number, b: number) => void;
     readonly __wbg_rendering_free: (a: number, b: number) => void;
+    readonly __wbg_stream_free: (a: number, b: number) => void;
+    readonly builtins: () => [number, number, number];
+    readonly checkpoint_position: (a: number) => number;
     readonly composition_bound_cache: (a: number, b: number) => void;
     readonly composition_cache_bytes: (a: number) => number;
     readonly composition_cache_max_bytes: (a: number) => number;
     readonly composition_clear_cache: (a: number) => void;
+    readonly composition_clear_volatile: (a: number) => void;
     readonly composition_insert: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly composition_is_persistent: (a: number) => number;
     readonly composition_new: (a: number, b: number) => number;
     readonly composition_persistent: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
     readonly composition_persistent_bytes: (a: number) => number;
     readonly composition_persistent_max_bytes: (a: number) => number;
-    readonly composition_render: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly composition_render: (a: number, b: number, c: number, d: number, e: any, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
+    readonly composition_set_volatile_max_bytes: (a: number, b: number) => void;
+    readonly composition_stream: (a: number, b: number, c: number, d: number, e: number, f: any, g: any, h: number, i: number, j: number) => [number, number, number];
+    readonly composition_volatile_bytes: (a: number) => number;
+    readonly composition_volatile_max_bytes: (a: number) => number;
+    readonly outline: (a: number, b: number) => [number, number, number];
     readonly rendering_channels: (a: number) => number;
     readonly rendering_duration_secs: (a: number) => number;
     readonly rendering_query: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
@@ -76,6 +136,14 @@ export interface InitOutput {
     readonly rendering_samples: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
     readonly rendering_stats: (a: number) => [number, number, number];
     readonly rendering_target: (a: number) => [number, number];
+    readonly stream_block: (a: number) => number;
+    readonly stream_channels: (a: number) => number;
+    readonly stream_checkpoint: (a: number) => number;
+    readonly stream_end: (a: number) => [number, number];
+    readonly stream_next: (a: number, b: number, c: number, d: any) => [number, number, number];
+    readonly stream_position: (a: number) => number;
+    readonly stream_resume: (a: number, b: number, c: any, d: any, e: number, f: number, g: number) => [number, number, number];
+    readonly stream_sample_rate: (a: number) => number;
     readonly wasm_bindgen__convert__closures_____invoke__h76bd71bceeca2b95: (a: number, b: number, c: any, d: any) => void;
     readonly wasm_bindgen__convert__closures_____invoke__hd55bb211d6a08150: (a: number, b: number, c: any) => [number, number];
     readonly __wbindgen_malloc: (a: number, b: number) => number;

package/sva_wasm.js

@@ -1,5 +1,32 @@
 /* @ts-self-types="./sva_wasm.d.ts" */
 
+export class Checkpoint {
+    static __wrap(ptr) {
+        const obj = Object.create(Checkpoint.prototype);
+        obj.__wbg_ptr = ptr;
+        CheckpointFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CheckpointFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_checkpoint_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get position() {
+        const ret = wasm.checkpoint_position(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) Checkpoint.prototype[Symbol.dispose] = Checkpoint.prototype.free;
+
 export class Composition {
     static __wrap(ptr) {
         const obj = Object.create(Composition.prototype);
@@ -44,6 +71,9 @@ export class Composition {
     clear_cache() {
         wasm.composition_clear_cache(this.__wbg_ptr);
     }
+    clear_volatile() {
+        wasm.composition_clear_volatile(this.__wbg_ptr);
+    }
     /**
      * @param {string} path
      * @param {string} text
@@ -105,21 +135,71 @@ export class Composition {
         return ret;
     }
     /**
-     * Unset, `target` is `master`; `seconds` is the horizon and `rate` the observation rate.
-     * @param {string | null} [target]
-     * @param {number | null} [rate]
-     * @param {number | null} [seconds]
+     * Unset, `target` is `master`; `until` is the horizon in seconds, or `"silent"` to end
+     * where every later sample is provably under `2^-bits` (default the profile's own), by
+     * `max_secs` at the latest. `rate` is the observation rate. What reads a `volatile`
+     * parameter is kept in a slot, never in either store.
+     * @param {string | null | undefined} target
+     * @param {number | null | undefined} rate
+     * @param {any} until
+     * @param {string[] | null} [volatile]
+     * @param {number | null} [bits]
+     * @param {number | null} [max_secs]
      * @returns {Rendering}
      */
-    render(target, rate, seconds) {
+    render(target, rate, until, volatile, bits, max_secs) {
         var ptr0 = isLikeNone(target) ? 0 : passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.composition_render(this.__wbg_ptr, ptr0, len0, isLikeNone(rate) ? Number.MAX_SAFE_INTEGER : (rate) >>> 0, !isLikeNone(seconds), isLikeNone(seconds) ? 0 : seconds);
+        var ptr1 = isLikeNone(volatile) ? 0 : passArrayJsValueToWasm0(volatile, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.composition_render(this.__wbg_ptr, ptr0, len0, isLikeNone(rate) ? Number.MAX_SAFE_INTEGER : (rate) >>> 0, until, ptr1, len1, isLikeNone(bits) ? Number.MAX_SAFE_INTEGER : (bits) >>> 0, !isLikeNone(max_secs), isLikeNone(max_secs) ? 0 : max_secs);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Rendering.__wrap(ret[0]);
     }
+    /**
+     * @param {number} max_bytes
+     */
+    set volatile_max_bytes(max_bytes) {
+        wasm.composition_set_volatile_max_bytes(this.__wbg_ptr, max_bytes);
+    }
+    /**
+     * A stream of `target` (`master` unset) at `rate`, `block` samples a block, each key of
+     * `bindings` a named argument on the target. `until: "silent"` ends it at the first block
+     * whose end proves every later sample under `2^-bits`, throwing past `max_secs`.
+     * @param {string | null | undefined} target
+     * @param {number | null | undefined} rate
+     * @param {number} block
+     * @param {any} bindings
+     * @param {any} until
+     * @param {number | null} [bits]
+     * @param {number | null} [max_secs]
+     * @returns {Stream}
+     */
+    stream(target, rate, block, bindings, until, bits, max_secs) {
+        var ptr0 = isLikeNone(target) ? 0 : passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composition_stream(this.__wbg_ptr, ptr0, len0, isLikeNone(rate) ? Number.MAX_SAFE_INTEGER : (rate) >>> 0, block, bindings, until, isLikeNone(bits) ? Number.MAX_SAFE_INTEGER : (bits) >>> 0, !isLikeNone(max_secs), isLikeNone(max_secs) ? 0 : max_secs);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Stream.__wrap(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get volatile_bytes() {
+        const ret = wasm.composition_volatile_bytes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get volatile_max_bytes() {
+        const ret = wasm.composition_volatile_max_bytes(this.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) Composition.prototype[Symbol.dispose] = Composition.prototype.free;
 
@@ -220,9 +300,135 @@ export class Rendering {
     }
 }
 if (Symbol.dispose) Rendering.prototype[Symbol.dispose] = Rendering.prototype.free;
+
+/**
+ * A target block by block, for a player that cannot know how long a note is held.
+ */
+export class Stream {
+    static __wrap(ptr) {
+        const obj = Object.create(Stream.prototype);
+        obj.__wbg_ptr = ptr;
+        StreamFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StreamFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_stream_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get block() {
+        const ret = wasm.stream_block(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get channels() {
+        const ret = wasm.stream_channels(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {Checkpoint}
+     */
+    checkpoint() {
+        const ret = wasm.stream_checkpoint(this.__wbg_ptr);
+        return Checkpoint.__wrap(ret);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get end() {
+        const ret = wasm.stream_end(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Writes the next block into `out`, component `c` from `c * block`, and returns the
+     * samples each component took: `block`, fewer where silence ends inside it, `0` after.
+     * @param {Float32Array} out
+     * @returns {number}
+     */
+    next(out) {
+        var ptr0 = passArrayF32ToWasm0(out, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.stream_next(this.__wbg_ptr, ptr0, len0, out);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get position() {
+        const ret = wasm.stream_position(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * `until` as `stream` takes it, `max_secs` counted from the checkpoint.
+     * @param {Checkpoint} checkpoint
+     * @param {any} bindings
+     * @param {any} until
+     * @param {number | null} [bits]
+     * @param {number | null} [max_secs]
+     * @returns {Stream}
+     */
+    resume(checkpoint, bindings, until, bits, max_secs) {
+        _assertClass(checkpoint, Checkpoint);
+        const ret = wasm.stream_resume(this.__wbg_ptr, checkpoint.__wbg_ptr, bindings, until, isLikeNone(bits) ? Number.MAX_SAFE_INTEGER : (bits) >>> 0, !isLikeNone(max_secs), isLikeNone(max_secs) ? 0 : max_secs);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Stream.__wrap(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get sample_rate() {
+        const ret = wasm.stream_sample_rate(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Stream.prototype[Symbol.dispose] = Stream.prototype.free;
+
+/**
+ * @returns {any}
+ */
+export function builtins() {
+    const ret = wasm.builtins();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * `sva-cli outline`'s `data`.
+ * @param {string} text
+ * @returns {any}
+ */
+export function outline(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.outline(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_copy_to_typed_array_cccd104be8cf0b8d: function(arg0, arg1, arg2) {
+            new Uint8Array(arg2.buffer, arg2.byteOffset, arg2.byteLength).set(getArrayU8FromWasm0(arg0, arg1));
+        },
         __wbg___wbindgen_is_falsy_4502df4d571fca70: function(arg0) {
             const ret = !arg0;
             return ret;
@@ -231,10 +437,20 @@ function __wbg_get_imports() {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
+        __wbg___wbindgen_is_null_5160b3e381865372: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_8c687d0b90d5b524: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
+        __wbg___wbindgen_number_get_1dc732b810cb937c: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
         __wbg___wbindgen_string_get_92ab86bb19cbc12f: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -264,9 +480,17 @@ function __wbg_get_imports() {
             const ret = arg0.createSyncAccessHandle();
             return ret;
         },
+        __wbg_entries_972a87586902cf87: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
         __wbg_flush_91458c8278aae724: function() { return handleError(function (arg0) {
             arg0.flush();
         }, arguments); },
+        __wbg_from_a39669ce566077da: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
         __wbg_getDirectoryHandle_df6fb6f1fc6240ed: function(arg0, arg1, arg2, arg3) {
             const ret = arg0.getDirectoryHandle(getStringFromWasm0(arg1, arg2), arg3);
             return ret;
@@ -287,6 +511,14 @@ function __wbg_get_imports() {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
+        __wbg_get_b1f0ab13c737f856: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_unchecked_363572bdd397d473: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
         __wbg_instanceof_FileSystemDirectoryHandle_a5c1bdaafba684ca: function(arg0) {
             let result;
             try {
@@ -307,6 +539,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Object_87732cb922ac2e2c: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Object;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_WorkerGlobalScope_0c1a6411473b843f: function(arg0) {
             let result;
             try {
@@ -321,11 +563,15 @@ function __wbg_get_imports() {
             const ret = arg0.keys();
             return ret;
         },
+        __wbg_length_4e1adc0d42e23620: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_navigator_d25c0f071226f233: function(arg0) {
             const ret = arg0.navigator;
             return ret;
         },
-        __wbg_new_26b7cfa43ced9e50: function(arg0, arg1) {
+        __wbg_new_60a94df323701352: function(arg0, arg1) {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -373,7 +619,7 @@ function __wbg_get_imports() {
             const ret = arg0.next();
             return ret;
         }, arguments); },
-        __wbg_parse_ad8a065cf8e96394: function() { return handleError(function (arg0, arg1) {
+        __wbg_parse_673c654d2b233b97: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
@@ -409,10 +655,10 @@ function __wbg_get_imports() {
         __wbg_set_create_8c556c6febf6436c: function(arg0, arg1) {
             arg0.create = arg1 !== 0;
         },
-        __wbg_set_name_4b42cb35261cf0ae: function(arg0, arg1, arg2) {
+        __wbg_set_name_f2e0b4f6b6b3d728: function(arg0, arg1, arg2) {
             arg0.name = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_refusal_bec4180664df2914: function(arg0, arg1) {
+        __wbg_set_refusal_0a35a4ef06d51ed7: function(arg0, arg1) {
             arg0.refusal = arg1;
         },
         __wbg_static_accessor_GLOBAL_8eb4cd83130a11a0: function() {
@@ -447,7 +693,7 @@ function __wbg_get_imports() {
             return ret;
         }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 94, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 99, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hd55bb211d6a08150);
             return ret;
         },
@@ -483,12 +729,18 @@ function wasm_bindgen__convert__closures_____invoke__h76bd71bceeca2b95(arg0, arg
     wasm.wasm_bindgen__convert__closures_____invoke__h76bd71bceeca2b95(arg0, arg1, arg2, arg3);
 }
 
+const CheckpointFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_checkpoint_free(ptr, 1));
 const CompositionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_composition_free(ptr, 1));
 const RenderingFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rendering_free(ptr, 1));
+const StreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_stream_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -496,6 +748,12 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
@@ -579,6 +837,23 @@ function makeMutClosure(arg0, arg1, f) {
     return real;
 }
 
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);