@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/lzma1/hc4.js

@@ -0,0 +1,142 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * Hash chain match finder with 2-, 3- and 4-byte hashing.
+ *
+ * Every position links to the previous position with the same 4-byte hash.
+ * Faster than the binary tree finder but finds fewer long matches.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HC4 = void 0;
+const hash234_1 = require("./hash234");
+const lz_encoder_1 = require("./lz-encoder");
+const MAX_POS = 0x7fffffff;
+class HC4 extends lz_encoder_1.LzEncoder {
+    hash;
+    /** Previous position with the same hash, per position in the cyclic buffer. */
+    chain;
+    matches;
+    depthLimit;
+    cyclicSize;
+    cyclicPos = -1;
+    /** Position counter stored in the hash tables and chain. */
+    lzPos;
+    constructor(config) {
+        super(config);
+        this.hash = new hash234_1.Hash234(config.dictSize);
+        this.cyclicSize = config.dictSize + 1;
+        this.chain = new Int32Array(this.cyclicSize);
+        this.lzPos = this.cyclicSize;
+        this.matches = new lz_encoder_1.Matches(config.niceLen - 1);
+        this.depthLimit = config.depthLimit > 0 ? config.depthLimit : 4 + (config.niceLen >>> 2);
+    }
+    /**
+     * Prepares for a new input without clearing the tables: positions
+     * continue after the previous input, so its entries are too far back
+     * (`delta >= cyclicSize`) and get ignored like empty ones.
+     */
+    reset() {
+        super.reset();
+        this.cyclicPos = -1;
+        this.lzPos += this.cyclicSize;
+        if (this.lzPos >= MAX_POS - this.cyclicSize) {
+            this.hash.clear();
+            this.chain.fill(0);
+            this.lzPos = this.cyclicSize;
+        }
+    }
+    getMatches() {
+        const matches = this.matches;
+        const buf = this.buf;
+        matches.count = 0;
+        let matchLenLimit = this.matchLenMax;
+        let niceLenLimit = this.niceLen;
+        const avail = this.movePosition();
+        if (avail < matchLenLimit) {
+            if (avail === 0)
+                return matches;
+            matchLenLimit = avail;
+            if (niceLenLimit > avail)
+                niceLenLimit = avail;
+        }
+        const readPos = this.readPos;
+        this.hash.calcHashes(buf, readPos);
+        let delta2 = this.lzPos - this.hash.getHash2Pos();
+        const delta3 = this.lzPos - this.hash.getHash3Pos();
+        let match = this.hash.getHash4Pos();
+        this.hash.updateTables(this.lzPos);
+        this.chain[this.cyclicPos] = match;
+        let lenBest = 0;
+        // A 2-byte match from the hash table.
+        if (delta2 < this.cyclicSize && buf[readPos - delta2] === buf[readPos]) {
+            lenBest = 2;
+            matches.len[0] = 2;
+            matches.dist[0] = delta2 - 1;
+            matches.count = 1;
+        }
+        // A 3-byte match, if it's at a different distance.
+        if (delta2 !== delta3 && delta3 < this.cyclicSize && buf[readPos - delta3] === buf[readPos]) {
+            lenBest = 3;
+            matches.dist[matches.count++] = delta3 - 1;
+            delta2 = delta3;
+        }
+        // Extend the hashed match as far as possible.
+        if (matches.count > 0) {
+            lenBest = (0, lz_encoder_1.getMatchLen)(buf, readPos, delta2, lenBest, matchLenLimit);
+            matches.len[matches.count - 1] = lenBest;
+            if (lenBest >= niceLenLimit)
+                return matches;
+        }
+        if (lenBest < 3)
+            lenBest = 3;
+        // Follow the chain of earlier positions with the same 4-byte hash.
+        let depth = this.depthLimit;
+        while (true) {
+            const delta = this.lzPos - match;
+            if (depth-- === 0 || delta >= this.cyclicSize) {
+                return matches;
+            }
+            match = this.chain[this.cyclicPos - delta + (delta > this.cyclicPos ? this.cyclicSize : 0)];
+            // Cheap checks first: a longer match must differ from the best
+            // one at `lenBest`, and must start with the same byte.
+            if (buf[readPos + lenBest - delta] === buf[readPos + lenBest] && buf[readPos - delta] === buf[readPos]) {
+                const len = (0, lz_encoder_1.getMatchLen)(buf, readPos, delta, 1, matchLenLimit);
+                if (len > lenBest) {
+                    lenBest = len;
+                    matches.len[matches.count] = len;
+                    matches.dist[matches.count] = delta - 1;
+                    ++matches.count;
+                    if (len >= niceLenLimit)
+                        return matches;
+                }
+            }
+        }
+    }
+    skip(len) {
+        for (let left = len; left > 0; --left) {
+            if (this.movePosition() !== 0) {
+                this.hash.calcHashes(this.buf, this.readPos);
+                this.chain[this.cyclicPos] = this.hash.getHash4Pos();
+                this.hash.updateTables(this.lzPos);
+            }
+        }
+    }
+    movePosition() {
+        const avail = this.movePos(4, 4);
+        if (avail !== 0) {
+            if (++this.lzPos === MAX_POS) {
+                const offset = MAX_POS - this.cyclicSize;
+                this.hash.normalize(offset);
+                (0, lz_encoder_1.normalizePositions)(this.chain, offset);
+                this.lzPos -= offset;
+            }
+            if (++this.cyclicPos === this.cyclicSize) {
+                this.cyclicPos = 0;
+            }
+        }
+        return avail;
+    }
+}
+exports.HC4 = HC4;

