@cathaysia/crown-wasm 0.19.0

package/crown_wasm_bg.js

@@ -0,0 +1,2881 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_0.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+const AeadCipherFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_aeadcipher_free(ptr >>> 0, 1));
+
+export class AeadCipher {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AeadCipher.prototype);
+        obj.__wbg_ptr = ptr;
+        AeadCipherFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AeadCipherFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_aeadcipher_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {AeadCipher}
+     */
+    static new_aes_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_aes_gcm(ptr0, len0);
+        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_aes_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_aes_ocb3(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_blowfish_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_blowfish_gcm(ptr0, len0);
+        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_blowfish_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_blowfish_ocb3(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_cast5_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_cast5_gcm(ptr0, len0);
+        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_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_cast5_ocb3(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_des_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_des_gcm(ptr0, len0);
+        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_des_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_des_ocb3(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_tripledes_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_tripledes_gcm(ptr0, len0);
+        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_tripledes_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_tripledes_ocb3(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_tea_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_tea_gcm(ptr0, len0);
+        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_tea_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_tea_ocb3(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_twofish_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_twofish_gcm(ptr0, len0);
+        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_twofish_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_twofish_ocb3(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_xtea_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_xtea_gcm(ptr0, len0);
+        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_xtea_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_xtea_ocb3(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_rc6_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_rc6_gcm(ptr0, len0);
+        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_rc6_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_rc6_ocb3(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_sm4_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_sm4_gcm(ptr0, len0);
+        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_sm4_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_sm4_ocb3(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_skipjack_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_skipjack_gcm(ptr0, len0);
+        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_skipjack_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_skipjack_ocb3(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_kasumi_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_kasumi_gcm(ptr0, len0);
+        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_kasumi_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_kasumi_ocb3(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_kseed_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_kseed_gcm(ptr0, len0);
+        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_kseed_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_kseed_ocb3(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_anubis_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_anubis_gcm(ptr0, len0);
+        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_anubis_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_anubis_ocb3(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_noekeon_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_noekeon_gcm(ptr0, len0);
+        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_noekeon_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_noekeon_ocb3(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_khazad_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_khazad_gcm(ptr0, len0);
+        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_khazad_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_khazad_ocb3(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_serpent_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_serpent_gcm(ptr0, len0);
+        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_serpent_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_serpent_ocb3(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_idea_gcm(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_idea_gcm(ptr0, len0);
+        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_idea_ocb3(key, tag_size, nonce_size) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_idea_ocb3(ptr0, len0, tag_size, nonce_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {number | null} [rounds]
+     * @returns {AeadCipher}
+     */
+    static new_rc2_gcm(key, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_rc2_gcm(ptr0, len0, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {number | null} [rounds]
+     * @returns {AeadCipher}
+     */
+    static new_rc5_gcm(key, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_rc5_gcm(ptr0, len0, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {number | null} [rounds]
+     * @returns {AeadCipher}
+     */
+    static new_camellia_gcm(key, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_camellia_gcm(ptr0, len0, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {number | null} [rounds]
+     * @returns {AeadCipher}
+     */
+    static new_multi2_gcm(key, rounds) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_multi2_gcm(ptr0, len0, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {AeadCipher}
+     */
+    static new_chacha20_poly1305(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_chacha20_poly1305(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {AeadCipher}
+     */
+    static new_xchacha20_poly1305(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_new_xchacha20_poly1305(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AeadCipher.__wrap(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    nonce_size() {
+        const ret = wasm.aeadcipher_nonce_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    tag_size() {
+        const ret = wasm.aeadcipher_tag_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {Uint8Array} data
+     * @param {Uint8Array} nonce
+     * @param {Uint8Array} aad
+     * @returns {Uint8Array}
+     */
+    seal_in_place_separate_tag(data, nonce, aad) {
+        var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(nonce, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(aad, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_seal_in_place_separate_tag(this.__wbg_ptr, ptr0, len0, data, 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 {Uint8Array} data
+     * @param {Uint8Array} tag
+     * @param {Uint8Array} nonce
+     * @param {Uint8Array} aad
+     */
+    open_in_place_separate_tag(data, tag, nonce, aad) {
+        var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(tag, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(nonce, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray8ToWasm0(aad, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.aeadcipher_open_in_place_separate_tag(this.__wbg_ptr, ptr0, len0, data, ptr1, len1, ptr2, len2, ptr3, len3);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) AeadCipher.prototype[Symbol.dispose] = AeadCipher.prototype.free;
+
+const BlockCipherFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_blockcipher_free(ptr >>> 0, 1));
+
+export class BlockCipher {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(BlockCipher.prototype);
+        obj.__wbg_ptr = ptr;
+        BlockCipherFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BlockCipherFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_blockcipher_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_aes_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_aes_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_blowfish_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_blowfish_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_cast5_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_cast5_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_des_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_des_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_tripledes_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_tripledes_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_tea_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_tea_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_twofish_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_twofish_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_xtea_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_xtea_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_idea_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_idea_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_rc6_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_rc6_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_sm4_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_sm4_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_skipjack_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_skipjack_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_kasumi_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_kasumi_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_kseed_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_kseed_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_anubis_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_anubis_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_noekeon_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_noekeon_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_khazad_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_khazad_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {BlockCipher}
+     */
+    static new_serpent_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_serpent_cbc(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {BlockCipher}
+     */
+    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_rc2_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
+     * @param {number | null} [rounds]
+     * @returns {BlockCipher}
+     */
+    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_rc5_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
+     * @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
+     * @param {number | null} [rounds]
+     * @returns {BlockCipher}
+     */
+    static new_multi2_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_multi2_cbc(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BlockCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} data
+     * @param {number} pos
+     * @returns {number}
+     */
+    encrypt(data, pos) {
+        var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.blockcipher_encrypt(this.__wbg_ptr, ptr0, len0, data, pos);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {Uint8Array} data
+     * @returns {number}
+     */
+    decrypt(data) {
+        var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.blockcipher_decrypt(this.__wbg_ptr, ptr0, len0, data);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+}
+if (Symbol.dispose) BlockCipher.prototype[Symbol.dispose] = BlockCipher.prototype.free;
+
+const HashFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_hash_free(ptr >>> 0, 1));
+
+export class Hash {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Hash.prototype);
+        obj.__wbg_ptr = ptr;
+        HashFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HashFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_hash_free(ptr, 0);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_md2() {
+        const ret = wasm.hash_new_md2();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_md2_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_md2_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_md4() {
+        const ret = wasm.hash_new_md4();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_md4_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_md4_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_md5() {
+        const ret = wasm.hash_new_md5();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_md5_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_md5_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha1() {
+        const ret = wasm.hash_new_sha1();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha1_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha1_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha224() {
+        const ret = wasm.hash_new_sha224();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha224_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha224_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha256() {
+        const ret = wasm.hash_new_sha256();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha256_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha256_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha384() {
+        const ret = wasm.hash_new_sha384();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha384_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha384_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha512() {
+        const ret = wasm.hash_new_sha512();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha512_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha512_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha512_224() {
+        const ret = wasm.hash_new_sha512_224();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha512_224_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha512_224_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha512_256() {
+        const ret = wasm.hash_new_sha512_256();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha512_256_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha512_256_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha3_224() {
+        const ret = wasm.hash_new_sha3_224();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha3_224_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha3_224_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha3_256() {
+        const ret = wasm.hash_new_sha3_256();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha3_256_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha3_256_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha3_384() {
+        const ret = wasm.hash_new_sha3_384();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha3_384_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha3_384_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sha3_512() {
+        const ret = wasm.hash_new_sha3_512();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sha3_512_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sha3_512_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_shake128() {
+        const ret = wasm.hash_new_shake128();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_shake128_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_shake128_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_shake256() {
+        const ret = wasm.hash_new_shake256();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_shake256_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_shake256_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Hash}
+     */
+    static new_sm3() {
+        const ret = wasm.hash_new_sm3();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {Hash}
+     */
+    static new_sm3_hmac(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_new_sm3_hmac(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        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);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Hash.__wrap(ret[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]);
+    }
+    /**
+     * @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;
+    }
+    flush() {
+        const ret = wasm.hash_flush(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @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 {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;
+    }
+    reset() {
+        wasm.hash_reset(this.__wbg_ptr);
+    }
+    /**
+     * @returns {number}
+     */
+    size() {
+        const ret = wasm.hash_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    block_size() {
+        const ret = wasm.hash_block_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Hash.prototype[Symbol.dispose] = Hash.prototype.free;
+
+const StreamCipherFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_streamcipher_free(ptr >>> 0, 1));
+
+export class StreamCipher {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StreamCipher.prototype);
+        obj.__wbg_ptr = ptr;
+        StreamCipherFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StreamCipherFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_streamcipher_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {StreamCipher}
+     */
+    static new_aes_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_aes_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_aes_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_aes_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_aes_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_aes_ofb(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_blowfish_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_blowfish_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_blowfish_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_blowfish_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_blowfish_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_blowfish_ofb(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_cast5_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_cast5_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_cast5_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_cast5_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_cast5_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_cast5_ofb(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_des_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_des_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_des_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_des_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_des_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_des_ofb(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_tripledes_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_tripledes_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_tripledes_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_tripledes_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_tripledes_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_tripledes_ofb(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_tea_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_tea_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_tea_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_tea_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_tea_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_tea_ofb(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_twofish_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_twofish_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_twofish_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_twofish_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_twofish_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_twofish_ofb(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_xtea_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_xtea_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_xtea_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_xtea_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_xtea_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_xtea_ofb(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_idea_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_idea_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_idea_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_idea_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_idea_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_idea_ofb(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_rc6_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_rc6_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_rc6_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_rc6_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_rc6_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_rc6_ofb(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_sm4_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_sm4_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_sm4_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_sm4_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_sm4_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_sm4_ofb(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_skipjack_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_skipjack_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_skipjack_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_skipjack_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_skipjack_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_skipjack_ofb(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_kasumi_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_kasumi_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_kasumi_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_kasumi_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_kasumi_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_kasumi_ofb(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_kseed_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_kseed_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_kseed_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_kseed_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_kseed_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_kseed_ofb(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_anubis_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_anubis_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_anubis_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_anubis_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_anubis_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_anubis_ofb(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_noekeon_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_noekeon_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_noekeon_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_noekeon_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_noekeon_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_noekeon_ofb(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_khazad_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_khazad_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_khazad_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_khazad_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_khazad_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_khazad_ofb(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_serpent_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_serpent_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_serpent_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_serpent_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_serpent_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_serpent_ofb(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_rc2_cfb(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.streamcipher_new_rc2_cfb(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_rc2_ctr(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.streamcipher_new_rc2_ctr(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_rc2_ofb(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.streamcipher_new_rc2_ofb(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_rc5_cfb(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.streamcipher_new_rc5_cfb(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_rc5_ctr(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.streamcipher_new_rc5_ctr(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_rc5_ofb(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.streamcipher_new_rc5_ofb(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_camellia_cfb(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.streamcipher_new_camellia_cfb(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_camellia_ctr(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.streamcipher_new_camellia_ctr(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_camellia_ofb(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.streamcipher_new_camellia_ofb(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_multi2_cfb(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.streamcipher_new_multi2_cfb(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_multi2_ctr(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.streamcipher_new_multi2_ctr(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {number | null} [rounds]
+     * @returns {StreamCipher}
+     */
+    static new_multi2_ofb(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.streamcipher_new_multi2_ofb(ptr0, len0, ptr1, len1, isLikeNone(rounds) ? 0x100000001 : (rounds) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @returns {StreamCipher}
+     */
+    static new_rc4(key) {
+        const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.streamcipher_new_rc4(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @returns {StreamCipher}
+     */
+    static new_salsa20(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_salsa20(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_chacha20(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_chacha20(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_rabbit(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_rabbit(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_sosemanuk(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_sosemanuk(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_sober128(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_sober128(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StreamCipher.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} data
+     */
+    encrypt(data) {
+        var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.streamcipher_encrypt(this.__wbg_ptr, ptr0, len0, data);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Uint8Array} data
+     */
+    decrypt(data) {
+        var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.streamcipher_decrypt(this.__wbg_ptr, ptr0, len0, data);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) StreamCipher.prototype[Symbol.dispose] = StreamCipher.prototype.free;
+
+export function __wbg_wbindgencopytotypedarray_d105febdb9374ca3(arg0, arg1, arg2) {
+    new Uint8Array(arg2.buffer, arg2.byteOffset, arg2.byteLength).set(getArrayU8FromWasm0(arg0, arg1));
+};
+
+export function __wbg_wbindgenthrow_451ec1a8469d7eb6(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_export_0;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+