lzma1 0.1.2 → 0.3.0

package/lib/match-finder.js

@@ -0,0 +1,402 @@
+import { CRC32_TABLE, DICTIONARY_SIZE_THRESHOLD, } from "./utils.js";
+/**
+ * BinTreeMatchFinder — Binary tree match finder for LZMA encoding.
+ *
+ * Combines input window management, hash-based match finding, and
+ * binary tree search into a single cohesive class.
+ */
+export class BinTreeMatchFinder {
+    // Input window fields
+    _posLimit = 0;
+    _bufferBase = new Uint8Array(0);
+    _pos = 0;
+    _streamPos = 0;
+    _streamEndWasReached = 0;
+    _bufferOffset = 0;
+    _blockSize = 0;
+    _keepSizeBefore = 0;
+    _keepSizeAfter = 0;
+    _pointerToLastSafePosition = 0;
+    _stream = null;
+    // Hash and tree fields
+    HASH_ARRAY = true;
+    kNumHashDirectBytes = 0;
+    kMinMatchCheck = 4;
+    kFixHashSize = 66560;
+    _hashMask = 0;
+    _hashSizeSum = 0;
+    _hash = new Int32Array(0);
+    _cyclicBufferSize = 0;
+    _cyclicBufferPos = 0;
+    _son = new Int32Array(0);
+    _matchMaxLen = 0;
+    _cutValue = 0xff;
+    // --- LzInWindow methods ---
+    getIndexByte(index) {
+        return this._bufferBase[this._bufferOffset + this._pos + index];
+    }
+    getMatchLen(index, distance, limit) {
+        if (this._streamEndWasReached) {
+            if (this._pos + index + limit > this._streamPos) {
+                limit = this._streamPos - (this._pos + index);
+            }
+        }
+        ++distance;
+        let i;
+        const pby = this._bufferOffset + this._pos + index;
+        for (i = 0; i < limit
+            && this._bufferBase[pby + i]
+                == this._bufferBase[pby + i - distance]; ++i)
+            ;
+        return i;
+    }
+    getNumAvailableBytes() {
+        return this._streamPos - this._pos;
+    }
+    moveBlock() {
+        let offset = this._bufferOffset + this._pos - this._keepSizeBefore;
+        if (offset > 0) {
+            --offset;
+        }
+        const numBytes = this._bufferOffset + this._streamPos - offset;
+        this._bufferBase.copyWithin(0, offset, offset + numBytes);
+        this._bufferOffset -= offset;
+    }
+    movePosInWindow() {
+        this._pos += 1;
+        if (this._pos > this._posLimit) {
+            const pointerToPosition = this._bufferOffset + this._pos;
+            if (pointerToPosition > this._pointerToLastSafePosition) {
+                this.moveBlock();
+            }
+            this.readBlock();
+        }
+    }
+    readBlock() {
+        if (this._streamEndWasReached) {
+            return;
+        }
+        while (true) {
+            const size = -this._bufferOffset + this._blockSize - this._streamPos;
+            if (!size) {
+                return;
+            }
+            const bytesRead = this.readFromStream(this._bufferOffset + this._streamPos, size);
+            if (bytesRead == -1) {
+                this._posLimit = this._streamPos;
+                const pointerToPosition = this._bufferOffset + this._posLimit;
+                if (pointerToPosition > this._pointerToLastSafePosition) {
+                    this._posLimit = this._pointerToLastSafePosition - this._bufferOffset;
+                }
+                this._streamEndWasReached = 1;
+                return;
+            }
+            this._streamPos += bytesRead;
+            if (this._streamPos >= this._pos + this._keepSizeAfter) {
+                this._posLimit = this._streamPos - this._keepSizeAfter;
+            }
+        }
+    }
+    reduceOffsets(subValue) {
+        this._bufferOffset += subValue;
+        this._posLimit -= subValue;
+        this._pos -= subValue;
+        this._streamPos -= subValue;
+    }
+    readFromStream(off, len) {
+        const stream = this._stream;
+        const buffer = this._bufferBase;
+        return stream.readBytes(buffer, off, len);
+    }
+    // --- Match finder configuration methods ---
+    createBuffers(keepSizeBefore, keepSizeAfter, keepSizeReserv) {
+        this._keepSizeBefore = keepSizeBefore;
+        this._keepSizeAfter = keepSizeAfter;
+        const blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
+        if (this._blockSize != blockSize) {
+            this._bufferBase = new Uint8Array(blockSize);
+            this._blockSize = blockSize;
+        }
+        this._pointerToLastSafePosition = this._blockSize - keepSizeAfter;
+    }
+    create(dictionarySize, numFastBytes, keepAddBufferBefore, keepAddBufferAfter) {
+        if (dictionarySize < DICTIONARY_SIZE_THRESHOLD) {
+            this._cutValue = 0x10 + (numFastBytes >> 1);
+            const windowReservSize = ~~((dictionarySize + keepAddBufferBefore + numFastBytes + keepAddBufferAfter) / 2) + 0x100;
+            this.createBuffers(dictionarySize + keepAddBufferBefore, numFastBytes + keepAddBufferAfter, windowReservSize);
+            this._matchMaxLen = numFastBytes;
+            // Ensure cyclic buffer
+            const cyclicBufferSize = dictionarySize + 1;
+            if (this._cyclicBufferSize !== cyclicBufferSize) {
+                this._cyclicBufferSize = cyclicBufferSize;
+                this._son = new Int32Array(cyclicBufferSize * 2);
+            }
+            // Compute hash size
+            let hs = 0x10000;
+            if (this.HASH_ARRAY) {
+                hs = dictionarySize - 1;
+                hs |= hs >> 1;
+                hs |= hs >> 2;
+                hs |= hs >> 4;
+                hs |= hs >> 0x08;
+                hs >>= 1;
+                hs |= 0xFFFF;
+                if (hs > 0x1000000) {
+                    hs >>= 1;
+                }
+                this._hashMask = hs;
+                hs += 1;
+                const finalHashSizeSum = hs + this.kFixHashSize;
+                if (finalHashSizeSum !== this._hashSizeSum) {
+                    this._hashSizeSum = finalHashSizeSum;
+                    this._hash = new Int32Array(finalHashSizeSum);
+                }
+            }
+            else {
+                if (hs !== this._hashSizeSum) {
+                    this._hashSizeSum = hs;
+                    this._hash = new Int32Array(hs);
+                }
+            }
+        }
+    }
+    // --- Match finding methods ---
+    getMatches(distances) {
+        let count, cur, curMatch, curMatch2, curMatch3, cyclicPos, delta, hash2Value, hash3Value, hashValue, len, len0, len1, lenLimit, matchMinPos, maxLen, offset, pby1, ptr0, ptr1, temp;
+        if (this._pos + this._matchMaxLen <= this._streamPos) {
+            lenLimit = this._matchMaxLen;
+        }
+        else {
+            lenLimit = this._streamPos - this._pos;
+            if (lenLimit < this.kMinMatchCheck) {
+                this.movePos();
+                return 0;
+            }
+        }
+        offset = 0;
+        matchMinPos = this._pos > this._cyclicBufferSize
+            ? this._pos - this._cyclicBufferSize
+            : 0;
+        cur = this._bufferOffset + this._pos;
+        maxLen = 1;
+        hash2Value = 0;
+        hash3Value = 0;
+        if (this.HASH_ARRAY) {
+            temp = CRC32_TABLE[this._bufferBase[cur]] ^ this._bufferBase[cur + 1];
+            hash2Value = temp & 0x3FF;
+            temp ^= this._bufferBase[cur + 2] << 0x08;
+            hash3Value = temp & 0xFFFF;
+            hashValue = (temp ^ (CRC32_TABLE[this._bufferBase[cur + 3]] << 5)) & this._hashMask;
+        }
+        else {
+            hashValue = this._bufferBase[cur] ^ (this._bufferBase[cur + 1] << 0x08);
+        }
+        curMatch = this._hash[this.kFixHashSize + hashValue] || 0;
+        if (this.HASH_ARRAY) {
+            curMatch2 = this._hash[hash2Value] || 0;
+            curMatch3 = this._hash[0x400 + hash3Value] || 0;
+            this._hash[hash2Value] = this._pos;
+            this._hash[0x400 + hash3Value] = this._pos;
+            if (curMatch2 > matchMinPos) {
+                if (this._bufferBase[this._bufferOffset + curMatch2] == this._bufferBase[cur]) {
+                    distances[offset++] = maxLen = 2;
+                    distances[offset++] = this._pos - curMatch2 - 1;
+                }
+            }
+            if (curMatch3 > matchMinPos) {
+                if (this._bufferBase[this._bufferOffset + curMatch3] == this._bufferBase[cur]) {
+                    if (curMatch3 == curMatch2) {
+                        offset -= 2;
+                    }
+                    distances[offset++] = maxLen = 3;
+                    distances[offset++] = this._pos - curMatch3 - 1;
+                    curMatch2 = curMatch3;
+                }
+            }
+            if (offset != 0 && curMatch2 == curMatch) {
+                offset -= 2;
+                maxLen = 1;
+            }
+        }
+        this._hash[this.kFixHashSize + hashValue] = this._pos;
+        ptr0 = (this._cyclicBufferPos << 1) + 1;
+        ptr1 = this._cyclicBufferPos << 1;
+        len0 = len1 = this.kNumHashDirectBytes;
+        if (this.kNumHashDirectBytes != 0) {
+            if (curMatch > matchMinPos) {
+                if (this._bufferBase[this._bufferOffset + curMatch + this.kNumHashDirectBytes] != this._bufferBase[cur + this.kNumHashDirectBytes]) {
+                    distances[offset++] = maxLen = this.kNumHashDirectBytes;
+                    distances[offset++] = this._pos - curMatch - 1;
+                }
+            }
+        }
+        count = this._cutValue;
+        while (1) {
+            if (curMatch <= matchMinPos || count == 0) {
+                count -= 1;
+                this._son[ptr0] = this._son[ptr1] = 0;
+                break;
+            }
+            delta = this._pos - curMatch;
+            cyclicPos = (delta <= this._cyclicBufferPos
+                ? this._cyclicBufferPos - delta
+                : this._cyclicBufferPos - delta + this._cyclicBufferSize) << 1;
+            pby1 = this._bufferOffset + curMatch;
+            len = len0 < len1 ? len0 : len1;
+            if (this._bufferBase[pby1 + len] == this._bufferBase[cur + len]) {
+                while ((len += 1) != lenLimit) {
+                    if (this._bufferBase[pby1 + len] != this._bufferBase[cur + len]) {
+                        break;
+                    }
+                }
+                if (maxLen < len) {
+                    distances[offset++] = maxLen = len;
+                    distances[offset++] = delta - 1;
+                    if (len == lenLimit) {
+                        this._son[ptr1] = this._son[cyclicPos];
+                        this._son[ptr0] = this._son[cyclicPos + 1];
+                        break;
+                    }
+                }
+            }
+            if (this._bufferBase[pby1 + len] < this._bufferBase[cur + len]) {
+                this._son[ptr1] = curMatch;
+                ptr1 = cyclicPos + 1;
+                curMatch = this._son[ptr1];
+                len1 = len;
+            }
+            else {
+                this._son[ptr0] = curMatch;
+                ptr0 = cyclicPos;
+                curMatch = this._son[ptr0];
+                len0 = len;
+            }
+        }
+        this.movePos();
+        return offset;
+    }
+    skip(num) {
+        let count, cur, curMatch, cyclicPos, delta, hash2Value, hash3Value, hashValue, len, len0, len1, lenLimit, matchMinPos, pby1, ptr0, ptr1, temp;
+        do {
+            if (this._pos + this._matchMaxLen <= this._streamPos) {
+                lenLimit = this._matchMaxLen;
+            }
+            else {
+                lenLimit = this._streamPos - this._pos;
+                if (lenLimit < this.kMinMatchCheck) {
+                    this.movePos();
+                    continue;
+                }
+            }
+            matchMinPos = this._pos > this._cyclicBufferSize
+                ? this._pos - this._cyclicBufferSize
+                : 0;
+            cur = this._bufferOffset + this._pos;
+            if (this.HASH_ARRAY) {
+                temp = CRC32_TABLE[this._bufferBase[cur]] ^ this._bufferBase[cur + 1];
+                hash2Value = temp & 0x3FF;
+                this._hash[hash2Value] = this._pos;
+                temp ^= this._bufferBase[cur + 2] << 0x08;
+                hash3Value = temp & 0xFFFF;
+                this._hash[0x400 + hash3Value] = this._pos;
+                hashValue = (temp ^ (CRC32_TABLE[this._bufferBase[cur + 3]] << 5)) & this._hashMask;
+            }
+            else {
+                hashValue = this._bufferBase[cur] ^ (this._bufferBase[cur + 1] << 0x08);
+            }
+            curMatch = this._hash[this.kFixHashSize + hashValue];
+            this._hash[this.kFixHashSize + hashValue] = this._pos;
+            ptr0 = (this._cyclicBufferPos << 1) + 1;
+            ptr1 = this._cyclicBufferPos << 1;
+            len0 = len1 = this.kNumHashDirectBytes;
+            count = this._cutValue;
+            while (1) {
+                if (curMatch <= matchMinPos || count == 0) {
+                    count -= 1;
+                    this._son[ptr0] = this._son[ptr1] = 0;
+                    break;
+                }
+                delta = this._pos - curMatch;
+                cyclicPos = (delta <= this._cyclicBufferPos
+                    ? this._cyclicBufferPos - delta
+                    : this._cyclicBufferPos - delta + this._cyclicBufferSize) << 1;
+                pby1 = this._bufferOffset + curMatch;
+                len = len0 < len1 ? len0 : len1;
+                if (this._bufferBase[pby1 + len] == this._bufferBase[cur + len]) {
+                    while ((len += 1) != lenLimit) {
+                        if (this._bufferBase[pby1 + len] != this._bufferBase[cur + len]) {
+                            break;
+                        }
+                    }
+                    if (len == lenLimit) {
+                        this._son[ptr1] = this._son[cyclicPos];
+                        this._son[ptr0] = this._son[cyclicPos + 1];
+                        break;
+                    }
+                }
+                if (this._bufferBase[pby1 + len] < this._bufferBase[cur + len]) {
+                    this._son[ptr1] = curMatch;
+                    ptr1 = cyclicPos + 1;
+                    curMatch = this._son[ptr1];
+                    len1 = len;
+                }
+                else {
+                    this._son[ptr0] = curMatch;
+                    ptr0 = cyclicPos;
+                    curMatch = this._son[ptr0];
+                    len0 = len;
+                }
+            }
+            this.movePos();
+        } while ((num -= 1) != 0);
+    }
+    movePos() {
+        if ((this._cyclicBufferPos += 1) >= this._cyclicBufferSize) {
+            this._cyclicBufferPos = 0;
+        }
+        this.movePosInWindow();
+        if (this._pos == DICTIONARY_SIZE_THRESHOLD) {
+            const subValue = this._pos - this._cyclicBufferSize;
+            this.normalizeLinks(this._son, this._cyclicBufferSize * 2, subValue);
+            this.normalizeLinks(this._hash, this._hashSizeSum, subValue);
+            this.reduceOffsets(subValue);
+        }
+    }
+    init() {
+        this._bufferOffset = 0;
+        this._pos = 0;
+        this._streamPos = 0;
+        this._streamEndWasReached = 0;
+        this.readBlock();
+        this._cyclicBufferPos = 0;
+        this.reduceOffsets(-1);
+    }
+    /**
+     * This is only called after reading one whole gigabyte.
+     */
+    normalizeLinks(items, numItems, subValue) {
+        for (let i = 0; i < numItems; ++i) {
+            let value = items[i];
+            if (value <= subValue) {
+                value = 0;
+            }
+            else {
+                value -= subValue;
+            }
+            items[i] = value;
+        }
+    }
+    setType(numHashBytes) {
+        this.HASH_ARRAY = numHashBytes > 2;
+        if (this.HASH_ARRAY) {
+            this.kNumHashDirectBytes = 0;
+            this.kMinMatchCheck = 4;
+            this.kFixHashSize = 66560;
+        }
+        else {
+            this.kNumHashDirectBytes = 2;
+            this.kMinMatchCheck = 3;
+            this.kFixHashSize = 0;
+        }
+    }
+}

