leviathan-crypto 1.4.0 → 2.0.0

package/dist/chacha20/pool.js

@@ -1,178 +0,0 @@
-// src/ts/chacha20/pool.ts
-//
-// XChaCha20Poly1305Pool — parallel worker pool for XChaCha20-Poly1305 AEAD.
-// Dispatches independent encrypt/decrypt jobs across Web Workers, each with
-// its own WebAssembly.Instance and isolated linear memory.
-import { isInitialized } from '../init.js';
-import { decodeWasm } from '../loader.js';
-// ── WASM module singleton ────────────────────────────────────────────────────
-let _wasmModule;
-async function getWasmModule() {
-    if (_wasmModule)
-        return _wasmModule;
-    const { WASM_GZ_BASE64 } = await import('../embedded/chacha20.js');
-    const bytes = await decodeWasm(WASM_GZ_BASE64);
-    _wasmModule = await WebAssembly.compile(bytes.buffer);
-    return _wasmModule;
-}
-// ── Worker spawning ──────────────────────────────────────────────────────────
-function spawnWorker(mod) {
-    return new Promise((resolve, reject) => {
-        const worker = new Worker(new URL('./pool.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', module: mod });
-    });
-}
-// ── Pool class ───────────────────────────────────────────────────────────────
-/**
- * Parallel worker pool for XChaCha20-Poly1305 AEAD.
- *
- * Each worker owns its own `WebAssembly.Instance` with isolated linear memory.
- * Jobs are dispatched round-robin to idle workers; excess jobs queue until a
- * worker frees up.
- *
- * **Warning:** Input buffers (`key`, `nonce`, `plaintext`/`ciphertext`, `aad`)
- * are transferred to the worker and neutered on the calling side. The caller
- * must copy any buffer they need to retain after calling `encrypt()`/`decrypt()`.
- */
-export class XChaCha20Poly1305Pool {
-    _workers;
-    _idle;
-    _queue;
-    _pending;
-    _nextId;
-    _disposed;
-    constructor(workers) {
-        this._workers = workers;
-        this._idle = [...workers];
-        this._queue = [];
-        this._pending = new Map();
-        this._nextId = 0;
-        this._disposed = false;
-        for (const w of workers) {
-            w.onmessage = (e) => this._onMessage(w, e);
-        }
-    }
-    /**
-     * Create a new pool. Requires `init(['chacha20'])` to have been called.
-     * Compiles the WASM module once and distributes it to all workers.
-     */
-    static async create(opts) {
-        if (!isInitialized('chacha20'))
-            throw new Error('leviathan-crypto: call init([\'chacha20\']) before using XChaCha20Poly1305Pool');
-        const n = opts?.workers ?? (typeof navigator !== 'undefined' ? navigator.hardwareConcurrency : undefined) ?? 4;
-        const mod = await getWasmModule();
-        // Sequential spawn — compatible with inline-worker test environments
-        const workers = [];
-        for (let i = 0; i < n; i++)
-            workers.push(await spawnWorker(mod));
-        return new XChaCha20Poly1305Pool(workers);
-    }
-    /**
-     * Encrypt plaintext with XChaCha20-Poly1305.
-     * Returns `ciphertext || tag` (plaintext.length + 16 bytes).
-     *
-     * **Warning:** All input buffers are transferred and neutered after dispatch.
-     */
-    encrypt(key, nonce, plaintext, aad = new Uint8Array(0)) {
-        if (this._disposed)
-            return Promise.reject(new Error('leviathan-crypto: pool is disposed'));
-        if (key.length !== 32)
-            return Promise.reject(new RangeError(`key must be 32 bytes (got ${key.length})`));
-        if (nonce.length !== 24)
-            return Promise.reject(new RangeError(`XChaCha20 nonce must be 24 bytes (got ${nonce.length})`));
-        return this._dispatch('encrypt', key, nonce, plaintext, aad);
-    }
-    /**
-     * Decrypt ciphertext with XChaCha20-Poly1305.
-     * Input is `ciphertext || tag` (at least 16 bytes).
-     *
-     * **Warning:** All input buffers are transferred and neutered after dispatch.
-     */
-    decrypt(key, nonce, ciphertext, aad = new Uint8Array(0)) {
-        if (this._disposed)
-            return Promise.reject(new Error('leviathan-crypto: pool is disposed'));
-        if (key.length !== 32)
-            return Promise.reject(new RangeError(`key must be 32 bytes (got ${key.length})`));
-        if (nonce.length !== 24)
-            return Promise.reject(new RangeError(`XChaCha20 nonce must be 24 bytes (got ${nonce.length})`));
-        if (ciphertext.length < 16)
-            return Promise.reject(new RangeError(`ciphertext too short — must include 16-byte tag (got ${ciphertext.length})`));
-        return this._dispatch('decrypt', key, nonce, ciphertext, aad);
-    }
-    /** 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;
-    }
-    /** 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, key, nonce, data, aad) {
-        return new Promise((resolve, reject) => {
-            const id = this._nextId++;
-            const job = { id, op, key, nonce, data, aad };
-            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) {
-        worker.postMessage({ type: 'job', ...job }, [job.key.buffer, job.nonce.buffer, job.data.buffer, job.aad.buffer]);
-    }
-    _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/chacha20/pool.worker.js

@@ -1,37 +0,0 @@
-// / <reference lib="webworker" />
-// src/ts/chacha20/pool.worker.ts
-//
-// Worker entry point for XChaCha20Poly1305Pool. Runs in a Web Worker or
-// worker_threads context — no access to the main thread's module cache.
-// Owns its own WebAssembly.Instance with its own linear memory.
-import { xcEncrypt, xcDecrypt } from './ops.js';
-let x;
-self.onmessage = async (e) => {
-    const msg = e.data;
-    if (msg.type === 'init') {
-        try {
-            const mem = new WebAssembly.Memory({ initial: 3, maximum: 3 });
-            const inst = await WebAssembly.instantiate(msg.module, { env: { memory: mem } });
-            x = inst.exports;
-            self.postMessage({ type: 'ready' });
-        }
-        catch (err) {
-            self.postMessage({ type: 'error', id: -1, message: err.message });
-        }
-        return;
-    }
-    if (!x) {
-        self.postMessage({ type: 'error', id: msg.id, message: 'worker not initialized' });
-        return;
-    }
-    try {
-        const { id, op, key, nonce, data, aad } = msg;
-        const result = op === 'encrypt'
-            ? xcEncrypt(x, key, nonce, data, aad)
-            : xcDecrypt(x, key, nonce, data, aad);
-        self.postMessage({ type: 'result', id, data: result }, [result.buffer]);
-    }
-    catch (err) {
-        self.postMessage({ type: 'error', id: msg.id, message: err.message });
-    }
-};

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

@@ -1,49 +0,0 @@
-export declare class XChaCha20StreamSealer {
-    private readonly _x;
-    private readonly _key;
-    private readonly _cs;
-    private readonly _id;
-    private readonly _framed;
-    private readonly _aad;
-    private _index;
-    private _state;
-    /** Public: consumers use this 3-param form. */
-    constructor(key: Uint8Array, chunkSize?: number, opts?: {
-        framed?: boolean;
-        aad?: Uint8Array;
-    });
-    /** @internal Test-only overload to inject fixed stream_id for deterministic output. */
-    constructor(key: Uint8Array, chunkSize: number | undefined, opts: {
-        framed?: boolean;
-        aad?: Uint8Array;
-    } | undefined, _id: Uint8Array);
-    header(): Uint8Array;
-    seal(plaintext: Uint8Array): Uint8Array;
-    final(plaintext: Uint8Array): Uint8Array;
-    private _sealChunk;
-    private _wipe;
-    dispose(): void;
-}
-export declare class XChaCha20StreamOpener {
-    private readonly _x;
-    private readonly _key;
-    private readonly _cs;
-    private readonly _id;
-    private readonly _framed;
-    private readonly _aad;
-    private readonly _buf;
-    private readonly _maxFrame;
-    private _bufLen;
-    private _index;
-    private _dead;
-    constructor(key: Uint8Array, header: Uint8Array, opts?: {
-        framed?: boolean;
-        aad?: Uint8Array;
-    });
-    get closed(): boolean;
-    open(chunk: Uint8Array): Uint8Array;
-    private _openRaw;
-    feed(bytes: Uint8Array): Uint8Array[];
-    private _wipe;
-    dispose(): void;
-}