package/dist/lzma1/header.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The 13-byte header of the `.lzma` ("LZMA_Alone") format:
+ *
+ * | bytes | field                                        |
+ * | ----- | -------------------------------------------- |
+ * | 0     | properties: `(pb * 5 + lp) * 9 + lc`         |
+ * | 1-4   | dictionary size, uint32 little-endian        |
+ * | 5-12  | uncompressed size, uint64 little-endian,     |
+ * |       | or all 0xFF when unknown (end marker is used)|
+ */
+export declare const HEADER_SIZE = 13;
+/** Uncompressed size value meaning "unknown, ends with an end marker". */
+export declare const UNKNOWN_SIZE = -1;
+export interface LzmaHeader {
+    /** Literal context bits (0-8) */
+    lc: number;
+    /** Literal position bits (0-4) */
+    lp: number;
+    /** Position bits (0-4) */
+    pb: number;
+    dictSize: number;
+    /** Uncompressed size in bytes, or `UNKNOWN_SIZE` */
+    uncompressedSize: number;
+}
+/**
+ * Rounds up to `2^n` or `2^n + 2^(n-1)`, the only dictionary sizes xz and
+ * 7-Zip accept in a `.lzma` header. A larger size than the encoder used is
+ * always valid, and liblzma rounds the same way.
+ */
+export declare function roundDictSize(dictSize: number): number;
+export declare function encodeHeader(header: LzmaHeader): Uint8Array;
+export declare function decodeHeader(bytes: Uint8Array): LzmaHeader;

package/dist/lzma1/header.js

