ping-openmls-sdk 0.1.2 → 0.5.0

package/wasm/ping_wasm.js

@@ -18,31 +18,37 @@ export class PingClient {
         wasm.__wbg_pingclient_free(ptr, 0);
     }
     /**
+     * Add members ([CR-2]). `entries` is an array of `{ deviceId: Uint8Array,
+     * keyPackage: Uint8Array }`. Bundling the device_id with the KeyPackage lets us
+     * persist a per-conversation device→leaf map for [`revokeDevice`].
      * @param {Uint8Array} conv_id
-     * @param {Uint8Array[]} key_packages
+     * @param {any} entries
      * @param {number} now_ms
      * @returns {Promise<void>}
      */
-    addMembers(conv_id, key_packages, now_ms) {
+    addMembers(conv_id, entries, now_ms) {
         const ptr0 = passArray8ToWasm0(conv_id, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayJsValueToWasm0(key_packages, wasm.__wbindgen_export);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.pingclient_addMembers(this.__wbg_ptr, ptr0, len0, ptr1, len1, now_ms);
+        const ret = wasm.pingclient_addMembers(this.__wbg_ptr, ptr0, len0, addHeapObject(entries), now_ms);
         return takeObject(ret);
     }
     /**
+     * Build a `LinkingTicket` ([CR-13] populates `catchup_snapshot` from `last_app_events`).
+     *
+     * `last_app_events` is an array of `{ conversationId: Uint8Array, appEventBytes:
+     * Uint8Array }`. Pass `[]` to suppress catchup data.
      * @param {Uint8Array} new_device_id
      * @param {Uint8Array} new_device_kp
+     * @param {any} last_app_events
      * @param {number} now_ms
      * @returns {Promise<any>}
      */
-    buildLinkingTicket(new_device_id, new_device_kp, now_ms) {
+    buildLinkingTicket(new_device_id, new_device_kp, last_app_events, now_ms) {
         const ptr0 = passArray8ToWasm0(new_device_id, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(new_device_kp, wasm.__wbindgen_export);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.pingclient_buildLinkingTicket(this.__wbg_ptr, ptr0, len0, ptr1, len1, now_ms);
+        const ret = wasm.pingclient_buildLinkingTicket(this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(last_app_events), now_ms);
         return takeObject(ret);
     }
     /**
@@ -81,6 +87,63 @@ export class PingClient {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Export a derived secret from a conversation's MLS exporter ([CR-8]).
+     *
+     * The core wraps the bytes in `Zeroizing<Vec<u8>>`; once they cross the WASM/JS
+     * boundary they live in a regular JS `Uint8Array` and JS GC controls the lifetime.
+     * Callers in JS MUST treat the buffer as a secret — never log, persist only
+     * encrypted, and clear the typed array when done (`u8.fill(0)`).
+     * @param {Uint8Array} conv_id
+     * @param {string} label
+     * @param {Uint8Array} context
+     * @param {number} length
+     * @returns {Uint8Array}
+     */
+    exportConversationSecret(conv_id, label, context, length) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(conv_id, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray8ToWasm0(context, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.pingclient_exportConversationSecret(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, length);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * [CR-7] Export the MLS state snapshot for one conversation.
+     * @param {Uint8Array} conv_id
+     * @param {number} now_ms
+     * @returns {Uint8Array}
+     */
+    exportConversationStateSnapshot(conv_id, now_ms) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(conv_id, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.pingclient_exportConversationStateSnapshot(retptr, this.__wbg_ptr, ptr0, len0, now_ms);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @returns {Uint8Array}
      */
@@ -119,21 +182,48 @@ export class PingClient {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * [CR-7] Import an MLS state snapshot produced by another device of the same
+     * user identity. Returns the conversation id the snapshot describes.
+     * @param {Uint8Array} snapshot_bytes
+     * @param {number} now_ms
+     * @returns {Promise<Uint8Array>}
+     */
+    importStateSnapshot(snapshot_bytes, now_ms) {
+        const ptr0 = passArray8ToWasm0(snapshot_bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pingclient_importStateSnapshot(this.__wbg_ptr, ptr0, len0, now_ms);
+        return takeObject(ret);
+    }
     /**
      * Initialise the client. Pass an exported identity (use `generateIdentity()` for a fresh one).
+     *
+     * `device_signing_secret_key`: optional 32-byte Ed25519 secret
+     * key the SDK should adopt as its device signing key on FIRST
+     * init. When supplied, `device_id` becomes
+     * `SHA-256(public_key_of(secret))` — deterministic from the
+     * caller's input, so the host can align the SDK's `device_id`
+     * (which the SDK stamps into every envelope's `sender_device`)
+     * with whatever device_id the auth layer registered in the JWT.
+     * Ignored on re-init when a `LocalDevice` is already persisted
+     * in `storage`. Pass `null`/`undefined` to keep the legacy
+     * random-key behaviour.
      * @param {Uint8Array} identity_export
      * @param {string} device_label
      * @param {JsStorage} storage
      * @param {JsTransport} transport
      * @param {number} now_ms
+     * @param {Uint8Array | null} [device_signing_secret_key]
      * @returns {Promise<PingClient>}
      */
-    static init(identity_export, device_label, storage, transport, now_ms) {
+    static init(identity_export, device_label, storage, transport, now_ms, device_signing_secret_key) {
         const ptr0 = passArray8ToWasm0(identity_export, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(device_label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.pingclient_init(ptr0, len0, ptr1, len1, addHeapObject(storage), addHeapObject(transport), now_ms);
+        var ptr2 = isLikeNone(device_signing_secret_key) ? 0 : passArray8ToWasm0(device_signing_secret_key, wasm.__wbindgen_export);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.pingclient_init(ptr0, len0, ptr1, len1, addHeapObject(storage), addHeapObject(transport), now_ms, ptr2, len2);
         return takeObject(ret);
     }
     /**
@@ -192,6 +282,21 @@ export class PingClient {
         const ret = wasm.pingclient_removeMembers(this.__wbg_ptr, ptr0, len0, ptr1, len1, now_ms);
         return takeObject(ret);
     }
+    /**
+     * Revoke a device ([CR-2]). Returns an array of Commit envelopes — one per
+     * conversation the device was a locally-known leaf in. Each envelope has already
+     * been handed to the transport; the host's hand-back is for any additional
+     * receipt-of-revocation handling.
+     * @param {Uint8Array} device_id
+     * @param {number} now_ms
+     * @returns {Promise<any>}
+     */
+    revokeDevice(device_id, now_ms) {
+        const ptr0 = passArray8ToWasm0(device_id, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pingclient_revokeDevice(this.__wbg_ptr, ptr0, len0, now_ms);
+        return takeObject(ret);
+    }
     /**
      * @param {Uint8Array} conv_id
      * @param {Uint8Array} plaintext
@@ -463,6 +568,91 @@ export function __wbgtest_module_signature() {
 export function _start() {
     wasm._start();
 }
+
+/**
+ * HPKE-open a sealed `LinkingTicket` ([CR-3]). Pure function — usable without an
+ * initialized `PingClient`, which is exactly the situation the receiving device is in
+ * (pre-bootstrap; no identity yet).
+ *
+ * `new_device_priv` must be 32 bytes (X25519 private key). Errors are returned with a
+ * generic message — the new device shouldn't get to discriminate "wrong key" from
+ * "tampered ciphertext".
+ * [CR-13] Decode a `LinkingTicket.catchup_snapshot` blob. Pure function; no client
+ * required. The new device calls this after `consumeLinkingTicket` to populate its
+ * initial UI.
+ * @param {Uint8Array} snapshot_bytes
+ * @returns {any}
+ */
+export function decodeCatchupSnapshot(snapshot_bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(snapshot_bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.decodeCatchupSnapshot(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {Uint8Array} sealed
+ * @param {Uint8Array} new_device_priv
+ * @returns {any}
+ */
+export function openLinkingTicket(sealed, new_device_priv) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(sealed, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(new_device_priv, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.openLinkingTicket(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * HPKE-seal a `LinkingTicket` ([CR-3]). Pure function — does not need an initialized
+ * `PingClient`, so it's exported at module scope and the JS facade can call it from an
+ * ephemeral worker (no full client init needed on the sender side).
+ *
+ * `new_device_pub` must be 32 bytes. Returns CBOR-encoded sealed bytes.
+ * @param {any} ticket
+ * @param {Uint8Array} new_device_pub
+ * @returns {Uint8Array}
+ */
+export function sealLinkingTicket(ticket, new_device_pub) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(new_device_pub, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.sealLinkingTicket(retptr, addHeapObject(ticket), ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -589,11 +779,11 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).crypto;
             return addHeapObject(ret);
         },
-        __wbg_del_bd0f0fc39ecf93f3: function(arg0, arg1, arg2, arg3, arg4) {
+        __wbg_del_66a920fc4595820f: function(arg0, arg1, arg2, arg3, arg4) {
             const ret = getObject(arg0).del(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
             return addHeapObject(ret);
         },
-        __wbg_discoverDevices_20f6d69fc3f0c6dc: function(arg0, arg1) {
+        __wbg_discoverDevices_472613341445f84b: function(arg0, arg1) {
             const ret = getObject(arg0).discoverDevices(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -619,7 +809,7 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_fetchSince_c99e6b5e03e34c45: function(arg0, arg1, arg2, arg3) {
+        __wbg_fetchSince_6aecae62f60e0c4d: function(arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).fetchSince(takeObject(arg1), takeObject(arg2), arg3 >>> 0);
             return addHeapObject(ret);
         },
@@ -630,7 +820,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_2213(a, state0.b, arg0, arg1, arg2);
+                        return __wasm_bindgen_func_elem_2611(a, state0.b, arg0, arg1, arg2);
                     } finally {
                         state0.a = a;
                     }
@@ -654,14 +844,14 @@ function __wbg_get_imports() {
         __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
             getObject(arg0).getRandomValues(getObject(arg1));
         }, arguments); },
-        __wbg_get_3b0e701762d26c7f: function(arg0, arg1, arg2, arg3, arg4) {
-            const ret = getObject(arg0).get(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
-            return addHeapObject(ret);
-        },
         __wbg_get_652f640b3b0b6e3e: function(arg0, arg1) {
             const ret = getObject(arg0)[arg1 >>> 0];
             return addHeapObject(ret);
         },
+        __wbg_get_766e63dd85cdb219: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).get(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+            return addHeapObject(ret);
+        },
         __wbg_get_9cfea9b7bbf12a15: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
@@ -714,7 +904,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).length;
             return ret;
         },
-        __wbg_listKeys_9c8036153fb97187: function(arg0, arg1, arg2, arg3, arg4) {
+        __wbg_listKeys_4dae540d80e53eed: function(arg0, arg1, arg2, arg3, arg4) {
             const ret = getObject(arg0).listKeys(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
             return addHeapObject(ret);
         },
@@ -771,7 +961,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_2212(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_2610(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -821,7 +1011,7 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_fd4050e806e1d519: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
-        __wbg_put_2b82187fb4a6bca4: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_put_427c95e389da8a00: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             const ret = getObject(arg0).put(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), takeObject(arg5));
             return addHeapObject(ret);
         },
@@ -847,7 +1037,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).self;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_send_774e8bbf824b9359: function(arg0, arg1) {
+        __wbg_send_5d4f40bbf83f6d1b: function(arg0, arg1) {
             const ret = getObject(arg0).send(takeObject(arg1));
             return addHeapObject(ret);
         },
@@ -944,8 +1134,8 @@ function __wbg_get_imports() {
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 614, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2203);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 722, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2601);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -989,10 +1179,10 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_2203(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_2601(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_2203(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_2601(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -1003,12 +1193,12 @@ function __wasm_bindgen_func_elem_2203(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_2212(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_2212(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_2610(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_2610(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
-function __wasm_bindgen_func_elem_2213(arg0, arg1, arg2, arg3, arg4) {
-    wasm.__wasm_bindgen_func_elem_2213(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
+function __wasm_bindgen_func_elem_2611(arg0, arg1, arg2, arg3, arg4) {
+    wasm.__wasm_bindgen_func_elem_2611(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
 }
 
 const WasmBindgenTestContextFinalization = (typeof FinalizationRegistry === 'undefined')

package/wasm/ping_wasm_bg.wasm.d.ts

@@ -2,22 +2,29 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_pingclient_free: (a: number, b: number) => void;
-export const pingclient_addMembers: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
-export const pingclient_buildLinkingTicket: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const decodeCatchupSnapshot: (a: number, b: number, c: number) => void;
+export const openLinkingTicket: (a: number, b: number, c: number, d: number, e: number) => void;
+export const pingclient_addMembers: (a: number, b: number, c: number, d: number, e: number) => number;
+export const pingclient_buildLinkingTicket: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
 export const pingclient_consumeLinkingTicket: (a: number, b: number, c: number) => number;
 export const pingclient_createConversation: (a: number, b: number, c: number, d: number) => number;
 export const pingclient_deviceId: (a: number, b: number) => void;
+export const pingclient_exportConversationSecret: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const pingclient_exportConversationStateSnapshot: (a: number, b: number, c: number, d: number, e: number) => void;
 export const pingclient_freshKeyPackage: (a: number, b: number) => void;
 export const pingclient_generateIdentity: (a: number) => void;
-export const pingclient_init: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const pingclient_importStateSnapshot: (a: number, b: number, c: number, d: number) => number;
+export const pingclient_init: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
 export const pingclient_joinConversation: (a: number, b: number, c: number) => number;
 export const pingclient_listConversations: (a: number, b: number) => void;
 export const pingclient_onMessage: (a: number, b: number) => void;
 export const pingclient_processEnvelope: (a: number, b: number, c: number) => number;
 export const pingclient_removeMembers: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const pingclient_revokeDevice: (a: number, b: number, c: number, d: number) => number;
 export const pingclient_send: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const pingclient_syncConversations: (a: number, b: number) => number;
 export const pingclient_userId: (a: number, b: number) => void;
+export const sealLinkingTicket: (a: number, b: number, c: number, d: number) => void;
 export const _start: () => void;
 export const __wbg_wasmbindgentestcontext_free: (a: number, b: number) => void;
 export const __wbgbench_dump: (a: number) => void;
@@ -34,9 +41,9 @@ export const wasmbindgentestcontext_filtered_count: (a: number, b: number) => vo
 export const wasmbindgentestcontext_include_ignored: (a: number, b: number) => void;
 export const wasmbindgentestcontext_new: (a: number) => number;
 export const wasmbindgentestcontext_run: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_2213: (a: number, b: number, c: number, d: number, e: number) => void;
-export const __wasm_bindgen_func_elem_2203: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_2212: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_2611: (a: number, b: number, c: number, d: number, e: number) => void;
+export const __wasm_bindgen_func_elem_2601: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_2610: (a: number, b: number, c: number, d: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;