@cathaysia/crown-wasm 0.26.6 → 0.27.0

package/crown_wasm.d.ts

@@ -1,5 +1,63 @@
 /* tslint:disable */
 /* eslint-disable */
+export function ed25519_keygen(): Uint8Array;
+export function ed25519_sign(secret: Uint8Array, msg: Uint8Array): Uint8Array;
+export function ed25519_verify(_public: Uint8Array, msg: Uint8Array, sig: Uint8Array): boolean;
+/**
+ * Returns `public || private`.
+ */
+export function ml_dsa_keygen(variant: number, seed: Uint8Array): Uint8Array;
+export function ml_dsa_sign(variant: number, _private: Uint8Array, msg: Uint8Array, ctx: Uint8Array): Uint8Array;
+export function ml_dsa_verify(variant: number, _public: Uint8Array, msg: Uint8Array, ctx: Uint8Array, sig: Uint8Array): boolean;
+/**
+ * Returns `public || private`.
+ */
+export function slh_dsa_keygen(name: string, seed: Uint8Array): Uint8Array;
+export function slh_dsa_sign(name: string, _private: Uint8Array, msg: Uint8Array, ctx: Uint8Array): Uint8Array;
+export function slh_dsa_verify(name: string, _public: Uint8Array, msg: Uint8Array, ctx: Uint8Array, sig: Uint8Array): boolean;
+export function aes_key_wrap(key: Uint8Array, plaintext: Uint8Array): Uint8Array;
+export function aes_key_unwrap(key: Uint8Array, ciphertext: Uint8Array): Uint8Array;
+export function aes_key_wrap_padded(key: Uint8Array, plaintext: Uint8Array): Uint8Array;
+export function aes_key_unwrap_padded(key: Uint8Array, ciphertext: Uint8Array): Uint8Array;
+export function ff1_encrypt_decimal(key: Uint8Array, tweak: Uint8Array, input: string): string;
+export function ff1_decrypt_decimal(key: Uint8Array, tweak: Uint8Array, input: string): string;
+/**
+ * PBKDF2-HMAC-SHA256.
+ */
+export function pbkdf2(password: Uint8Array, salt: Uint8Array, iterations: number, length: number): Uint8Array;
+/**
+ * HKDF-Extract + Expand with SHA-256. `info` may be empty.
+ */
+export function hkdf(ikm: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number): Uint8Array;
+/**
+ * TLS 1.2 PRF with SHA-256. `seed` is the label+seed material.
+ */
+export function tls1_prf(secret: Uint8Array, seed: Uint8Array, length: number): Uint8Array;
+/**
+ * SSKDF (hash-based) with SHA-256.
+ */
+export function sskdf(secret: Uint8Array, info: Uint8Array, length: number): Uint8Array;
+/**
+ * X963KDF with SHA-256.
+ */
+export function x963_kdf(secret: Uint8Array, info: Uint8Array, length: number): Uint8Array;
+/**
+ * HOTP (RFC 4226).
+ */
+export function hotp(key: Uint8Array, counter: number, digits: number): number;
+/**
+ * TOTP (RFC 6238).
+ */
+export function totp(key: Uint8Array, time: number, step: number, digits: number, t0: number): number;
+/**
+ * Returns `public || private`.
+ */
+export function ml_kem_keygen(variant: number, seed: Uint8Array): Uint8Array;
+/**
+ * Returns `ciphertext || shared_secret`.
+ */
+export function ml_kem_encapsulate(variant: number, _public: Uint8Array, message: Uint8Array): Uint8Array;
+export function ml_kem_decapsulate(variant: number, _private: Uint8Array, ciphertext: Uint8Array): Uint8Array;
 export class AeadCipher {
   private constructor();
   free(): void;
@@ -20,6 +78,9 @@ export class AeadCipher {
   static new_multi2_eax(key: Uint8Array, tag_size: number, nonce_size: number, rounds?: number | null): AeadCipher;
   static new_chacha20_poly1305(key: Uint8Array): AeadCipher;
   static new_xchacha20_poly1305(key: Uint8Array): AeadCipher;
+  static new_aes_gcm_siv(key: Uint8Array): AeadCipher;
+  static new_ascon_aead128(key: Uint8Array): AeadCipher;
+  static new_aes_siv(key: Uint8Array): AeadCipher;
   nonce_size(): number;
   open_in_place_separate_tag(data: Uint8Array, tag: Uint8Array, nonce: Uint8Array, aad: Uint8Array): void;
   seal_in_place_separate_tag(data: Uint8Array, nonce: Uint8Array, aad: Uint8Array): Uint8Array;
@@ -103,6 +164,7 @@ export class BlockCipher {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  static new_camellia_cbc(key: Uint8Array, iv: Uint8Array, rounds?: number | null): BlockCipher;
   static new_multi2_cbc(key: Uint8Array, iv: Uint8Array, rounds?: number | null): BlockCipher;
   decrypt(data: Uint8Array): number;
   encrypt(data: Uint8Array, pos: number): number;
@@ -125,14 +187,22 @@ export class BlockCipher {
   static new_noekeon_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
   static new_khazad_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
   static new_serpent_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
+  static new_desx_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
   static new_rc2_cbc(key: Uint8Array, iv: Uint8Array, rounds?: number | null): BlockCipher;
   static new_rc5_cbc(key: Uint8Array, iv: Uint8Array, rounds?: number | null): BlockCipher;
-  static new_camellia_cbc(key: Uint8Array, iv: Uint8Array, rounds?: number | null): BlockCipher;
 }
 export class Hash {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  static new_blake2b(key: Uint8Array | null | undefined, output_len: number): Hash;
+  block_size(): number;
+  sum(): Uint8Array;
+  read(buf: Uint8Array): number;
+  size(): number;
+  flush(): void;
+  reset(): void;
+  write(data: Uint8Array): number;
   static new_md2_hmac(key: Uint8Array): Hash;
   static new_md2(): Hash;
   static new_md4_hmac(key: Uint8Array): Hash;
@@ -167,15 +237,27 @@ export class Hash {
   static new_shake256_hmac(key: Uint8Array): Hash;
   static new_sm3_hmac(key: Uint8Array): Hash;
   static new_sm3(): Hash;
+  static new_md5_sha1(): Hash;
+  static new_md5_sha1_hmac(key: Uint8Array): Hash;
+  static new_ripemd160(): Hash;
+  static new_ripemd160_hmac(key: Uint8Array): Hash;
+  static new_mdc2_hmac(key: Uint8Array): Hash;
+  static new_mdc2(): Hash;
+  static new_whirlpool(): Hash;
+  static new_whirlpool_hmac(key: Uint8Array): Hash;
   static new_blake2s(key: Uint8Array | null | undefined, output_len: number): Hash;
-  static new_blake2b(key: Uint8Array | null | undefined, output_len: number): Hash;
-  block_size(): number;
+}
+export class Mac {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static new_kmac128(key: Uint8Array, custom: Uint8Array, output_len: number): Mac;
+  static new_kmac256(key: Uint8Array, custom: Uint8Array, output_len: number): Mac;
+  static new_siphash(key: Uint8Array, output_len: number): Mac;
+  static new_cmac_aes(key: Uint8Array): Mac;
+  static new_gmac_aes(key: Uint8Array, iv: Uint8Array): Mac;
   sum(): Uint8Array;
-  read(buf: Uint8Array): number;
-  size(): number;
-  flush(): void;
-  reset(): void;
-  write(data: Uint8Array): number;
+  write(data: Uint8Array): void;
 }
 export class StreamCipher {
   private constructor();
@@ -259,3 +341,13 @@ export class StreamCipher {
   static new_camellia_ctr(key: Uint8Array, iv: Uint8Array, rounds?: number | null): StreamCipher;
   static new_camellia_ofb(key: Uint8Array, iv: Uint8Array, rounds?: number | null): StreamCipher;
 }
+export class Xts {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static new_sm4_gb(key: Uint8Array): Xts;
+  decrypt(tweak: Uint8Array, data: Uint8Array): void;
+  encrypt(tweak: Uint8Array, data: Uint8Array): void;
+  static new_aes(key: Uint8Array): Xts;
+  static new_sm4(key: Uint8Array): Xts;
+}

package/crown_wasm_bg.js

@@ -18,6 +18,21 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 
 cachedTextDecoder.decode();
@@ -49,7 +64,7 @@ function passArray8ToWasm0(arg, malloc) {
 }
 
 function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_0.get(idx);
+    const value = wasm.__wbindgen_export_2.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
@@ -57,6 +72,580 @@ function takeFromExternrefTable0(idx) {
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
+/**
+ * @returns {Uint8Array}
+ */
+export function ed25519_keygen() {
+    const ret = wasm.ed25519_keygen();
+    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} secret
+ * @param {Uint8Array} msg
+ * @returns {Uint8Array}
+ */
+export function ed25519_sign(secret, msg) {
+    const ptr0 = passArray8ToWasm0(secret, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.ed25519_sign(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {Uint8Array} _public
+ * @param {Uint8Array} msg
+ * @param {Uint8Array} sig
+ * @returns {boolean}
+ */
+export function ed25519_verify(_public, msg, sig) {
+    const ptr0 = passArray8ToWasm0(_public, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(sig, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.ed25519_verify(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+
+/**
+ * Returns `public || private`.
+ * @param {number} variant
+ * @param {Uint8Array} seed
+ * @returns {Uint8Array}
+ */
+export function ml_dsa_keygen(variant, seed) {
+    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ml_dsa_keygen(variant, ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * @param {number} variant
+ * @param {Uint8Array} _private
+ * @param {Uint8Array} msg
+ * @param {Uint8Array} ctx
+ * @returns {Uint8Array}
+ */
+export function ml_dsa_sign(variant, _private, msg, ctx) {
+    const ptr0 = passArray8ToWasm0(_private, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(ctx, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.ml_dsa_sign(variant, ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v4;
+}
+
+/**
+ * @param {number} variant
+ * @param {Uint8Array} _public
+ * @param {Uint8Array} msg
+ * @param {Uint8Array} ctx
+ * @param {Uint8Array} sig
+ * @returns {boolean}
+ */
+export function ml_dsa_verify(variant, _public, msg, ctx, sig) {
+    const ptr0 = passArray8ToWasm0(_public, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(ctx, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray8ToWasm0(sig, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.ml_dsa_verify(variant, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+
+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
+        };
+    }
+}
+
+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;
+}
+/**
+ * Returns `public || private`.
+ * @param {string} name
+ * @param {Uint8Array} seed
+ * @returns {Uint8Array}
+ */
+export function slh_dsa_keygen(name, seed) {
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.slh_dsa_keygen(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {string} name
+ * @param {Uint8Array} _private
+ * @param {Uint8Array} msg
+ * @param {Uint8Array} ctx
+ * @returns {Uint8Array}
+ */
+export function slh_dsa_sign(name, _private, msg, ctx) {
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(_private, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray8ToWasm0(ctx, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.slh_dsa_sign(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v5;
+}
+
+/**
+ * @param {string} name
+ * @param {Uint8Array} _public
+ * @param {Uint8Array} msg
+ * @param {Uint8Array} ctx
+ * @param {Uint8Array} sig
+ * @returns {boolean}
+ */
+export function slh_dsa_verify(name, _public, msg, ctx, sig) {
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(_public, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray8ToWasm0(ctx, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passArray8ToWasm0(sig, wasm.__wbindgen_malloc);
+    const len4 = WASM_VECTOR_LEN;
+    const ret = wasm.slh_dsa_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+
+/**
+ * @param {Uint8Array} key
+ * @param {Uint8Array} plaintext
+ * @returns {Uint8Array}
+ */
+export function aes_key_wrap(key, plaintext) {
+    const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.aes_key_wrap(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {Uint8Array} key
+ * @param {Uint8Array} ciphertext
+ * @returns {Uint8Array}
+ */
+export function aes_key_unwrap(key, ciphertext) {
+    const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.aes_key_unwrap(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {Uint8Array} key
+ * @param {Uint8Array} plaintext
+ * @returns {Uint8Array}
+ */
+export function aes_key_wrap_padded(key, plaintext) {
+    const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.aes_key_wrap_padded(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {Uint8Array} key
+ * @param {Uint8Array} ciphertext
+ * @returns {Uint8Array}
+ */
+export function aes_key_unwrap_padded(key, ciphertext) {
+    const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.aes_key_unwrap_padded(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {Uint8Array} key
+ * @param {Uint8Array} tweak
+ * @param {string} input
+ * @returns {string}
+ */
+export function ff1_encrypt_decimal(key, tweak, input) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(tweak, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.ff1_encrypt_decimal(ptr0, len0, ptr1, len1, ptr2, len2);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
+        if (ret[3]) {
+            ptr4 = 0; len4 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+
+/**
+ * @param {Uint8Array} key
+ * @param {Uint8Array} tweak
+ * @param {string} input
+ * @returns {string}
+ */
+export function ff1_decrypt_decimal(key, tweak, input) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(tweak, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.ff1_decrypt_decimal(ptr0, len0, ptr1, len1, ptr2, len2);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
+        if (ret[3]) {
+            ptr4 = 0; len4 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+
+/**
+ * PBKDF2-HMAC-SHA256.
+ * @param {Uint8Array} password
+ * @param {Uint8Array} salt
+ * @param {number} iterations
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export function pbkdf2(password, salt, iterations, length) {
+    const ptr0 = passArray8ToWasm0(password, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(salt, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.pbkdf2(ptr0, len0, ptr1, len1, iterations, length);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * HKDF-Extract + Expand with SHA-256. `info` may be empty.
+ * @param {Uint8Array} ikm
+ * @param {Uint8Array} salt
+ * @param {Uint8Array} info
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export function hkdf(ikm, salt, info, length) {
+    const ptr0 = passArray8ToWasm0(ikm, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(salt, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(info, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.hkdf(ptr0, len0, ptr1, len1, ptr2, len2, length);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v4;
+}
+
+/**
+ * TLS 1.2 PRF with SHA-256. `seed` is the label+seed material.
+ * @param {Uint8Array} secret
+ * @param {Uint8Array} seed
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export function tls1_prf(secret, seed, length) {
+    const ptr0 = passArray8ToWasm0(secret, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.tls1_prf(ptr0, len0, ptr1, len1, length);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * SSKDF (hash-based) with SHA-256.
+ * @param {Uint8Array} secret
+ * @param {Uint8Array} info
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export function sskdf(secret, info, length) {
+    const ptr0 = passArray8ToWasm0(secret, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(info, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.sskdf(ptr0, len0, ptr1, len1, length);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * X963KDF with SHA-256.
+ * @param {Uint8Array} secret
+ * @param {Uint8Array} info
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export function x963_kdf(secret, info, length) {
+    const ptr0 = passArray8ToWasm0(secret, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(info, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.x963_kdf(ptr0, len0, ptr1, len1, length);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * HOTP (RFC 4226).
+ * @param {Uint8Array} key
+ * @param {number} counter
+ * @param {number} digits
+ * @returns {number}
+ */
+export function hotp(key, counter, digits) {
+    const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hotp(ptr0, len0, counter, digits);
+    return ret >>> 0;
+}
+
+/**
+ * TOTP (RFC 6238).
+ * @param {Uint8Array} key
+ * @param {number} time
+ * @param {number} step
+ * @param {number} digits
+ * @param {number} t0
+ * @returns {number}
+ */
+export function totp(key, time, step, digits, t0) {
+    const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.totp(ptr0, len0, time, step, digits, t0);
+    return ret >>> 0;
+}
+
+/**
+ * Returns `public || private`.
+ * @param {number} variant
+ * @param {Uint8Array} seed
+ * @returns {Uint8Array}
+ */
+export function ml_kem_keygen(variant, seed) {
+    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ml_kem_keygen(variant, ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Returns `ciphertext || shared_secret`.
+ * @param {number} variant
+ * @param {Uint8Array} _public
+ * @param {Uint8Array} message
+ * @returns {Uint8Array}
+ */
+export function ml_kem_encapsulate(variant, _public, message) {
+    const ptr0 = passArray8ToWasm0(_public, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.ml_kem_encapsulate(variant, ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {number} variant
+ * @param {Uint8Array} _private
+ * @param {Uint8Array} ciphertext
+ * @returns {Uint8Array}
+ */
+export function ml_kem_decapsulate(variant, _private, ciphertext) {
+    const ptr0 = passArray8ToWasm0(_private, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.ml_kem_decapsulate(variant, ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
 
 const AeadCipherFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -315,6 +904,45 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @returns {AeadCipher}
+     */
+    static new_aes_gcm_siv(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_aes_gcm_siv(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {AeadCipher}
+     */
+    static new_ascon_aead128(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_ascon_aead128(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {AeadCipher}
+     */
+    static new_aes_siv(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_aes_siv(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @returns {number}
      */
@@ -1478,6 +2106,23 @@ export class BlockCipher {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_blockcipher_free(ptr, 0);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {BlockCipher}
+     */
+    static new_camellia_cbc(key, iv, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(iv, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.blockcipher_new_camellia_cbc(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @param {Uint8Array} iv
@@ -1829,15 +2474,14 @@ export class BlockCipher {
     /**
      * @param {Uint8Array} key
      * @param {Uint8Array} iv
-     * @param {number | null} [rounds]
      * @returns {BlockCipher}
      */
-    static new_rc2_cbc(key, iv, rounds) {
+    static new_desx_cbc(key, iv) {
         const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(iv, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.blockcipher_new_rc2_cbc(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        const ret = wasm.blockcipher_new_desx_cbc(ptr0, len0, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -1849,12 +2493,12 @@ export class BlockCipher {
      * @param {number | null} [rounds]
      * @returns {BlockCipher}
      */
-    static new_rc5_cbc(key, iv, rounds) {
+    static new_rc2_cbc(key, iv, rounds) {
         const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(iv, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.blockcipher_new_rc5_cbc(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        const ret = wasm.blockcipher_new_rc2_cbc(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -1866,12 +2510,12 @@ export class BlockCipher {
      * @param {number | null} [rounds]
      * @returns {BlockCipher}
      */
-    static new_camellia_cbc(key, iv, rounds) {
+    static new_rc5_cbc(key, iv, rounds) {
         const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(iv, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.blockcipher_new_camellia_cbc(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        const ret = wasm.blockcipher_new_rc5_cbc(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -1905,6 +2549,78 @@ export class Hash {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_hash_free(ptr, 0);
     }
+    /**
+     * @param {Uint8Array | null | undefined} key
+     * @param {number} output_len
+     * @returns {Hash}
+     */
+    static new_blake2b(key, output_len) {
+        var ptr0 = isLikeNone(key) ? 0 : passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_blake2b(ptr0, len0, output_len);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    block_size() {
+        const ret = wasm.hash_block_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    sum() {
+        const ret = wasm.hash_sum(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {Uint8Array} buf
+     * @returns {number}
+     */
+    read(buf) {
+        var ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_read(this.__wbg_ptr, ptr0, len0, buf);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    size() {
+        const ret = wasm.hash_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    flush() {
+        const ret = wasm.hash_flush(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    reset() {
+        wasm.hash_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Uint8Array} data
+     * @returns {number}
+     */
+    write(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_write(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * @param {Uint8Array} key
      * @returns {Hash}
@@ -2297,14 +3013,92 @@ export class Hash {
         return Hash.__wrap(ret[0]);
     }
     /**
-     * @param {Uint8Array | null | undefined} key
-     * @param {number} output_len
      * @returns {Hash}
      */
-    static new_blake2s(key, output_len) {
-        var ptr0 = isLikeNone(key) ? 0 : passArray8ToWasm0(key, wasm.__wbindgen_malloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hash_new_blake2s(ptr0, len0, output_len);
+    static new_md5_sha1() {
+        const ret = wasm.hash_new_md5_sha1();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_md5_sha1_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_md5_sha1_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_ripemd160() {
+        const ret = wasm.hash_new_ripemd160();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_ripemd160_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_ripemd160_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_mdc2_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_mdc2_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_mdc2() {
+        const ret = wasm.hash_new_mdc2();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_whirlpool() {
+        const ret = wasm.hash_new_whirlpool();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_whirlpool_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_whirlpool_hmac(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -2315,75 +3109,139 @@ export class Hash {
      * @param {number} output_len
      * @returns {Hash}
      */
-    static new_blake2b(key, output_len) {
+    static new_blake2s(key, output_len) {
         var ptr0 = isLikeNone(key) ? 0 : passArray8ToWasm0(key, wasm.__wbindgen_malloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hash_new_blake2b(ptr0, len0, output_len);
+        const ret = wasm.hash_new_blake2s(ptr0, len0, output_len);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Hash.__wrap(ret[0]);
     }
+}
+if (Symbol.dispose) Hash.prototype[Symbol.dispose] = Hash.prototype.free;
+
+const MacFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mac_free(ptr >>> 0, 1));
+
+export class Mac {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Mac.prototype);
+        obj.__wbg_ptr = ptr;
+        MacFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MacFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mac_free(ptr, 0);
+    }
     /**
-     * @returns {number}
+     * @param {Uint8Array} key
+     * @param {Uint8Array} custom
+     * @param {number} output_len
+     * @returns {Mac}
      */
-    block_size() {
-        const ret = wasm.hash_block_size(this.__wbg_ptr);
-        return ret >>> 0;
+    static new_kmac128(key, custom, output_len) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(custom, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mac_new_kmac128(ptr0, len0, ptr1, len1, output_len);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Mac.__wrap(ret[0]);
     }
     /**
-     * @returns {Uint8Array}
+     * @param {Uint8Array} key
+     * @param {Uint8Array} custom
+     * @param {number} output_len
+     * @returns {Mac}
      */
-    sum() {
-        const ret = wasm.hash_sum(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
+    static new_kmac256(key, custom, output_len) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(custom, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mac_new_kmac256(ptr0, len0, ptr1, len1, output_len);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Mac.__wrap(ret[0]);
     }
     /**
-     * @param {Uint8Array} buf
-     * @returns {number}
+     * @param {Uint8Array} key
+     * @param {number} output_len
+     * @returns {Mac}
      */
-    read(buf) {
-        var ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hash_read(this.__wbg_ptr, ptr0, len0, buf);
+    static new_siphash(key, output_len) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mac_new_siphash(ptr0, len0, output_len);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0] >>> 0;
+        return Mac.__wrap(ret[0]);
     }
     /**
-     * @returns {number}
+     * @param {Uint8Array} key
+     * @returns {Mac}
      */
-    size() {
-        const ret = wasm.hash_size(this.__wbg_ptr);
-        return ret >>> 0;
+    static new_cmac_aes(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mac_new_cmac_aes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Mac.__wrap(ret[0]);
     }
-    flush() {
-        const ret = wasm.hash_flush(this.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {Mac}
+     */
+    static new_gmac_aes(key, iv) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(iv, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mac_new_gmac_aes(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return Mac.__wrap(ret[0]);
     }
-    reset() {
-        wasm.hash_reset(this.__wbg_ptr);
+    /**
+     * @returns {Uint8Array}
+     */
+    sum() {
+        const ret = wasm.mac_sum(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
     }
     /**
      * @param {Uint8Array} data
-     * @returns {number}
      */
     write(data) {
         const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hash_write(this.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
+        wasm.mac_write(this.__wbg_ptr, ptr0, len0);
     }
 }
-if (Symbol.dispose) Hash.prototype[Symbol.dispose] = Hash.prototype.free;
+if (Symbol.dispose) Mac.prototype[Symbol.dispose] = Mac.prototype.free;
 
 const StreamCipherFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3644,6 +4502,105 @@ export class StreamCipher {
 }
 if (Symbol.dispose) StreamCipher.prototype[Symbol.dispose] = StreamCipher.prototype.free;
 
+const XtsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_xts_free(ptr >>> 0, 1));
+
+export class Xts {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Xts.prototype);
+        obj.__wbg_ptr = ptr;
+        XtsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        XtsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_xts_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Xts}
+     */
+    static new_sm4_gb(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.xts_new_sm4_gb(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Xts.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} tweak
+     * @param {Uint8Array} data
+     */
+    decrypt(tweak, data) {
+        const ptr0 = passArray8ToWasm0(tweak, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.xts_decrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1, data);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Uint8Array} tweak
+     * @param {Uint8Array} data
+     */
+    encrypt(tweak, data) {
+        const ptr0 = passArray8ToWasm0(tweak, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.xts_encrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1, data);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Xts}
+     */
+    static new_aes(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.xts_new_aes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Xts.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Xts}
+     */
+    static new_sm4(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.xts_new_sm4(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Xts.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) Xts.prototype[Symbol.dispose] = Xts.prototype.free;
+
+export function __wbg_getRandomValues_3c9c0d586e575a16() { return handleError(function (arg0, arg1) {
+    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+}, arguments) };
+
 export function __wbg_wbindgencopytotypedarray_d105febdb9374ca3(arg0, arg1, arg2) {
     new Uint8Array(arg2.buffer, arg2.byteOffset, arg2.byteLength).set(getArrayU8FromWasm0(arg0, arg1));
 };
@@ -3659,7 +4616,7 @@ export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
 };
 
 export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_export_0;
+    const table = wasm.__wbindgen_export_2;
     const offset = table.grow(4);
     table.set(0, undefined);
     table.set(offset + 0, undefined);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@cathaysia/crown-wasm",
   "type": "module",
   "description": "A cryptographic library.",
-  "version": "0.26.6",
+  "version": "0.27.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",