@@ -0,0 +1,73 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * The 13-byte header of the `.lzma` ("LZMA_Alone") format:
+ *
+ * | bytes | field                                        |
+ * | ----- | -------------------------------------------- |
+ * | 0     | properties: `(pb * 5 + lp) * 9 + lc`         |
+ * | 1-4   | dictionary size, uint32 little-endian        |
+ * | 5-12  | uncompressed size, uint64 little-endian,     |
+ * |       | or all 0xFF when unknown (end marker is used)|
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNKNOWN_SIZE = exports.HEADER_SIZE = void 0;
+exports.roundDictSize = roundDictSize;
+exports.encodeHeader = encodeHeader;
+exports.decodeHeader = decodeHeader;
+exports.HEADER_SIZE = 13;
+/** Uncompressed size value meaning "unknown, ends with an end marker". */
+exports.UNKNOWN_SIZE = -1;
+/**
+ * Rounds up to `2^n` or `2^n + 2^(n-1)`, the only dictionary sizes xz and
+ * 7-Zip accept in a `.lzma` header. A larger size than the encoder used is
+ * always valid, and liblzma rounds the same way.
+ */
+function roundDictSize(dictSize) {
+    let d = dictSize - 1;
+    d |= d >>> 2;
+    d |= d >>> 3;
+    d |= d >>> 4;
+    d |= d >>> 8;
+    d |= d >>> 16;
+    return Math.min((d >>> 0) + 1, 0xffffffff);
+}
+function encodeHeader(header) {
+    const bytes = new Uint8Array(exports.HEADER_SIZE);
+    const view = new DataView(bytes.buffer);
+    bytes[0] = (header.pb * 5 + header.lp) * 9 + header.lc;
+    view.setUint32(1, roundDictSize(header.dictSize), true);
+    if (header.uncompressedSize === exports.UNKNOWN_SIZE) {
+        bytes.fill(0xff, 5);
+    }
+    else {
+        view.setUint32(5, header.uncompressedSize % 0x100000000, true);
+        view.setUint32(9, Math.floor(header.uncompressedSize / 0x100000000), true);
+    }
+    return bytes;
+}
+function decodeHeader(bytes) {
+    if (bytes.length < exports.HEADER_SIZE) {
+        throw new Error('Truncated input');
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, exports.HEADER_SIZE);
+    let props = bytes[0];
+    if (props >= 9 * 5 * 5) {
+        throw new Error('Corrupted input: invalid LZMA properties');
+    }
+    const lc = props % 9;
+    props = (props / 9) | 0;
+    const lp = props % 5;
+    const pb = (props / 5) | 0;
+    const dictSize = view.getUint32(1, true);
+    const sizeLow = view.getUint32(5, true);
+    const sizeHigh = view.getUint32(9, true);
+    let uncompressedSize = exports.UNKNOWN_SIZE;
+    if (sizeLow !== 0xffffffff || sizeHigh !== 0xffffffff) {
+        uncompressedSize = sizeHigh * 0x100000000 + sizeLow;
+        if (!Number.isSafeInteger(uncompressedSize)) {
+            throw new Error('Unsupported input: uncompressed size is too large');
+        }
+    }
+    return { lc, lp, pb, dictSize, uncompressedSize };
+}

package/dist/lzma1/lz-decoder.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Decoder-side LZ window: a circular buffer holding the most recent output
+ * (the dictionary), which matches copy from.
+ *
+ * The buffer starts small and doubles until it reaches the dictionary size,
+ * so small outputs don't allocate the whole dictionary up front, unless
+ * `preallocate` is set. Bytes are passed to `sink` before they get
+ * overwritten.
+ */
+export declare class LzDecoder {
+    private buf;
+    private readonly maxSize;
+    private readonly sink;
+    /** Next write position. */
+    private pos;
+    /** Start of the bytes not yet passed to the sink. */
+    private start;
+    private wrapped;
+    /**
+     * @param dictSize Largest distance a match may reach back
+     * @param sink Receives decoded data. The chunk is only valid during the call.
+     * @param preallocate Allocate the whole dictionary now instead of growing
+     */
+    constructor(dictSize: number, sink: (chunk: Uint8Array) => void, preallocate?: boolean);
+    /** Returns the byte `dist + 1` positions back. */
+    getByte(dist: number): number;
+    putByte(byte: number): void;
+    /** Copies `len` bytes starting `dist + 1` positions back. */
+    repeat(dist: number, length: number): void;
+    /**
+     * Copies `len` bytes of uncompressed data from `input` at `inPos`. XZ for
+     * Java copies up to the end of the buffer and leaves the rest to its
+     * caller; this copy continues past the end like `repeat`.
+     */
+    copyUncompressed(input: Uint8Array, offset: number, length: number): void;
+    /** Empties the dictionary, so matches can't reach back before this point. */
+    reset(): void;
+    /** Passes all pending bytes to the sink. */
+    flush(): void;
+    private onBufferEnd;
+}

