@cathaysia/crown-wasm 0.22.0 → 0.24.0

package/crown_wasm.d.ts

@@ -5,44 +5,69 @@ export class AeadCipher {
   free(): void;
   [Symbol.dispose](): void;
   nonce_size(): number;
+  static new_aes_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_aes_gcm(key: Uint8Array): AeadCipher;
+  static new_des_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_des_gcm(key: Uint8Array): AeadCipher;
+  static new_rc2_ccm(key: Uint8Array, tag_size: number, nonce_size: number, rounds?: number | null): AeadCipher;
   static new_rc2_gcm(key: Uint8Array, rounds?: number | null): AeadCipher;
+  static new_rc5_ccm(key: Uint8Array, tag_size: number, nonce_size: number, rounds?: number | null): AeadCipher;
   static new_rc5_gcm(key: Uint8Array, rounds?: number | null): AeadCipher;
+  static new_rc6_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_rc6_gcm(key: Uint8Array): AeadCipher;
+  static new_sm4_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_sm4_gcm(key: Uint8Array): AeadCipher;
+  static new_tea_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_tea_gcm(key: Uint8Array): AeadCipher;
   static new_aes_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_aria_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_aria_gcm(key: Uint8Array): AeadCipher;
   static new_des_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_idea_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_idea_gcm(key: Uint8Array): AeadCipher;
   static new_rc6_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_sm4_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_tea_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_xtea_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_xtea_gcm(key: Uint8Array): AeadCipher;
+  static new_aria_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_cast5_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_cast5_gcm(key: Uint8Array): AeadCipher;
   static new_idea_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_kseed_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_kseed_gcm(key: Uint8Array): AeadCipher;
   static new_xtea_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_anubis_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_anubis_gcm(key: Uint8Array): AeadCipher;
   static new_cast5_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_kasumi_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_kasumi_gcm(key: Uint8Array): AeadCipher;
+  static new_khazad_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_khazad_gcm(key: Uint8Array): AeadCipher;
   static new_kseed_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_multi2_ccm(key: Uint8Array, tag_size: number, nonce_size: number, rounds?: number | null): AeadCipher;
   static new_multi2_gcm(key: Uint8Array, rounds?: number | null): AeadCipher;
   static new_anubis_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_kasumi_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_khazad_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_noekeon_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_noekeon_gcm(key: Uint8Array): AeadCipher;
+  static new_serpent_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_serpent_gcm(key: Uint8Array): AeadCipher;
+  static new_twofish_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_twofish_gcm(key: Uint8Array): AeadCipher;
+  static new_blowfish_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_blowfish_gcm(key: Uint8Array): AeadCipher;
+  static new_camellia_ccm(key: Uint8Array, tag_size: number, nonce_size: number, rounds?: number | null): AeadCipher;
   static new_camellia_gcm(key: Uint8Array, rounds?: number | null): AeadCipher;
   static new_noekeon_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_serpent_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_skipjack_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_skipjack_gcm(key: Uint8Array): AeadCipher;
   static new_twofish_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_blowfish_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_skipjack_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
+  static new_tripledes_ccm(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_tripledes_gcm(key: Uint8Array): AeadCipher;
   static new_tripledes_ocb3(key: Uint8Array, tag_size: number, nonce_size: number): AeadCipher;
   static new_chacha20_poly1305(key: Uint8Array): AeadCipher;
@@ -62,6 +87,7 @@ export class BlockCipher {
   static new_rc6_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
   static new_sm4_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
   static new_tea_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
+  static new_aria_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
   static new_idea_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
   static new_xtea_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
   static new_cast5_cbc(key: Uint8Array, iv: Uint8Array): BlockCipher;
@@ -155,6 +181,9 @@ export class StreamCipher {
   static new_tea_cfb(key: Uint8Array, iv: Uint8Array): StreamCipher;
   static new_tea_ctr(key: Uint8Array, iv: Uint8Array): StreamCipher;
   static new_tea_ofb(key: Uint8Array, iv: Uint8Array): StreamCipher;
+  static new_aria_cfb(key: Uint8Array, iv: Uint8Array): StreamCipher;
+  static new_aria_ctr(key: Uint8Array, iv: Uint8Array): StreamCipher;
+  static new_aria_ofb(key: Uint8Array, iv: Uint8Array): StreamCipher;
   static new_chacha20(key: Uint8Array, iv: Uint8Array): StreamCipher;
   static new_idea_cfb(key: Uint8Array, iv: Uint8Array): StreamCipher;
   static new_idea_ctr(key: Uint8Array, iv: Uint8Array): StreamCipher;

package/crown_wasm_bg.js

@@ -90,6 +90,21 @@ export class AeadCipher {
         const ret = wasm.aeadcipher_nonce_size(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_aes_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_aes_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -103,6 +118,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_des_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_des_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -116,6 +146,22 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @param {number | null} [rounds]
+     * @returns {AeadCipher}
+     */
+    static new_rc2_ccm(key, tag_size, nonce_size, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_rc2_ccm(ptr0, len0, tag_size, nonce_size, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @param {number | null} [rounds]
@@ -130,6 +176,22 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @param {number | null} [rounds]
+     * @returns {AeadCipher}
+     */
+    static new_rc5_ccm(key, tag_size, nonce_size, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_rc5_ccm(ptr0, len0, tag_size, nonce_size, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @param {number | null} [rounds]
@@ -144,6 +206,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_rc6_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_rc6_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -157,6 +234,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_sm4_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_sm4_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -170,6 +262,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_tea_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_tea_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -198,6 +305,34 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_aria_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_aria_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {AeadCipher}
+     */
+    static new_aria_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_aria_gcm(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @param {number} tag_size
@@ -213,6 +348,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_idea_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_idea_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -271,6 +421,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_xtea_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_xtea_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -284,6 +449,36 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_aria_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_aria_ocb3(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_cast5_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_cast5_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -312,6 +507,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_kseed_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_kseed_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -340,6 +550,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_anubis_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_anubis_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -368,6 +593,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_kasumi_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_kasumi_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -381,6 +621,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_khazad_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_khazad_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -409,6 +664,22 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @param {number | null} [rounds]
+     * @returns {AeadCipher}
+     */
+    static new_multi2_ccm(key, tag_size, nonce_size, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_multi2_ccm(ptr0, len0, tag_size, nonce_size, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @param {number | null} [rounds]
@@ -468,6 +739,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_noekeon_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_noekeon_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -481,6 +767,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_serpent_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_serpent_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -494,6 +795,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_twofish_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_twofish_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -507,6 +823,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_blowfish_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_blowfish_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -520,6 +851,22 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @param {number | null} [rounds]
+     * @returns {AeadCipher}
+     */
+    static new_camellia_ccm(key, tag_size, nonce_size, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_camellia_ccm(ptr0, len0, tag_size, nonce_size, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @param {number | null} [rounds]
@@ -564,6 +911,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_skipjack_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_skipjack_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -622,6 +984,21 @@ export class AeadCipher {
         }
         return AeadCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {number} tag_size
+     * @param {number} nonce_size
+     * @returns {AeadCipher}
+     */
+    static new_tripledes_ccm(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_tripledes_ccm(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @returns {AeadCipher}
@@ -866,6 +1243,22 @@ export class BlockCipher {
         }
         return BlockCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_aria_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_aria_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @param {Uint8Array} iv
@@ -2042,6 +2435,54 @@ export class StreamCipher {
         }
         return StreamCipher.__wrap(ret[0]);
     }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {StreamCipher}
+     */
+    static new_aria_cfb(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.streamcipher_new_aria_cfb(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {StreamCipher}
+     */
+    static new_aria_ctr(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.streamcipher_new_aria_ctr(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {StreamCipher}
+     */
+    static new_aria_ofb(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.streamcipher_new_aria_ofb(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} key
      * @param {Uint8Array} iv

package/package.json

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