whatsapp-rust-bridge/dist/index.js

A high-performance utilities for WhatsApp, powered by Rust and WebAssembly.

// pkg/whatsapp_rust_bridge.js
class ExpandedAppStateKeys {
  static __wrap(ptr) {
    const obj = Object.create(ExpandedAppStateKeys.prototype);
    obj.__wbg_ptr = ptr;
    ExpandedAppStateKeysFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    ExpandedAppStateKeysFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_expandedappstatekeys_free(ptr, 0);
  }
  get indexKey() {
    const ret = wasm.expandedappstatekeys_indexKey(this.__wbg_ptr);
    return takeObject(ret);
  }
  get patchMacKey() {
    const ret = wasm.expandedappstatekeys_patchMacKey(this.__wbg_ptr);
    return takeObject(ret);
  }
  get snapshotMacKey() {
    const ret = wasm.expandedappstatekeys_snapshotMacKey(this.__wbg_ptr);
    return takeObject(ret);
  }
  get valueEncryptionKey() {
    const ret = wasm.expandedappstatekeys_valueEncryptionKey(this.__wbg_ptr);
    return takeObject(ret);
  }
  get valueMacKey() {
    const ret = wasm.expandedappstatekeys_valueMacKey(this.__wbg_ptr);
    return takeObject(ret);
  }
}
if (Symbol.dispose)
  ExpandedAppStateKeys.prototype[Symbol.dispose] = ExpandedAppStateKeys.prototype.free;

class GroupCipher {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    GroupCipherFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_groupcipher_free(ptr, 0);
  }
  decrypt(ciphertext) {
    const ptr0 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.groupcipher_decrypt(this.__wbg_ptr, ptr0, len0);
    return takeObject(ret);
  }
  encrypt(plaintext) {
    const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.groupcipher_encrypt(this.__wbg_ptr, ptr0, len0);
    return takeObject(ret);
  }
  constructor(storage, group_id, sender) {
    const ptr0 = passStringToWasm0(group_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    _assertClass(sender, ProtocolAddress);
    const ret = wasm.groupcipher_new(addHeapObject(storage), ptr0, len0, sender.__wbg_ptr);
    this.__wbg_ptr = ret;
    GroupCipherFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
}
if (Symbol.dispose)
  GroupCipher.prototype[Symbol.dispose] = GroupCipher.prototype.free;

class GroupSessionBuilder {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    GroupSessionBuilderFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_groupsessionbuilder_free(ptr, 0);
  }
  create(sender_key_name) {
    _assertClass(sender_key_name, SenderKeyName);
    const ret = wasm.groupsessionbuilder_create(this.__wbg_ptr, sender_key_name.__wbg_ptr);
    return takeObject(ret);
  }
  constructor(storage) {
    const ret = wasm.groupsessionbuilder_new(addHeapObject(storage));
    this.__wbg_ptr = ret;
    GroupSessionBuilderFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  process(sender_key_name, skdm) {
    _assertClass(sender_key_name, SenderKeyName);
    _assertClass(skdm, SenderKeyDistributionMessage);
    const ret = wasm.groupsessionbuilder_process(this.__wbg_ptr, sender_key_name.__wbg_ptr, skdm.__wbg_ptr);
    return takeObject(ret);
  }
}
if (Symbol.dispose)
  GroupSessionBuilder.prototype[Symbol.dispose] = GroupSessionBuilder.prototype.free;

class InternalBinaryNode {
  static __wrap(ptr) {
    const obj = Object.create(InternalBinaryNode.prototype);
    obj.__wbg_ptr = ptr;
    InternalBinaryNodeFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    InternalBinaryNodeFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_internalbinarynode_free(ptr, 0);
  }
  get attrs() {
    const ret = wasm.internalbinarynode_attrs(this.__wbg_ptr);
    return takeObject(ret);
  }
  get content() {
    const ret = wasm.internalbinarynode_content(this.__wbg_ptr);
    return takeObject(ret);
  }
  set attrs(new_attrs) {
    wasm.internalbinarynode_set_attrs(this.__wbg_ptr, addHeapObject(new_attrs));
  }
  set content(new_content) {
    wasm.internalbinarynode_set_content(this.__wbg_ptr, addHeapObject(new_content));
  }
  get tag() {
    let deferred1_0;
    let deferred1_1;
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.internalbinarynode_tag(retptr, this.__wbg_ptr);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      deferred1_0 = r0;
      deferred1_1 = r1;
      return getStringFromWasm0(r0, r1);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
    }
  }
  toJSON() {
    const ret = wasm.internalbinarynode_toJSON(this.__wbg_ptr);
    return takeObject(ret);
  }
}
if (Symbol.dispose)
  InternalBinaryNode.prototype[Symbol.dispose] = InternalBinaryNode.prototype.free;

