@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/lzma1/lzma-decoder.js

@@ -0,0 +1,484 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * LZMA decoder: turns range-coded symbols back into literals and matches.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov. The main
+ * loop is structured like `LzmaDec_DecodeReal` of the LZMA SDK.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LzmaDecoder = void 0;
+const lzma_coder_1 = require("./lzma-coder");
+const range_coder_1 = require("./range-coder");
+/** Distance value that marks the end of the stream. */
+const END_MARKER_DIST = -1;
+class LzmaDecoder extends lzma_coder_1.LzmaCoder {
+    lz;
+    rc;
+    /** Number of bytes decoded so far. */
+    outPos = 0;
+    constructor(lz, rc, lc, lp, pb, probs) {
+        super(lc, lp, pb, probs);
+        this.lz = lz;
+        this.rc = rc;
+        this.reset();
+    }
+    /**
+     * Decodes symbols until `outLimit` bytes have been produced or the input
+     * position passes `inLimit`.
+     *
+     * Performance: this is the hot loop of decompression. The range decoder
+     * state, the coder state and the reps live in local variables, and the
+     * bit decoding step (`decodeBit` in `range-coder_test.ts`) is repeated inline:
+     *
+     *     prob = probs[i];
+     *     bound = (range >>> 11) * prob;
+     *     if (code < bound) { range = bound; probs[i] = prob + ((2048 - prob) >>> 5); bit 0 }
+     *     else { range -= bound; code -= bound; probs[i] = prob - (prob >>> 5); bit 1 }
+     *     if (range < 2^24) { shift in the next input byte }
+     *
+     * With the state in object fields, engines store and reload it around
+     * every probability update, which costs 10-15% on V8.
+     *
+     * @returns `true` if the end marker was decoded
+     */
+    decode(outLimit, inLimit) {
+        const probs = this.probs;
+        const lz = this.lz;
+        const reps = this.reps;
+        const posMask = this.posMask;
+        const rc = this.rc;
+        const input = rc.input;
+        const inputEnd = input.length;
+        let range = rc.range;
+        let code = rc.code;
+        let inPos = rc.pos;
+        let state = this.state;
+        let outPos = this.outPos;
+        let rep0 = reps[0];
+        let rep1 = reps[1];
+        let rep2 = reps[2];
+        let rep3 = reps[3];
+        let endMarker = false;
+        let i = 0;
+        let prob = 0;
+        let bound = 0;
+        while (outPos < outLimit && inPos <= inLimit) {
+            const posState = outPos & posMask;
+            // -- Literal or match? --
+            i = lzma_coder_1.IS_MATCH + (state << 4) + posState;
+            prob = probs[i];
+            bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+            if (code < bound) {
+                range = bound;
+                probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                if (range < range_coder_1.TOP_VALUE) {
+                    if (inPos >= inputEnd)
+                        throw truncated();
+                    range = (range << 8) >>> 0;
+                    code = ((code << 8) | input[inPos++]) >>> 0;
+                }
+                // -- Literal: 8 bits, MSB first --
+                const offset = this.literalOffset(lz.getByte(0), outPos);
+                let symbol = 1;
+                if ((0, lzma_coder_1.isLiteralState)(state)) {
+                    do {
+                        i = offset + symbol;
+                        prob = probs[i];
+                        bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                        if (code < bound) {
+                            range = bound;
+                            probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                            symbol <<= 1;
+                        }
+                        else {
+                            range -= bound;
+                            code -= bound;
+                            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                            symbol = (symbol << 1) | 1;
+                        }
+                        if (range < range_coder_1.TOP_VALUE) {
+                            if (inPos >= inputEnd)
+                                throw truncated();
+                            range = (range << 8) >>> 0;
+                            code = ((code << 8) | input[inPos++]) >>> 0;
+                        }
+                    } while (symbol < 0x100);
+                }
+                else {
+                    // After a match, the bits of the byte at rep0 select the
+                    // probabilities until the first bit that differs.
+                    let matchByte = lz.getByte(rep0);
+                    let matchOffset = 0x100;
+                    do {
+                        matchByte <<= 1;
+                        const matchBit = matchByte & matchOffset;
+                        i = offset + matchOffset + matchBit + symbol;
+                        prob = probs[i];
+                        bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                        if (code < bound) {
+                            range = bound;
+                            probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                            symbol <<= 1;
+                            matchOffset &= ~matchBit;
+                        }
+                        else {
+                            range -= bound;
+                            code -= bound;
+                            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                            symbol = (symbol << 1) | 1;
+                            matchOffset &= matchBit;
+                        }
+                        if (range < range_coder_1.TOP_VALUE) {
+                            if (inPos >= inputEnd)
+                                throw truncated();
+                            range = (range << 8) >>> 0;
+                            code = ((code << 8) | input[inPos++]) >>> 0;
+                        }
+                    } while (symbol < 0x100);
+                }
+                lz.putByte(symbol & 0xff);
+                state = (0, lzma_coder_1.stateAfterLiteral)(state);
+                ++outPos;
+                continue;
+            }
+            range -= bound;
+            code -= bound;
+            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+            if (range < range_coder_1.TOP_VALUE) {
+                if (inPos >= inputEnd)
+                    throw truncated();
+                range = (range << 8) >>> 0;
+                code = ((code << 8) | input[inPos++]) >>> 0;
+            }
+            // -- Match or rep match? --
+            let lenCoder;
+            i = lzma_coder_1.IS_REP + state;
+            prob = probs[i];
+            bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+            if (code < bound) {
+                range = bound;
+                probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                if (range < range_coder_1.TOP_VALUE) {
+                    if (inPos >= inputEnd)
+                        throw truncated();
+                    range = (range << 8) >>> 0;
+                    code = ((code << 8) | input[inPos++]) >>> 0;
+                }
+                // Match: the distance follows the length.
+                state = (0, lzma_coder_1.stateAfterMatch)(state);
+                rep3 = rep2;
+                rep2 = rep1;
+                rep1 = rep0;
+                lenCoder = lzma_coder_1.MATCH_LEN;
+            }
+            else {
+                range -= bound;
+                code -= bound;
+                probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                if (range < range_coder_1.TOP_VALUE) {
+                    if (inPos >= inputEnd)
+                        throw truncated();
+                    range = (range << 8) >>> 0;
+                    code = ((code << 8) | input[inPos++]) >>> 0;
+                }
+                // Rep match: one of the four recent distances.
+                i = lzma_coder_1.IS_REP0 + state;
+                prob = probs[i];
+                bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                if (code < bound) {
+                    range = bound;
+                    probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                    if (range < range_coder_1.TOP_VALUE) {
+                        if (inPos >= inputEnd)
+                            throw truncated();
+                        range = (range << 8) >>> 0;
+                        code = ((code << 8) | input[inPos++]) >>> 0;
+                    }
+                    // rep0: a single byte ("short rep") or a longer match?
+                    i = lzma_coder_1.IS_REP0_LONG + (state << 4) + posState;
+                    prob = probs[i];
+                    bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                    if (code < bound) {
+                        range = bound;
+                        probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                        if (range < range_coder_1.TOP_VALUE) {
+                            if (inPos >= inputEnd)
+                                throw truncated();
+                            range = (range << 8) >>> 0;
+                            code = ((code << 8) | input[inPos++]) >>> 0;
+                        }
+                        state = (0, lzma_coder_1.stateAfterShortRep)(state);
+                        if (outPos >= outLimit)
+                            throw exceedsSize();
+                        lz.repeat(rep0, 1);
+                        ++outPos;
+                        continue;
+                    }
+                    range -= bound;
+                    code -= bound;
+                    probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                    if (range < range_coder_1.TOP_VALUE) {
+                        if (inPos >= inputEnd)
+                            throw truncated();
+                        range = (range << 8) >>> 0;
+                        code = ((code << 8) | input[inPos++]) >>> 0;
+                    }
+                }
+                else {
+                    range -= bound;
+                    code -= bound;
+                    probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                    if (range < range_coder_1.TOP_VALUE) {
+                        if (inPos >= inputEnd)
+                            throw truncated();
+                        range = (range << 8) >>> 0;
+                        code = ((code << 8) | input[inPos++]) >>> 0;
+                    }
+                    let dist;
+                    // rep1, or rep2/rep3?
+                    i = lzma_coder_1.IS_REP1 + state;
+                    prob = probs[i];
+                    bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                    if (code < bound) {
+                        range = bound;
+                        probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                        dist = rep1;
+                    }
+                    else {
+                        range -= bound;
+                        code -= bound;
+                        probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                        if (range < range_coder_1.TOP_VALUE) {
+                            if (inPos >= inputEnd)
+                                throw truncated();
+                            range = (range << 8) >>> 0;
+                            code = ((code << 8) | input[inPos++]) >>> 0;
+                        }
+                        // rep2 or rep3?
+                        i = lzma_coder_1.IS_REP2 + state;
+                        prob = probs[i];
+                        bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                        if (code < bound) {
+                            range = bound;
+                            probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                            dist = rep2;
+                        }
+                        else {
+                            range -= bound;
+                            code -= bound;
+                            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                            dist = rep3;
+                            rep3 = rep2;
+                        }
+                        rep2 = rep1;
+                    }
+                    if (range < range_coder_1.TOP_VALUE) {
+                        if (inPos >= inputEnd)
+                            throw truncated();
+                        range = (range << 8) >>> 0;
+                        code = ((code << 8) | input[inPos++]) >>> 0;
+                    }
+                    rep1 = rep0;
+                    rep0 = dist;
+                }
+                state = (0, lzma_coder_1.stateAfterLongRep)(state);
+                lenCoder = lzma_coder_1.REP_LEN;
+            }
+            // -- Length: choice bits select the low, mid or high tree --
+            let treeOffset;
+            let treeBits;
+            let len;
+            i = lenCoder + lzma_coder_1.LEN_CHOICE;
+            prob = probs[i];
+            bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+            if (code < bound) {
+                range = bound;
+                probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                treeOffset = lenCoder + lzma_coder_1.LEN_LOW + posState * lzma_coder_1.LOW_SYMBOLS;
+                treeBits = 3;
+                len = lzma_coder_1.MATCH_LEN_MIN;
+            }
+            else {
+                range -= bound;
+                code -= bound;
+                probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                if (range < range_coder_1.TOP_VALUE) {
+                    if (inPos >= inputEnd)
+                        throw truncated();
+                    range = (range << 8) >>> 0;
+                    code = ((code << 8) | input[inPos++]) >>> 0;
+                }
+                i = lenCoder + lzma_coder_1.LEN_CHOICE2;
+                prob = probs[i];
+                bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                if (code < bound) {
+                    range = bound;
+                    probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                    treeOffset = lenCoder + lzma_coder_1.LEN_MID + posState * lzma_coder_1.MID_SYMBOLS;
+                    treeBits = 3;
+                    len = lzma_coder_1.MATCH_LEN_MIN + lzma_coder_1.LOW_SYMBOLS;
+                }
+                else {
+                    range -= bound;
+                    code -= bound;
+                    probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                    treeOffset = lenCoder + lzma_coder_1.LEN_HIGH;
+                    treeBits = 8;
+                    len = lzma_coder_1.MATCH_LEN_MIN + lzma_coder_1.LOW_SYMBOLS + lzma_coder_1.MID_SYMBOLS;
+                }
+            }
+            if (range < range_coder_1.TOP_VALUE) {
+                if (inPos >= inputEnd)
+                    throw truncated();
+                range = (range << 8) >>> 0;
+                code = ((code << 8) | input[inPos++]) >>> 0;
+            }
+            {
+                const end = 1 << treeBits;
+                let symbol = 1;
+                do {
+                    i = treeOffset + symbol;
+                    prob = probs[i];
+                    bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                    if (code < bound) {
+                        range = bound;
+                        probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                        symbol <<= 1;
+                    }
+                    else {
+                        range -= bound;
+                        code -= bound;
+                        probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                        symbol = (symbol << 1) | 1;
+                    }
+                    if (range < range_coder_1.TOP_VALUE) {
+                        if (inPos >= inputEnd)
+                            throw truncated();
+                        range = (range << 8) >>> 0;
+                        code = ((code << 8) | input[inPos++]) >>> 0;
+                    }
+                } while (symbol < end);
+                len += symbol - end;
+            }
+            // -- Distance (normal matches only) --
+            if (lenCoder === lzma_coder_1.MATCH_LEN) {
+                // Distance slot: 6 bits, MSB first
+                const slotTree = lzma_coder_1.DIST_SLOTS + ((0, lzma_coder_1.getDistState)(len) << lzma_coder_1.DIST_SLOT_BITS);
+                let distSlot = 1;
+                do {
+                    i = slotTree + distSlot;
+                    prob = probs[i];
+                    bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                    if (code < bound) {
+                        range = bound;
+                        probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                        distSlot <<= 1;
+                    }
+                    else {
+                        range -= bound;
+                        code -= bound;
+                        probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                        distSlot = (distSlot << 1) | 1;
+                    }
+                    if (range < range_coder_1.TOP_VALUE) {
+                        if (inPos >= inputEnd)
+                            throw truncated();
+                        range = (range << 8) >>> 0;
+                        code = ((code << 8) | input[inPos++]) >>> 0;
+                    }
+                } while (distSlot < 1 << lzma_coder_1.DIST_SLOT_BITS);
+                distSlot -= 1 << lzma_coder_1.DIST_SLOT_BITS;
+                if (distSlot < lzma_coder_1.DIST_MODEL_START) {
+                    rep0 = distSlot;
+                }
+                else {
+                    // The slot gives the top two bits; the footer bits follow.
+                    const footerBits = (distSlot >>> 1) - 1;
+                    let dist = (2 | (distSlot & 1)) << footerBits;
+                    let reverseTree;
+                    let reverseBits;
+                    if (distSlot < lzma_coder_1.DIST_MODEL_END) {
+                        reverseTree = (0, lzma_coder_1.distSpecialOffset)(distSlot, dist);
+                        reverseBits = footerBits;
+                    }
+                    else {
+                        // Direct bits with a fixed 50% probability, then 4
+                        // align bits with probabilities.
+                        let direct = 0;
+                        for (let k = footerBits - lzma_coder_1.ALIGN_BITS; k > 0; --k) {
+                            range >>>= 1;
+                            let bit = 0;
+                            if (code >= range) {
+                                code -= range;
+                                bit = 1;
+                            }
+                            direct = ((direct << 1) | bit) >>> 0;
+                            if (range < range_coder_1.TOP_VALUE) {
+                                if (inPos >= inputEnd)
+                                    throw truncated();
+                                range = (range << 8) >>> 0;
+                                code = ((code << 8) | input[inPos++]) >>> 0;
+                            }
+                        }
+                        dist |= direct << lzma_coder_1.ALIGN_BITS;
+                        reverseTree = lzma_coder_1.DIST_ALIGN;
+                        reverseBits = lzma_coder_1.ALIGN_BITS;
+                    }
+                    // Footer or align bits, LSB first
+                    let symbol = 1;
+                    for (let k = 0; k < reverseBits; ++k) {
+                        i = reverseTree + symbol;
+                        prob = probs[i];
+                        bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+                        if (code < bound) {
+                            range = bound;
+                            probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+                            symbol <<= 1;
+                        }
+                        else {
+                            range -= bound;
+                            code -= bound;
+                            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
+                            symbol = (symbol << 1) | 1;
+                            dist |= 1 << k;
+                        }
+                        if (range < range_coder_1.TOP_VALUE) {
+                            if (inPos >= inputEnd)
+                                throw truncated();
+                            range = (range << 8) >>> 0;
+                            code = ((code << 8) | input[inPos++]) >>> 0;
+                        }
+                    }
+                    // As int32, the end marker distance 0xFFFFFFFF is -1.
+                    rep0 = dist | 0;
+                    if (rep0 === END_MARKER_DIST) {
+                        endMarker = true;
+                        break;
+                    }
+                }
+            }
+            if (len > outLimit - outPos)
+                throw exceedsSize();
+            lz.repeat(rep0, len);
+            outPos += len;
+        }
+        rc.range = range;
+        rc.code = code;
+        rc.pos = inPos;
+        this.state = state;
+        this.outPos = outPos;
+        reps[0] = rep0;
+        reps[1] = rep1;
+        reps[2] = rep2;
+        reps[3] = rep3;
+        return endMarker;
+    }
+}
+exports.LzmaDecoder = LzmaDecoder;
+function truncated() {
+    return new Error('Truncated input');
+}
+function exceedsSize() {
+    return new Error('Corrupted input: data exceeds the declared size');
+}

