@lanitlabs/pqc-lnqc714 1.0.2 → 1.1.0

package/README.md

@@ -100,20 +100,6 @@ LNQC.getLdpcCodewordBits() // 2048
 - **Constant-time**: The `subtle` crate guards token comparison against timing side-channels.
 - **LDPC protection**: Regular column-weight-15 parity-check matrix eliminates single-check failure modes.
 
-## Development
-
-```bash
-# Build WASM targets
-wasm-pack build --target bundler --out-dir pkg/browser --release
-wasm-pack build --target nodejs  --out-dir pkg/node    --release
-
-# Test (native)
-cargo test --release
-
-# Publish
-npm publish --access public
-```
-
 ## License
 
 MIT

package/dist/index.d.ts

@@ -17,16 +17,13 @@ export class Ciphertext {
 }
 
 export const LNQC: {
-  keyGen(): KeyPair;
-  encapsulate(publicKeyA: Uint8Array, publicKeyT: Uint8Array, message: Uint8Array): Ciphertext;
-  decapsulate(privateKey: Uint8Array, u: Uint8Array, v: Uint8Array): Uint8Array;
+  getVariants(): string[];
+  getVariantInfo(variant: string): string;
+  keyGen(variant: string): KeyPair;
+  encapsulate(variant: string, publicKeyA: Uint8Array, publicKeyT: Uint8Array, message: Uint8Array): Ciphertext;
+  decapsulate(variant: string, privateKey: Uint8Array, u: Uint8Array, v: Uint8Array): Uint8Array;
   constantTimeVerify(a: Uint8Array, b: Uint8Array): boolean;
   randomBits(len: number): Uint8Array;
-  getNCols(): number;
-  getMRows(): number;
-  getNoiseWeight(): number;
-  getLdpcDataBits(): number;
-  getLdpcCodewordBits(): number;
 };
 
 export default LNQC;

package/dist/index.js

@@ -11,31 +11,32 @@ if (isNode) {
 export type { KeyPair, Ciphertext } from '../pkg/browser/pqc_lnqc714';
 
 export const LNQC = {
-  keyGen: (): import('../pkg/browser/pqc_lnqc714').KeyPair => engine.key_gen(),
+  getVariants: (): string[] => engine.get_variants(),
+
+  getVariantInfo: (variant: string): string => engine.get_variant_info(variant),
+
+  keyGen: (variant: string): import('../pkg/browser/pqc_lnqc714').KeyPair =>
+    engine.key_gen(variant),
 
   encapsulate: (
+    variant: string,
     publicKeyA: Uint8Array,
     publicKeyT: Uint8Array,
     message: Uint8Array,
   ): import('../pkg/browser/pqc_lnqc714').Ciphertext =>
-    engine.encapsulate(publicKeyA, publicKeyT, message),
+    engine.encapsulate(variant, publicKeyA, publicKeyT, message),
 
   decapsulate: (
+    variant: string,
     privateKey: Uint8Array,
     u: Uint8Array,
     v: Uint8Array,
-  ): Uint8Array => engine.decapsulate(privateKey, u, v),
+  ): Uint8Array => engine.decapsulate(variant, privateKey, u, v),
 
   constantTimeVerify: (a: Uint8Array, b: Uint8Array): boolean =>
     engine.constant_time_verify(a, b),
 
   randomBits: (len: number): Uint8Array => engine.random_bits(len),
-
-  getNCols: (): number => engine.get_n_cols(),
-  getMRows: (): number => engine.get_m_rows(),
-  getNoiseWeight: (): number => engine.get_noise_weight(),
-  getLdpcDataBits: (): number => engine.get_ldpc_data_bits(),
-  getLdpcCodewordBits: (): number => engine.get_ldpc_codeword_bits(),
 };
 
 export default LNQC;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanitlabs/pqc-lnqc714",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/lanitlabs/pqc-lnqc714"

package/pkg/browser/README.md

