@wireapp/core-crypto 0.4.0

package/platforms/web/corecrypto.js

@@ -0,0 +1,2315 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+let wasm$1;
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8Memory0 = new Uint8Array();
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm$1.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedFloat64Memory0 = new Float64Array();
+
+function getFloat64Memory0() {
+    if (cachedFloat64Memory0.byteLength === 0) {
+        cachedFloat64Memory0 = new Float64Array(wasm$1.memory.buffer);
+    }
+    return cachedFloat64Memory0;
+}
+
+let cachedInt32Memory0 = new Int32Array();
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm$1.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm$1.__wbindgen_export_2.get(state.dtor)(a, state.b);
+
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+
+    return real;
+}
+function __wbg_adapter_40(arg0, arg1, arg2) {
+    try {
+        const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+        wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hbae3a5a03bcd9ebb(retptr, arg0, arg1, addHeapObject(arg2));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        if (r1) {
+            throw takeObject(r0);
+        }
+    } finally {
+        wasm$1.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+function __wbg_adapter_43(arg0, arg1, arg2) {
+    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h04f9c855c75e5606(arg0, arg1, addHeapObject(arg2));
+}
+
+/**
+* @returns {string}
+*/
+function version() {
+    try {
+        const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+        wasm$1.version(retptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm$1.__wbindgen_add_to_stack_pointer(16);
+        wasm$1.__wbindgen_free(r0, r1);
+    }
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1);
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+    return instance.ptr;
+}
+
+let cachedUint32Memory0 = new Uint32Array();
+
+function getUint32Memory0() {
+    if (cachedUint32Memory0.byteLength === 0) {
+        cachedUint32Memory0 = new Uint32Array(wasm$1.memory.buffer);
+    }
+    return cachedUint32Memory0;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4);
+    const mem = getUint32Memory0();
+    for (let i = 0; i < array.length; i++) {
+        mem[ptr / 4 + i] = addHeapObject(array[i]);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm$1.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function __wbg_adapter_176(arg0, arg1, arg2, arg3) {
+    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__h4791cbe418449d5d(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+/**
+* see [core_crypto::prelude::CiphersuiteName]
+*/
+const Ciphersuite = Object.freeze({
+/**
+* DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
+*/
+MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519:1,"1":"MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519",
+/**
+* DH KEM P256 | AES-GCM 128 | SHA2-256 | EcDSA P256
+*/
+MLS_128_DHKEMP256_AES128GCM_SHA256_P256:2,"2":"MLS_128_DHKEMP256_AES128GCM_SHA256_P256",
+/**
+* DH KEM x25519 | Chacha20Poly1305 | SHA2-256 | Ed25519
+*/
+MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519:3,"3":"MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519",
+/**
+* DH KEM x448 | AES-GCM 256 | SHA2-512 | Ed448
+*/
+MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448:4,"4":"MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448",
+/**
+* DH KEM P521 | AES-GCM 256 | SHA2-512 | EcDSA P521
+*/
+MLS_256_DHKEMP521_AES256GCM_SHA512_P521:5,"5":"MLS_256_DHKEMP521_AES256GCM_SHA512_P521",
+/**
+* DH KEM x448 | Chacha20Poly1305 | SHA2-512 | Ed448
+*/
+MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448:6,"6":"MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448",
+/**
+* DH KEM P384 | AES-GCM 256 | SHA2-384 | EcDSA P384
+*/
+MLS_256_DHKEMP384_AES256GCM_SHA384_P384:7,"7":"MLS_256_DHKEMP384_AES256GCM_SHA384_P384", });
+/**
+*/
+class CommitBundle {
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_commitbundle_free(ptr);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get commit() {
+        const ret = wasm$1.commitbundle_commit(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array | undefined}
+    */
+    get welcome() {
+        const ret = wasm$1.commitbundle_welcome(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get public_group_state() {
+        const ret = wasm$1.commitbundle_public_group_state(this.ptr);
+        return takeObject(ret);
+    }
+}
+/**
+* see [core_crypto::prelude::MlsConversationConfiguration]
+*/
+class ConversationConfiguration {
+
+    static __wrap(ptr) {
+        const obj = Object.create(ConversationConfiguration.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_conversationconfiguration_free(ptr);
+    }
+    /**
+    * @param {(Uint8Array)[] | undefined} admins
+    * @param {number | undefined} ciphersuite
+    * @param {number | undefined} key_rotation_span
+    * @param {(Uint8Array)[] | undefined} external_senders
+    */
+    constructor(admins, ciphersuite, key_rotation_span, external_senders) {
+        var ptr0 = isLikeNone(admins) ? 0 : passArrayJsValueToWasm0(admins, wasm$1.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(external_senders) ? 0 : passArrayJsValueToWasm0(external_senders, wasm$1.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.conversationconfiguration_new(ptr0, len0, isLikeNone(ciphersuite) ? 8 : ciphersuite, !isLikeNone(key_rotation_span), isLikeNone(key_rotation_span) ? 0 : key_rotation_span, ptr1, len1);
+        return ConversationConfiguration.__wrap(ret);
+    }
+}
+/**
+*/
+class CoreCrypto$1 {
+
+    static __wrap(ptr) {
+        const obj = Object.create(CoreCrypto$1.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_corecrypto_free(ptr);
+    }
+    /**
+    * see [core_crypto::MlsCentral::try_new]
+    * @param {string} path
+    * @param {string} key
+    * @param {string} client_id
+    * @param {Uint8Array | undefined} entropy_seed
+    * @returns {Promise<CoreCrypto>}
+    */
+    static _internal_new(path, key, client_id, entropy_seed) {
+        const ptr0 = passStringToWasm0(path, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(key, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(client_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm$1.__wbindgen_malloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto__internal_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::MlsCentral::close]
+    * @returns {Promise<any>}
+    */
+    close() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm$1.corecrypto_close(ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::MlsCentral::wipe]
+    * @returns {Promise<any>}
+    */
+    wipe() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm$1.corecrypto_wipe(ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::MlsCentral::callbacks]
+    * @param {CoreCryptoWasmCallbacks} callbacks
+    * @returns {Promise<any>}
+    */
+    set_callbacks(callbacks) {
+        _assertClass(callbacks, CoreCryptoWasmCallbacks);
+        var ptr0 = callbacks.ptr;
+        callbacks.ptr = 0;
+        const ret = wasm$1.corecrypto_set_callbacks(this.ptr, ptr0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns:: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::client_public_key]
+    * @returns {Promise<any>}
+    */
+    client_public_key() {
+        const ret = wasm$1.corecrypto_client_public_key(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Array<js_sys::Uint8Array>>`]
+    *
+    * see [core_crypto::MlsCentral::client_keypackages]
+    * @param {number} amount_requested
+    * @returns {Promise<any>}
+    */
+    client_keypackages(amount_requested) {
+        const ret = wasm$1.corecrypto_client_keypackages(this.ptr, amount_requested);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<usize>`]
+    *
+    * see [core_crypto::MlsCentral::client_valid_keypackages_count]
+    * @returns {Promise<any>}
+    */
+    client_valid_keypackages_count() {
+        const ret = wasm$1.corecrypto_client_valid_keypackages_count(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::MlsCentral::new_conversation]
+    * @param {Uint8Array} conversation_id
+    * @param {ConversationConfiguration} config
+    * @returns {Promise<any>}
+    */
+    create_conversation(conversation_id, config) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(config, ConversationConfiguration);
+        var ptr1 = config.ptr;
+        config.ptr = 0;
+        const ret = wasm$1.corecrypto_create_conversation(this.ptr, ptr0, len0, ptr1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns [`WasmCryptoResult<u64>`]
+    *
+    * see [core_crypto::MlsCentral::conversation_epoch]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    conversation_epoch(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_conversation_epoch(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`bool`]
+    *
+    * see [core_crypto::MlsCentral::conversation_exists]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    conversation_exists(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_conversation_exists(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::process_raw_welcome_message]
+    * @param {Uint8Array} welcome_message
+    * @returns {Promise<any>}
+    */
+    process_welcome_message(welcome_message) {
+        const ptr0 = passArray8ToWasm0(welcome_message, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_process_welcome_message(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Option<MemberAddedMessages>>`]
+    *
+    * see [core_crypto::MlsCentral::add_members_to_conversation]
+    * @param {Uint8Array} conversation_id
+    * @param {any[]} clients
+    * @returns {Promise<any>}
+    */
+    add_clients_to_conversation(conversation_id, clients) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_add_clients_to_conversation(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Option<js_sys::Uint8Array>>`]
+    *
+    * see [core_crypto::MlsCentral::remove_members_from_conversation]
+    * @param {Uint8Array} conversation_id
+    * @param {(Uint8Array)[]} clients
+    * @returns {Promise<any>}
+    */
+    remove_clients_from_conversation(conversation_id, clients) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_remove_clients_from_conversation(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<CommitBundle>`]
+    *
+    * see [core_crypto::MlsCentral::update_keying_material]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    update_keying_material(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_update_keying_material(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * see [core_crypto::MlsCentral::commit_pending_proposals]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    commit_pending_proposals(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_commit_pending_proposals(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Option<MemberAddedMessages>>`]
+    *
+    * see [core_crypto::MlsCentral::add_members_to_conversation]
+    * @param {Uint8Array} conversation_id
+    * @param {any[]} clients
+    * @returns {Promise<any>}
+    */
+    final_add_clients_to_conversation(conversation_id, clients) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_final_add_clients_to_conversation(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Option<js_sys::Uint8Array>>`]
+    *
+    * see [core_crypto::MlsCentral::remove_members_from_conversation]
+    * @param {Uint8Array} conversation_id
+    * @param {(Uint8Array)[]} clients
+    * @returns {Promise<any>}
+    */
+    final_remove_clients_from_conversation(conversation_id, clients) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_final_remove_clients_from_conversation(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<CommitBundle>`]
+    *
+    * see [core_crypto::MlsCentral::update_keying_material]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    final_update_keying_material(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_final_update_keying_material(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * see [core_crypto::MlsCentral::commit_pending_proposals]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    final_commit_pending_proposals(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_final_commit_pending_proposals(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::MlsCentral::wipe_conversation]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    wipe_conversation(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_wipe_conversation(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<DecryptedMessage>`]
+    *
+    * see [core_crypto::MlsCentral::decrypt_message]
+    * @param {Uint8Array} conversation_id
+    * @param {Uint8Array} payload
+    * @returns {Promise<any>}
+    */
+    decrypt_message(conversation_id, payload) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(payload, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_decrypt_message(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::encrypt_message]
+    * @param {Uint8Array} conversation_id
+    * @param {Uint8Array} message
+    * @returns {Promise<any>}
+    */
+    encrypt_message(conversation_id, message) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_encrypt_message(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::new_proposal]
+    * @param {Uint8Array} conversation_id
+    * @param {Uint8Array} keypackage
+    * @returns {Promise<any>}
+    */
+    new_add_proposal(conversation_id, keypackage) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(keypackage, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_new_add_proposal(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::new_proposal]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    new_update_proposal(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_new_update_proposal(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::new_proposal]
+    * @param {Uint8Array} conversation_id
+    * @param {Uint8Array} client_id
+    * @returns {Promise<any>}
+    */
+    new_remove_proposal(conversation_id, client_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(client_id, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_new_remove_proposal(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::new_external_add_proposal]
+    * @param {Uint8Array} conversation_id
+    * @param {number} epoch
+    * @returns {Promise<any>}
+    */
+    new_external_add_proposal(conversation_id, epoch) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_new_external_add_proposal(this.ptr, ptr0, len0, epoch);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::new_external_remove_proposal]
+    * @param {Uint8Array} conversation_id
+    * @param {number} epoch
+    * @param {Uint8Array} keypackage_ref
+    * @returns {Promise<any>}
+    */
+    new_external_remove_proposal(conversation_id, epoch, keypackage_ref) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(keypackage_ref, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_new_external_remove_proposal(this.ptr, ptr0, len0, epoch, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::export_public_group_state]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    export_group_state(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_export_group_state(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<MlsConversationInitMessage>`]
+    *
+    * see [core_crypto::MlsCentral::join_by_external_commit]
+    * @param {Uint8Array} group_state
+    * @returns {Promise<any>}
+    */
+    join_by_external_commit(group_state) {
+        const ptr0 = passArray8ToWasm0(group_state, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_join_by_external_commit(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::MlsCentral::merge_pending_group_from_external_commit]
+    * @param {Uint8Array} conversation_id
+    * @param {ConversationConfiguration} configuration
+    * @returns {Promise<any>}
+    */
+    merge_pending_group_from_external_commit(conversation_id, configuration) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(configuration, ConversationConfiguration);
+        var ptr1 = configuration.ptr;
+        configuration.ptr = 0;
+        const ret = wasm$1.corecrypto_merge_pending_group_from_external_commit(this.ptr, ptr0, len0, ptr1);
+        return takeObject(ret);
+    }
+    /**
+    * see [core_crypto::MlsCentral::commit_accepted]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    commit_accepted(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_commit_accepted(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * see [core_crypto::MlsCentral::clear_pending_proposal]
+    * @param {Uint8Array} conversation_id
+    * @param {Uint8Array} proposal_ref
+    * @returns {Promise<any>}
+    */
+    clear_pending_proposal(conversation_id, proposal_ref) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(proposal_ref, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_clear_pending_proposal(this.ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * see [core_crypto::MlsCentral::clear_pending_commit]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    clear_pending_commit(conversation_id) {
+        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_clear_pending_commit(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::MlsCentral::random_bytes]
+    * @param {number} len
+    * @returns {Promise<any>}
+    */
+    random_bytes(len) {
+        const ret = wasm$1.corecrypto_random_bytes(this.ptr, len);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [mls_crypto_provider::MlsCryptoProvider::reseed]
+    * @param {Uint8Array} seed
+    * @returns {Promise<any>}
+    */
+    reseed_rng(seed) {
+        const ptr0 = passArray8ToWasm0(seed, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_reseed_rng(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+}
+/**
+* see [core_crypto::prelude::CoreCryptoCallbacks]
+*/
+class CoreCryptoWasmCallbacks {
+
+    static __wrap(ptr) {
+        const obj = Object.create(CoreCryptoWasmCallbacks.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_corecryptowasmcallbacks_free(ptr);
+    }
+    /**
+    * @param {Function} authorize
+    * @param {Function} is_user_in_group
+    */
+    constructor(authorize, is_user_in_group) {
+        const ret = wasm$1.corecryptowasmcallbacks_new(addHeapObject(authorize), addHeapObject(is_user_in_group));
+        return CoreCryptoWasmCallbacks.__wrap(ret);
+    }
+}
+/**
+* see [core_crypto::prelude::decrypt::MlsConversationDecryptMessage]
+*/
+class DecryptedMessage {
+
+    static __wrap(ptr) {
+        const obj = Object.create(DecryptedMessage.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_decryptedmessage_free(ptr);
+    }
+    /**
+    * @returns {Uint8Array | undefined}
+    */
+    get message() {
+        const ret = wasm$1.decryptedmessage_message(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Array<any>}
+    */
+    get proposals() {
+        const ret = wasm$1.decryptedmessage_proposals(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {boolean}
+    */
+    get is_active() {
+        const ret = wasm$1.decryptedmessage_is_active(this.ptr);
+        return ret !== 0;
+    }
+    /**
+    * @returns {number | undefined}
+    */
+    get commit_delay() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.decryptedmessage_commit_delay(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return r0 === 0 ? undefined : r1 >>> 0;
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+/**
+* see [core_crypto::prelude::ConversationMember]
+*/
+class Invitee {
+
+    static __wrap(ptr) {
+        const obj = Object.create(Invitee.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_invitee_free(ptr);
+    }
+    /**
+    * @param {Uint8Array} id
+    * @param {Uint8Array} kp
+    */
+    constructor(id, kp) {
+        const ret = wasm$1.invitee_new(addHeapObject(id), addHeapObject(kp));
+        return Invitee.__wrap(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get id() {
+        const ret = wasm$1.invitee_id(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get kp() {
+        const ret = wasm$1.invitee_kp(this.ptr);
+        return takeObject(ret);
+    }
+}
+/**
+* see [core_crypto::prelude::MlsConversationCreationMessage]
+*/
+class MemberAddedMessages {
+
+    static __wrap(ptr) {
+        const obj = Object.create(MemberAddedMessages.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_memberaddedmessages_free(ptr);
+    }
+    /**
+    * @param {Uint8Array} welcome
+    * @param {Uint8Array} commit
+    * @param {Uint8Array} public_group_state
+    */
+    constructor(welcome, commit, public_group_state) {
+        const ret = wasm$1.memberaddedmessages_new(addHeapObject(welcome), addHeapObject(commit), addHeapObject(public_group_state));
+        return MemberAddedMessages.__wrap(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get welcome() {
+        const ret = wasm$1.memberaddedmessages_welcome(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get commit() {
+        const ret = wasm$1.memberaddedmessages_commit(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get public_group_state() {
+        const ret = wasm$1.memberaddedmessages_public_group_state(this.ptr);
+        return takeObject(ret);
+    }
+}
+/**
+*/
+class MlsConversationInitMessage {
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_mlsconversationinitmessage_free(ptr);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get commit() {
+        const ret = wasm$1.mlsconversationinitmessage_commit(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get group() {
+        const ret = wasm$1.mlsconversationinitmessage_group(this.ptr);
+        return takeObject(ret);
+    }
+}
+/**
+*/
+class ProposalBundle {
+
+    static __wrap(ptr) {
+        const obj = Object.create(ProposalBundle.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_proposalbundle_free(ptr);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get proposal() {
+        const ret = wasm$1.proposalbundle_proposal(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get proposal_ref() {
+        const ret = wasm$1.proposalbundle_proposal_ref(this.ptr);
+        return takeObject(ret);
+    }
+}
+
+async function load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function getImports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_is_object = function(arg0) {
+        const val = getObject(arg0);
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbg_new_e6a9fecc2bf26696 = function() {
+        const ret = new Object();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_e93b31d47b90bff6 = function(arg0, arg1, arg2) {
+        getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+    };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new0_adda2d4bcb124f0a = function() {
+        const ret = new Date();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getTime_58b0bdbebd4ef11d = function(arg0) {
+        const ret = getObject(arg0).getTime();
+        return ret;
+    };
+    imports.wbg.__wbg_new_cda198d9dbc6d7ea = function(arg0) {
+        const ret = new Uint8Array(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_corecrypto_new = function(arg0) {
+        const ret = CoreCrypto$1.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_bigint_new = function(arg0, arg1) {
+        const ret = BigInt(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_decryptedmessage_new = function(arg0) {
+        const ret = DecryptedMessage.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_ee1a3da85465d621 = function() {
+        const ret = new Array();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_push_0bc7fce4a139a883 = function(arg0, arg1) {
+        const ret = getObject(arg0).push(getObject(arg1));
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_boolean_get = function(arg0) {
+        const v = getObject(arg0);
+        const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+        return ret;
+    };
+    imports.wbg.__wbg_new_52205195aa880fc2 = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_176(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return addHeapObject(ret);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_proposalbundle_new = function(arg0) {
+        const ret = ProposalBundle.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_get_093fe3cdafaf8976 = function(arg0, arg1) {
+        const ret = getObject(arg0)[takeObject(arg1)];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_isArray_a1a8c3a8ac24bdf1 = function(arg0) {
+        const ret = Array.isArray(getObject(arg0));
+        return ret;
+    };
+    imports.wbg.__wbg_length_a73bfd4c96dd97ef = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_iterator_22ed2b976832ff0c = function() {
+        const ret = Symbol.iterator;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_get_72332cd2bc57924c = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg_call_33d7bcddbbfa394a = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_next_726d1c2255989269 = function(arg0) {
+        const ret = getObject(arg0).next;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_next_3d0c4cc33e7418c9 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).next();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_done_e5655b169bb04f60 = function(arg0) {
+        const ret = getObject(arg0).done;
+        return ret;
+    };
+    imports.wbg.__wbg_value_8f901bca1014f843 = function(arg0) {
+        const ret = getObject(arg0).value;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
+        getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    };
+    imports.wbg.__wbg_isSafeInteger_f6dd91807e9c4d35 = function(arg0) {
+        const ret = Number.isSafeInteger(getObject(arg0));
+        return ret;
+    };
+    imports.wbg.__wbg_get_ad41fee29b7e0f53 = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_is_null = function(arg0) {
+        const ret = getObject(arg0) === null;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg_name_f232931b09239ddb = function(arg0, arg1) {
+        const ret = getObject(arg1).name;
+        const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_transaction_0dcffc72158c7b6f = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).transaction(getObject(arg1), takeObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_set_64cc39858b2ec3f1 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = takeObject(arg0).original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
+    };
+    imports.wbg.__wbg_setonsuccess_bb91afe1f8110021 = function(arg0, arg1) {
+        getObject(arg0).onsuccess = getObject(arg1);
+    };
+    imports.wbg.__wbg_setonerror_db491b84dd45e918 = function(arg0, arg1) {
+        getObject(arg0).onerror = getObject(arg1);
+    };
+    imports.wbg.__wbg_commit_6211fe2744b83edc = function() { return handleError(function (arg0) {
+        getObject(arg0).commit();
+    }, arguments) };
+    imports.wbg.__wbg_setoncomplete_8bfbade4ed628fd0 = function(arg0, arg1) {
+        getObject(arg0).oncomplete = getObject(arg1);
+    };
+    imports.wbg.__wbg_setonerror_9d842115702fd223 = function(arg0, arg1) {
+        getObject(arg0).onerror = getObject(arg1);
+    };
+    imports.wbg.__wbg_put_e193e5c9c96e937f = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_put_a727d1fdb5788ec1 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).put(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_delete_1ca98818fdc40291 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).delete(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_deleteDatabase_7b98d08298856363 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_close_87495affacd7f79d = function(arg0) {
+        getObject(arg0).close();
+    };
+    imports.wbg.__wbg_openCursor_4292a52d0e6d4246 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).openCursor(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_openCursor_10a7a7a41fce054c = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).openCursor();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_count_6f4c35312ff0234d = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).count();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_count_ea5300005a5f227d = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).count(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_get_28f9ffc7eb5802f3 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).get(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_get_a06b4198f86b037d = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).get(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_openCursor_a9656bd0901e39c0 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).openCursor();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_openCursor_2cfe2e04de0b6b91 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).openCursor(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_open_2a1e9120d3d8897d = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_open_3384efa97bde264f = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_setonupgradeneeded_8956d6214819f478 = function(arg0, arg1) {
+        getObject(arg0).onupgradeneeded = getObject(arg1);
+    };
+    imports.wbg.__wbg_randomFillSync_91e2b39becca6147 = function() { return handleError(function (arg0, arg1, arg2) {
+        getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
+    }, arguments) };
+    imports.wbg.__wbg_subarray_270ff8dd5582c1ac = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getRandomValues_b14734aa289bc356 = function() { return handleError(function (arg0, arg1) {
+        getObject(arg0).getRandomValues(getObject(arg1));
+    }, arguments) };
+    imports.wbg.__wbg_length_51f19f73d6d9eff3 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_process_e56fd54cf6319b6c = function(arg0) {
+        const ret = getObject(arg0).process;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_versions_77e21455908dad33 = function(arg0) {
+        const ret = getObject(arg0).versions;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_node_0dd25d832e4785d5 = function(arg0) {
+        const ret = getObject(arg0).node;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbg_static_accessor_NODE_MODULE_26b231378c1be7dd = function() {
+        const ret = module;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_require_0db1598d9ccecb30 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).require(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_crypto_b95d7173266618a9 = function(arg0) {
+        const ret = getObject(arg0).crypto;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_msCrypto_5a86d77a66230f81 = function(arg0) {
+        const ret = getObject(arg0).msCrypto;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithlength_66e5530e7079ea1b = function(arg0) {
+        const ret = new Uint8Array(arg0 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_self_fd00a1ef86d1b2ed = function() { return handleError(function () {
+        const ret = self.self;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_window_6f6e346d8bbd61d7 = function() { return handleError(function () {
+        const ret = window.window;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_globalThis_3348936ac49df00a = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_global_67175caf56f55ca9 = function() { return handleError(function () {
+        const ret = global.global;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_newnoargs_971e9a5abe185139 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_call_65af9f665ab6ade5 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_call_187e4e7f6f4285fb = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_set_2762e698c2f5b7e0 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm$1.memory;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_buffer_34f5ec9f8a838ba0 = function(arg0) {
+        const ret = getObject(arg0).buffer;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_88fdad741db1b182 = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_1a930cfcda1a8067 = function(arg0, arg1, arg2) {
+        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+    };
+    imports.wbg.__wbg_now_1b6e18d94ce2c037 = function() {
+        const ret = Date.now();
+        return ret;
+    };
+    imports.wbg.__wbg_target_68a5c10e2732a79e = function(arg0) {
+        const ret = getObject(arg0).target;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_objectStoreNames_d11a3d06e3226638 = function(arg0) {
+        const ret = getObject(arg0).objectStoreNames;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_contains_bcaf1388e1ca982c = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
+        return ret;
+    };
+    imports.wbg.__wbg_createObjectStore_454d7cf701faa545 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2), getObject(arg3));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_transaction_0ba302b35542323f = function(arg0) {
+        const ret = getObject(arg0).transaction;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_indexNames_8f97f1f79bc278bf = function(arg0) {
+        const ret = getObject(arg0).indexNames;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_createIndex_20c39366f6b22548 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_length_580a8f6d9757b9da = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_deleteIndex_9d33d4fd04e9038c = function() { return handleError(function (arg0, arg1, arg2) {
+        getObject(arg0).deleteIndex(getStringFromWasm0(arg1, arg2));
+    }, arguments) };
+    imports.wbg.__wbg_deleteObjectStore_ec34033b22e0c4e1 = function() { return handleError(function (arg0, arg1, arg2) {
+        getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
+    }, arguments) };
+    imports.wbg.__wbg_error_c872d3f7251736f1 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).error;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_is_falsy = function(arg0) {
+        const ret = !getObject(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_key_3ce14c27a234543a = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).key;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_advance_5da26ebf2f15b82e = function() { return handleError(function (arg0, arg1) {
+        getObject(arg0).advance(arg1 >>> 0);
+    }, arguments) };
+    imports.wbg.__wbg_instanceof_IdbFactory_acaddaa9df3f73bc = function(arg0) {
+        const ret = getObject(arg0) instanceof IDBFactory;
+        return ret;
+    };
+    imports.wbg.__wbg_index_49e22b15910e16d4 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_toString_dc4768002eeae1b0 = function(arg0) {
+        const ret = getObject(arg0).toString();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_3ee7ebe9952c1fbd = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_instanceof_Uint8Array_36c37b9ca15e3e0a = function(arg0) {
+        const ret = getObject(arg0) instanceof Uint8Array;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_ArrayBuffer_02bbeeb60438c785 = function(arg0) {
+        const ret = getObject(arg0) instanceof ArrayBuffer;
+        return ret;
+    };
+    imports.wbg.__wbg_String_7462bcc0fcdbaf7d = function(arg0, arg1) {
+        const ret = String(getObject(arg1));
+        const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+        const ret = debugString(getObject(arg1));
+        const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_then_18da6e5453572fc8 = function(arg0, arg1) {
+        const ret = getObject(arg0).then(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_resolve_0107b3a501450ba0 = function(arg0) {
+        const ret = Promise.resolve(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_get_50220f3428ca7e51 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg1)[arg2 >>> 0];
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_continue_43562ff8da972056 = function() { return handleError(function (arg0) {
+        getObject(arg0).continue();
+    }, arguments) };
+    imports.wbg.__wbg_value_a3a782e66c6935d3 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).value;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_openCursor_48949b0ae4868b31 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_openCursor_abefd2bc54b71e0f = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_result_4b44b0d900b4ab6f = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).result;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_objectStore_76c268be095ec9a5 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_closure_wrapper2517 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 105, __wbg_adapter_40);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper4457 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 113, __wbg_adapter_43);
+        return addHeapObject(ret);
+    };
+
+    return imports;
+}
+
+function finalizeInit(instance, module) {
+    wasm$1 = instance.exports;
+    init.__wbindgen_wasm_module = module;
+    cachedFloat64Memory0 = new Float64Array();
+    cachedInt32Memory0 = new Int32Array();
+    cachedUint32Memory0 = new Uint32Array();
+    cachedUint8Memory0 = new Uint8Array();
+
+
+    return wasm$1;
+}
+
+function initSync(bytes) {
+    const imports = getImports();
+
+    const module = new WebAssembly.Module(bytes);
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return finalizeInit(instance, module);
+}
+
+async function init(input) {
+    if (typeof input === 'undefined') {
+        input = new URL('index_bg.wasm', import.meta.url);
+    }
+    const imports = getImports();
+
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
+    }
+
+    const { instance, module } = await load(await input, imports);
+
+    return finalizeInit(instance, module);
+}
+
+var exports = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    version: version,
+    Ciphersuite: Ciphersuite,
+    CommitBundle: CommitBundle,
+    ConversationConfiguration: ConversationConfiguration,
+    CoreCrypto: CoreCrypto$1,
+    CoreCryptoWasmCallbacks: CoreCryptoWasmCallbacks,
+    DecryptedMessage: DecryptedMessage,
+    Invitee: Invitee,
+    MemberAddedMessages: MemberAddedMessages,
+    MlsConversationInitMessage: MlsConversationInitMessage,
+    ProposalBundle: ProposalBundle,
+    initSync: initSync,
+    'default': init
+});
+
+var wasm = async (opt = {}) => {
+                        let {importHook, serverPath} = opt;
+
+                        let path = "assets/core_crypto_ffi-0df6a73f.wasm";
+
+                        if (serverPath != null) {
+                            path = serverPath + /[^\/\\]*$/.exec(path)[0];
+                        }
+
+                        if (importHook != null) {
+                            path = importHook(path);
+                        }
+
+                        await init(path);
+                        return exports;
+                    };
+
+// Wire
+// Copyright (C) 2022 Wire Swiss GmbH
+var _a, _CoreCrypto_module, _CoreCrypto_cc;
+/**
+ * Wrapper for the WASM-compiled version of CoreCrypto
+ */
+class CoreCrypto {
+    /** @hidden */
+    constructor(cc) {
+        /** @hidden */
+        _CoreCrypto_cc.set(this, void 0);
+        __classPrivateFieldSet(this, _CoreCrypto_cc, cc, "f");
+    }
+    /**
+     * This is your entrypoint to initialize {@link CoreCrypto}!
+     *
+     * @param params - {@link CoreCryptoParams}
+     *
+     * @example
+     * ## Simple init
+     * ```ts
+     * const cc = await CoreCrypto.init({ databaseName: "test", key: "test", clientId: "test" });
+     * // Do the rest with `cc`
+     * ```
+     *
+     * ## Custom Entropy seed init & wasm file location
+     * ```ts
+     * // FYI, this is the IETF test vector #1
+     * const entropySeed = Uint32Array.from([
+     *   0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653,
+     *   0xb819d2bd, 0x1aed8da0, 0xccef36a8, 0xc70d778b,
+     *   0x7c5941da, 0x8d485751, 0x3fe02477, 0x374ad8b8,
+     *   0xf4b8436a, 0x1ca11815, 0x69b687c3, 0x8665eeb2,
+     * ]);
+     *
+     * const wasmFilePath = "/long/complicated/path/on/webserver/whatever.wasm";
+     *
+     * const cc = await CoreCrypto.init({
+     *   databaseName: "test",
+     *   key: "test",
+     *   clientId: "test",
+     *   entropySeed,
+     *   wasmFilePath,
+     * });
+     * ````
+     */
+    static async init({ databaseName, key, clientId, wasmFilePath, entropySeed }) {
+        if (!__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module)) {
+            const wasmImportArgs = wasmFilePath ? { importHook: () => wasmFilePath } : undefined;
+            const exports = (await wasm(wasmImportArgs));
+            __classPrivateFieldSet(this, _a, exports, "f", _CoreCrypto_module);
+        }
+        const cc = await __classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto._internal_new(databaseName, key, clientId, entropySeed);
+        return new this(cc);
+    }
+    /**
+     * Wipes the {@link CoreCrypto} backing storage (i.e. {@link https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API | IndexedDB} database)
+     *
+     * **CAUTION**: This {@link CoreCrypto} instance won't be useable after a call to this method, but there's no way to express this requirement in TypeScript so you'll get errors instead!
+     */
+    async wipe() {
+        await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").wipe();
+    }
+    /**
+     * Closes this {@link CoreCrypto} instance and deallocates all loaded resources
+     *
+     * **CAUTION**: This {@link CoreCrypto} instance won't be useable after a call to this method, but there's no way to express this requirement in TypeScript so you'll get errors instead!
+     */
+    async close() {
+        await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").close();
+    }
+    /**
+     * Checks if the Client is member of a given conversation and if the MLS Group is loaded up
+     *
+     * @returns Whether the given conversation ID exists
+     *
+     * @example
+     * ```ts
+     *  const cc = await CoreCrypto.init({ databaseName: "test", key: "test", clientId: "test" });
+     *  const encoder = new TextEncoder();
+     *  if (await cc.conversationExists(encoder.encode("my super chat"))) {
+     *    // Do something
+     *  } else {
+     *    // Do something else
+     *  }
+     * ```
+     */
+    async conversationExists(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").conversation_exists(conversationId);
+    }
+    /**
+     * Returns the current epoch of a conversation
+     *
+     * @returns the epoch of the conversation
+     *
+     * @example
+     * ```ts
+     *  const cc = await CoreCrypto.init({ databaseName: "test", key: "test", clientId: "test" });
+     *  const encoder = new TextEncoder();
+     *  console.log(await cc.conversationEpoch(encoder.encode("my super chat")))
+     * ```
+     */
+    async conversationEpoch(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").conversation_epoch(conversationId);
+    }
+    /**
+     * Wipes and destroys the local storage of a given conversation / MLS group
+     *
+     * @param conversationId - The ID of the conversation to remove
+     */
+    async wipeConversation(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").wipe_conversation(conversationId);
+    }
+    /**
+     * Creates a new conversation with the current client being the sole member
+     * You will want to use {@link CoreCrypto.addClientsToConversation} afterwards to add clients to this conversation
+     *
+     * @param conversationId - The conversation ID; You can either make them random or let the backend attribute MLS group IDs
+     * @param configuration.admins - An array of client IDs that will have administrative permissions over the group
+     * @param configuration.ciphersuite - The {@link Ciphersuite} that is chosen to be the group's
+     * @param configuration.keyRotationSpan - The amount of time in milliseconds after which the MLS Keypackages will be rotated
+     * @param configuration.externalSenders - Array of Client IDs that are qualified as external senders within the group
+     */
+    async createConversation(conversationId, configuration = {}) {
+        const { admins, ciphersuite, keyRotationSpan, externalSenders } = configuration !== null && configuration !== void 0 ? configuration : {};
+        const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).ConversationConfiguration)(admins, ciphersuite, keyRotationSpan, externalSenders);
+        const ret = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").create_conversation(conversationId, config);
+        return ret;
+    }
+    /**
+     * Decrypts a message for a given conversation
+     *
+     * @param conversationId - The ID of the conversation
+     * @param payload - The encrypted message buffer
+     *
+     * @returns Either a {@link DecryptedMessage} payload or `undefined` - This happens when the encrypted payload contains a system message such a proposal or commit
+     */
+    async decryptMessage(conversationId, payload) {
+        const ffiDecryptedMessage = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").decrypt_message(conversationId, payload);
+        const commitDelay = ffiDecryptedMessage.commit_delay ?
+            ffiDecryptedMessage.commit_delay * 1000 :
+            undefined;
+        const ret = {
+            message: ffiDecryptedMessage.message,
+            proposals: ffiDecryptedMessage.proposals,
+            isActive: ffiDecryptedMessage.is_active,
+            commitDelay,
+        };
+        return ret;
+    }
+    /**
+     * Encrypts a message for a given conversation
+     *
+     * @param conversationId - The ID of the conversation
+     * @param message - The plaintext message to encrypt
+     *
+     * @returns The encrypted payload for the given group. This needs to be fanned out to the other members of the group.
+     */
+    async encryptMessage(conversationId, message) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").encrypt_message(conversationId, message);
+    }
+    /**
+     * Ingest a TLS-serialized MLS welcome message to join a an existing MLS group
+     *
+     * @param welcomeMessage - TLS-serialized MLS Welcome message
+     * @returns The conversation ID of the newly joined group. You can use the same ID to decrypt/encrypt messages
+     */
+    async processWelcomeMessage(welcomeMessage) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").process_welcome_message(welcomeMessage);
+    }
+    /**
+     * @returns The client's public key
+     */
+    async clientPublicKey() {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_public_key();
+    }
+    /**
+     * @returns The amount of valid, non-expired KeyPackages that are persisted in the backing storage
+     */
+    async clientValidKeypackagesCount() {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_valid_keypackages_count();
+    }
+    /**
+     * Fetches a requested amount of keypackages
+     *
+     * @param amountRequested - The amount of keypackages requested
+     * @returns An array of length `amountRequested` containing TLS-serialized KeyPackages
+     */
+    async clientKeypackages(amountRequested) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_keypackages(amountRequested);
+    }
+    /**
+     * Adds new clients to a conversation, assuming the current client has the right to add new clients to the conversation.
+     *
+     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
+     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
+     * epoch, use new encryption secrets etc...
+     *
+     * @param conversationId - The ID of the conversation
+     * @param clients - Array of {@link Invitee} (which are Client ID / KeyPackage pairs)
+     *
+     * @returns A {@link CommitBundle}
+     */
+    async addClientsToConversation(conversationId, clients) {
+        const ffiClients = clients.map((invitee) => new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).Invitee)(invitee.id, invitee.kp));
+        const ffiRet = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").add_clients_to_conversation(conversationId, ffiClients);
+        ffiClients.forEach(c => c.free());
+        const ret = {
+            welcome: ffiRet.welcome,
+            commit: ffiRet.commit,
+            publicGroupState: ffiRet.public_group_state,
+        };
+        return ret;
+    }
+    /**
+     * Removes the provided clients from a conversation; Assuming those clients exist and the current client is allowed
+     * to do so, otherwise this operation does nothing.
+     *
+     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
+     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
+     * epoch, use new encryption secrets etc...
+     *
+     * @param conversationId - The ID of the conversation
+     * @param clientIds - Array of Client IDs to remove.
+     *
+     * @returns A {@link CommitBundle}, or `undefined` if for any reason, the operation would result in an empty commit
+     */
+    async removeClientsFromConversation(conversationId, clientIds) {
+        const ffiRet = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").remove_clients_from_conversation(conversationId, clientIds);
+        const ret = {
+            welcome: ffiRet.welcome,
+            commit: ffiRet.commit,
+            publicGroupState: ffiRet.public_group_state,
+        };
+        return ret;
+    }
+    /**
+     * Creates an update commit which forces every client to update their keypackages in the conversation
+     *
+     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
+     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
+     * epoch, use new encryption secrets etc...
+     *
+     * @param conversationId - The ID of the conversation
+     *
+     * @returns A {@link CommitBundle}
+     */
+    async updateKeyingMaterial(conversationId) {
+        const ffiRet = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").update_keying_material(conversationId);
+        const ret = {
+            welcome: ffiRet.welcome,
+            commit: ffiRet.commit,
+            publicGroupState: ffiRet.public_group_state,
+        };
+        return ret;
+    }
+    /**
+     * Commits the local pending proposals and returns the {@link CommitBundle} object containing what can result from this operation.
+     *
+     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
+     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
+     * epoch, use new encryption secrets etc...
+     *
+     * @param conversationId - The ID of the conversation
+     *
+     * @returns A {@link CommitBundle}
+     */
+    async commitPendingProposals(conversationId) {
+        const ffiCommitBundle = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").commit_pending_proposals(conversationId);
+        const ret = {
+            welcome: ffiCommitBundle.welcome,
+            commit: ffiCommitBundle.commit,
+            publicGroupState: ffiCommitBundle.public_group_state,
+        };
+        return ret;
+    }
+    /**
+     * Adds new clients to a conversation, assuming the current client has the right to add new clients to the conversation.
+     * The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
+     * It also contains a Welcome message the Delivery Service will forward to invited clients and
+     * an updated PublicGroupState required by clients willing to join the group by an external commit.
+     *
+     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
+     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
+     * epoch, use new encryption secrets etc...
+     *
+     * @param conversationId - The ID of the conversation
+     * @param clients - Array of {@link Invitee} (which are Client ID / KeyPackage pairs)
+     *
+     * @returns A {@link CommitBundle} byte array to fan out to the Delivery Service
+     */
+    async finalAddClientsToConversation(conversationId, clients) {
+        const ffiClients = clients.map((invitee) => new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).Invitee)(invitee.id, invitee.kp));
+        const ret = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").add_clients_to_conversation(conversationId, ffiClients);
+        ffiClients.forEach(c => c.free());
+        return ret;
+    }
+    /**
+     * Removes the provided clients from a conversation; Assuming those clients exist and the current client is allowed
+     * to do so, otherwise this operation does nothing.
+     *
+     * The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
+     * It also contains a Welcome message the Delivery Service will forward to invited clients and
+     * an updated PublicGroupState required by clients willing to join the group by an external commit.
+     *
+     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
+     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
+     * epoch, use new encryption secrets etc...
+     *
+     * @param conversationId - The ID of the conversation
+     * @param clientIds - Array of Client IDs to remove.
+     *
+     * @returns A {@link CommitBundle} byte array to fan out to the Delivery Service, or `undefined` if for any reason, the operation would result in an empty commit
+     */
+    async finalRemoveClientsFromConversation(conversationId, clientIds) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").remove_clients_from_conversation(conversationId, clientIds);
+    }
+    /**
+     * Creates an update commit which forces every client to update their keypackages in the conversation
+     *
+     * The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
+     * It also contains a Welcome message the Delivery Service will forward to invited clients and
+     * an updated PublicGroupState required by clients willing to join the group by an external commit.
+     *
+     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
+     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
+     * epoch, use new encryption secrets etc...
+     *
+     * @param conversationId - The ID of the conversation
+     *
+     * @returns A {@link CommitBundle} byte array to fan out to the Delivery Service
+     */
+    async finalUpdateKeyingMaterial(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").update_keying_material(conversationId);
+    }
+    /**
+     * Commits the local pending proposals and returns the {@link CommitBundle} object containing what can result from this operation.
+     *
+     * The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
+     * It also contains a Welcome message the Delivery Service will forward to invited clients and
+     * an updated PublicGroupState required by clients willing to join the group by an external commit.
+     *
+     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
+     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
+     * epoch, use new encryption secrets etc...
+     *
+     * @param conversationId - The ID of the conversation
+     *
+     * @returns A {@link CommitBundle} byte array to fan out to the Delivery Service
+     */
+    async finalCommitPendingProposals(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").commit_pending_proposals(conversationId);
+    }
+    /**
+     * Creates a new proposal for the provided Conversation ID
+     *
+     * @param proposalType - The type of proposal, see {@link ProposalType}
+     * @param args - The arguments of the proposal, see {@link ProposalArgs}, {@link AddProposalArgs} or {@link RemoveProposalArgs}
+     *
+     * @returns A {@link ProposalBundle} containing the Proposal and its reference in order to roll it back if necessary
+     */
+    async newProposal(proposalType, args) {
+        switch (proposalType) {
+            case 0 /* ProposalType.Add */: {
+                if (!args.kp) {
+                    throw new Error("kp is not contained in the proposal arguments");
+                }
+                return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_add_proposal(args.conversationId, args.kp);
+            }
+            case 1 /* ProposalType.Remove */: {
+                if (!args.clientId) {
+                    throw new Error("clientId is not contained in the proposal arguments");
+                }
+                return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_remove_proposal(args.conversationId, args.clientId);
+            }
+            case 2 /* ProposalType.Update */: {
+                return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_update_proposal(args.conversationId);
+            }
+            default:
+                throw new Error("Invalid proposal type!");
+        }
+    }
+    async newExternalProposal(externalProposalType, args) {
+        switch (externalProposalType) {
+            case 0 /* ExternalProposalType.Add */: {
+                return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_external_add_proposal(args.conversationId, args.epoch);
+            }
+            case 1 /* ExternalProposalType.Remove */: {
+                if (!args.keyPackageRef) {
+                    throw new Error("keyPackageRef is not contained in the external proposal arguments");
+                }
+                return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_external_remove_proposal(args.conversationId, args.epoch, args.keyPackageRef);
+            }
+            default:
+                throw new Error("Invalid external proposal type!");
+        }
+    }
+    /**
+     * Exports public group state for use in external commits
+     *
+     * @param conversationId - MLS Conversation ID
+     * @returns TLS-serialized MLS public group state
+     */
+    async exportGroupState(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").export_group_state(conversationId);
+    }
+    /**
+     * Allows to create an external commit to "apply" to join a group through its public group state
+     *
+     * Also see the second step of this process: {@link CoreCrypto.mergePendingGroupFromExternalCommit}
+     *
+     * @param publicGroupState - The public group state that can be fetched from the backend for a given conversation
+     * @returns see {@link MlsConversationInitMessage}
+     */
+    async joinByExternalCommit(publicGroupState) {
+        const ffiInitMessage = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").join_by_external_commit(publicGroupState);
+        const ret = {
+            group: ffiInitMessage.group,
+            commit: ffiInitMessage.commit,
+        };
+        return ret;
+    }
+    /**
+     * This is the second step of the process of joining a group through an external commit
+     *
+     * This step makes the group operational and ready to encrypt/decrypt message
+     *
+     * @param conversationId - The ID of the conversation
+     * @param configuration - Configuration of the group, see {@link ConversationConfiguration}
+     */
+    async mergePendingGroupFromExternalCommit(conversationId, configuration) {
+        const { admins, ciphersuite, keyRotationSpan, externalSenders } = configuration !== null && configuration !== void 0 ? configuration : {};
+        const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).ConversationConfiguration)(admins, ciphersuite, keyRotationSpan, externalSenders);
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").merge_pending_group_from_external_commit(conversationId, config);
+    }
+    /**
+     * Allows to mark the latest commit produced as "accepted" and be able to safely merge it
+     * into the local group state
+     *
+     * @param conversationId - The group's ID
+     */
+    async commitAccepted(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").commit_accepted(conversationId);
+    }
+    /**
+     * Allows {@link CoreCrypto} to act as a CSPRNG provider
+     * @note The underlying CSPRNG algorithm is ChaCha20 and takes in account the external seed provider either at init time or provided with {@link CoreCrypto.reseedRng}
+     *
+     * @param length - The number of bytes to be returned in the `Uint8Array`
+     *
+     * @returns A `Uint8Array` buffer that contains `length` cryptographically-secure random bytes
+     */
+    async randomBytes(length) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").random_bytes(length);
+    }
+    /**
+     * Allows to reseed {@link CoreCrypto}'s internal CSPRNG with a new seed.
+     *
+     * @param seed - **exactly 32** bytes buffer seed
+     */
+    async reseedRng(seed) {
+        if (seed.length !== 32) {
+            throw new Error(`The seed length needs to be exactly 32 bytes. ${seed.length} bytes provided.`);
+        }
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").reseed_rng(seed);
+    }
+    /**
+     * Allows to remove a pending proposal (rollback). Use this when backend rejects the proposal you just sent e.g. if permissions
+     * have changed meanwhile.
+     *
+     * **CAUTION**: only use this when you had an explicit response from the Delivery Service
+     * e.g. 403 or 409. Do not use otherwise e.g. 5xx responses, timeout etc..
+     *
+     * @param conversationId - The group's ID
+     * @param proposalRef - A reference to the proposal to delete. You get one when using {@link CoreCrypto.newProposal}
+     */
+    async clear_pending_proposal(conversationId, proposalRef) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_proposal(conversationId, proposalRef);
+    }
+    /**
+     * Allows to remove a pending commit (rollback). Use this when backend rejects the commit you just sent e.g. if permissions
+     * have changed meanwhile.
+     *
+     * **CAUTION**: only use this when you had an explicit response from the Delivery Service
+     * e.g. 403. Do not use otherwise e.g. 5xx responses, timeout etc..
+     * **DO NOT** use when Delivery Service responds 409, pending state will be renewed
+     * in {@link CoreCrypto.decrypt_message}
+     *
+     * @param conversationId - The group's ID
+     */
+    async clear_pending_commit(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_commit(conversationId);
+    }
+    /**
+     * Returns the current version of {@link CoreCrypto}
+     *
+     * @returns The `core-crypto-ffi` version as defined in its `Cargo.toml` file
+     */
+    static version() {
+        if (!__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module)) {
+            throw new Error("Internal module hasn't been initialized. Please use `await CoreCrypto.init(params)`!");
+        }
+        return __classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).version();
+    }
+}
+_a = CoreCrypto, _CoreCrypto_cc = new WeakMap();
+/** @hidden */
+_CoreCrypto_module = { value: void 0 };
+
+export { CoreCrypto };