package/dist/lzma1/lzma-encoder-fast.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Fast LZMA encoder: picks symbols with simple heuristics, similar to a
+ * lazy-matching LZ77 encoder.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+import { LzmaEncoder } from './lzma-encoder';
+export declare const FAST_EXTRA_SIZE_BEFORE = 1;
+export declare const FAST_EXTRA_SIZE_AFTER: number;
+export declare class LzmaEncoderFast extends LzmaEncoder {
+    private matches;
+    protected getNextSymbol(): number;
+}

package/dist/lzma1/lzma-encoder-fast.js

@@ -0,0 +1,114 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * Fast LZMA encoder: picks symbols with simple heuristics, similar to a
+ * lazy-matching LZ77 encoder.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LzmaEncoderFast = exports.FAST_EXTRA_SIZE_AFTER = exports.FAST_EXTRA_SIZE_BEFORE = void 0;
+const lzma_coder_1 = require("./lzma-coder");
+const lzma_encoder_1 = require("./lzma-encoder");
+exports.FAST_EXTRA_SIZE_BEFORE = 1;
+exports.FAST_EXTRA_SIZE_AFTER = lzma_coder_1.MATCH_LEN_MAX - 1;
+/** True if `smallDist` is so much shorter that it's worth a byte of length. */
+function changePair(smallDist, bigDist) {
+    return smallDist < bigDist >>> 7;
+}
+class LzmaEncoderFast extends lzma_encoder_1.LzmaEncoder {
+    matches = null;
+    getNextSymbol() {
+        // Get the matches for the next byte unless they were already read
+        // during the previous call.
+        if (this.readAhead === -1) {
+            this.matches = this.getMatches();
+        }
+        this.back = -1;
+        // Not enough bytes left for a match: encode a literal.
+        const avail = Math.min(this.lz.getAvail(), lzma_coder_1.MATCH_LEN_MAX);
+        if (avail < lzma_coder_1.MATCH_LEN_MIN) {
+            return 1;
+        }
+        // Look for a match at one of the four recent distances.
+        let bestRepLen = 0;
+        let bestRepIndex = 0;
+        for (let rep = 0; rep < lzma_coder_1.REPS; ++rep) {
+            const len = this.lz.getMatchLen(0, this.reps[rep], avail);
+            if (len < lzma_coder_1.MATCH_LEN_MIN)
+                continue;
+            // Long enough: take it.
+            if (len >= this.niceLen) {
+                this.back = rep;
+                this.skip(len - 1);
+                return len;
+            }
+            if (len > bestRepLen) {
+                bestRepIndex = rep;
+                bestRepLen = len;
+            }
+        }
+        let mainLen = 0;
+        let mainDist = 0;
+        let matches = this.matches;
+        if (matches === null)
+            throw new Error('No matches were read');
+        if (matches.count > 0) {
+            mainLen = matches.len[matches.count - 1];
+            mainDist = matches.dist[matches.count - 1];
+            if (mainLen >= this.niceLen) {
+                this.back = mainDist + lzma_coder_1.REPS;
+                this.skip(mainLen - 1);
+                return mainLen;
+            }
+            // Prefer a one byte shorter match if its distance is much smaller.
+            while (matches.count > 1 && mainLen === matches.len[matches.count - 2] + 1) {
+                if (!changePair(matches.dist[matches.count - 2], mainDist))
+                    break;
+                --matches.count;
+                mainLen = matches.len[matches.count - 1];
+                mainDist = matches.dist[matches.count - 1];
+            }
+            // A 2-byte match with a big distance costs more than two literals.
+            if (mainLen === lzma_coder_1.MATCH_LEN_MIN && mainDist >= 0x80) {
+                mainLen = 1;
+            }
+        }
+        // Prefer a rep match unless the normal match is clearly longer.
+        if (bestRepLen >= lzma_coder_1.MATCH_LEN_MIN) {
+            if (bestRepLen + 1 >= mainLen || (bestRepLen + 2 >= mainLen && mainDist >= 1 << 9) || (bestRepLen + 3 >= mainLen && mainDist >= 1 << 15)) {
+                this.back = bestRepIndex;
+                this.skip(bestRepLen - 1);
+                return bestRepLen;
+            }
+        }
+        if (mainLen < lzma_coder_1.MATCH_LEN_MIN || avail <= lzma_coder_1.MATCH_LEN_MIN) {
+            return 1;
+        }
+        // Lazy matching: if the next position has a better match, encode
+        // the current byte as a literal.
+        this.matches = this.getMatches();
+        matches = this.matches;
+        if (matches.count > 0) {
+            const newLen = matches.len[matches.count - 1];
+            const newDist = matches.dist[matches.count - 1];
+            if ((newLen >= mainLen && newDist < mainDist) ||
+                (newLen === mainLen + 1 && !changePair(mainDist, newDist)) ||
+                newLen > mainLen + 1 ||
+                (newLen + 1 >= mainLen && mainLen >= lzma_coder_1.MATCH_LEN_MIN + 1 && changePair(newDist, mainDist))) {
+                return 1;
+            }
+        }
+        // A rep match of almost the same length is cheaper.
+        const limit = Math.max(mainLen - 1, lzma_coder_1.MATCH_LEN_MIN);
+        for (let rep = 0; rep < lzma_coder_1.REPS; ++rep) {
+            if (this.lz.getMatchLen(0, this.reps[rep], limit) === limit) {
+                return 1;
+            }
+        }
+        this.back = mainDist + lzma_coder_1.REPS;
+        this.skip(mainLen - 2);
+        return mainLen;
+    }
+}
+exports.LzmaEncoderFast = LzmaEncoderFast;