@@ -0,0 +1,105 @@
+# @lanitlabs/pqc-lnqc714
+
+**Post-Quantum Key Encapsulation Mechanism (KEM)** — LPN-based key agreement with LDPC error correction.  
+Constant-time Rust/WASM engine targeting browsers, Node.js, and Edge runtimes.
+
+```
+npm install @lanitlabs/pqc-lnqc714
+```
+
+## Overview
+
+LNQC-714 is a KEM whose security reduces to the hardness of the fixed-weight **Learning Parity with Noise (LPN)** problem over GF(2). A **Low-Density Parity-Check (LDPC)** code with a Gallager bit-flipping decoder absorbs the sparse LPN noise, achieving 0% decryption failure at the security parameters:
+
+| Parameter | Value |
+|---|---|
+| LPN dimension | `n = 512` |
+| LPN samples | `m = 512` |
+| Noise weight | `w = 4` |
+| LDPC codeword | 2048 bits |
+| LDPC data | 256 bits |
+| Decoder | Gallager bit-flipping (50 iters) |
+| Public key | 262 656 bytes |
+| Ciphertext | 1 050 624 bytes |
+
+All operations execute in **constant-time binary matrix algebra modulo 2** — no data-dependent branching, no rejection sampling, no modular arithmetic. This provides architectural immunity to cache-timing and power-analysis side-channel attacks.
+
+## API
+
+```ts
+import LNQC from '@lanitlabs/pqc-lnqc714';
+
+// ── Key Generation ──────────────────────────────────────────
+const keys = LNQC.keyGen();
+// keys.publicKeyA:  Uint8Array  (512 × 512 bits, row-major)
+// keys.publicKeyT:  Uint8Array  (512 bits)
+// keys.privateKey:  Uint8Array  (512 bits)
+
+// ── Encapsulation ───────────────────────────────────────────
+const msg = LNQC.randomBits(256);            // 256-bit shared secret
+const ct = LNQC.encapsulate(
+  keys.publicKeyA,
+  keys.publicKeyT,
+  msg,
+);
+// ct.u:  Uint8Array  (2048 × 512 bits)
+// ct.v:  Uint8Array  (2048 bits)
+// ct.byteLength:  number
+
+// ── Decapsulation ───────────────────────────────────────────
+const recovered = LNQC.decapsulate(
+  keys.privateKey,
+  ct.u,
+  ct.v,
+);
+// recovered equals `msg` (LDPC decoder corrects LPN noise)
+
+// ── Constant-Time Verification ──────────────────────────────
+const match = LNQC.constantTimeVerify(secretA, secretB);
+// Returns true/false in constant time (subtle::ConstantTimeEq)
+```
+
+### Parameter getters
+
+```ts
+LNQC.getNCols()            // 512
+LNQC.getMRows()            // 512
+LNQC.getNoiseWeight()      // 4
+LNQC.getLdpcDataBits()     // 256
+LNQC.getLdpcCodewordBits() // 2048
+```
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  JS/TS (consumer)                                       │
+│    import LNQC from '@lanitlabs/pqc-lnqc714'            │
+└─────────────────────┬────────────────────────────────────┘
+                      │
+┌─────────────────────▼────────────────────────────────────┐
+│  dist/index.js  (dynamic loader)                         │
+│    Node.js  →  pkg/node/pqc_lnqc714.js                  │
+│    Browser  →  pkg/browser/pqc_lnqc714.js               │
+└─────────────────────┬────────────────────────────────────┘
+                      │ wasm-bindgen
+┌─────────────────────▼────────────────────────────────────┐
+│  Rust/WASM  (src/crypto.rs)                              │
+│    • Secure RNG via getrandom (os.urandom)               │
+│    • Regular LDPC construction (col_weight=15)           │
+│    • Gallager bit-flipping decoder                       │
+│    • Sparse R_indices optimization                       │
+│    • subtle::ConstantTimeEq for verification             │
+└──────────────────────────────────────────────────────────┘
+```
+
+## Security
+
+- **LPN hardness**: No known sub-exponential quantum algorithm.
+- **CSPRNG**: All keys, noise vectors, and ephemeral randomness use `getrandom` (OS entropy / `crypto.getRandomValues`). **No** insecure PRNG (PCG, xorshift) is used for security-critical data.
+- **Constant-time**: The `subtle` crate guards token comparison against timing side-channels.
+- **LDPC protection**: Regular column-weight-15 parity-check matrix eliminates single-check failure modes.
+
+## License
+
+MIT

package/pkg/node/README.md

@@ -0,0 +1,105 @@
+# @lanitlabs/pqc-lnqc714
+
+**Post-Quantum Key Encapsulation Mechanism (KEM)** — LPN-based key agreement with LDPC error correction.  
+Constant-time Rust/WASM engine targeting browsers, Node.js, and Edge runtimes.
+
+```
+npm install @lanitlabs/pqc-lnqc714
+```
+
+## Overview
+
+LNQC-714 is a KEM whose security reduces to the hardness of the fixed-weight **Learning Parity with Noise (LPN)** problem over GF(2). A **Low-Density Parity-Check (LDPC)** code with a Gallager bit-flipping decoder absorbs the sparse LPN noise, achieving 0% decryption failure at the security parameters:
+
+| Parameter | Value |
+|---|---|
+| LPN dimension | `n = 512` |
+| LPN samples | `m = 512` |
+| Noise weight | `w = 4` |
+| LDPC codeword | 2048 bits |
+| LDPC data | 256 bits |
+| Decoder | Gallager bit-flipping (50 iters) |
+| Public key | 262 656 bytes |
+| Ciphertext | 1 050 624 bytes |
+
+All operations execute in **constant-time binary matrix algebra modulo 2** — no data-dependent branching, no rejection sampling, no modular arithmetic. This provides architectural immunity to cache-timing and power-analysis side-channel attacks.
+
+## API
+
+```ts
+import LNQC from '@lanitlabs/pqc-lnqc714';
+
+// ── Key Generation ──────────────────────────────────────────
+const keys = LNQC.keyGen();
+// keys.publicKeyA:  Uint8Array  (512 × 512 bits, row-major)
+// keys.publicKeyT:  Uint8Array  (512 bits)
+// keys.privateKey:  Uint8Array  (512 bits)
+
+// ── Encapsulation ───────────────────────────────────────────
+const msg = LNQC.randomBits(256);            // 256-bit shared secret
+const ct = LNQC.encapsulate(
+  keys.publicKeyA,
+  keys.publicKeyT,
+  msg,
+);
+// ct.u:  Uint8Array  (2048 × 512 bits)
+// ct.v:  Uint8Array  (2048 bits)
+// ct.byteLength:  number
+
+// ── Decapsulation ───────────────────────────────────────────
+const recovered = LNQC.decapsulate(
+  keys.privateKey,
+  ct.u,
+  ct.v,
+);
+// recovered equals `msg` (LDPC decoder corrects LPN noise)
+
+// ── Constant-Time Verification ──────────────────────────────
+const match = LNQC.constantTimeVerify(secretA, secretB);
+// Returns true/false in constant time (subtle::ConstantTimeEq)
+```
+
+### Parameter getters
+
+```ts
+LNQC.getNCols()            // 512
+LNQC.getMRows()            // 512
+LNQC.getNoiseWeight()      // 4
+LNQC.getLdpcDataBits()     // 256
+LNQC.getLdpcCodewordBits() // 2048
+```
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  JS/TS (consumer)                                       │
+│    import LNQC from '@lanitlabs/pqc-lnqc714'            │
+└─────────────────────┬────────────────────────────────────┘
+                      │
+┌─────────────────────▼────────────────────────────────────┐
+│  dist/index.js  (dynamic loader)                         │
+│    Node.js  →  pkg/node/pqc_lnqc714.js                  │
+│    Browser  →  pkg/browser/pqc_lnqc714.js               │
+└─────────────────────┬────────────────────────────────────┘
+                      │ wasm-bindgen
+┌─────────────────────▼────────────────────────────────────┐
+│  Rust/WASM  (src/crypto.rs)                              │
+│    • Secure RNG via getrandom (os.urandom)               │
+│    • Regular LDPC construction (col_weight=15)           │
+│    • Gallager bit-flipping decoder                       │
+│    • Sparse R_indices optimization                       │
+│    • subtle::ConstantTimeEq for verification             │
+└──────────────────────────────────────────────────────────┘
+```
+
+## Security
+
+- **LPN hardness**: No known sub-exponential quantum algorithm.
+- **CSPRNG**: All keys, noise vectors, and ephemeral randomness use `getrandom` (OS entropy / `crypto.getRandomValues`). **No** insecure PRNG (PCG, xorshift) is used for security-critical data.
+- **Constant-time**: The `subtle` crate guards token comparison against timing side-channels.
+- **LDPC protection**: Regular column-weight-15 parity-check matrix eliminates single-check failure modes.
+
+## License
+
+MIT

