leviathan-crypto 1.3.1 → 2.0.0

package/dist/docs/wasm.md

@@ -1,194 +0,0 @@
-# WebAssembly Primer
-
-> [!NOTE]
-> - A short introduction to WebAssembly concepts as they apply to the leviathan-crypto library.
-> - If you already understand WASM, skip to [Project-Specific Concepts](#project-specific-concepts).
-> - WebAssembly specification and documentation: [webassembly.org](https://webassembly.org/)
-
-## What is WebAssembly?
-
-WebAssembly (WASM) is a binary instruction format that runs in browsers and
-server-side runtimes alongside JavaScript. Rather than a programming language
-one writes by hand, it serves as a compilation target. Code is written in a higher-level
-language, compiled to `.wasm`, and then executed by the browser.
-
-Consider it a small, fast virtual machine built into every modern browser.
-JavaScript can load a `.wasm` binary, call its exported functions, and read
-its results. The WASM code runs in its own sandboxed memory space, and thus cannot
-touch the DOM, access JavaScript variables, or reach the network. It computes
-and returns values, and that is its sole function.
-
----
-
-## How It Runs
-
-When a browser encounters a `.wasm` binary, it performs two steps:
-
-1. Compilation: The binary is validated and compiled into native machine code.
-   This is fast because WASM is already a low-level format, requiring less
-   work for the compiler compared to parsing and optimizing JavaScript.
-
-2. Instantiation: The compiled module is paired with its imports, such as a
-   memory object, to create a live instance. The instance's exported functions
-   are then callable from JavaScript.
-
-Once instantiated, calling a WASM function is similar to calling any JavaScript
-function: you pass arguments, it runs, and it returns a result. The key difference
-lies in how it runs. WASM execution is deterministic and not subject to the
-JIT compiler's speculative optimizations. Unlike JavaScript, the browser does not rewrite, inline,
-or de-optimize WASM code paths based on runtime profiling.
-
----
-
-## Why We Use It
-
-Leviathan performs all cryptographic computations in WASM because JavaScript
-engines offer no formal constant-time guarantees for arbitrary code. The JIT
-compiler can introduce timing variations that leak information about secret
-data; WASM execution avoids this class of problem.
-
-For architectural details and security rationale, see [architecture.md](./architecture.md).
-
-**TLDR:** _TypeScript handles the API, and WASM handles the math._
-
----
-
-## Core Concepts
-
-### Module
-
-A `WebAssembly.Module` is a compiled `.wasm` binary and a stateless
-template for creating instances. You can compile a module once and create
-multiple instances from it. For example, [XChaCha20Poly1305Pool](./chacha20_pool.md)
-uses one compiled module to create many worker instances.
-
----
-
-### Instance
-
-A WebAssembly.Instance is a live, runnable copy of a module, complete with
-its own memory and state. When you call `init('serpent')`, the library
-compiles the Serpent WASM binary and creates a single instance. All
-Serpent classes (`Serpent`, `SerpentCtr`, `SerpentCbc`) share this instance.
-
----
-
-### Memory
-
-A `WebAssembly.Memory` is a contiguous block of bytes, essentially a
- `Uint8Array` that WASM functions can read and write, also known as **linear
-memory**. Each of our WASM modules gets its own memory (3 pages = 192 KB).
-
-The TypeScript layer communicates with WASM by writing inputs to specific offsets
-in this memory, calling a WASM function, and then reading the outputs from other
-offsets. There is no other communication channel, no function arguments for
-large data, and no return values beyond a single number. Memory is the data bus.
-
----
-
-### Exports
-
-A WASM instance exposes exports: functions and memory that JavaScript can
-access. In leviathan-crypto, every WASM module exports:
-
-- **Getter functions** like getKeyOffset() and getChunkPtOffset(): these
-  return the memory offsets where the TypeScript layer should write inputs
-  or read outputs.
-- **Operation functions** like chachaEncryptChunk() and sha256Final():
-  these perform the actual cryptographic computation on data already in memory.
-- **wipeBuffers():** this zeros all sensitive regions of memory and is called
-  by every class's dispose() method.
-- **memory:** the linear memory object itself, which allows the TypeScript
-  layer to create Uint8Array views over it.
-
----
-
-### Imports
-
-When instantiating a module, you can pass **imports:** objects the WASM code
-needs from the host. Our modules import only one thing: the Memory object.
-We create the memory on the JavaScript side and pass it in, giving us
-control over its size and lifecycle.
-
----
-
-## Project-Specific Concepts
-
-### AssemblyScript
-
-The WASM binaries in this project are written in [AssemblyScript](https://www.assemblyscript.org/):
-a TypeScript-like language that compiles to WebAssembly. It resembles
-TypeScript but targets WASM instead of JavaScript. The source code
-resides in `src/asm/` and compiles into `.wasm` binaries in `build/`.
-
-AssemblyScript was selected because its syntax is familiar to TypeScript
-developers. It produces small binaries and grants low-level control over
-memory layout without requiring C, C++, or Rust.
-
----
-
-### Thunks
-
-In this project, a **thunk** is a base64-encoded WASM binary embedded directly
-within a TypeScript file. The files in `src/ts/embedded/`
-(such as chacha20.ts and serpent.ts) each export a single constant:
-
-```typescript
-export const WASM_BASE64 = 'AGFzbQEAAAAB...'
-```
-
-This represents the entire compiled .wasm binary, encoded as a base64 string. When
-you call init('chacha20') in embedded mode (the default), the library
-imports this string, decodes it back into bytes, and compiles it into a
-`WebAssembly.Module`.
-
-Why embed the binary as a string? This approach enables the library to function with zero
-configuration. There's no need to serve .wasm files from a CDN, configure MIME
-types, or establish a build plugin to manage binary imports. Simply npm install and
-import. The tradeoff is bundle size, as base64 encoding increases the size by
-approximately 33% compared to the raw binary. For production deployments where bundle size is
-critical, the library also supports [streaming and manual loading modes](./loader.md).
-
-**TLDR:** Thunks are build artifacts generated by `scripts/embed-wasm.ts`.
-They are gitignored and regenerated during each build. Avoid manual edits.
-
----
-
-### Buffer Layout
-
-Each WASM module divides its linear memory into fixed regions at known offsets.
-For example, the ChaCha20 module has a region for the key, a region for the
-nonce, a region for plaintext input, a region for ciphertext output, and so on.
-These offsets are defined in `src/asm/*/buffers.ts` and never change at runtime.
-The TypeScript layer calls getter functions (like `getKeyOffset()`) to
-determine where each region starts, then reads and writes `Uint8Array` slices at those
-positions. This is the only way data moves between TypeScript and
-WASM. There is no serialization, no copying to intermediate buffers, and no function call
-overhead for large data. Data is transferred via direct byte writes to shared memory.
-
-The buffer layouts for each module are documented in [architecture.md](./architecture.md).
-
----
-
-### The `init()` Gate
-
-WASM modules must be compiled and instantiated before use. Because compilation
-returns a Promise, this is an asynchronous operation. Rather than hiding this
-behind lazy auto-initialization, which would make every cryptographic call
-implicitly asynchronous and create race conditions, the library requires an explicit
-`init()` call up front. If you forget, every class immediately throws an error message
-indicating which `init(init()` call is missing. _This is deliberate._
-
-See [init.md](./init.md) for the full API.
-
----
-
-> ## Cross-References
->
-> - [index](./README.md) — Project Documentation index
-> - [architecture](./architecture.md) — architecture overview, module relationships, buffer layouts, and build pipeline
-> - [serpent_simd_bench](./serpent_simd_bench.md) Serpent-256 SIMD benchmark results: CTR and CBC-decrypt inter-block 4-wide, scalar vs SIMD across V8, SpiderMonkey, and JSC
-> - [chacha_simd_bench](./chacha_simd_bench.md) ChaCha20 SIMD benchmark results: 4-wide inter-block parallelism, scalar vs SIMD across V8, SpiderMonkey, and JSC. Includes documented negative result for intra-block approach
-> - [init](./init.md) — `init()` API and the three loading modes
-> - [loader](./loader.md) — how WASM binaries are loaded and instantiated
-> - [chacha20_pool](./chacha20_pool.md) — example of one compiled module spawning many instances across workers

package/dist/serpent/seal.d.ts

@@ -1,8 +0,0 @@
-export declare class SerpentSeal {
-    private readonly _cbc;
-    private readonly _hmac;
-    constructor();
-    encrypt(key: Uint8Array, plaintext: Uint8Array, _iv?: Uint8Array): Uint8Array;
-    decrypt(key: Uint8Array, data: Uint8Array): Uint8Array;
-    dispose(): void;
-}

package/dist/serpent/stream-pool.d.ts

@@ -1,48 +0,0 @@
-export interface StreamPoolOpts {
-    /** Number of workers. Default: navigator.hardwareConcurrency ?? 4 */
-    workers?: number;
-}
-/**
- * Parallel worker pool for SerpentStream chunked authenticated encryption.
- *
- * Each worker owns its own `serpent.wasm` and `sha2.wasm` instances with
- * isolated linear memory. Key derivation happens on the main thread; workers
- * receive pre-derived encKey/macKey per chunk.
- *
- * Produces the same wire format as `SerpentStream` -- either can decrypt
- * the other's output.
- */
-export declare class SerpentStreamPool {
-    private readonly _workers;
-    private readonly _idle;
-    private readonly _queue;
-    private readonly _pending;
-    private readonly _hkdf;
-    private _nextId;
-    private _disposed;
-    private constructor();
-    /**
-     * Create a new pool. Requires `init(['serpent', 'sha2'])` to have been called.
-     * Compiles both WASM modules once and distributes them to all workers.
-     */
-    static create(opts?: StreamPoolOpts): Promise<SerpentStreamPool>;
-    /**
-     * Encrypt plaintext with SerpentStream chunked authenticated encryption.
-     * Returns the complete wire format (header + encrypted chunks).
-     */
-    seal(key: Uint8Array, plaintext: Uint8Array, chunkSize?: number): Promise<Uint8Array>;
-    /**
-     * Decrypt SerpentStream wire format.
-     * If any chunk fails authentication, rejects immediately -- no partial plaintext.
-     */
-    open(key: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
-    /** Terminates all workers. Rejects all pending and queued jobs. */
-    dispose(): void;
-    /** Number of workers in the pool. */
-    get size(): number;
-    /** Number of jobs currently queued (waiting for a free worker). */
-    get queueDepth(): number;
-    private _dispatch;
-    private _send;
-    private _onMessage;
-}

package/dist/serpent/stream-pool.js

@@ -1,285 +0,0 @@
-//                  ▄▄▄▄▄▄▄▄▄▄
-//           ▄████████████████████▄▄          ▒  ▄▀▀ ▒ ▒ █ ▄▀▄ ▀█▀ █ ▒ ▄▀▄ █▀▄
-//        ▄██████████████████████ ▀████▄      ▓  ▓▀  ▓ ▓ ▓ ▓▄▓  ▓  ▓▀▓ ▓▄▓ ▓ ▓
-//      ▄█████████▀▀▀     ▀███████▄▄███████▌  ▀▄ ▀▄▄ ▀▄▀ ▒ ▒ ▒  ▒  ▒ █ ▒ ▒ ▒ █
-//     ▐████████▀   ▄▄▄▄     ▀████████▀██▀█▌
-//     ████████      ███▀▀     ████▀  █▀ █▀       Leviathan Crypto Library
-//     ███████▌    ▀██▀         ███
-//      ███████   ▀███           ▀██ ▀█▄      Repository & Mirror:
-//       ▀██████   ▄▄██            ▀▀  ██▄    github.com/xero/leviathan-crypto
-//         ▀█████▄   ▄██▄             ▄▀▄▀    unpkg.com/leviathan-crypto
-//            ▀████▄   ▄██▄
-//              ▐████   ▐███                  Author: xero (https://x-e.ro)
-//       ▄▄██████████    ▐███         ▄▄      License: MIT
-//    ▄██▀▀▀▀▀▀▀▀▀▀     ▄████      ▄██▀
-//  ▄▀  ▄▄█████████▄▄  ▀▀▀▀▀     ▄███         This file is provided completely
-//   ▄██████▀▀▀▀▀▀██████▄ ▀▄▄▄▄████▀          free, "as is", and without
-//  ████▀    ▄▄▄▄▄▄▄ ▀████▄ ▀█████▀  ▄▄▄▄     warranty of any kind. The author
-//  █████▄▄█████▀▀▀▀▀▀▄ ▀███▄      ▄████      assumes absolutely no liability
-//   ▀██████▀             ▀████▄▄▄████▀       for its {ab,mis,}use.
-//                           ▀█████▀▀
-//
-// src/ts/serpent/stream-pool.ts
-//
-// SerpentStreamPool — parallel worker pool for SerpentStream.
-// Dispatches chunk-level seal/open jobs across Web Workers, each
-// with its own serpent.wasm and sha2.wasm instances.
-import { isInitialized } from '../init.js';
-import { HKDF_SHA256 } from '../sha2/index.js';
-import { u32be, u64be, deriveChunkKeys } from './stream.js';
-// ── Constants ─────────────────────────────────────────────────────────────────
-const CHUNK_MIN = 1024;
-const CHUNK_MAX = 65536;
-const CHUNK_DEF = 65536;
-// ── Module-private base64 decoder ─────────────────────────────────────────────
-function base64ToBytes(b64) {
-    if (typeof atob === 'function') {
-        const raw = atob(b64);
-        const out = new Uint8Array(raw.length);
-        for (let i = 0; i < raw.length; i++)
-            out[i] = raw.charCodeAt(i);
-        return out;
-    }
-    return new Uint8Array(Buffer.from(b64, 'base64'));
-}
-// ── WASM module singletons ──────────────────────────────────────────────────
-let _serpentModule;
-let _sha2Module;
-async function getSerpentModule() {
-    if (_serpentModule)
-        return _serpentModule;
-    const { WASM_BASE64 } = await import('../embedded/serpent.js');
-    const bytes = base64ToBytes(WASM_BASE64);
-    _serpentModule = await WebAssembly.compile(bytes.buffer);
-    return _serpentModule;
-}
-async function getSha2Module() {
-    if (_sha2Module)
-        return _sha2Module;
-    const { WASM_BASE64 } = await import('../embedded/sha2.js');
-    const bytes = base64ToBytes(WASM_BASE64);
-    _sha2Module = await WebAssembly.compile(bytes.buffer);
-    return _sha2Module;
-}
-// ── Worker spawning ──────────────────────────────────────────────────────────
-function spawnWorker(serpentMod, sha2Mod) {
-    return new Promise((resolve, reject) => {
-        const worker = new Worker(new URL('./stream.worker.js', import.meta.url), { type: 'module' });
-        const onMessage = (e) => {
-            cleanup();
-            if (e.data.type === 'ready') {
-                resolve(worker);
-            }
-            else {
-                worker.terminate();
-                reject(new Error(`leviathan-crypto: worker init failed: ${e.data.message}`));
-            }
-        };
-        const onError = (e) => {
-            cleanup();
-            worker.terminate();
-            reject(new Error(`leviathan-crypto: worker init failed: ${e.message}`));
-        };
-        const cleanup = () => {
-            worker.removeEventListener('message', onMessage);
-            worker.removeEventListener('error', onError);
-        };
-        worker.addEventListener('message', onMessage);
-        worker.addEventListener('error', onError);
-        worker.postMessage({ type: 'init', serpentModule: serpentMod, sha2Module: sha2Mod });
-    });
-}
-// ── Pool class ───────────────────────────────────────────────────────────────
-/**
- * Parallel worker pool for SerpentStream chunked authenticated encryption.
- *
- * Each worker owns its own `serpent.wasm` and `sha2.wasm` instances with
- * isolated linear memory. Key derivation happens on the main thread; workers
- * receive pre-derived encKey/macKey per chunk.
- *
- * Produces the same wire format as `SerpentStream` -- either can decrypt
- * the other's output.
- */
-export class SerpentStreamPool {
-    _workers;
-    _idle;
-    _queue;
-    _pending;
-    _hkdf;
-    _nextId;
-    _disposed;
-    constructor(workers, hkdf) {
-        this._workers = workers;
-        this._idle = [...workers];
-        this._queue = [];
-        this._pending = new Map();
-        this._hkdf = hkdf;
-        this._nextId = 0;
-        this._disposed = false;
-        for (const w of workers) {
-            w.onmessage = (e) => this._onMessage(w, e);
-        }
-    }
-    /**
-     * Create a new pool. Requires `init(['serpent', 'sha2'])` to have been called.
-     * Compiles both WASM modules once and distributes them to all workers.
-     */
-    static async create(opts) {
-        if (!isInitialized('serpent') || !isInitialized('sha2'))
-            throw new Error('leviathan-crypto: call init([\'serpent\', \'sha2\']) before using SerpentStreamPool');
-        const n = opts?.workers ?? (typeof navigator !== 'undefined' ? navigator.hardwareConcurrency : undefined) ?? 4;
-        const [serpentMod, sha2Mod] = await Promise.all([getSerpentModule(), getSha2Module()]);
-        // Sequential spawn — compatible with inline-worker test environments
-        const workers = [];
-        for (let i = 0; i < n; i++)
-            workers.push(await spawnWorker(serpentMod, sha2Mod));
-        const hkdf = new HKDF_SHA256();
-        return new SerpentStreamPool(workers, hkdf);
-    }
-    /**
-     * Encrypt plaintext with SerpentStream chunked authenticated encryption.
-     * Returns the complete wire format (header + encrypted chunks).
-     */
-    async seal(key, plaintext, chunkSize) {
-        if (this._disposed)
-            throw new Error('leviathan-crypto: pool is disposed');
-        if (key.length !== 32)
-            throw new RangeError(`SerpentStream key must be 32 bytes (got ${key.length})`);
-        const cs = chunkSize ?? CHUNK_DEF;
-        if (cs < CHUNK_MIN || cs > CHUNK_MAX)
-            throw new RangeError(`SerpentStream chunkSize must be ${CHUNK_MIN}..${CHUNK_MAX} (got ${cs})`);
-        const streamNonce = new Uint8Array(16);
-        crypto.getRandomValues(streamNonce);
-        const chunkCount = plaintext.length === 0 ? 1 : Math.ceil(plaintext.length / cs);
-        // Dispatch all chunk jobs in parallel
-        const chunkPromises = [];
-        for (let i = 0; i < chunkCount; i++) {
-            const start = i * cs;
-            const end = Math.min(start + cs, plaintext.length);
-            const slice = plaintext.slice(start, end);
-            const isLast = i === chunkCount - 1;
-            const { encKey, macKey } = deriveChunkKeys(this._hkdf, key, streamNonce, cs, chunkCount, i, isLast);
-            chunkPromises.push(this._dispatch('seal', encKey, macKey, slice));
-        }
-        const chunkResults = await Promise.all(chunkPromises);
-        // Compute total output size
-        let totalWire = 28;
-        for (const c of chunkResults)
-            totalWire += c.length;
-        const out = new Uint8Array(totalWire);
-        // Write header
-        out.set(streamNonce, 0);
-        out.set(u32be(cs), 16);
-        out.set(u64be(chunkCount), 20);
-        let pos = 28;
-        for (const c of chunkResults) {
-            out.set(c, pos);
-            pos += c.length;
-        }
-        return out;
-    }
-    /**
-     * Decrypt SerpentStream wire format.
-     * If any chunk fails authentication, rejects immediately -- no partial plaintext.
-     */
-    async open(key, ciphertext) {
-        if (this._disposed)
-            throw new Error('leviathan-crypto: pool is disposed');
-        if (key.length !== 32)
-            throw new RangeError(`SerpentStream key must be 32 bytes (got ${key.length})`);
-        if (ciphertext.length < 28 + 32)
-            throw new RangeError('SerpentStream: ciphertext too short');
-        // Parse header
-        const streamNonce = ciphertext.subarray(0, 16);
-        const csView = ciphertext.subarray(16, 20);
-        const cs = (csView[0] << 24) | (csView[1] << 16) | (csView[2] << 8) | csView[3];
-        const ccView = ciphertext.subarray(20, 28);
-        let chunkCount = 0;
-        for (let i = 0; i < 8; i++)
-            chunkCount = chunkCount * 256 + ccView[i];
-        // Dispatch all chunk jobs
-        const chunkPromises = [];
-        let pos = 28;
-        for (let i = 0; i < chunkCount; i++) {
-            const isLast = i === chunkCount - 1;
-            const wireLen = isLast ? ciphertext.length - pos : cs + 32;
-            const wireSlice = ciphertext.slice(pos, pos + wireLen);
-            const { encKey, macKey } = deriveChunkKeys(this._hkdf, key, streamNonce, cs, chunkCount, i, isLast);
-            chunkPromises.push(this._dispatch('open', encKey, macKey, wireSlice));
-            pos += wireLen;
-        }
-        // Await all — Promise.all rejects on first failure
-        const results = await Promise.all(chunkPromises);
-        // Reassemble plaintext
-        let totalPt = 0;
-        for (const r of results)
-            totalPt += r.length;
-        const plaintext = new Uint8Array(totalPt);
-        let ptPos = 0;
-        for (const r of results) {
-            plaintext.set(r, ptPos);
-            ptPos += r.length;
-        }
-        return plaintext;
-    }
-    /** Terminates all workers. Rejects all pending and queued jobs. */
-    dispose() {
-        if (this._disposed)
-            return;
-        this._disposed = true;
-        for (const w of this._workers)
-            w.terminate();
-        const err = new Error('leviathan-crypto: pool disposed');
-        for (const { reject } of this._pending.values())
-            reject(err);
-        for (const job of this._queue)
-            this._pending.get(job.id)?.reject(err);
-        this._pending.clear();
-        this._queue.length = 0;
-        this._hkdf.dispose();
-    }
-    /** Number of workers in the pool. */
-    get size() {
-        return this._workers.length;
-    }
-    /** Number of jobs currently queued (waiting for a free worker). */
-    get queueDepth() {
-        return this._queue.length;
-    }
-    // ── Internals ────────────────────────────────────────────────────────────
-    _dispatch(op, encKey, macKey, data) {
-        return new Promise((resolve, reject) => {
-            const id = this._nextId++;
-            const job = { id, op, encKey, macKey, data };
-            this._pending.set(id, { resolve, reject });
-            const worker = this._idle.pop();
-            if (worker)
-                this._send(worker, job);
-            else
-                this._queue.push(job);
-        });
-    }
-    _send(worker, job) {
-        // No transfer list: @vitest/web-worker (same-thread fake worker used in
-        // Vitest test environment) silently drops postMessage calls that include a
-        // non-empty Transferable array. encKey/macKey/data are already .slice()
-        // copies — neutering was never part of SerpentStreamPool's public contract.
-        worker.postMessage({ type: 'job', ...job });
-    }
-    _onMessage(worker, e) {
-        const msg = e.data;
-        const job = this._pending.get(msg.id);
-        if (!job)
-            return;
-        this._pending.delete(msg.id);
-        if (msg.type === 'result')
-            job.resolve(msg.data);
-        else
-            job.reject(new Error(msg.message));
-        const next = this._queue.shift();
-        if (next)
-            this._send(worker, next);
-        else
-            this._idle.push(worker);
-    }
-}

package/dist/serpent/stream-sealer.d.ts

@@ -1,50 +0,0 @@
-export declare class SerpentStreamSealer {
-    private readonly _key;
-    private readonly _cs;
-    private readonly _nonce;
-    private readonly _cbc;
-    private readonly _hmac;
-    private readonly _hkdf;
-    private readonly _framed;
-    private readonly _ivs;
-    private _ivIdx;
-    private _index;
-    private _state;
-    /** Public: consumers use this 3-param form. */
-    constructor(key: Uint8Array, chunkSize?: number, opts?: {
-        framed?: boolean;
-    });
-    /** @internal Test-only overload to inject fixed nonce/IVs for deterministic KAT vectors. */
-    constructor(key: Uint8Array, chunkSize: number | undefined, opts: {
-        framed?: boolean;
-    } | undefined, _nonce: Uint8Array, _ivs?: Uint8Array[]);
-    header(): Uint8Array;
-    seal(plaintext: Uint8Array): Uint8Array;
-    final(plaintext: Uint8Array): Uint8Array;
-    private _sealChunk;
-    private _wipe;
-    dispose(): void;
-}
-export declare class SerpentStreamOpener {
-    private readonly _key;
-    private readonly _cs;
-    private readonly _nonce;
-    private readonly _cbc;
-    private readonly _hmac;
-    private readonly _hkdf;
-    private readonly _framed;
-    private readonly _buf;
-    private readonly _maxFrame;
-    private _bufLen;
-    private _index;
-    private _dead;
-    constructor(key: Uint8Array, header: Uint8Array, opts?: {
-        framed?: boolean;
-    });
-    get closed(): boolean;
-    open(chunk: Uint8Array): Uint8Array;
-    private _openRaw;
-    feed(bytes: Uint8Array): Uint8Array[];
-    private _wipe;
-    dispose(): void;
-}