package/dist/lzma1/lz-decoder.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LzDecoder = void 0;
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * Decoder-side LZ window: a circular buffer holding the most recent output
+ * (the dictionary), which matches copy from.
+ *
+ * The buffer starts small and doubles until it reaches the dictionary size,
+ * so small outputs don't allocate the whole dictionary up front, unless
+ * `preallocate` is set. Bytes are passed to `sink` before they get
+ * overwritten.
+ */
+class LzDecoder {
+    buf;
+    maxSize;
+    sink;
+    /** Next write position. */
+    pos = 0;
+    /** Start of the bytes not yet passed to the sink. */
+    start = 0;
+    wrapped = false;
+    /**
+     * @param dictSize Largest distance a match may reach back
+     * @param sink Receives decoded data. The chunk is only valid during the call.
+     * @param preallocate Allocate the whole dictionary now instead of growing
+     */
+    constructor(dictSize, sink, preallocate = false) {
+        this.maxSize = dictSize;
+        this.buf = new Uint8Array(preallocate ? dictSize : Math.min(dictSize, 1 << 16));
+        this.sink = sink;
+    }
+    /** Returns the byte `dist + 1` positions back. */
+    getByte(dist) {
+        let offset = this.pos - dist - 1;
+        if (offset < 0) {
+            offset += this.buf.length;
+        }
+        return this.buf[offset];
+    }
+    putByte(byte) {
+        this.buf[this.pos++] = byte;
+        if (this.pos === this.buf.length) {
+            this.onBufferEnd();
+        }
+    }
+    /** Copies `len` bytes starting `dist + 1` positions back. */
+    repeat(dist, length) {
+        let len = length;
+        const history = this.wrapped ? this.buf.length : this.pos;
+        if (dist < 0 || dist >= history) {
+            throw new Error('Corrupted input: match distance is too large');
+        }
+        while (len > 0) {
+            const buf = this.buf;
+            let back = this.pos - dist - 1;
+            if (back < 0) {
+                back += buf.length;
+            }
+            const count = Math.min(len, buf.length - this.pos, buf.length - back);
+            if (count <= dist && count >= 32) {
+                // Source and destination don't overlap.
+                buf.copyWithin(this.pos, back, back + count);
+                this.pos += count;
+            }
+            else {
+                // A forward byte copy repeats short distances correctly.
+                for (let i = 0; i < count; ++i) {
+                    buf[this.pos++] = buf[back + i];
+                }
+            }
+            len -= count;
+            if (this.pos === buf.length) {
+                this.onBufferEnd();
+            }
+        }
+    }
+    /**
+     * Copies `len` bytes of uncompressed data from `input` at `inPos`. XZ for
+     * Java copies up to the end of the buffer and leaves the rest to its
+     * caller; this copy continues past the end like `repeat`.
+     */
+    copyUncompressed(input, offset, length) {
+        let inPos = offset;
+        let len = length;
+        while (len > 0) {
+            const copySize = Math.min(this.buf.length - this.pos, len);
+            this.buf.set(input.subarray(inPos, inPos + copySize), this.pos);
+            this.pos += copySize;
+            inPos += copySize;
+            len -= copySize;
+            if (this.pos === this.buf.length) {
+                this.onBufferEnd();
+            }
+        }
+    }
+    /** Empties the dictionary, so matches can't reach back before this point. */
+    reset() {
+        // In XZ for Java the caller flushes first. Here the sink has to get
+        // the pending bytes before the positions restart, or they are lost.
+        this.flush();
+        this.start = 0;
+        this.pos = 0;
+        this.wrapped = false;
+        // getByte(0) has to return 0x00 when nothing has been decoded.
+        this.buf[this.buf.length - 1] = 0x00;
+    }
+    /** Passes all pending bytes to the sink. */
+    flush() {
+        if (this.pos > this.start) {
+            this.sink(this.buf.subarray(this.start, this.pos));
+        }
+        this.start = this.pos;
+    }
+    onBufferEnd() {
+        if (!this.wrapped && this.buf.length < this.maxSize) {
+            const grown = new Uint8Array(Math.min(this.buf.length * 2, this.maxSize));
+            grown.set(this.buf);
+            this.buf = grown;
+            return;
+        }
+        this.flush();
+        this.pos = 0;
+        this.start = 0;
+        this.wrapped = true;
+    }
+}
+exports.LzDecoder = LzDecoder;