package/pkg/browser/pqc_lnqc714.d.ts

@@ -1,68 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-export class Ciphertext {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    /**
-     * Total ciphertext size in bytes (U + V).
-     */
-    readonly byte_length: number;
-    readonly u: Uint8Array;
-    readonly v: Uint8Array;
-}
-
-export class KeyPair {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    readonly private_key: Uint8Array;
-    readonly public_key_a: Uint8Array;
-    readonly public_key_t: Uint8Array;
-}
-
-/**
- * Constant-time comparison of two byte slices.
- * Returns `true` if they are identical, `false` otherwise.
- * Execution time does NOT depend on the position of the first mismatch.
- */
-export function constant_time_verify(a: Uint8Array, b: Uint8Array): boolean;
-
-/**
- * Decapsulate a Ciphertext (U, V) using the private key `s`.
- * Returns the recovered LDPC_DATA_BITS message.
- */
-export function decapsulate(private_key_s: Uint8Array, u: Uint8Array, v: Uint8Array): Uint8Array;
-
-/**
- * Encapsulate a `message` (LDPC_DATA_BITS bits) under a public key.
- * `public_key_a` and `public_key_t` must be the outputs from `key_gen()`.
- * Returns a Ciphertext containing (U, V).
- */
-export function encapsulate(public_key_a: Uint8Array, public_key_t: Uint8Array, message: Uint8Array): Ciphertext;
-
-export function get_ldpc_codeword_bits(): number;
-
-export function get_ldpc_data_bits(): number;
-
-export function get_m_rows(): number;
-
-export function get_n_cols(): number;
-
-export function get_noise_weight(): number;
-
-/**
- * Generate a fresh LNQC-714 key pair.
- * Returns a KeyPair with:
- *   - public_key_a:  M_ROWS × N_COLS binary matrix (flat, row-major)
- *   - public_key_t:  M_ROWS-bit noisy public key
- *   - private_key:   N_COLS-bit secret vector
- */
-export function key_gen(): KeyPair;
-
-/**
- * Generate `len` cryptographically secure random bits.
- * Returns a flat Vec<u8> where each element is 0 or 1.
- */
-export function random_bits(len: number): Uint8Array;