package/lib/range-bit-tree-coder.js

@@ -0,0 +1,95 @@
+import { getBitPrice, initArray, } from "./utils.js";
+export class RangeBitTreeCoder {
+    models;
+    numBitLevels;
+    constructor(numBitLevels) {
+        this.numBitLevels = numBitLevels;
+        this.models = initArray(1 << numBitLevels, 1024); // Initialize with default probability
+    }
+    /**
+     * Decode symbol using range decoder
+     */
+    decode(rd) {
+        let res = 1;
+        for (let bitIndex = this.numBitLevels; bitIndex !== 0; bitIndex--) {
+            const bit = rd.decodeBit(this.models, res);
+            res = (res << 1) + bit;
+        }
+        res -= 1 << this.numBitLevels;
+        return res;
+    }
+    /**
+     * Reverse decode symbol using range decoder
+     */
+    reverseDecode(rd) {
+        let index = 1;
+        let res = 0;
+        for (let bitIndex = 0; bitIndex < this.numBitLevels; bitIndex++) {
+            const bit = rd.decodeBit(this.models, index);
+            index <<= 1;
+            index += bit;
+            res |= bit << bitIndex;
+        }
+        return res;
+    }
+    /**
+     * Encode symbol using range encoder
+     */
+    encode(re, symbol) {
+        let m = 1;
+        for (let bitIndex = this.numBitLevels; bitIndex !== 0;) {
+            bitIndex--;
+            const bit = (symbol >> bitIndex) & 1;
+            re.encodeBit(this.models, m, bit);
+            m = (m << 1) | bit;
+        }
+    }
+    /**
+     * Reverse encode symbol using range encoder
+     */
+    reverseEncode(re, symbol) {
+        let m = 1;
+        for (let i = 0; i < this.numBitLevels; i++) {
+            const bit = symbol & 1;
+            re.encodeBit(this.models, m, bit);
+            m = (m << 1) | bit;
+            symbol >>= 1;
+        }
+    }
+    /**
+     * Get price for encoding symbol
+     */
+    getPrice(symbol) {
+        let res = 0;
+        let m = 1;
+        for (let bitIndex = this.numBitLevels; bitIndex !== 0;) {
+            bitIndex--;
+            const bit = (symbol >> bitIndex) & 1;
+            res += getBitPrice(this.models[m], bit);
+            m = (m << 1) + bit;
+        }
+        return res;
+    }
+    /**
+     * Get price for reverse encoding symbol
+     */
+    reverseGetPrice(symbol) {
+        let res = 0;
+        let m = 1;
+        for (let i = this.numBitLevels; i !== 0; i--) {
+            const bit = symbol & 1;
+            symbol >>= 1;
+            res += getBitPrice(this.models[m], bit);
+            m = (m << 1) | bit;
+        }
+        return res;
+    }
+    /**
+     * Reset models to initial state
+     */
+    reset() {
+        for (let i = 0; i < this.models.length; i++) {
+            this.models[i] = 1024; // Default probability
+        }
+    }
+}