class LTHashAntiTampering {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    LTHashAntiTamperingFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_lthashantitampering_free(ptr, 0);
  }
  constructor() {
    const ret = wasm.lthashantitampering_new();
    this.__wbg_ptr = ret;
    LTHashAntiTamperingFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  subtractThenAdd(base, subtract, add) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(base, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      const ptr1 = passArrayJsValueToWasm0(subtract, wasm.__wbindgen_export);
      const len1 = WASM_VECTOR_LEN;
      const ptr2 = passArrayJsValueToWasm0(add, wasm.__wbindgen_export);
      const len2 = WASM_VECTOR_LEN;
      wasm.lthashantitampering_subtractThenAdd(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
}
if (Symbol.dispose)
  LTHashAntiTampering.prototype[Symbol.dispose] = LTHashAntiTampering.prototype.free;

class LTHashState {
  static __wrap(ptr) {
    const obj = Object.create(LTHashState.prototype);
    obj.__wbg_ptr = ptr;
    LTHashStateFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    LTHashStateFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_lthashstate_free(ptr, 0);
  }
  clone() {
    const ret = wasm.lthashstate_clone(this.__wbg_ptr);
    return LTHashState.__wrap(ret);
  }
  deleteValueMac(index_mac_base64) {
    const ptr0 = passStringToWasm0(index_mac_base64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.lthashstate_deleteValueMac(this.__wbg_ptr, ptr0, len0);
    return ret !== 0;
  }
  getValueMac(index_mac_base64) {
    const ptr0 = passStringToWasm0(index_mac_base64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.lthashstate_getValueMac(this.__wbg_ptr, ptr0, len0);
    return takeObject(ret);
  }
  hasValueMac(index_mac_base64) {
    const ptr0 = passStringToWasm0(index_mac_base64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.lthashstate_hasValueMac(this.__wbg_ptr, ptr0, len0);
    return ret !== 0;
  }
  get hash() {
    const ret = wasm.lthashstate_hash(this.__wbg_ptr);
    return takeObject(ret);
  }
  constructor() {
    const ret = wasm.lthashstate_new();
    this.__wbg_ptr = ret;
    LTHashStateFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  setValueMac(index_mac_base64, value_mac) {
    const ptr0 = passStringToWasm0(index_mac_base64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(value_mac, wasm.__wbindgen_export);
    const len1 = WASM_VECTOR_LEN;
    wasm.lthashstate_setValueMac(this.__wbg_ptr, ptr0, len0, ptr1, len1);
  }
  set hash(hash) {
    const ptr0 = passArray8ToWasm0(hash, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    wasm.lthashstate_set_hash(this.__wbg_ptr, ptr0, len0);
  }
  set version(version) {
    wasm.lthashstate_set_version(this.__wbg_ptr, version);
  }
  get version() {
    const ret = wasm.lthashstate_version(this.__wbg_ptr);
    return BigInt.asUintN(64, ret);
  }
}
if (Symbol.dispose)
  LTHashState.prototype[Symbol.dispose] = LTHashState.prototype.free;

class NoiseSession {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    NoiseSessionFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_noisesession_free(ptr, 0);
  }
  authenticate(data) {
    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    wasm.noisesession_authenticate(this.__wbg_ptr, ptr0, len0);
  }
  get bufferedBytes() {
    const ret = wasm.noisesession_bufferedBytes(this.__wbg_ptr);
    return ret >>> 0;
  }
  clearBuffer() {
    wasm.noisesession_clearBuffer(this.__wbg_ptr);
  }
  decodeFrame(new_data) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(new_data, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      wasm.noisesession_decodeFrame(retptr, this.__wbg_ptr, ptr0, len0);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  decrypt(ciphertext) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      wasm.noisesession_decrypt(retptr, this.__wbg_ptr, ptr0, len0);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  encodeFrame(node) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.noisesession_encodeFrame(retptr, this.__wbg_ptr, addHeapObject(node));
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  encodeFrameRaw(data) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      wasm.noisesession_encodeFrameRaw(retptr, this.__wbg_ptr, ptr0, len0);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  encrypt(plaintext) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      wasm.noisesession_encrypt(retptr, this.__wbg_ptr, ptr0, len0);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  finishInit() {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.noisesession_finishInit(retptr, this.__wbg_ptr);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      if (r1) {
        throw takeObject(r0);
      }
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  getHash() {
    const ret = wasm.noisesession_getHash(this.__wbg_ptr);
    return takeObject(ret);
  }
  get isFinished() {
    const ret = wasm.noisesession_isFinished(this.__wbg_ptr);
    return ret !== 0;
  }
  mixIntoKey(data) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      wasm.noisesession_mixIntoKey(retptr, this.__wbg_ptr, ptr0, len0);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      if (r1) {
        throw takeObject(r0);
      }
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  constructor(public_key, noise_header, routing_info) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(public_key, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      const ptr1 = passArray8ToWasm0(noise_header, wasm.__wbindgen_export);
      const len1 = WASM_VECTOR_LEN;
      var ptr2 = isLikeNone(routing_info) ? 0 : passArray8ToWasm0(routing_info, wasm.__wbindgen_export);
      var len2 = WASM_VECTOR_LEN;
      wasm.noisesession_new(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      this.__wbg_ptr = r0;
      NoiseSessionFinalization.register(this, this.__wbg_ptr, this);
      return this;
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  processHandshakeFinish(noise_public_key, noise_private_key, server_ephemeral) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(noise_public_key, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      const ptr1 = passArray8ToWasm0(noise_private_key, wasm.__wbindgen_export);
      const len1 = WASM_VECTOR_LEN;
      const ptr2 = passArray8ToWasm0(server_ephemeral, wasm.__wbindgen_export);
      const len2 = WASM_VECTOR_LEN;
      wasm.noisesession_processHandshakeFinish(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  processHandshakeInit(server_ephemeral, server_static_encrypted, server_payload_encrypted, private_key) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(server_ephemeral, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      const ptr1 = passArray8ToWasm0(server_static_encrypted, wasm.__wbindgen_export);
      const len1 = WASM_VECTOR_LEN;
      const ptr2 = passArray8ToWasm0(server_payload_encrypted, wasm.__wbindgen_export);
      const len2 = WASM_VECTOR_LEN;
      const ptr3 = passArray8ToWasm0(private_key, wasm.__wbindgen_export);
      const len3 = WASM_VECTOR_LEN;
      wasm.noisesession_processHandshakeInit(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
}
if (Symbol.dispose)
  NoiseSession.prototype[Symbol.dispose] = NoiseSession.prototype.free;

class ProtocolAddress {
  static __wrap(ptr) {
    const obj = Object.create(ProtocolAddress.prototype);
    obj.__wbg_ptr = ptr;
    ProtocolAddressFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    ProtocolAddressFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_protocoladdress_free(ptr, 0);
  }
  get deviceId() {
    const ret = wasm.protocoladdress_deviceId(this.__wbg_ptr);
    return ret >>> 0;
  }
  static from(encoded) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.protocoladdress_from(retptr, addHeapObject(encoded));
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return ProtocolAddress.__wrap(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  get id() {
    let deferred1_0;
    let deferred1_1;
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.protocoladdress_id(retptr, this.__wbg_ptr);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      deferred1_0 = r0;
      deferred1_1 = r1;
      return getStringFromWasm0(r0, r1);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
    }
  }
  is(other) {
    _assertClass(other, ProtocolAddress);
    const ret = wasm.protocoladdress_is(this.__wbg_ptr, other.__wbg_ptr);
    return ret !== 0;
  }
  constructor(id, device_id) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.protocoladdress_new(retptr, addHeapObject(id), addHeapObject(device_id));
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      this.__wbg_ptr = r0;
      ProtocolAddressFinalization.register(this, this.__wbg_ptr, this);
      return this;
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  toString() {
    let deferred1_0;
    let deferred1_1;
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.protocoladdress_toString(retptr, this.__wbg_ptr);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      deferred1_0 = r0;
      deferred1_1 = r1;
      return getStringFromWasm0(r0, r1);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
    }
  }
}
if (Symbol.dispose)
  ProtocolAddress.prototype[Symbol.dispose] = ProtocolAddress.prototype.free;

class SenderKeyDistributionMessage {
  static __wrap(ptr) {
    const obj = Object.create(SenderKeyDistributionMessage.prototype);
    obj.__wbg_ptr = ptr;
    SenderKeyDistributionMessageFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    SenderKeyDistributionMessageFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_senderkeydistributionmessage_free(ptr, 0);
  }
  static deserialize(serialized) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(serialized, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      wasm.senderkeydistributionmessage_deserialize(retptr, ptr0, len0);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return SenderKeyDistributionMessage.__wrap(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  serialize() {
    const ret = wasm.senderkeydistributionmessage_serialize(this.__wbg_ptr);
    return takeObject(ret);
  }
}
if (Symbol.dispose)
  SenderKeyDistributionMessage.prototype[Symbol.dispose] = SenderKeyDistributionMessage.prototype.free;

class SenderKeyName {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    SenderKeyNameFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_senderkeyname_free(ptr, 0);
  }
  constructor(group_id, sender) {
    const ptr0 = passStringToWasm0(group_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    _assertClass(sender, ProtocolAddress);
    const ret = wasm.senderkeyname_new(ptr0, len0, sender.__wbg_ptr);
    this.__wbg_ptr = ret;
    SenderKeyNameFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  toString() {
    let deferred1_0;
    let deferred1_1;
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.senderkeyname_toString(retptr, this.__wbg_ptr);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      deferred1_0 = r0;
      deferred1_1 = r1;
      return getStringFromWasm0(r0, r1);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
    }
  }
}
if (Symbol.dispose)
  SenderKeyName.prototype[Symbol.dispose] = SenderKeyName.prototype.free;

class SenderKeyRecord {
  static __wrap(ptr) {
    const obj = Object.create(SenderKeyRecord.prototype);
    obj.__wbg_ptr = ptr;
    SenderKeyRecordFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    SenderKeyRecordFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_senderkeyrecord_free(ptr, 0);
  }
  static deserialize(serialized) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      const ptr0 = passArray8ToWasm0(serialized, wasm.__wbindgen_export);
      const len0 = WASM_VECTOR_LEN;
      wasm.senderkeyrecord_deserialize(retptr, ptr0, len0);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return SenderKeyRecord.__wrap(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  isEmpty() {
    const ret = wasm.senderkeyrecord_isEmpty(this.__wbg_ptr);
    return ret !== 0;
  }
  constructor() {
    const ret = wasm.senderkeyrecord_new();
    this.__wbg_ptr = ret;
    SenderKeyRecordFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  serialize() {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.senderkeyrecord_serialize(retptr, this.__wbg_ptr);
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return takeObject(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
}
if (Symbol.dispose)
  SenderKeyRecord.prototype[Symbol.dispose] = SenderKeyRecord.prototype.free;

class SessionBuilder {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    SessionBuilderFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_sessionbuilder_free(ptr, 0);
  }
  initOutgoing(bundle_input) {
    const ret = wasm.sessionbuilder_initOutgoing(this.__wbg_ptr, addHeapObject(bundle_input));
    return takeObject(ret);
  }
  constructor(storage, remote_address) {
    _assertClass(remote_address, ProtocolAddress);
    const ret = wasm.sessionbuilder_new(addHeapObject(storage), remote_address.__wbg_ptr);
    this.__wbg_ptr = ret;
    SessionBuilderFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  processPreKeyBundle(bundle_input) {
    const ret = wasm.sessionbuilder_processPreKeyBundle(this.__wbg_ptr, addHeapObject(bundle_input));
    return takeObject(ret);
  }
}
if (Symbol.dispose)
  SessionBuilder.prototype[Symbol.dispose] = SessionBuilder.prototype.free;

class SessionCipher {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    SessionCipherFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_sessioncipher_free(ptr, 0);
  }
  decryptPreKeyWhisperMessage(ciphertext) {
    const ptr0 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.sessioncipher_decryptPreKeyWhisperMessage(this.__wbg_ptr, ptr0, len0);
    return takeObject(ret);
  }
  decryptWhisperMessage(ciphertext) {
    const ptr0 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.sessioncipher_decryptWhisperMessage(this.__wbg_ptr, ptr0, len0);
    return takeObject(ret);
  }
  encrypt(plaintext) {
    const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.sessioncipher_encrypt(this.__wbg_ptr, ptr0, len0);
    return takeObject(ret);
  }
  hasOpenSession() {
    const ret = wasm.sessioncipher_hasOpenSession(this.__wbg_ptr);
    return takeObject(ret);
  }
  constructor(storage, remote_address) {
    _assertClass(remote_address, ProtocolAddress);
    const ret = wasm.sessioncipher_new(addHeapObject(storage), remote_address.__wbg_ptr);
    this.__wbg_ptr = ret;
    SessionCipherFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
}
if (Symbol.dispose)
  SessionCipher.prototype[Symbol.dispose] = SessionCipher.prototype.free;

class SessionRecord {
  static __wrap(ptr) {
    const obj = Object.create(SessionRecord.prototype);
    obj.__wbg_ptr = ptr;
    SessionRecordFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    SessionRecordFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_sessionrecord_free(ptr, 0);
  }
  static deserialize(val) {
    try {
      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
      wasm.sessionrecord_deserialize(retptr, addHeapObject(val));
      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
      if (r2) {
        throw takeObject(r1);
      }
      return SessionRecord.__wrap(r0);
    } finally {
      wasm.__wbindgen_add_to_stack_pointer(16);
    }
  }
  haveOpenSession() {
    const ret = wasm.sessionrecord_haveOpenSession(this.__wbg_ptr);
    return ret !== 0;
  }
  serialize() {
    const ret = wasm.sessionrecord_serialize(this.__wbg_ptr);
    return takeObject(ret);
  }
}
if (Symbol.dispose)
  SessionRecord.prototype[Symbol.dispose] = SessionRecord.prototype.free;
function _serializeIdentityKeyPair(key_pair) {
  const ret = wasm._serializeIdentityKeyPair(addHeapObject(key_pair));
  return takeObject(ret);
}
function calculateAgreement(public_key_bytes, private_key_bytes) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_export);
    const len1 = WASM_VECTOR_LEN;
    wasm.calculateAgreement(retptr, ptr0, len0, ptr1, len1);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function calculateSignature(private_key_bytes, message) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export);
    const len1 = WASM_VECTOR_LEN;
    wasm.calculateSignature(retptr, ptr0, len0, ptr1, len1);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function decodeNode(data) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    wasm.decodeNode(retptr, ptr0, len0);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return InternalBinaryNode.__wrap(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function encodeNode(node_val) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    wasm.encodeNode(retptr, addHeapObject(node_val));
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function expandAppStateKeys(key_data) {
  const ptr0 = passArray8ToWasm0(key_data, wasm.__wbindgen_export);
  const len0 = WASM_VECTOR_LEN;
  const ret = wasm.expandAppStateKeys(ptr0, len0);
  return ExpandedAppStateKeys.__wrap(ret);
}
function generateContentMac(operation, data, key_id, key) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(key_id, wasm.__wbindgen_export);
    const len1 = WASM_VECTOR_LEN;
    const ptr2 = passArray8ToWasm0(key, wasm.__wbindgen_export);
    const len2 = WASM_VECTOR_LEN;
    wasm.generateContentMac(retptr, operation, ptr0, len0, ptr1, len1, ptr2, len2);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function generateIdentityKeyPair() {
  const ret = wasm.generateIdentityKeyPair();
  return takeObject(ret);
}
function generateIndexMac(index_bytes, key) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(index_bytes, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_export);
    const len1 = WASM_VECTOR_LEN;
    wasm.generateIndexMac(retptr, ptr0, len0, ptr1, len1);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function generateKeyPair() {
  const ret = wasm.generateKeyPair();
  return takeObject(ret);
}
function generatePatchMac(snapshot_mac, value_macs, version, name, key) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(snapshot_mac, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArrayJsValueToWasm0(value_macs, wasm.__wbindgen_export);
    const len1 = WASM_VECTOR_LEN;
    const ptr2 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len2 = WASM_VECTOR_LEN;
    const ptr3 = passArray8ToWasm0(key, wasm.__wbindgen_export);
    const len3 = WASM_VECTOR_LEN;
    wasm.generatePatchMac(retptr, ptr0, len0, ptr1, len1, version, ptr2, len2, ptr3, len3);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function generatePreKey(key_id) {
  const ret = wasm.generatePreKey(key_id);
  return takeObject(ret);
}
function generateRegistrationId() {
  const ret = wasm.generateRegistrationId();
  return ret >>> 0;
}
function generateSignedPreKey(identity_key_pair, signed_key_id) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    wasm.generateSignedPreKey(retptr, addHeapObject(identity_key_pair), signed_key_id);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function generateSnapshotMac(lt_hash, version, name, key) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(lt_hash, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len1 = WASM_VECTOR_LEN;
    const ptr2 = passArray8ToWasm0(key, wasm.__wbindgen_export);
    const len2 = WASM_VECTOR_LEN;
    wasm.generateSnapshotMac(retptr, ptr0, len0, version, ptr1, len1, ptr2, len2);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function getEnabledFeatures() {
  const ret = wasm.getEnabledFeatures();
  return takeObject(ret);
}
function getPublicFromPrivateKey(private_key_bytes) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    wasm.getPublicFromPrivateKey(retptr, ptr0, len0);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function getWAConnHeader() {
  const ret = wasm.getWAConnHeader();
  return takeObject(ret);
}
function hasLogger() {
  const ret = wasm.hasLogger();
  return ret !== 0;
}
function hkdf(buffer, expanded_length, info) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    wasm.hkdf(retptr, ptr0, len0, expanded_length, addHeapObject(info));
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return takeObject(r0);
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function logMessage(level, message) {
  const ptr0 = passStringToWasm0(level, wasm.__wbindgen_export, wasm.__wbindgen_export2);
  const len0 = WASM_VECTOR_LEN;
  const ptr1 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
  const len1 = WASM_VECTOR_LEN;
  wasm.logMessage(ptr0, len0, ptr1, len1);
}
function md5(buffer) {
  const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_export);
  const len0 = WASM_VECTOR_LEN;
  const ret = wasm.md5(ptr0, len0);
  return takeObject(ret);
}
function setLogger(logger) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    wasm.setLogger(retptr, addHeapObject(logger));
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    if (r1) {
      throw takeObject(r0);
    }
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function updateLogger(logger) {
  wasm.updateLogger(addHeapObject(logger));
}
function verifySignature(public_key_bytes, message, signature) {
  try {
    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export);
    const len1 = WASM_VECTOR_LEN;
    const ptr2 = passArray8ToWasm0(signature, wasm.__wbindgen_export);
    const len2 = WASM_VECTOR_LEN;
    wasm.verifySignature(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
    if (r2) {
      throw takeObject(r1);
    }
    return r0 !== 0;
  } finally {
    wasm.__wbindgen_add_to_stack_pointer(16);
  }
}
function __wbg_get_imports() {
  const import0 = {
    __proto__: null,
    __wbg_Error_bce6d499ff0a4aff: function(arg0, arg1) {
      const ret = Error(getStringFromWasm0(arg0, arg1));
      return addHeapObject(ret);
    },
    __wbg_Number_b7972a139bfbfdf0: function(arg0) {
      const ret = Number(getObject(arg0));
      return ret;
    },
    __wbg_String_8564e559799eccda: function(arg0, arg1) {
      const ret = String(getObject(arg1));
      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
      const len1 = WASM_VECTOR_LEN;
      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
    },
    __wbg___wbindgen_bigint_get_as_i64_410e28c7b761ad83: function(arg0, arg1) {
      const v = getObject(arg1);
      const ret = typeof v === "bigint" ? v : undefined;
      getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
      getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
    },
    __wbg___wbindgen_boolean_get_2304fb8c853028c8: function(arg0) {
      const v = getObject(arg0);
      const ret = typeof v === "boolean" ? v : undefined;
      return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
    },
    __wbg___wbindgen_debug_string_edece8177ad01481: function(arg0, arg1) {
      const ret = debugString(getObject(arg1));
      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
      const len1 = WASM_VECTOR_LEN;
      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
    },
    __wbg___wbindgen_in_07056af4f902c445: function(arg0, arg1) {
      const ret = getObject(arg0) in getObject(arg1);
      return ret;
    },
    __wbg___wbindgen_is_bigint_aeae3893f30ed54e: function(arg0) {
      const ret = typeof getObject(arg0) === "bigint";
      return ret;
    },
    __wbg___wbindgen_is_function_5cd60d5cf78b4eef: function(arg0) {
      const ret = typeof getObject(arg0) === "function";
      return ret;
    },
    __wbg___wbindgen_is_null_2042690d351e14f0: function(arg0) {
      const ret = getObject(arg0) === null;
      return ret;
    },
    __wbg___wbindgen_is_object_b4593df85baada48: function(arg0) {
      const val = getObject(arg0);
      const ret = typeof val === "object" && val !== null;
      return ret;
    },
    __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5: function(arg0) {
      const ret = getObject(arg0) === undefined;
      return ret;
    },
    __wbg___wbindgen_jsval_eq_c0ed08b3e0f393b9: function(arg0, arg1) {
      const ret = getObject(arg0) === getObject(arg1);
      return ret;
    },
    __wbg___wbindgen_jsval_loose_eq_0ad77b7717db155c: function(arg0, arg1) {
      const ret = getObject(arg0) == getObject(arg1);
      return ret;
    },
    __wbg___wbindgen_number_get_f73a1244370fcc2c: function(arg0, arg1) {
      const obj = getObject(arg1);
      const ret = typeof obj === "number" ? obj : undefined;
      getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
      getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
    },
    __wbg___wbindgen_string_get_d109740c0d18f4d7: function(arg0, arg1) {
      const obj = getObject(arg1);
      const ret = typeof obj === "string" ? obj : undefined;
      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
      var len1 = WASM_VECTOR_LEN;
      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
    },
    __wbg___wbindgen_throw_9c31b086c2b26051: function(arg0, arg1) {
      throw new Error(getStringFromWasm0(arg0, arg1));
    },
    __wbg__wbg_cb_unref_3fa391f3fcdb55f8: function(arg0) {
      getObject(arg0)._wbg_cb_unref();
    },
    __wbg_attrs_eb268b5ce109b817: function(arg0) {
      const ret = getObject(arg0).attrs;
      return addHeapObject(ret);
    },
    __wbg_call_13665d9f14390edc: function() {
      return handleError(function(arg0, arg1) {
        const ret = getObject(arg0).call(getObject(arg1));
        return addHeapObject(ret);
      }, arguments);
    },
    __wbg_call_dfde26266607c996: function() {
      return handleError(function(arg0, arg1, arg2) {
        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
        return addHeapObject(ret);
      }, arguments);
    },
    __wbg_content_54fb4ecf37d1b68a: function(arg0) {
      const ret = getObject(arg0).content;
      return addHeapObject(ret);
    },
    __wbg_debug_10ca7029b12f8d85: function(arg0, arg1, arg2, arg3) {
      getObject(arg0).debug(getObject(arg1), arg2 === 0 ? undefined : getStringFromWasm0(arg2, arg3));
    },
    __wbg_done_54b8da57023b7ed2: function(arg0) {
      const ret = getObject(arg0).done;
      return ret;
    },
    __wbg_entries_564a7e8b1e54ede5: function(arg0) {
      const ret = Object.entries(getObject(arg0));
      return addHeapObject(ret);
    },
    __wbg_error_9cce413345f88385: function(arg0, arg1, arg2, arg3) {
      getObject(arg0).error(getObject(arg1), arg2 === 0 ? undefined : getStringFromWasm0(arg2, arg3));
    },
    __wbg_from_fa561fa561dc8031: function(arg0) {
      const ret = Array.from(getObject(arg0));
      return addHeapObject(ret);
    },
    __wbg_getOurIdentity_85a51d9b5b46c006: function() {
      return handleError(function(arg0) {
        const ret = getObject(arg0).getOurIdentity();
        return addHeapObject(ret);
      }, arguments);
    },
    __wbg_getOurRegistrationId_6d41d022f3c2af8a: function() {
      return handleError(function(arg0) {
        const ret = getObject(arg0).getOurRegistrationId();
        return addHeapObject(ret);
      }, arguments);
    },
    __wbg_getRandomValues_76dfc69825c9c552: function() {
      return handleError(function(arg0, arg1) {
        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
      }, arguments);
    },
    __wbg_get_3e9a707ab7d352eb: function() {
      return handleError(function(arg0, arg1) {
        const ret = Reflect.get(getObject(arg0), getObject(arg1));
        return addHeapObject(ret);
      }, arguments);
    },
    __wbg_get_98fdf51d029a75eb: function(arg0, arg1) {
      const ret = getObject(arg0)[arg1 >>> 0];
      return addHeapObject(ret);
    },
    __wbg_get_dcf82ab8aad1a593: function() {
      return handleError(function(arg0, arg1) {
        const ret = Reflect.get(getObject(arg0), getObject(arg1));
        return addHeapObject(ret);
      }, arguments);
    },
    __wbg_get_unchecked_1dfe6d05ad91d9b7: function(arg0, arg1) {
      const ret = getObject(arg0)[arg1 >>> 0];
      return addHeapObject(ret);
    },
    __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
      const ret = getObject(arg0)[getObject(arg1)];
      return addHeapObject(ret);
    },
    __wbg_has_ef192b1f278770eb: function() {
      return handleError(function(arg0, arg1) {
        const ret = Reflect.has(getObject(arg0), getObject(arg1));
        return ret;
      }, arguments);
    },
    __wbg_info_b728e87a346ff6a2: function(arg0, arg1, arg2, arg3) {
      getObject(arg0).info(getObject(arg1), arg2 === 0 ? undefined : getStringFromWasm0(arg2, arg3));
    },
    __wbg_instanceof_ArrayBuffer_53db37b06f6b9afe: function(arg0) {
      let result;
      try {
        result = getObject(arg0) instanceof ArrayBuffer;
      } catch (_) {
        result = false;
      }
      const ret = result;
      return ret;
    },
    __wbg_instanceof_Map_16f217b9a2a08d8c: function(arg0) {
      let result;
      try {
        result = getObject(arg0) instanceof Map;
      } catch (_) {
        result = false;
      }
      const ret = result;
      return ret;
    },
    __wbg_instanceof_Object_03924e0dbda74bd8: function(arg0) {
      let result;
      try {
        result = getObject(arg0) instanceof Object;
      } catch (_) {
        result = false;
      }
      const ret = result;
      return ret;
    },
    __wbg_instanceof_Promise_09012cfa9708520a: function(arg0) {
      let result;
      try {
        result = getObject(arg0) instanceof Promise;
      } catch (_) {
        result = false;
      }
      const ret = result;
      return ret;
    },
    __wbg_instanceof_Uint8Array_abd07d4bd221d50b: function(arg0) {
      let result;
      try {
        result = getObject(arg0) instanceof Uint8Array;
      } catch (_) {
        result = false;
      }
      const ret = result;
      return ret;
    },
    __wbg_internalbinarynode_new: function(arg0) {
      const ret = InternalBinaryNode.__wrap(arg0);
      return addHeapObject(ret);
    },
    __wbg_isArray_94898ed3aad6947b: function(arg0) {
      const ret = Array.isArray(getObject(arg0));
      return ret;
    },
    __wbg_isSafeInteger_01e964d144ad3a55: function(arg0) {
      const ret = Number.isSafeInteger(getObject(arg0));
      return ret;
    },
    __wbg_isTrustedIdentity_8beedd37958ed6af: function() {
      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
        const ret = getObject(arg0).isTrustedIdentity(getStringFromWasm0(arg1, arg2), getObject(arg3), arg4 >>> 0);
        return addHeapObject(ret);
      }, arguments);
    },
    __wbg_iterator_1441b47f341dc34f: function() {
      const ret = Symbol.iterator;
      return addHeapObject(ret);
    },
    __wbg_keys_682010b680c9b1f8: function(arg0) {
      const ret = Object.keys(getObject(arg0));
      return addHeapObject(ret);
    },
    __wbg_length_2591a0f4f659a55c: function(arg0) {
      const ret = getObject(arg0).length;
      return ret;
    },
    __wbg_length_56fcd3e2b7e0299d: function(arg0) {
      const ret = getObject(arg0).length;
      return ret;
    },
    __wbg_level_4b50b181832c5acf: function(arg0, arg1) {
      const ret = getObject(arg1).level;
      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
      const len1