package/dist/lzma1/lz-encoder.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Encoder-side LZ window and the base class of the match finders.
+ *
+ * The window holds `keepSizeBefore` bytes of history (the dictionary plus
+ * what the encoder needs) and `keepSizeAfter` bytes of lookahead. When the
+ * read position gets close to the end of the buffer, the window is moved
+ * back to the start of the buffer.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+export type MatchFinderType = 'hc4' | 'bt4';
+/** Matches found at one position, sorted by increasing length. */
+export declare class Matches {
+    readonly len: Int32Array;
+    /** Distances minus one (0 means the previous byte). */
+    readonly dist: Int32Array;
+    count: number;
+    constructor(countMax: number);
+}
+/**
+ * Returns how many bytes starting at `off + len` equal the bytes `delta`
+ * positions earlier, up to `lenLimit` in total.
+ */
+export declare function getMatchLen(buf: Uint8Array, off: number, delta: number, len: number, lenLimit: number): number;
+/** Subtracts `offset` from all positions, clamping at zero. */
+export declare function normalizePositions(positions: Int32Array, offset: number): void;
+export interface LzEncoderConfig {
+    dictSize: number;
+    extraSizeBefore: number;
+    extraSizeAfter: number;
+    niceLen: number;
+    matchLenMax: number;
+    /** Search depth limit, 0 = automatic */
+    depthLimit: number;
+    /** Total input size, when known in advance, to avoid oversized buffers */
+    inputSize?: number;
+}
+export declare abstract class LzEncoder {
+    private readonly keepSizeBefore;
+    private readonly keepSizeAfter;
+    readonly matchLenMax: number;
+    readonly niceLen: number;
+    readonly buf: Uint8Array;
+    /** Position of the byte most recently returned by the match finder. */
+    protected readPos: number;
+    private readLimit;
+    private finishing;
+    private writePos;
+    /** Bytes that were skipped because there wasn't enough lookahead yet. */
+    private pendingSize;
+    constructor(config: LzEncoderConfig);
+    /** Prepares the window for a new, independent input. */
+    reset(): void;
+    /** Returns matches at the next position. */
+    abstract getMatches(): Matches;
+    /** Advances `len` positions, updating the match finder structures. */
+    abstract skip(len: number): void;
+    /**
+     * Copies input into the window.
+     *
+     * @returns number of bytes consumed; call again with the rest
+     */
+    fillWindow(input: Uint8Array, off: number, length: number): number;
+    /** Marks the end of input so that the lookahead can be used up. */
+    setFinishing(): void;
+    isStarted(): boolean;
+    /** True if there is enough input to encode more symbols. */
+    hasEnoughData(alreadyReadLen: number): boolean;
+    /** Bytes available from the read position, including it. */
+    getAvail(): number;
+    getPos(): number;
+    /** Byte `backward` positions before the read position. */
+    getByte(backward: number): number;
+    /** Byte `backward` positions before `forward` bytes after the read position. */
+    getByteAt(forward: number, backward: number): number;
+    /** Length of the match at distance `dist` starting `forward` bytes ahead. */
+    getMatchLen(forward: number, dist: number, lenLimit: number): number;
+    /**
+     * Advances the read position.
+     *
+     * @returns number of bytes available, or 0 if the position must be
+     *          processed later when more input has arrived
+     */
+    protected movePos(requiredForFlushing: number, requiredForFinishing: number): number;
+    private moveWindow;
+    private processPendingBytes;
+}

package/dist/lzma1/lz-encoder.js