package/dist/chacha20/stream-sealer.js

@@ -1,327 +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/chacha20/stream-sealer.ts
-//
-// XChaCha20Stream — chunked authenticated encryption for large payloads.
-// Tier 2 pure-TS: XChaCha20-Poly1305 per chunk. Simpler than SerpentStream —
-// no HKDF, no HMAC; Poly1305 handles auth. Stream binding via per-chunk AAD.
-// Wire format: header(20) | chunks: isLast(1) || nonce(24) || ct || tag(16)
-import { getInstance } from '../init.js';
-import { xcEncrypt, xcDecrypt } from './ops.js';
-import { randomBytes, wipe } from '../utils.js';
-import { _chachaReady } from './index.js';
-const CHUNK_MIN = 1024;
-const CHUNK_MAX = 65536;
-const CHUNK_DEF = 65536;
-function u32be(n) {
-    const b = new Uint8Array(4);
-    b[0] = (n >>> 24) & 0xff;
-    b[1] = (n >>> 16) & 0xff;
-    b[2] = (n >>> 8) & 0xff;
-    b[3] = n & 0xff;
-    return b;
-}
-function u64be(n) {
-    const b = new Uint8Array(8);
-    const hi = Math.floor(n / 0x100000000);
-    const lo = n >>> 0;
-    b[0] = (hi >>> 24) & 0xff;
-    b[1] = (hi >>> 16) & 0xff;
-    b[2] = (hi >>> 8) & 0xff;
-    b[3] = hi & 0xff;
-    b[4] = (lo >>> 24) & 0xff;
-    b[5] = (lo >>> 16) & 0xff;
-    b[6] = (lo >>> 8) & 0xff;
-    b[7] = lo & 0xff;
-    return b;
-}
-function getExports() {
-    return getInstance('chacha20').exports;
-}
-/** Build internal AAD: stream_id(16) || u64be(index) || isLast(1) || u32be(userAad.length) || userAad */
-function chunkAAD(streamId, index, isLast, userAad) {
-    const out = new Uint8Array(16 + 8 + 1 + 4 + userAad.length);
-    let off = 0;
-    out.set(streamId, off);
-    off += 16;
-    out.set(u64be(index), off);
-    off += 8;
-    out[off++] = isLast ? 1 : 0;
-    out.set(u32be(userAad.length), off);
-    off += 4;
-    out.set(userAad, off);
-    return out;
-}
-export class XChaCha20StreamSealer {
-    _x;
-    _key;
-    _cs;
-    _id; // stream_id (16 bytes)
-    _framed;
-    _aad;
-    _index;
-    _state;
-    constructor(key, chunkSize, opts, _id) {
-        if (!_chachaReady())
-            throw new Error('leviathan-crypto: call init([\'chacha20\']) before using XChaCha20StreamSealer');
-        if (key.length !== 32)
-            throw new RangeError(`XChaCha20StreamSealer key must be 32 bytes (got ${key.length})`);
-        const cs = chunkSize ?? CHUNK_DEF;
-        if (cs < CHUNK_MIN || cs > CHUNK_MAX)
-            throw new RangeError(`XChaCha20StreamSealer chunkSize must be ${CHUNK_MIN}..${CHUNK_MAX} (got ${cs})`);
-        this._x = getExports();
-        this._key = key.slice();
-        this._cs = cs;
-        this._framed = opts?.framed ?? false;
-        this._aad = opts?.aad ? opts.aad.slice() : new Uint8Array(0);
-        this._id = new Uint8Array(16);
-        if (_id && _id.length === 16)
-            this._id.set(_id);
-        else
-            crypto.getRandomValues(this._id);
-        this._index = 0;
-        this._state = 'fresh';
-    }
-    header() {
-        if (this._state === 'sealing')
-            throw new Error('XChaCha20StreamSealer: header() already called');
-        if (this._state === 'dead')
-            throw new Error('XChaCha20StreamSealer: stream is closed');
-        this._state = 'sealing';
-        const hdr = new Uint8Array(20);
-        hdr.set(this._id, 0);
-        hdr.set(u32be(this._cs), 16);
-        return hdr;
-    }
-    seal(plaintext) {
-        if (this._state === 'fresh')
-            throw new Error('XChaCha20StreamSealer: call header() first');
-        if (this._state === 'dead')
-            throw new Error('XChaCha20StreamSealer: stream is closed');
-        if (plaintext.length !== this._cs)
-            throw new RangeError(`XChaCha20StreamSealer: seal() requires exactly ${this._cs} bytes (got ${plaintext.length})`);
-        return this._sealChunk(plaintext, false);
-    }
-    final(plaintext) {
-        if (this._state === 'fresh')
-            throw new Error('XChaCha20StreamSealer: call header() first');
-        if (this._state === 'dead')
-            throw new Error('XChaCha20StreamSealer: stream is closed');
-        if (plaintext.length > this._cs)
-            throw new RangeError(`XChaCha20StreamSealer: final() plaintext exceeds chunkSize (got ${plaintext.length})`);
-        const out = this._sealChunk(plaintext, true);
-        this._wipe();
-        return out;
-    }
-    _sealChunk(plaintext, isLast) {
-        const nonce = randomBytes(24);
-        const aad = chunkAAD(this._id, this._index, isLast, this._aad);
-        const sealed = xcEncrypt(this._x, this._key, nonce, plaintext, aad);
-        this._index++;
-        // sealed = ciphertext || tag(16)
-        // wire chunk = isLast(1) || nonce(24) || sealed
-        const chunk = new Uint8Array(1 + 24 + sealed.length);
-        chunk[0] = isLast ? 1 : 0;
-        chunk.set(nonce, 1);
-        chunk.set(sealed, 25);
-        if (!this._framed)
-            return chunk;
-        const out = new Uint8Array(4 + chunk.length);
-        out.set(u32be(chunk.length), 0);
-        out.set(chunk, 4);
-        return out;
-    }
-    _wipe() {
-        wipe(this._key);
-        wipe(this._id);
-        wipe(this._aad);
-        this._x.wipeBuffers();
-        this._state = 'dead';
-    }
-    dispose() {
-        if (this._state !== 'dead')
-            this._wipe();
-    }
-}
-export class XChaCha20StreamOpener {
-    _x;
-    _key;
-    _cs;
-    _id; // stream_id from header
-    _framed;
-    _aad;
-    _buf;
-    _maxFrame;
-    _bufLen;
-    _index;
-    _dead;
-    constructor(key, header, opts) {
-        if (!_chachaReady())
-            throw new Error('leviathan-crypto: call init([\'chacha20\']) before using XChaCha20StreamOpener');
-        if (key.length !== 32)
-            throw new RangeError(`XChaCha20StreamOpener key must be 32 bytes (got ${key.length})`);
-        if (header.length !== 20)
-            throw new RangeError(`XChaCha20StreamOpener header must be 20 bytes (got ${header.length})`);
-        this._x = getExports();
-        this._key = key.slice();
-        this._id = header.slice(0, 16);
-        this._cs = (header[16] << 24 | header[17] << 16 | header[18] << 8 | header[19]) >>> 0;
-        if (this._cs < CHUNK_MIN || this._cs > CHUNK_MAX)
-            throw new RangeError(`XChaCha20StreamOpener: header contains invalid chunkSize ${this._cs} (expected ${CHUNK_MIN}..${CHUNK_MAX})`);
-        this._framed = opts?.framed ?? false;
-        this._aad = opts?.aad ? opts.aad.slice() : new Uint8Array(0);
-        this._index = 0;
-        this._dead = false;
-        this._bufLen = 0;
-        if (this._framed) {
-            // max sealed chunk: 1 + 24 + CHUNK_MAX + 16
-            this._maxFrame = 4 + 1 + 24 + CHUNK_MAX + 16;
-            this._buf = new Uint8Array(this._maxFrame);
-        }
-    }
-    get closed() {
-        return this._dead;
-    }
-    open(chunk) {
-        if (this._dead)
-            throw new Error('XChaCha20StreamOpener: stream is closed');
-        if (this._framed)
-            throw new Error('XChaCha20StreamOpener: call feed() on framed openers — open() expects raw sealed chunks without length prefix');
-        return this._openRaw(chunk);
-    }
-    _openRaw(chunk) {
-        // isLast(1) || nonce(24) || ciphertext || tag(16)
-        if (chunk.length < 1 + 24 + 16)
-            throw new RangeError('XChaCha20StreamOpener: chunk too short');
-        const isLast = chunk[0] !== 0;
-        const nonce = chunk.subarray(1, 25);
-        const payload = chunk.subarray(25); // ciphertext || tag(16)
-        if (payload.length < 16)
-            throw new RangeError('XChaCha20StreamOpener: chunk too short for tag');
-        const aad = chunkAAD(this._id, this._index, isLast, this._aad);
-        // xcDecrypt expects ciphertext || tag combined
-        const plaintext = xcDecrypt(this._x, this._key, nonce, payload, aad);
-        this._index++;
-        if (isLast)
-            this._wipe();
-        return plaintext;
-    }
-    feed(bytes) {
-        if (!this._framed)
-            throw new Error('XChaCha20StreamOpener: feed() requires { framed: true }');
-        if (this._dead)
-            throw new Error('XChaCha20StreamOpener: stream is closed');
-        const buf = this._buf;
-        const maxFrame = this._maxFrame;
-        const results = [];
-        let consumed = 0;
-        // ── Phase 1: drain carry-over ─────────────────────────────────────
-        if (this._bufLen > 0) {
-            if (this._bufLen < 4) {
-                const need = 4 - this._bufLen;
-                const take = Math.min(need, bytes.length - consumed);
-                buf.set(bytes.subarray(consumed, consumed + take), this._bufLen);
-                this._bufLen += take;
-                consumed += take;
-                if (this._bufLen < 4)
-                    return results;
-            }
-            const sealedLen = (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
-            if (sealedLen === 0 || sealedLen > (maxFrame - 4)) {
-                this._wipe();
-                throw new Error('XChaCha20StreamOpener: invalid sealed chunk length');
-            }
-            const frameLen = 4 + sealedLen;
-            const haveInBuf = this._bufLen;
-            const needMore = frameLen - haveInBuf;
-            if (needMore > 0) {
-                const take = Math.min(needMore, bytes.length - consumed);
-                buf.set(bytes.subarray(consumed, consumed + take), haveInBuf);
-                this._bufLen += take;
-                consumed += take;
-                if (this._bufLen < frameLen)
-                    return results;
-            }
-            results.push(this._openRaw(buf.subarray(4, frameLen)));
-            this._bufLen = 0;
-            if (this._dead) {
-                if (consumed < bytes.length) {
-                    this._wipe();
-                    throw new Error('XChaCha20StreamOpener: unexpected bytes after final chunk');
-                }
-                return results;
-            }
-        }
-        // ── Phase 2: parse complete frames directly from bytes ────────────
-        let pos = consumed;
-        while (true) {
-            if (bytes.length - pos < 4)
-                break;
-            const sealedLen = (bytes[pos] << 24 | bytes[pos + 1] << 16 | bytes[pos + 2] << 8 | bytes[pos + 3]) >>> 0;
-            if (sealedLen === 0 || sealedLen > (maxFrame - 4)) {
-                this._wipe();
-                throw new Error('XChaCha20StreamOpener: invalid sealed chunk length');
-            }
-            const frameLen = 4 + sealedLen;
-            if (bytes.length - pos < frameLen)
-                break;
-            results.push(this._openRaw(bytes.subarray(pos + 4, pos + frameLen)));
-            if (this._dead) {
-                const remaining = bytes.length - pos - frameLen;
-                if (remaining > 0) {
-                    this._wipe();
-                    throw new Error('XChaCha20StreamOpener: unexpected bytes after final chunk');
-                }
-                return results;
-            }
-            pos += frameLen;
-        }
-        // ── Carry over incomplete trailing bytes ──────────────────────────
-        const leftover = bytes.length - pos;
-        if (leftover > 0) {
-            if (leftover > maxFrame) {
-                this._wipe();
-                throw new Error('XChaCha20StreamOpener: input exceeds maximum frame size');
-            }
-            buf.set(bytes.subarray(pos), 0);
-            this._bufLen = leftover;
-        }
-        return results;
-    }
-    _wipe() {
-        if (this._dead)
-            return;
-        wipe(this._key);
-        wipe(this._id);
-        wipe(this._aad);
-        this._x.wipeBuffers();
-        if (this._framed) {
-            wipe(this._buf);
-            this._bufLen = 0;
-        }
-        this._dead = true;
-    }
-    dispose() {
-        if (!this._dead)
-            this._wipe();
-    }
-}