@imweapp/openclaw-imwe 2026.4.12-alpha.1

package/src/vodozemackit/pkg/vodozemackit_wasm_bg.js

@@ -0,0 +1,1172 @@
+export class Account {
+  static __wrap(ptr) {
+    const obj = Object.create(Account.prototype);
+    obj.__wbg_ptr = ptr;
+    AccountFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AccountFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_account_free(ptr, 0);
+  }
+  /**
+   * @param {EncryptedMessage} message
+   * @returns {InboundCreationResult}
+   */
+  createInboundSession(message) {
+    _assertClass(message, EncryptedMessage);
+    const ret = wasm.account_createInboundSession(this.__wbg_ptr, message.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return InboundCreationResult.__wrap(ret[0]);
+  }
+  /**
+   * @param {string} identity_key
+   * @param {string} one_time_key
+   * @returns {Session}
+   */
+  createOutboundSession(identity_key, one_time_key) {
+    const ptr0 = passStringToWasm0(identity_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(one_time_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.account_createOutboundSession(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return Session.__wrap(ret[0]);
+  }
+  /**
+   * @returns {string}
+   */
+  curve25519Key() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.account_curve25519Key(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  ed25519Key() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.account_ed25519Key(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {any}
+   */
+  fallbackKey() {
+    const ret = wasm.account_fallbackKey(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  generateFallbackKey() {
+    wasm.account_generateFallbackKey(this.__wbg_ptr);
+  }
+  /**
+   * @param {number} number_of_keys
+   */
+  generateOneTimeKeys(number_of_keys) {
+    wasm.account_generateOneTimeKeys(this.__wbg_ptr, number_of_keys);
+  }
+  /**
+   * Generates one-time keys and returns metadata about the keys that were
+   * created along with any keys evicted to make room. Mirrors
+   * `Account.generate_one_time_keys_with_info` on the UniFFI side.
+   * @param {number} number_of_keys
+   * @returns {OneTimeKeyGenerationInfo}
+   */
+  generateOneTimeKeysWithInfo(number_of_keys) {
+    const ret = wasm.account_generateOneTimeKeysWithInfo(this.__wbg_ptr, number_of_keys);
+    return OneTimeKeyGenerationInfo.__wrap(ret);
+  }
+  markKeysAsPublished() {
+    wasm.account_markKeysAsPublished(this.__wbg_ptr);
+  }
+  /**
+   * @returns {number}
+   */
+  maxNumberOfOneTimeKeys() {
+    const ret = wasm.account_maxNumberOfOneTimeKeys(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  constructor() {
+    const ret = wasm.account_new();
+    this.__wbg_ptr = ret;
+    AccountFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @returns {any}
+   */
+  oneTimeKeys() {
+    const ret = wasm.account_oneTimeKeys(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Returns the full list of currently unpublished one-time keys as
+   * `OneTimeKeyInfo` entries. Mirrors `Account.one_time_keys_with_info` on
+   * the UniFFI side.
+   * @returns {OneTimeKeyInfo[]}
+   */
+  oneTimeKeysWithInfo() {
+    const ret = wasm.account_oneTimeKeysWithInfo(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+  /**
+   * @param {Uint8Array} pickle_key
+   * @returns {string}
+   */
+  pickle(pickle_key) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passArray8ToWasm0(pickle_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.account_pickle(this.__wbg_ptr, ptr0, len0);
+      var ptr2 = ret[0];
+      var len2 = ret[1];
+      if (ret[3]) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * @param {string} message
+   * @returns {string}
+   */
+  sign(message) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.account_sign(this.__wbg_ptr, ptr0, len0);
+      deferred2_0 = ret[0];
+      deferred2_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * Returns the number of one-time keys that are generated but not yet
+   * marked as published.
+   * @returns {number}
+   */
+  unpublishedOneTimeKeyCount() {
+    const ret = wasm.account_unpublishedOneTimeKeyCount(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+}
+if (Symbol.dispose) Account.prototype[Symbol.dispose] = Account.prototype.free;
+
+export class DecryptedMessage {
+  static __wrap(ptr) {
+    const obj = Object.create(DecryptedMessage.prototype);
+    obj.__wbg_ptr = ptr;
+    DecryptedMessageFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    DecryptedMessageFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_decryptedmessage_free(ptr, 0);
+  }
+  /**
+   * @returns {number}
+   */
+  get messageIndex() {
+    const ret = wasm.decryptedmessage_messageIndex(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  get plaintext() {
+    const ret = wasm.decryptedmessage_plaintext(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+}
+if (Symbol.dispose) DecryptedMessage.prototype[Symbol.dispose] = DecryptedMessage.prototype.free;
+
+export class EncryptedMessage {
+  static __wrap(ptr) {
+    const obj = Object.create(EncryptedMessage.prototype);
+    obj.__wbg_ptr = ptr;
+    EncryptedMessageFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    EncryptedMessageFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_encryptedmessage_free(ptr, 0);
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  get body() {
+    const ret = wasm.encryptedmessage_body(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * @param {Uint8Array} body
+   */
+  constructor(body) {
+    const ptr0 = passArray8ToWasm0(body, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.encryptedmessage_new(ptr0, len0);
+    this.__wbg_ptr = ret;
+    EncryptedMessageFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
+if (Symbol.dispose) EncryptedMessage.prototype[Symbol.dispose] = EncryptedMessage.prototype.free;
+
+export class GroupSession {
+  static __wrap(ptr) {
+    const obj = Object.create(GroupSession.prototype);
+    obj.__wbg_ptr = ptr;
+    GroupSessionFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    GroupSessionFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_groupsession_free(ptr, 0);
+  }
+  /**
+   * @param {Uint8Array} payload
+   * @returns {EncryptedMessage}
+   */
+  encrypt(payload) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.groupsession_encrypt(this.__wbg_ptr, ptr0, len0);
+    return EncryptedMessage.__wrap(ret);
+  }
+  /**
+   * @returns {number}
+   */
+  messageIndex() {
+    const ret = wasm.groupsession_messageIndex(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  constructor() {
+    const ret = wasm.groupsession_new();
+    this.__wbg_ptr = ret;
+    GroupSessionFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Uint8Array} pickle_key
+   * @returns {string}
+   */
+  pickle(pickle_key) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passArray8ToWasm0(pickle_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.groupsession_pickle(this.__wbg_ptr, ptr0, len0);
+      var ptr2 = ret[0];
+      var len2 = ret[1];
+      if (ret[3]) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  sessionId() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.groupsession_sessionId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  sessionKey() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.groupsession_sessionKey(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+}
+if (Symbol.dispose) GroupSession.prototype[Symbol.dispose] = GroupSession.prototype.free;
+
+export class InboundCreationResult {
+  static __wrap(ptr) {
+    const obj = Object.create(InboundCreationResult.prototype);
+    obj.__wbg_ptr = ptr;
+    InboundCreationResultFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    InboundCreationResultFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_inboundcreationresult_free(ptr, 0);
+  }
+  /**
+   * The base64 encoded one-time key that was used in the pre-key message
+   * to establish the inbound session.
+   * @returns {string}
+   */
+  oneTimeKey() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.inboundcreationresult_oneTimeKey(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  plaintext() {
+    const ret = wasm.inboundcreationresult_plaintext(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * @returns {Session}
+   */
+  takeSession() {
+    const ret = wasm.inboundcreationresult_takeSession(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return Session.__wrap(ret[0]);
+  }
+}
+if (Symbol.dispose)
+  InboundCreationResult.prototype[Symbol.dispose] = InboundCreationResult.prototype.free;
+
+export class InboundGroupSession {
+  static __wrap(ptr) {
+    const obj = Object.create(InboundGroupSession.prototype);
+    obj.__wbg_ptr = ptr;
+    InboundGroupSessionFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    InboundGroupSessionFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_inboundgroupsession_free(ptr, 0);
+  }
+  /**
+   * @param {Uint8Array} payload
+   * @returns {DecryptedMessage}
+   */
+  decrypt(payload) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.inboundgroupsession_decrypt(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return DecryptedMessage.__wrap(ret[0]);
+  }
+  /**
+   * @param {number} index
+   * @returns {string | undefined}
+   */
+  exportAt(index) {
+    const ret = wasm.inboundgroupsession_exportAt(this.__wbg_ptr, index);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+  }
+  /**
+   * @returns {number}
+   */
+  firstKnownIndex() {
+    const ret = wasm.inboundgroupsession_firstKnownIndex(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * @param {Uint8Array} pickle_key
+   * @returns {string}
+   */
+  pickle(pickle_key) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passArray8ToWasm0(pickle_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.inboundgroupsession_pickle(this.__wbg_ptr, ptr0, len0);
+      var ptr2 = ret[0];
+      var len2 = ret[1];
+      if (ret[3]) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  sessionId() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.inboundgroupsession_sessionId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+}
+if (Symbol.dispose)
+  InboundGroupSession.prototype[Symbol.dispose] = InboundGroupSession.prototype.free;
+
+/**
+ * Result of generating one-time keys, containing detailed info about newly
+ * created keys and the base64 public keys that were evicted.
+ */
+export class OneTimeKeyGenerationInfo {
+  static __wrap(ptr) {
+    const obj = Object.create(OneTimeKeyGenerationInfo.prototype);
+    obj.__wbg_ptr = ptr;
+    OneTimeKeyGenerationInfoFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OneTimeKeyGenerationInfoFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_onetimekeygenerationinfo_free(ptr, 0);
+  }
+  /**
+   * @returns {OneTimeKeyInfo[]}
+   */
+  get created() {
+    const ret = wasm.onetimekeygenerationinfo_created(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+  /**
+   * @returns {string[]}
+   */
+  get removed() {
+    const ret = wasm.onetimekeygenerationinfo_removed(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+}
+if (Symbol.dispose)
+  OneTimeKeyGenerationInfo.prototype[Symbol.dispose] = OneTimeKeyGenerationInfo.prototype.free;
+
+/**
+ * Detailed info about a single one-time key.
+ */
+export class OneTimeKeyInfo {
+  static __wrap(ptr) {
+    const obj = Object.create(OneTimeKeyInfo.prototype);
+    obj.__wbg_ptr = ptr;
+    OneTimeKeyInfoFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OneTimeKeyInfoFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_onetimekeyinfo_free(ptr, 0);
+  }
+  /**
+   * @returns {string}
+   */
+  get keyId() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.onetimekeyinfo_keyId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get publicKey() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.onetimekeyinfo_publicKey(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+}
+if (Symbol.dispose) OneTimeKeyInfo.prototype[Symbol.dispose] = OneTimeKeyInfo.prototype.free;
+
+export class Session {
+  static __wrap(ptr) {
+    const obj = Object.create(Session.prototype);
+    obj.__wbg_ptr = ptr;
+    SessionFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SessionFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_session_free(ptr, 0);
+  }
+  /**
+   * @param {EncryptedMessage} message
+   * @returns {Uint8Array}
+   */
+  decrypt(message) {
+    _assertClass(message, EncryptedMessage);
+    const ret = wasm.session_decrypt(this.__wbg_ptr, message.__wbg_ptr);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * @param {Uint8Array} payload
+   * @returns {EncryptedMessage}
+   */
+  encrypt(payload) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.session_encrypt(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return EncryptedMessage.__wrap(ret[0]);
+  }
+  /**
+   * @param {Uint8Array} pickle_key
+   * @returns {string}
+   */
+  pickle(pickle_key) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passArray8ToWasm0(pickle_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.session_pickle(this.__wbg_ptr, ptr0, len0);
+      var ptr2 = ret[0];
+      var len2 = ret[1];
+      if (ret[3]) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  sessionId() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.session_sessionId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {EncryptedMessage} message
+   * @returns {boolean}
+   */
+  sessionMatches(message) {
+    _assertClass(message, EncryptedMessage);
+    const ret = wasm.session_sessionMatches(this.__wbg_ptr, message.__wbg_ptr);
+    return ret !== 0;
+  }
+}
+if (Symbol.dispose) Session.prototype[Symbol.dispose] = Session.prototype.free;
+
+/**
+ * @param {string} pickle
+ * @param {Uint8Array} pickle_key
+ * @returns {Account}
+ */
+export function accountFromPickle(pickle, pickle_key) {
+  const ptr0 = passStringToWasm0(pickle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArray8ToWasm0(pickle_key, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.accountFromPickle(ptr0, len0, ptr1, len1);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return Account.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} pickle
+ * @param {Uint8Array} pickle_key
+ * @returns {GroupSession}
+ */
+export function groupSessionFromPickle(pickle, pickle_key) {
+  const ptr0 = passStringToWasm0(pickle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArray8ToWasm0(pickle_key, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.groupSessionFromPickle(ptr0, len0, ptr1, len1);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return GroupSession.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} session_key
+ * @returns {InboundGroupSession}
+ */
+export function importInboundGroupSession(session_key) {
+  const ptr0 = passStringToWasm0(session_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.importInboundGroupSession(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return InboundGroupSession.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} pickle
+ * @param {Uint8Array} pickle_key
+ * @returns {InboundGroupSession}
+ */
+export function inboundGroupSessionFromPickle(pickle, pickle_key) {
+  const ptr0 = passStringToWasm0(pickle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArray8ToWasm0(pickle_key, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.inboundGroupSessionFromPickle(ptr0, len0, ptr1, len1);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return InboundGroupSession.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} session_key
+ * @returns {InboundGroupSession}
+ */
+export function newInboundGroupSession(session_key) {
+  const ptr0 = passStringToWasm0(session_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.newInboundGroupSession(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return InboundGroupSession.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} pickle
+ * @param {Uint8Array} pickle_key
+ * @returns {Session}
+ */
+export function sessionFromPickle(pickle, pickle_key) {
+  const ptr0 = passStringToWasm0(pickle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArray8ToWasm0(pickle_key, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.sessionFromPickle(ptr0, len0, ptr1, len1);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return Session.__wrap(ret[0]);
+}
+
+export function start() {
+  wasm.start();
+}
+export function __wbg_Error_3639a60ed15f87e7(arg0, arg1) {
+  const ret = Error(getStringFromWasm0(arg0, arg1));
+  return ret;
+}
+export function __wbg_String_8564e559799eccda(arg0, arg1) {
+  const ret = String(arg1);
+  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg___wbindgen_is_function_2f0fd7ceb86e64c5(arg0) {
+  const ret = typeof arg0 === 'function';
+  return ret;
+}
+export function __wbg___wbindgen_is_object_5b22ff2418063a9c(arg0) {
+  const val = arg0;
+  const ret = typeof val === 'object' && val !== null;
+  return ret;
+}
+export function __wbg___wbindgen_is_string_eddc07a3efad52e6(arg0) {
+  const ret = typeof arg0 === 'string';
+  return ret;
+}
+export function __wbg___wbindgen_is_undefined_244a92c34d3b6ec0(arg0) {
+  const ret = arg0 === undefined;
+  return ret;
+}
+export function __wbg___wbindgen_throw_9c75d47bf9e7731e(arg0, arg1) {
+  throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_call_a41d6421b30a32c5() {
+  return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+  }, arguments);
+}
+export function __wbg_crypto_38df2bab126b63dc(arg0) {
+  const ret = arg0.crypto;
+  return ret;
+}
+export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
+  let deferred0_0;
+  let deferred0_1;
+  try {
+    deferred0_0 = arg0;
+    deferred0_1 = arg1;
+    console.error(getStringFromWasm0(arg0, arg1));
+  } finally {
+    wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+  }
+}
+export function __wbg_getRandomValues_c44a50d8cfdaebeb() {
+  return handleError(function (arg0, arg1) {
+    arg0.getRandomValues(arg1);
+  }, arguments);
+}
+export function __wbg_length_ba3c032602efe310(arg0) {
+  const ret = arg0.length;
+  return ret;
+}
+export function __wbg_msCrypto_bd5a034af96bcba6(arg0) {
+  const ret = arg0.msCrypto;
+  return ret;
+}
+export function __wbg_new_227d7c05414eb861() {
+  const ret = new Error();
+  return ret;
+}
+export function __wbg_new_2fad8ca02fd00684() {
+  const ret = new Object();
+  return ret;
+}
+export function __wbg_new_46ae4e4ff2a07a64() {
+  const ret = new Map();
+  return ret;
+}
+export function __wbg_new_c9ea13ea803a692e(arg0, arg1) {
+  const ret = new Error(getStringFromWasm0(arg0, arg1));
+  return ret;
+}
+export function __wbg_new_with_length_9011f5da794bf5d9(arg0) {
+  const ret = new Uint8Array(arg0 >>> 0);
+  return ret;
+}
+export function __wbg_node_84ea875411254db1(arg0) {
+  const ret = arg0.node;
+  return ret;
+}
+export function __wbg_onetimekeyinfo_new(arg0) {
+  const ret = OneTimeKeyInfo.__wrap(arg0);
+  return ret;
+}
+export function __wbg_process_44c7a14e11e9f69e(arg0) {
+  const ret = arg0.process;
+  return ret;
+}
+export function __wbg_prototypesetcall_fd4050e806e1d519(arg0, arg1, arg2) {
+  Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_randomFillSync_6c25eac9869eb53c() {
+  return handleError(function (arg0, arg1) {
+    arg0.randomFillSync(arg1);
+  }, arguments);
+}
+export function __wbg_require_b4edbdcf3e2a1ef0() {
+  return handleError(function () {
+    const ret = module.require;
+    return ret;
+  }, arguments);
+}
+export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
+  arg0[arg1] = arg2;
+}
+export function __wbg_set_82f7a370f604db70(arg0, arg1, arg2) {
+  const ret = arg0.set(arg1, arg2);
+  return ret;
+}
+export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
+  const ret = arg1.stack;
+  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg_static_accessor_GLOBAL_THIS_1c7f1bd6c6941fdb() {
+  const ret = typeof globalThis === 'undefined' ? null : globalThis;
+  return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_GLOBAL_e039bc914f83e74e() {
+  const ret = typeof global === 'undefined' ? null : global;
+  return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_SELF_8bf8c48c28420ad5() {
+  // eslint-disable-next-line
+  const ret = typeof self === 'undefined' ? null : self;
+  return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_WINDOW_6aeee9b51652ee0f() {
+  // eslint-disable-next-line
+  const ret = typeof window === 'undefined' ? null : window;
+  return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_subarray_fbe3cef290e1fa43(arg0, arg1, arg2) {
+  const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+  return ret;
+}
+export function __wbg_versions_276b2795b1c6a219(arg0) {
+  const ret = arg0.versions;
+  return ret;
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+  // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+  const ret = getArrayU8FromWasm0(arg0, arg1);
+  return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
+  // Cast intrinsic for `Ref(String) -> Externref`.
+  const ret = getStringFromWasm0(arg0, arg1);
+  return ret;
+}
+export function __wbindgen_init_externref_table() {
+  const table = wasm.__wbindgen_externrefs;
+  const offset = table.grow(4);
+  table.set(0, undefined);
+  table.set(offset + 0, undefined);
+  table.set(offset + 1, null);
+  table.set(offset + 2, true);
+  table.set(offset + 3, false);
+}
+const AccountFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_account_free(ptr, 1));
+const DecryptedMessageFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_decryptedmessage_free(ptr, 1));
+const EncryptedMessageFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_encryptedmessage_free(ptr, 1));
+const GroupSessionFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_groupsession_free(ptr, 1));
+const InboundCreationResultFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_inboundcreationresult_free(ptr, 1));
+const InboundGroupSessionFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_inboundgroupsession_free(ptr, 1));
+const OneTimeKeyGenerationInfoFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_onetimekeygenerationinfo_free(ptr, 1));
+const OneTimeKeyInfoFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_onetimekeyinfo_free(ptr, 1));
+const SessionFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_session_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  const mem = getDataViewMemory0();
+  const result = [];
+  for (let i = ptr; i < ptr + 4 * len; i += 4) {
+    result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+  }
+  wasm.__externref_drop_slice(ptr, len);
+  return result;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (
+    cachedDataViewMemory0 === null ||
+    cachedDataViewMemory0.buffer.detached === true ||
+    (cachedDataViewMemory0.buffer.detached === undefined &&
+      cachedDataViewMemory0.buffer !== wasm.memory.buffer)
+  ) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+  return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+
+function isLikeNone(x) {
+  return x === undefined || x === null;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === undefined) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0()
+      .subarray(ptr, ptr + buf.length)
+      .set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr;
+  }
+
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+
+  const mem = getUint8ArrayMemory0();
+
+  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), 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length,
+    };
+  };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasm;
+export function __wbg_set_wasm(val) {
+  wasm = val;
+}