package/pkg/browser/pqc_lnqc714.js

@@ -1,9 +0,0 @@
-/* @ts-self-types="./pqc_lnqc714.d.ts" */
-import * as wasm from "./pqc_lnqc714_bg.wasm";
-import { __wbg_set_wasm } from "./pqc_lnqc714_bg.js";
-
-__wbg_set_wasm(wasm);
-wasm.__wbindgen_start();
-export {
-    Ciphertext, KeyPair, constant_time_verify, decapsulate, encapsulate, get_ldpc_codeword_bits, get_ldpc_data_bits, get_m_rows, get_n_cols, get_noise_weight, key_gen, random_bits
-} from "./pqc_lnqc714_bg.js";

package/pkg/browser/pqc_lnqc714_bg.js

@@ -1,391 +0,0 @@
-export class Ciphertext {
-    static __wrap(ptr) {
-        const obj = Object.create(Ciphertext.prototype);
-        obj.__wbg_ptr = ptr;
-        CiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        CiphertextFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ciphertext_free(ptr, 0);
-    }
-    /**
-     * Total ciphertext size in bytes (U + V).
-     * @returns {number}
-     */
-    get byte_length() {
-        const ret = wasm.ciphertext_byte_length(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get u() {
-        const ret = wasm.ciphertext_u(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get v() {
-        const ret = wasm.ciphertext_v(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) Ciphertext.prototype[Symbol.dispose] = Ciphertext.prototype.free;
-
-export class KeyPair {
-    static __wrap(ptr) {
-        const obj = Object.create(KeyPair.prototype);
-        obj.__wbg_ptr = ptr;
-        KeyPairFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        KeyPairFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_keypair_free(ptr, 0);
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get private_key() {
-        const ret = wasm.keypair_private_key(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get public_key_a() {
-        const ret = wasm.keypair_public_key_a(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get public_key_t() {
-        const ret = wasm.keypair_public_key_t(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) KeyPair.prototype[Symbol.dispose] = KeyPair.prototype.free;
-
-/**
- * Constant-time comparison of two byte slices.
- * Returns `true` if they are identical, `false` otherwise.
- * Execution time does NOT depend on the position of the first mismatch.
- * @param {Uint8Array} a
- * @param {Uint8Array} b
- * @returns {boolean}
- */
-export function constant_time_verify(a, b) {
-    const ptr0 = passArray8ToWasm0(a, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(b, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.constant_time_verify(ptr0, len0, ptr1, len1);
-    return ret !== 0;
-}
-
-/**
- * Decapsulate a Ciphertext (U, V) using the private key `s`.
- * Returns the recovered LDPC_DATA_BITS message.
- * @param {Uint8Array} private_key_s
- * @param {Uint8Array} u
- * @param {Uint8Array} v
- * @returns {Uint8Array}
- */
-export function decapsulate(private_key_s, u, v) {
-    const ptr0 = passArray8ToWasm0(private_key_s, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(u, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(v, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ret = wasm.decapsulate(ptr0, len0, ptr1, len1, ptr2, len2);
-    var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v4;
-}
-
-/**
- * Encapsulate a `message` (LDPC_DATA_BITS bits) under a public key.
- * `public_key_a` and `public_key_t` must be the outputs from `key_gen()`.
- * Returns a Ciphertext containing (U, V).
- * @param {Uint8Array} public_key_a
- * @param {Uint8Array} public_key_t
- * @param {Uint8Array} message
- * @returns {Ciphertext}
- */
-export function encapsulate(public_key_a, public_key_t, message) {
-    const ptr0 = passArray8ToWasm0(public_key_a, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(public_key_t, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ret = wasm.encapsulate(ptr0, len0, ptr1, len1, ptr2, len2);
-    return Ciphertext.__wrap(ret);
-}
-
-/**
- * @returns {number}
- */
-export function get_ldpc_codeword_bits() {
-    const ret = wasm.get_ldpc_codeword_bits();
-    return ret >>> 0;
-}
-
-/**
- * @returns {number}
- */
-export function get_ldpc_data_bits() {
-    const ret = wasm.get_ldpc_data_bits();
-    return ret >>> 0;
-}
-
-/**
- * @returns {number}
- */
-export function get_m_rows() {
-    const ret = wasm.get_m_rows();
-    return ret >>> 0;
-}
-
-/**
- * @returns {number}
- */
-export function get_n_cols() {
-    const ret = wasm.get_n_cols();
-    return ret >>> 0;
-}
-
-/**
- * @returns {number}
- */
-export function get_noise_weight() {
-    const ret = wasm.get_noise_weight();
-    return ret >>> 0;
-}
-
-/**
- * Generate a fresh LNQC-714 key pair.
- * Returns a KeyPair with:
- *   - public_key_a:  M_ROWS × N_COLS binary matrix (flat, row-major)
- *   - public_key_t:  M_ROWS-bit noisy public key
- *   - private_key:   N_COLS-bit secret vector
- * @returns {KeyPair}
- */
-export function key_gen() {
-    const ret = wasm.key_gen();
-    return KeyPair.__wrap(ret);
-}
-
-/**
- * Generate `len` cryptographically secure random bits.
- * Returns a flat Vec<u8> where each element is 0 or 1.
- * @param {number} len
- * @returns {Uint8Array}
- */
-export function random_bits(len) {
-    const ret = wasm.random_bits(len);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-}
-export function __wbg___wbindgen_is_function_754e9f305ff6029e(arg0) {
-    const ret = typeof(arg0) === 'function';
-    return ret;
-}
-export function __wbg___wbindgen_is_object_56732c2bc353f41d(arg0) {
-    const val = arg0;
-    const ret = typeof(val) === 'object' && val !== null;
-    return ret;
-}
-export function __wbg___wbindgen_is_string_c236cabd84a4d769(arg0) {
-    const ret = typeof(arg0) === 'string';
-    return ret;
-}
-export function __wbg___wbindgen_is_undefined_67b456be8673d3d7(arg0) {
-    const ret = arg0 === undefined;
-    return ret;
-}
-export function __wbg___wbindgen_throw_1506f2235d1bdba0(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-}
-export function __wbg_call_9c758de292015997() { return handleError(function (arg0, arg1, arg2) {
-    const ret = arg0.call(arg1, arg2);
-    return ret;
-}, arguments); }
-export function __wbg_crypto_38df2bab126b63dc(arg0) {
-    const ret = arg0.crypto;
-    return ret;
-}
-export function __wbg_getRandomValues_c44a50d8cfdaebeb() { return handleError(function (arg0, arg1) {
-    arg0.getRandomValues(arg1);
-}, arguments); }
-export function __wbg_length_4a591ecaa01354d9(arg0) {
-    const ret = arg0.length;
-    return ret;
-}
-export function __wbg_msCrypto_bd5a034af96bcba6(arg0) {
-    const ret = arg0.msCrypto;
-    return ret;
-}
-export function __wbg_new_with_length_36a4998e27b014c5(arg0) {
-    const ret = new Uint8Array(arg0 >>> 0);
-    return ret;
-}
-export function __wbg_node_84ea875411254db1(arg0) {
-    const ret = arg0.node;
-    return ret;
-}
-export function __wbg_process_44c7a14e11e9f69e(arg0) {
-    const ret = arg0.process;
-    return ret;
-}
-export function __wbg_prototypesetcall_3249fc62a0fafa30(arg0, arg1, arg2) {
-    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
-}
-export function __wbg_randomFillSync_6c25eac9869eb53c() { return handleError(function (arg0, arg1) {
-    arg0.randomFillSync(arg1);
-}, arguments); }
-export function __wbg_require_b4edbdcf3e2a1ef0() { return handleError(function () {
-    const ret = module.require;
-    return ret;
-}, arguments); }
-export function __wbg_static_accessor_GLOBAL_9d53f2689e622ca1() {
-    const ret = typeof global === 'undefined' ? null : global;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-}
-export function __wbg_static_accessor_GLOBAL_THIS_a1a35cec07001a8a() {
-    const ret = typeof globalThis === 'undefined' ? null : globalThis;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-}
-export function __wbg_static_accessor_SELF_4c59f6c7ea29a144() {
-    const ret = typeof self === 'undefined' ? null : self;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-}
-export function __wbg_static_accessor_WINDOW_e70ae9f2eb052253() {
-    const ret = typeof window === 'undefined' ? null : window;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-}
-export function __wbg_subarray_4aa221f6a4f5ab22(arg0, arg1, arg2) {
-    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
-    return ret;
-}
-export function __wbg_versions_276b2795b1c6a219(arg0) {
-    const ret = arg0.versions;
-    return ret;
-}
-export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-    const ret = getArrayU8FromWasm0(arg0, arg1);
-    return ret;
-}
-export function __wbindgen_cast_0000000000000002(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);
-}
-const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertext_free(ptr, 1));
-const KeyPairFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_keypair_free(ptr, 1));
-
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_externrefs.set(idx, obj);
-    return idx;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-function getStringFromWasm0(ptr, len) {
-    return decodeText(ptr >>> 0, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-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));
-}
-
-let WASM_VECTOR_LEN = 0;
-
-
-let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}

package/pkg/browser/pqc_lnqc714_bg.wasm.d.ts

@@ -1,27 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export const memory: WebAssembly.Memory;
-export const __wbg_ciphertext_free: (a: number, b: number) => void;
-export const __wbg_keypair_free: (a: number, b: number) => void;
-export const ciphertext_byte_length: (a: number) => number;
-export const ciphertext_u: (a: number) => [number, number];
-export const ciphertext_v: (a: number) => [number, number];
-export const constant_time_verify: (a: number, b: number, c: number, d: number) => number;
-export const decapsulate: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
-export const encapsulate: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
-export const get_ldpc_codeword_bits: () => number;
-export const get_ldpc_data_bits: () => number;
-export const get_m_rows: () => number;
-export const get_noise_weight: () => number;
-export const key_gen: () => number;
-export const keypair_private_key: (a: number) => [number, number];
-export const keypair_public_key_a: (a: number) => [number, number];
-export const keypair_public_key_t: (a: number) => [number, number];
-export const random_bits: (a: number) => [number, number];
-export const get_n_cols: () => number;
-export const __wbindgen_exn_store: (a: number) => void;
-export const __externref_table_alloc: () => number;
-export const __wbindgen_externrefs: WebAssembly.Table;
-export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __wbindgen_malloc: (a: number, b: number) => number;
-export const __wbindgen_start: () => void;

package/pkg/node/pqc_lnqc714.d.ts

@@ -1,68 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-export class Ciphertext {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    /**
-     * Total ciphertext size in bytes (U + V).
-     */
-    readonly byte_length: number;
-    readonly u: Uint8Array;
-    readonly v: Uint8Array;
-}
-
-export class KeyPair {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    readonly private_key: Uint8Array;
-    readonly public_key_a: Uint8Array;
-    readonly public_key_t: Uint8Array;
-}
-
-/**
- * Constant-time comparison of two byte slices.
- * Returns `true` if they are identical, `false` otherwise.
- * Execution time does NOT depend on the position of the first mismatch.
- */
-export function constant_time_verify(a: Uint8Array, b: Uint8Array): boolean;
-
-/**
- * Decapsulate a Ciphertext (U, V) using the private key `s`.
- * Returns the recovered LDPC_DATA_BITS message.
- */
-export function decapsulate(private_key_s: Uint8Array, u: Uint8Array, v: Uint8Array): Uint8Array;
-
-/**
- * Encapsulate a `message` (LDPC_DATA_BITS bits) under a public key.
- * `public_key_a` and `public_key_t` must be the outputs from `key_gen()`.
- * Returns a Ciphertext containing (U, V).
- */
-export function encapsulate(public_key_a: Uint8Array, public_key_t: Uint8Array, message: Uint8Array): Ciphertext;
-
-export function get_ldpc_codeword_bits(): number;
-
-export function get_ldpc_data_bits(): number;
-
-export function get_m_rows(): number;
-
-export function get_n_cols(): number;
-
-export function get_noise_weight(): number;
-
-/**
- * Generate a fresh LNQC-714 key pair.
- * Returns a KeyPair with:
- *   - public_key_a:  M_ROWS × N_COLS binary matrix (flat, row-major)
- *   - public_key_t:  M_ROWS-bit noisy public key
- *   - private_key:   N_COLS-bit secret vector
- */
-export function key_gen(): KeyPair;
-
-/**
- * Generate `len` cryptographically secure random bits.
- * Returns a flat Vec<u8> where each element is 0 or 1.
- */
-export function random_bits(len: number): Uint8Array;

package/pkg/node/pqc_lnqc714.js

@@ -1,408 +0,0 @@
-/* @ts-self-types="./pqc_lnqc714.d.ts" */
-
-class Ciphertext {
-    static __wrap(ptr) {
-        const obj = Object.create(Ciphertext.prototype);
-        obj.__wbg_ptr = ptr;
-        CiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        CiphertextFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ciphertext_free(ptr, 0);
-    }
-    /**
-     * Total ciphertext size in bytes (U + V).
-     * @returns {number}
-     */
-    get byte_length() {
-        const ret = wasm.ciphertext_byte_length(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get u() {
-        const ret = wasm.ciphertext_u(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get v() {
-        const ret = wasm.ciphertext_v(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) Ciphertext.prototype[Symbol.dispose] = Ciphertext.prototype.free;
-exports.Ciphertext = Ciphertext;
-
-class KeyPair {
-    static __wrap(ptr) {
-        const obj = Object.create(KeyPair.prototype);
-        obj.__wbg_ptr = ptr;
-        KeyPairFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        KeyPairFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_keypair_free(ptr, 0);
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get private_key() {
-        const ret = wasm.keypair_private_key(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get public_key_a() {
-        const ret = wasm.keypair_public_key_a(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get public_key_t() {
-        const ret = wasm.keypair_public_key_t(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) KeyPair.prototype[Symbol.dispose] = KeyPair.prototype.free;
-exports.KeyPair = KeyPair;
-
-/**
- * Constant-time comparison of two byte slices.
- * Returns `true` if they are identical, `false` otherwise.
- * Execution time does NOT depend on the position of the first mismatch.
- * @param {Uint8Array} a
- * @param {Uint8Array} b
- * @returns {boolean}
- */
-function constant_time_verify(a, b) {
-    const ptr0 = passArray8ToWasm0(a, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(b, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.constant_time_verify(ptr0, len0, ptr1, len1);
-    return ret !== 0;
-}
-exports.constant_time_verify = constant_time_verify;
-
-/**
- * Decapsulate a Ciphertext (U, V) using the private key `s`.
- * Returns the recovered LDPC_DATA_BITS message.
- * @param {Uint8Array} private_key_s
- * @param {Uint8Array} u
- * @param {Uint8Array} v
- * @returns {Uint8Array}
- */
-function decapsulate(private_key_s, u, v) {
-    const ptr0 = passArray8ToWasm0(private_key_s, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(u, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(v, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ret = wasm.decapsulate(ptr0, len0, ptr1, len1, ptr2, len2);
-    var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v4;
-}
-exports.decapsulate = decapsulate;
-
-/**
- * Encapsulate a `message` (LDPC_DATA_BITS bits) under a public key.
- * `public_key_a` and `public_key_t` must be the outputs from `key_gen()`.
- * Returns a Ciphertext containing (U, V).
- * @param {Uint8Array} public_key_a
- * @param {Uint8Array} public_key_t
- * @param {Uint8Array} message
- * @returns {Ciphertext}
- */
-function encapsulate(public_key_a, public_key_t, message) {
-    const ptr0 = passArray8ToWasm0(public_key_a, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(public_key_t, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ret = wasm.encapsulate(ptr0, len0, ptr1, len1, ptr2, len2);
-    return Ciphertext.__wrap(ret);
-}
-exports.encapsulate = encapsulate;
-
-/**
- * @returns {number}
- */
-function get_ldpc_codeword_bits() {
-    const ret = wasm.get_ldpc_codeword_bits();
-    return ret >>> 0;
-}
-exports.get_ldpc_codeword_bits = get_ldpc_codeword_bits;
-
-/**
- * @returns {number}
- */
-function get_ldpc_data_bits() {
-    const ret = wasm.get_ldpc_data_bits();
-    return ret >>> 0;
-}
-exports.get_ldpc_data_bits = get_ldpc_data_bits;
-
-/**
- * @returns {number}
- */
-function get_m_rows() {
-    const ret = wasm.get_m_rows();
-    return ret >>> 0;
-}
-exports.get_m_rows = get_m_rows;
-
-/**
- * @returns {number}
- */
-function get_n_cols() {
-    const ret = wasm.get_n_cols();
-    return ret >>> 0;
-}
-exports.get_n_cols = get_n_cols;
-
-/**
- * @returns {number}
- */
-function get_noise_weight() {
-    const ret = wasm.get_noise_weight();
-    return ret >>> 0;
-}
-exports.get_noise_weight = get_noise_weight;
-
-/**
- * Generate a fresh LNQC-714 key pair.
- * Returns a KeyPair with:
- *   - public_key_a:  M_ROWS × N_COLS binary matrix (flat, row-major)
- *   - public_key_t:  M_ROWS-bit noisy public key
- *   - private_key:   N_COLS-bit secret vector
- * @returns {KeyPair}
- */
-function key_gen() {
-    const ret = wasm.key_gen();
-    return KeyPair.__wrap(ret);
-}
-exports.key_gen = key_gen;
-
-/**
- * Generate `len` cryptographically secure random bits.
- * Returns a flat Vec<u8> where each element is 0 or 1.
- * @param {number} len
- * @returns {Uint8Array}
- */
-function random_bits(len) {
-    const ret = wasm.random_bits(len);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-}
-exports.random_bits = random_bits;
-function __wbg_get_imports() {
-    const import0 = {
-        __proto__: null,
-        __wbg___wbindgen_is_function_754e9f305ff6029e: function(arg0) {
-            const ret = typeof(arg0) === 'function';
-            return ret;
-        },
-        __wbg___wbindgen_is_object_56732c2bc353f41d: function(arg0) {
-            const val = arg0;
-            const ret = typeof(val) === 'object' && val !== null;
-            return ret;
-        },
-        __wbg___wbindgen_is_string_c236cabd84a4d769: function(arg0) {
-            const ret = typeof(arg0) === 'string';
-            return ret;
-        },
-        __wbg___wbindgen_is_undefined_67b456be8673d3d7: function(arg0) {
-            const ret = arg0 === undefined;
-            return ret;
-        },
-        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
-            throw new Error(getStringFromWasm0(arg0, arg1));
-        },
-        __wbg_call_9c758de292015997: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = arg0.call(arg1, arg2);
-            return ret;
-        }, arguments); },
-        __wbg_crypto_38df2bab126b63dc: function(arg0) {
-            const ret = arg0.crypto;
-            return ret;
-        },
-        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
-            arg0.getRandomValues(arg1);
-        }, arguments); },
-        __wbg_length_4a591ecaa01354d9: function(arg0) {
-            const ret = arg0.length;
-            return ret;
-        },
-        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
-            const ret = arg0.msCrypto;
-            return ret;
-        },
-        __wbg_new_with_length_36a4998e27b014c5: function(arg0) {
-            const ret = new Uint8Array(arg0 >>> 0);
-            return ret;
-        },
-        __wbg_node_84ea875411254db1: function(arg0) {
-            const ret = arg0.node;
-            return ret;
-        },
-        __wbg_process_44c7a14e11e9f69e: function(arg0) {
-            const ret = arg0.process;
-            return ret;
-        },
-        __wbg_prototypesetcall_3249fc62a0fafa30: function(arg0, arg1, arg2) {
-            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
-        },
-        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
-            arg0.randomFillSync(arg1);
-        }, arguments); },
-        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
-            const ret = module.require;
-            return ret;
-        }, arguments); },
-        __wbg_static_accessor_GLOBAL_9d53f2689e622ca1: function() {
-            const ret = typeof global === 'undefined' ? null : global;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
-        __wbg_static_accessor_GLOBAL_THIS_a1a35cec07001a8a: function() {
-            const ret = typeof globalThis === 'undefined' ? null : globalThis;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
-        __wbg_static_accessor_SELF_4c59f6c7ea29a144: function() {
-            const ret = typeof self === 'undefined' ? null : self;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
-        __wbg_static_accessor_WINDOW_e70ae9f2eb052253: function() {
-            const ret = typeof window === 'undefined' ? null : window;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
-        __wbg_subarray_4aa221f6a4f5ab22: function(arg0, arg1, arg2) {
-            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
-            return ret;
-        },
-        __wbg_versions_276b2795b1c6a219: function(arg0) {
-            const ret = arg0.versions;
-            return ret;
-        },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-            const ret = getArrayU8FromWasm0(arg0, arg1);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(String) -> Externref`.
-            const ret = getStringFromWasm0(arg0, arg1);
-            return ret;
-        },
-        __wbindgen_init_externref_table: function() {
-            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);
-        },
-    };
-    return {
-        __proto__: null,
-        "./pqc_lnqc714_bg.js": import0,
-    };
-}
-
-const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertext_free(ptr, 1));
-const KeyPairFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_keypair_free(ptr, 1));
-
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_externrefs.set(idx, obj);
-    return idx;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-function getStringFromWasm0(ptr, len) {
-    return decodeText(ptr >>> 0, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-function decodeText(ptr, len) {
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const wasmPath = `${__dirname}/pqc_lnqc714_bg.wasm`;
-const wasmBytes = require('fs').readFileSync(wasmPath);
-const wasmModule = new WebAssembly.Module(wasmBytes);
-let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
-let wasm = wasmInstance.exports;
-wasm.__wbindgen_start();

package/pkg/node/pqc_lnqc714_bg.wasm.d.ts

@@ -1,27 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export const memory: WebAssembly.Memory;
-export const __wbg_ciphertext_free: (a: number, b: number) => void;
-export const __wbg_keypair_free: (a: number, b: number) => void;
-export const ciphertext_byte_length: (a: number) => number;
-export const ciphertext_u: (a: number) => [number, number];
-export const ciphertext_v: (a: number) => [number, number];
-export const constant_time_verify: (a: number, b: number, c: number, d: number) => number;
-export const decapsulate: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
-export const encapsulate: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
-export const get_ldpc_codeword_bits: () => number;
-export const get_ldpc_data_bits: () => number;
-export const get_m_rows: () => number;
-export const get_noise_weight: () => number;
-export const key_gen: () => number;
-export const keypair_private_key: (a: number) => [number, number];
-export const keypair_public_key_a: (a: number) => [number, number];
-export const keypair_public_key_t: (a: number) => [number, number];
-export const random_bits: (a: number) => [number, number];
-export const get_n_cols: () => number;
-export const __wbindgen_exn_store: (a: number) => void;
-export const __externref_table_alloc: () => number;
-export const __wbindgen_externrefs: WebAssembly.Table;
-export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __wbindgen_malloc: (a: number, b: number) => number;
-export const __wbindgen_start: () => void;