package/lib/range-decoder.js

@@ -0,0 +1,85 @@
+export class RangeDecoder {
+    stream = null;
+    code = 0;
+    rrange = 0;
+    /**
+     * Set input stream for decoding
+     */
+    setStream(stream) {
+        this.stream = stream;
+    }
+    /**
+     * Initialize range decoder
+     */
+    init() {
+        this.code = 0;
+        this.rrange = -1;
+        for (let i = 0; i < 5; ++i) {
+            this.code = this.code << 8 | this.readFromStream();
+        }
+    }
+    /**
+     * Decode a single bit using probability model
+     */
+    decodeBit(probs, index) {
+        let newBound, prob = probs[index];
+        newBound = (this.rrange >>> 11) * prob;
+        if ((this.code ^ -0x80000000) < (newBound ^ -0x80000000)) {
+            this.rrange = newBound;
+            probs[index] = prob + ((2048 - prob) >>> 5);
+            if (!(this.rrange & -0x1000000)) {
+                this.code = this.code << 8 | this.readFromStream();
+                this.rrange <<= 8;
+            }
+            return 0;
+        }
+        else {
+            this.rrange -= newBound;
+            this.code -= newBound;
+            probs[index] = prob - (prob >>> 5);
+            if (!(this.rrange & -0x1000000)) {
+                this.code = this.code << 8 | this.readFromStream();
+                this.rrange <<= 8;
+            }
+            return 1;
+        }
+    }
+    /**
+     * Decode direct bits (without probability model)
+     */
+    decodeDirectBits(numTotalBits) {
+        let result = 0;
+        for (let i = numTotalBits; i != 0; i -= 1) {
+            this.rrange >>>= 1;
+            let t = (this.code - this.rrange) >>> 31;
+            this.code -= this.rrange & (t - 1);
+            result = result << 1 | 1 - t;
+            if (!(this.rrange & -0x1000000)) {
+                this.code = this.code << 8 | this.readFromStream();
+                this.rrange <<= 8;
+            }
+        }
+        return result;
+    }
+    /**
+     * Get current code value (for compatibility)
+     */
+    get currentCode() {
+        return this.code;
+    }
+    /**
+     * Get current range value (for compatibility)
+     */
+    get currentRange() {
+        return this.rrange;
+    }
+    /**
+     * Read a single byte from the input stream
+     */
+    readFromStream() {
+        if (!this.stream) {
+            return 0;
+        }
+        return this.stream.readByte();
+    }
+}