@@ -0,0 +1,166 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * Encoder-side LZ window and the base class of the match finders.
+ *
+ * The window holds `keepSizeBefore` bytes of history (the dictionary plus
+ * what the encoder needs) and `keepSizeAfter` bytes of lookahead. When the
+ * read position gets close to the end of the buffer, the window is moved
+ * back to the start of the buffer.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LzEncoder = exports.Matches = void 0;
+exports.getMatchLen = getMatchLen;
+exports.normalizePositions = normalizePositions;
+/** Matches found at one position, sorted by increasing length. */
+class Matches {
+    len;
+    /** Distances minus one (0 means the previous byte). */
+    dist;
+    count = 0;
+    constructor(countMax) {
+        this.len = new Int32Array(countMax);
+        this.dist = new Int32Array(countMax);
+    }
+}
+exports.Matches = Matches;
+/**
+ * Returns how many bytes starting at `off + len` equal the bytes `delta`
+ * positions earlier, up to `lenLimit` in total.
+ */
+function getMatchLen(buf, off, delta, len, lenLimit) {
+    const end = off + lenLimit;
+    let i = off + len;
+    while (i < end && buf[i] === buf[i - delta]) {
+        ++i;
+    }
+    return i - off;
+}
+/** Subtracts `offset` from all positions, clamping at zero. */
+function normalizePositions(positions, offset) {
+    for (let i = 0; i < positions.length; ++i) {
+        positions[i] = positions[i] <= offset ? 0 : positions[i] - offset;
+    }
+}
+class LzEncoder {
+    keepSizeBefore;
+    keepSizeAfter;
+    matchLenMax;
+    niceLen;
+    buf;
+    /** Position of the byte most recently returned by the match finder. */
+    readPos = -1;
+    readLimit = -1;
+    finishing = false;
+    writePos = 0;
+    /** Bytes that were skipped because there wasn't enough lookahead yet. */
+    pendingSize = 0;
+    constructor(config) {
+        this.keepSizeBefore = config.extraSizeBefore + config.dictSize;
+        this.keepSizeAfter = config.extraSizeAfter + config.matchLenMax;
+        this.matchLenMax = config.matchLenMax;
+        this.niceLen = config.niceLen;
+        const reserveSize = Math.min((config.dictSize >>> 1) + (256 << 10), 512 << 20);
+        let bufSize = this.keepSizeBefore + this.keepSizeAfter + reserveSize;
+        if (config.inputSize !== undefined) {
+            // The whole input fits, so the window never has to move.
+            bufSize = Math.min(bufSize, config.inputSize + this.keepSizeAfter);
+        }
+        this.buf = new Uint8Array(bufSize);
+    }
+    /** Prepares the window for a new, independent input. */
+    reset() {
+        this.readPos = -1;
+        this.readLimit = -1;
+        this.finishing = false;
+        this.writePos = 0;
+        this.pendingSize = 0;
+    }
+    /**
+     * Copies input into the window.
+     *
+     * @returns number of bytes consumed; call again with the rest
+     */
+    fillWindow(input, off, length) {
+        if (this.readPos >= this.buf.length - this.keepSizeAfter) {
+            this.moveWindow();
+        }
+        const len = Math.min(length, this.buf.length - this.writePos);
+        this.buf.set(input.subarray(off, off + len), this.writePos);
+        this.writePos += len;
+        if (this.writePos >= this.keepSizeAfter) {
+            this.readLimit = this.writePos - this.keepSizeAfter;
+        }
+        this.processPendingBytes();
+        return len;
+    }
+    /** Marks the end of input so that the lookahead can be used up. */
+    setFinishing() {
+        this.readLimit = this.writePos - 1;
+        this.finishing = true;
+        this.processPendingBytes();
+    }
+    isStarted() {
+        return this.readPos !== -1;
+    }
+    /** True if there is enough input to encode more symbols. */
+    hasEnoughData(alreadyReadLen) {
+        return this.readPos - alreadyReadLen < this.readLimit;
+    }
+    /** Bytes available from the read position, including it. */
+    getAvail() {
+        return this.writePos - this.readPos;
+    }
+    getPos() {
+        return this.readPos;
+    }
+    /** Byte `backward` positions before the read position. */
+    getByte(backward) {
+        return this.buf[this.readPos - backward];
+    }
+    /** Byte `backward` positions before `forward` bytes after the read position. */
+    getByteAt(forward, backward) {
+        return this.buf[this.readPos + forward - backward];
+    }
+    /** Length of the match at distance `dist` starting `forward` bytes ahead. */
+    getMatchLen(forward, dist, lenLimit) {
+        return getMatchLen(this.buf, this.readPos + forward, dist + 1, 0, lenLimit);
+    }
+    /**
+     * Advances the read position.
+     *
+     * @returns number of bytes available, or 0 if the position must be
+     *          processed later when more input has arrived
+     */
+    movePos(requiredForFlushing, requiredForFinishing) {
+        ++this.readPos;
+        let avail = this.writePos - this.readPos;
+        if (avail < requiredForFlushing) {
+            if (avail < requiredForFinishing || !this.finishing) {
+                ++this.pendingSize;
+                avail = 0;
+            }
+        }
+        return avail;
+    }
+    moveWindow() {
+        // Keep the offset a multiple of 16 so that the low bits of positions,
+        // which select probabilities, don't change.
+        const moveOffset = (this.readPos + 1 - this.keepSizeBefore) & ~15;
+        this.buf.copyWithin(0, moveOffset, this.writePos);
+        this.readPos -= moveOffset;
+        this.readLimit -= moveOffset;
+        this.writePos -= moveOffset;
+    }
+    processPendingBytes() {
+        if (this.pendingSize > 0 && this.readPos < this.readLimit) {
+            this.readPos -= this.pendingSize;
+            const oldPendingSize = this.pendingSize;
+            this.pendingSize = 0;
+            this.skip(oldPendingSize);
+        }
+    }
+}
+exports.LzEncoder = LzEncoder;