pqc-binary-format 1.0.7

package/pqc_binary_format_bg.js

@@ -0,0 +1,827 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const WasmAlgorithmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmalgorithm_free(ptr >>> 0, 1));
+
+const WasmCompressionParametersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcompressionparameters_free(ptr >>> 0, 1));
+
+const WasmEncParametersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmencparameters_free(ptr >>> 0, 1));
+
+const WasmFormatFlagsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmformatflags_free(ptr >>> 0, 1));
+
+const WasmKemParametersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmkemparameters_free(ptr >>> 0, 1));
+
+const WasmPqcBinaryFormatFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpqcbinaryformat_free(ptr >>> 0, 1));
+
+const WasmPqcMetadataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpqcmetadata_free(ptr >>> 0, 1));
+
+const WasmSigParametersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsigparameters_free(ptr >>> 0, 1));
+
+/**
+ * WebAssembly wrapper for Algorithm
+ */
+export class WasmAlgorithm {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmAlgorithm.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmAlgorithmFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmAlgorithmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmalgorithm_free(ptr, 0);
+    }
+    /**
+     * Get all supported algorithm names
+     * @returns {any[]}
+     */
+    static supportedAlgorithms() {
+        const ret = wasm.wasmalgorithm_supportedAlgorithms();
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get algorithm ID
+     * @returns {number}
+     */
+    get id() {
+        const ret = wasm.wasmalgorithm_id(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a new algorithm from name
+     * @param {string} name
+     */
+    constructor(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmalgorithm_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmAlgorithmFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get algorithm name
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmalgorithm_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmAlgorithm.prototype[Symbol.dispose] = WasmAlgorithm.prototype.free;
+
+/**
+ * WebAssembly wrapper for CompressionParameters
+ */
+export class WasmCompressionParameters {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmCompressionParametersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcompressionparameters_free(ptr, 0);
+    }
+    /**
+     * Get original size
+     * @returns {bigint}
+     */
+    get original_size() {
+        const ret = wasm.wasmcompressionparameters_original_size(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Create new compression parameters
+     * @param {string} algorithm
+     * @param {number} level
+     * @param {bigint} original_size
+     */
+    constructor(algorithm, level, original_size) {
+        const ptr0 = passStringToWasm0(algorithm, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmcompressionparameters_new(ptr0, len0, level, original_size);
+        this.__wbg_ptr = ret >>> 0;
+        WasmCompressionParametersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get compression level
+     * @returns {number}
+     */
+    get level() {
+        const ret = wasm.wasmcompressionparameters_level(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get compression algorithm
+     * @returns {string}
+     */
+    get algorithm() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmcompressionparameters_algorithm(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmCompressionParameters.prototype[Symbol.dispose] = WasmCompressionParameters.prototype.free;
+
+/**
+ * WebAssembly wrapper for EncParameters
+ */
+export class WasmEncParameters {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmEncParametersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmencparameters_free(ptr, 0);
+    }
+    /**
+     * Get IV/nonce
+     * @returns {Uint8Array}
+     */
+    get iv() {
+        const ret = wasm.wasmencparameters_iv(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Create new encryption parameters
+     * @param {Uint8Array} iv
+     * @param {Uint8Array} tag
+     */
+    constructor(iv, tag) {
+        const ptr0 = passArray8ToWasm0(iv, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(tag, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmencparameters_new(ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        WasmEncParametersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get authentication tag
+     * @returns {Uint8Array}
+     */
+    get tag() {
+        const ret = wasm.wasmencparameters_tag(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Set IV/nonce
+     * @param {Uint8Array} iv
+     */
+    set iv(iv) {
+        const ptr0 = passArray8ToWasm0(iv, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmencparameters_set_iv(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Set authentication tag
+     * @param {Uint8Array} tag
+     */
+    set tag(tag) {
+        const ptr0 = passArray8ToWasm0(tag, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmencparameters_set_tag(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) WasmEncParameters.prototype[Symbol.dispose] = WasmEncParameters.prototype.free;
+
+/**
+ * WebAssembly wrapper for FormatFlags
+ */
+export class WasmFormatFlags {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmFormatFlags.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmFormatFlagsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmFormatFlagsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmformatflags_free(ptr, 0);
+    }
+    /**
+     * Check if streaming is enabled
+     * @returns {boolean}
+     */
+    hasStreaming() {
+        const ret = wasm.wasmformatflags_hasStreaming(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Enable streaming flag
+     * @returns {WasmFormatFlags}
+     */
+    withStreaming() {
+        const ret = wasm.wasmformatflags_withStreaming(this.__wbg_ptr);
+        return WasmFormatFlags.__wrap(ret);
+    }
+    /**
+     * Check if compression is enabled
+     * @returns {boolean}
+     */
+    hasCompression() {
+        const ret = wasm.wasmformatflags_hasCompression(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if experimental features are enabled
+     * @returns {boolean}
+     */
+    hasExperimental() {
+        const ret = wasm.wasmformatflags_hasExperimental(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Enable compression flag
+     * @returns {WasmFormatFlags}
+     */
+    withCompression() {
+        const ret = wasm.wasmformatflags_withCompression(this.__wbg_ptr);
+        return WasmFormatFlags.__wrap(ret);
+    }
+    /**
+     * Enable experimental features flag
+     * @returns {WasmFormatFlags}
+     */
+    withExperimental() {
+        const ret = wasm.wasmformatflags_withExperimental(this.__wbg_ptr);
+        return WasmFormatFlags.__wrap(ret);
+    }
+    /**
+     * Check if additional auth is enabled
+     * @returns {boolean}
+     */
+    hasAdditionalAuth() {
+        const ret = wasm.wasmformatflags_hasAdditionalAuth(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Enable additional auth flag
+     * @returns {WasmFormatFlags}
+     */
+    withAdditionalAuth() {
+        const ret = wasm.wasmformatflags_withAdditionalAuth(this.__wbg_ptr);
+        return WasmFormatFlags.__wrap(ret);
+    }
+    /**
+     * Create new empty flags
+     */
+    constructor() {
+        const ret = wasm.wasmformatflags_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmFormatFlagsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmFormatFlags.prototype[Symbol.dispose] = WasmFormatFlags.prototype.free;
+
+/**
+ * WebAssembly wrapper for KemParameters
+ */
+export class WasmKemParameters {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmKemParametersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmkemparameters_free(ptr, 0);
+    }
+    /**
+     * Get ciphertext
+     * @returns {Uint8Array}
+     */
+    get ciphertext() {
+        const ret = wasm.wasmkemparameters_ciphertext(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Get public key
+     * @returns {Uint8Array}
+     */
+    get public_key() {
+        const ret = wasm.wasmkemparameters_public_key(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Create new KEM parameters
+     * @param {Uint8Array} public_key
+     * @param {Uint8Array} ciphertext
+     */
+    constructor(public_key, ciphertext) {
+        const ptr0 = passArray8ToWasm0(public_key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmencparameters_new(ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        WasmKemParametersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmKemParameters.prototype[Symbol.dispose] = WasmKemParameters.prototype.free;
+
+/**
+ * WebAssembly wrapper for PqcBinaryFormat
+ */
+export class WasmPqcBinaryFormat {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmPqcBinaryFormat.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmPqcBinaryFormatFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPqcBinaryFormatFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpqcbinaryformat_free(ptr, 0);
+    }
+    /**
+     * Deserialize from bytes
+     *
+     * @param {Uint8Array} data - Bytes to deserialize
+     * @returns {WasmPqcBinaryFormat} Deserialized instance
+     * @throws {Error} If deserialization fails
+     * @param {Uint8Array} data
+     * @returns {WasmPqcBinaryFormat}
+     */
+    static fromBytes(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpqcbinaryformat_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmPqcBinaryFormat.__wrap(ret[0]);
+    }
+    /**
+     * Get total serialized size
+     *
+     * @returns {number} Size in bytes
+     * @returns {number}
+     */
+    totalSize() {
+        const ret = wasm.wasmpqcbinaryformat_totalSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create with specific flags
+     *
+     * @param {WasmAlgorithm} algorithm - Algorithm to use
+     * @param {WasmFormatFlags} flags - Format flags
+     * @param {WasmPqcMetadata} metadata - Metadata container
+     * @param {Uint8Array} data - Encrypted data bytes
+     * @returns {WasmPqcBinaryFormat} New instance
+     * @param {WasmAlgorithm} algorithm
+     * @param {WasmFormatFlags} flags
+     * @param {WasmPqcMetadata} metadata
+     * @param {Uint8Array} data
+     * @returns {WasmPqcBinaryFormat}
+     */
+    static withFlags(algorithm, flags, metadata, data) {
+        _assertClass(algorithm, WasmAlgorithm);
+        var ptr0 = algorithm.__destroy_into_raw();
+        _assertClass(flags, WasmFormatFlags);
+        var ptr1 = flags.__destroy_into_raw();
+        _assertClass(metadata, WasmPqcMetadata);
+        var ptr2 = metadata.__destroy_into_raw();
+        const ptr3 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpqcbinaryformat_withFlags(ptr0, ptr1, ptr2, ptr3, len3);
+        return WasmPqcBinaryFormat.__wrap(ret);
+    }
+    /**
+     * Create a new PQC Binary Format structure
+     *
+     * @param {WasmAlgorithm} algorithm - Algorithm to use
+     * @param {WasmPqcMetadata} metadata - Metadata container
+     * @param {Uint8Array} data - Encrypted data bytes
+     * @returns {WasmPqcBinaryFormat} New instance
+     * @param {WasmAlgorithm} algorithm
+     * @param {WasmPqcMetadata} metadata
+     * @param {Uint8Array} data
+     */
+    constructor(algorithm, metadata, data) {
+        _assertClass(algorithm, WasmAlgorithm);
+        var ptr0 = algorithm.__destroy_into_raw();
+        _assertClass(metadata, WasmPqcMetadata);
+        var ptr1 = metadata.__destroy_into_raw();
+        const ptr2 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpqcbinaryformat_new(ptr0, ptr1, ptr2, len2);
+        this.__wbg_ptr = ret >>> 0;
+        WasmPqcBinaryFormatFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get encrypted data
+     *
+     * @returns {Uint8Array} Encrypted data
+     * @returns {Uint8Array}
+     */
+    get data() {
+        const ret = wasm.wasmpqcbinaryformat_data(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Get format flags
+     *
+     * @returns {WasmFormatFlags} Format flags
+     * @returns {WasmFormatFlags}
+     */
+    get flags() {
+        const ret = wasm.wasmpqcbinaryformat_flags(this.__wbg_ptr);
+        return WasmFormatFlags.__wrap(ret);
+    }
+    /**
+     * Serialize to bytes
+     *
+     * @returns {Uint8Array} Serialized bytes
+     * @throws {Error} If serialization fails
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.wasmpqcbinaryformat_toBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Validate the format structure
+     *
+     * @throws {Error} If validation fails
+     */
+    validate() {
+        const ret = wasm.wasmpqcbinaryformat_validate(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Get algorithm
+     *
+     * @returns {WasmAlgorithm} Algorithm used
+     * @returns {WasmAlgorithm}
+     */
+    get algorithm() {
+        const ret = wasm.wasmpqcbinaryformat_algorithm(this.__wbg_ptr);
+        return WasmAlgorithm.__wrap(ret);
+    }
+}
+if (Symbol.dispose) WasmPqcBinaryFormat.prototype[Symbol.dispose] = WasmPqcBinaryFormat.prototype.free;
+
+/**
+ * WebAssembly wrapper for PqcMetadata
+ */
+export class WasmPqcMetadata {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPqcMetadataFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpqcmetadata_free(ptr, 0);
+    }
+    /**
+     * Set KEM parameters
+     * @param {WasmKemParameters} kem_params
+     */
+    setKemParams(kem_params) {
+        _assertClass(kem_params, WasmKemParameters);
+        var ptr0 = kem_params.__destroy_into_raw();
+        wasm.wasmpqcmetadata_setKemParams(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Set signature parameters
+     * @param {WasmSigParameters} sig_params
+     */
+    setSigParams(sig_params) {
+        _assertClass(sig_params, WasmSigParameters);
+        var ptr0 = sig_params.__destroy_into_raw();
+        wasm.wasmpqcmetadata_setSigParams(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Set compression parameters
+     * @param {WasmCompressionParameters} compression_params
+     */
+    setCompressionParams(compression_params) {
+        _assertClass(compression_params, WasmCompressionParameters);
+        var ptr0 = compression_params.__destroy_into_raw();
+        wasm.wasmpqcmetadata_setCompressionParams(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Create new metadata
+     * @param {WasmEncParameters} enc_params
+     */
+    constructor(enc_params) {
+        _assertClass(enc_params, WasmEncParameters);
+        var ptr0 = enc_params.__destroy_into_raw();
+        const ret = wasm.wasmpqcmetadata_new(ptr0);
+        this.__wbg_ptr = ret >>> 0;
+        WasmPqcMetadataFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmPqcMetadata.prototype[Symbol.dispose] = WasmPqcMetadata.prototype.free;
+
+/**
+ * WebAssembly wrapper for SigParameters
+ */
+export class WasmSigParameters {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSigParametersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsigparameters_free(ptr, 0);
+    }
+    /**
+     * Get public key
+     * @returns {Uint8Array}
+     */
+    get public_key() {
+        const ret = wasm.wasmsigparameters_public_key(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Create new signature parameters
+     * @param {Uint8Array} public_key
+     * @param {Uint8Array} signature
+     */
+    constructor(public_key, signature) {
+        const ptr0 = passArray8ToWasm0(public_key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmencparameters_new(ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        WasmSigParametersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get signature
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.wasmsigparameters_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) WasmSigParameters.prototype[Symbol.dispose] = WasmSigParameters.prototype.free;
+
+/**
+ * Get the PQC Binary Format spec version
+ * @returns {number}
+ */
+export function getBinaryVersion() {
+    const ret = wasm.getBinaryVersion();
+    return ret;
+}
+
+/**
+ * Get the PQC Binary Format version
+ * @returns {string}
+ */
+export function getVersion() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.getVersion();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+export function __wbg___wbindgen_throw_dd24417ed36fc46e(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_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+};