package/lib/range-encoder.js

@@ -0,0 +1,119 @@
+export class RangeEncoder {
+    stream = null;
+    low = 0n;
+    rrange = 0;
+    cache = 0;
+    cacheSize = 0;
+    position = 0n;
+    constructor() {
+        // Initialize with default values
+    }
+    /**
+     * Set output stream for encoding
+     */
+    setStream(stream) {
+        this.stream = stream;
+    }
+    /**
+     * Initialize range encoder
+     */
+    init() {
+        this.position = 0n;
+        this.low = 0n;
+        this.rrange = -1;
+        this.cacheSize = 1;
+        this.cache = 0;
+    }
+    /**
+     * Encode a single bit using probability model
+     */
+    encodeBit(probs, index, bit) {
+        const prob = probs[index];
+        const newBound = (this.rrange >>> 11) * prob;
+        if (bit === 0) {
+            this.rrange = newBound;
+            probs[index] = prob + ((2048 - prob) >>> 5);
+        }
+        else {
+            this.low += BigInt(newBound);
+            this.rrange -= newBound;
+            probs[index] = prob - (prob >>> 5);
+        }
+        if (!(this.rrange & -0x1000000)) {
+            this.rrange <<= 8;
+            this.shiftLow();
+        }
+    }
+    /**
+     * Encode direct bits (without probability model)
+     */
+    encodeDirectBits(value, numTotalBits) {
+        for (let i = numTotalBits - 1; i >= 0; i--) {
+            this.rrange >>>= 1;
+            if (((value >>> i) & 1) === 1) {
+                this.low += BigInt(this.rrange);
+            }
+            if (!(this.rrange & -0x1000000)) {
+                this.rrange <<= 8;
+                this.shiftLow();
+            }
+        }
+    }
+    /**
+     * Encode bit tree symbol
+     */
+    encodeBitTree(numBitLevels, models, symbol, startIndex = 1) {
+        let m = 1;
+        for (let bitIndex = numBitLevels; bitIndex !== 0; bitIndex--) {
+            const bit = (symbol >>> (bitIndex - 1)) & 1;
+            this.encodeBit(models, startIndex + m - 1, bit);
+            m = (m << 1) | bit;
+        }
+    }
+    /**
+     * Reverse encode bits
+     */
+    reverseEncodeBits(numBitLevels, models, symbol, startIndex) {
+        let m = 1;
+        for (let i = 0; i < numBitLevels; i++) {
+            const bit = symbol & 1;
+            this.encodeBit(models, startIndex + m, bit);
+            m = (m << 1) | bit;
+            symbol >>>= 1;
+        }
+    }
+    /**
+     * Finish encoding and flush remaining data
+     */
+    finish() {
+        for (let i = 0; i < 5; i++) {
+            this.shiftLow();
+        }
+    }
+    /**
+     * Shift low value and write to stream
+     */
+    shiftLow() {
+        const lowHi = Number((this.low >> 32n) & 0xffffffffn);
+        if (lowHi !== 0 || Number(this.low & 0xffffffffn) < 0xFF000000) {
+            this.position += BigInt(this.cacheSize);
+            let temp = this.cache;
+            do {
+                this.writeToStream(temp + lowHi);
+                temp = 255;
+            } while (--this.cacheSize !== 0);
+            this.cache = (Number(this.low & 0xffffffffn) >>> 24) & 0xFF;
+        }
+        this.cacheSize++;
+        this.low = BigInt(Number(this.low & 0xffffffffn) & 0xFFFFFF) << 8n;
+    }
+    /**
+     * Write byte to output stream
+     */
+    writeToStream(value) {
+        if (!this.stream) {
+            return;
+        }
+        this.stream.writeByte(value & 0xFF);
+    }
+}