lzma
Version:
A JavaScript implementation of the Lempel-Ziv-Markov (LZMA) chain compression algorithm
1,184 lines (1,106 loc) • 85.6 kB
JavaScript
///NOTE: This file was generated by minify.js from lzma_worker.js. Do not modify.
/// © 2015 Nathan Rugg <nmrugg@gmail.com> | MIT
/// See LICENSE for more details.
/* jshint noarg:true, boss:true, unused:strict, strict:true, undef:true, noarg: true, forin:true, evil:true, newcap:false, -W041, -W021, worker:true, browser:true, node:true */
/* global setImmediate, setTimeout, window, onmessage */
var LZMA = (function () {
"use strict";
var /** cs */
action_compress = 1,
/** ce */
action_progress = 3,
wait = typeof setImmediate == "function" ? setImmediate : setTimeout,
__4294967296 = 4294967296,
N1_longLit = [4294967295, -__4294967296],
/** cs */
MIN_VALUE = [0, -9223372036854775808],
/** ce */
P0_longLit = [0, 0],
P1_longLit = [1, 0];
function update_progress(percent, cbn) {
postMessage({
action: action_progress,
cbn: cbn,
result: percent
});
}
function initDim(len) {
///NOTE: This is MUCH faster than "new Array(len)" in newer versions of v8 (starting with Node.js 0.11.15, which uses v8 3.28.73).
var a = [];
a[len - 1] = undefined;
return a;
}
function add(a, b) {
return create(a[0] + b[0], a[1] + b[1]);
}
/** cs */
function and(a, b) {
return makeFromBits(~~Math.max(Math.min(a[1] / __4294967296, 2147483647), -2147483648) & ~~Math.max(Math.min(b[1] / __4294967296, 2147483647), -2147483648), lowBits_0(a) & lowBits_0(b));
}
/** ce */
function compare(a, b) {
var nega, negb;
if (a[0] == b[0] && a[1] == b[1]) {
return 0;
}
nega = a[1] < 0;
negb = b[1] < 0;
if (nega && !negb) {
return -1;
}
if (!nega && negb) {
return 1;
}
if (sub(a, b)[1] < 0) {
return -1;
}
return 1;
}
function create(valueLow, valueHigh) {
var diffHigh, diffLow;
valueHigh %= 1.8446744073709552E19;
valueLow %= 1.8446744073709552E19;
diffHigh = valueHigh % __4294967296;
diffLow = Math.floor(valueLow / __4294967296) * __4294967296;
valueHigh = valueHigh - diffHigh + diffLow;
valueLow = valueLow - diffLow + diffHigh;
while (valueLow < 0) {
valueLow += __4294967296;
valueHigh -= __4294967296;
}
while (valueLow > 4294967295) {
valueLow -= __4294967296;
valueHigh += __4294967296;
}
valueHigh = valueHigh % 1.8446744073709552E19;
while (valueHigh > 9223372032559808512) {
valueHigh -= 1.8446744073709552E19;
}
while (valueHigh < -9223372036854775808) {
valueHigh += 1.8446744073709552E19;
}
return [valueLow, valueHigh];
}
/** cs */
function eq(a, b) {
return a[0] == b[0] && a[1] == b[1];
}
/** ce */
function fromInt(value) {
if (value >= 0) {
return [value, 0];
} else {
return [value + __4294967296, -__4294967296];
}
}
function lowBits_0(a) {
if (a[0] >= 2147483648) {
return ~~Math.max(Math.min(a[0] - __4294967296, 2147483647), -2147483648);
} else {
return ~~Math.max(Math.min(a[0], 2147483647), -2147483648);
}
}
/** cs */
function makeFromBits(highBits, lowBits) {
var high, low;
high = highBits * __4294967296;
low = lowBits;
if (lowBits < 0) {
low += __4294967296;
}
return [low, high];
}
function pwrAsDouble(n) {
if (n <= 30) {
return 1 << n;
} else {
return pwrAsDouble(30) * pwrAsDouble(n - 30);
}
}
function shl(a, n) {
var diff, newHigh, newLow, twoToN;
n &= 63;
if (eq(a, MIN_VALUE)) {
if (!n) {
return a;
}
return P0_longLit;
}
if (a[1] < 0) {
throw new Error("Neg");
}
twoToN = pwrAsDouble(n);
newHigh = a[1] * twoToN % 1.8446744073709552E19;
newLow = a[0] * twoToN;
diff = newLow - newLow % __4294967296;
newHigh += diff;
newLow -= diff;
if (newHigh >= 9223372036854775807) {
newHigh -= 1.8446744073709552E19;
}
return [newLow, newHigh];
}
function shr(a, n) {
var shiftFact;
n &= 63;
shiftFact = pwrAsDouble(n);
return create(Math.floor(a[0] / shiftFact), a[1] / shiftFact);
}
function shru(a, n) {
var sr;
n &= 63;
sr = shr(a, n);
if (a[1] < 0) {
sr = add(sr, shl([2, 0], 63 - n));
}
return sr;
}
/** ce */
function sub(a, b) {
return create(a[0] - b[0], a[1] - b[1]);
}
function $ByteArrayInputStream(this$static, buf) {
this$static.buf = buf;
this$static.pos = 0;
this$static.count = buf.length;
return this$static;
}
/** cs */
function $read_0(this$static, buf, off, len) {
if (this$static.pos >= this$static.count)
return -1;
len = Math.min(len, this$static.count - this$static.pos);
arraycopy(this$static.buf, this$static.pos, buf, off, len);
this$static.pos += len;
return len;
}
/** ce */
function $ByteArrayOutputStream(this$static) {
this$static.buf = initDim(32);
this$static.count = 0;
return this$static;
}
function $toByteArray(this$static) {
var data = this$static.buf;
data.length = this$static.count;
return data;
}
/** cs */
function $write(this$static, b) {
this$static.buf[this$static.count++] = b << 24 >> 24;
}
/** ce */
function $write_0(this$static, buf, off, len) {
arraycopy(buf, off, this$static.buf, this$static.count, len);
this$static.count += len;
}
/** cs */
function $getChars(this$static, srcBegin, srcEnd, dst, dstBegin) {
var srcIdx;
for (srcIdx = srcBegin; srcIdx < srcEnd; ++srcIdx) {
dst[dstBegin++] = this$static.charCodeAt(srcIdx);
}
}
/** ce */
function arraycopy(src, srcOfs, dest, destOfs, len) {
for (var i = 0; i < len; ++i) {
dest[destOfs + i] = src[srcOfs + i];
}
}
/** cs */
function $configure(this$static, encoder) {
$SetDictionarySize_0(encoder, 1 << this$static.s);
encoder._numFastBytes = this$static.f;
$SetMatchFinder(encoder, this$static.m);
/// lc is always 3
/// lp is always 0
/// pb is always 2
encoder._numLiteralPosStateBits = 0;
encoder._numLiteralContextBits = 3;
encoder._posStateBits = 2;
///this$static._posStateMask = (1 << pb) - 1;
encoder._posStateMask = 3;
}
function $init(this$static, input, output, length_0, mode) {
var encoder, i;
if (compare(length_0, N1_longLit) < 0)
throw new Error("invalid length " + length_0);
this$static.length_0 = length_0;
encoder = $Encoder({});
$configure(mode, encoder);
encoder._writeEndMark = typeof LZMA.disableEndMark == "undefined";
$WriteCoderProperties(encoder, output);
for (i = 0; i < 64; i += 8)
$write(output, lowBits_0(shr(length_0, i)) & 255);
this$static.chunker = (encoder._needReleaseMFStream = 0 , (encoder._inStream = input , encoder._finished = 0 , $Create_2(encoder) , encoder._rangeEncoder.Stream = output , $Init_4(encoder) , $FillDistancesPrices(encoder) , $FillAlignPrices(encoder) , encoder._lenEncoder._tableSize = encoder._numFastBytes + 1 - 2 , $UpdateTables(encoder._lenEncoder, 1 << encoder._posStateBits) , encoder._repMatchLenEncoder._tableSize = encoder._numFastBytes + 1 - 2 , $UpdateTables(encoder._repMatchLenEncoder, 1 << encoder._posStateBits) , encoder.nowPos64 = P0_longLit , undefined) , $Chunker_0({}, encoder));
}
function $LZMAByteArrayCompressor(this$static, data, mode) {
this$static.output = $ByteArrayOutputStream({});
$init(this$static, $ByteArrayInputStream({}, data), this$static.output, fromInt(data.length), mode);
return this$static;
}
/** ce */
/** cs */
function $Create_4(this$static, keepSizeBefore, keepSizeAfter, keepSizeReserv) {
var blockSize;
this$static._keepSizeBefore = keepSizeBefore;
this$static._keepSizeAfter = keepSizeAfter;
blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
if (this$static._bufferBase == null || this$static._blockSize != blockSize) {
this$static._bufferBase = null;
this$static._blockSize = blockSize;
this$static._bufferBase = initDim(this$static._blockSize);
}
this$static._pointerToLastSafePosition = this$static._blockSize - keepSizeAfter;
}
function $GetIndexByte(this$static, index) {
return this$static._bufferBase[this$static._bufferOffset + this$static._pos + index];
}
function $GetMatchLen(this$static, index, distance, limit) {
var i, pby;
if (this$static._streamEndWasReached) {
if (this$static._pos + index + limit > this$static._streamPos) {
limit = this$static._streamPos - (this$static._pos + index);
}
}
++distance;
pby = this$static._bufferOffset + this$static._pos + index;
for (i = 0; i < limit && this$static._bufferBase[pby + i] == this$static._bufferBase[pby + i - distance]; ++i) {
}
return i;
}
function $GetNumAvailableBytes(this$static) {
return this$static._streamPos - this$static._pos;
}
function $MoveBlock(this$static) {
var i, numBytes, offset;
offset = this$static._bufferOffset + this$static._pos - this$static._keepSizeBefore;
if (offset > 0) {
--offset;
}
numBytes = this$static._bufferOffset + this$static._streamPos - offset;
for (i = 0; i < numBytes; ++i) {
this$static._bufferBase[i] = this$static._bufferBase[offset + i];
}
this$static._bufferOffset -= offset;
}
function $MovePos_1(this$static) {
var pointerToPostion;
++this$static._pos;
if (this$static._pos > this$static._posLimit) {
pointerToPostion = this$static._bufferOffset + this$static._pos;
if (pointerToPostion > this$static._pointerToLastSafePosition) {
$MoveBlock(this$static);
}
$ReadBlock(this$static);
}
}
function $ReadBlock(this$static) {
var numReadBytes, pointerToPostion, size;
if (this$static._streamEndWasReached)
return;
while (1) {
size = -this$static._bufferOffset + this$static._blockSize - this$static._streamPos;
if (!size)
return;
numReadBytes = $read_0(this$static._stream, this$static._bufferBase, this$static._bufferOffset + this$static._streamPos, size);
if (numReadBytes == -1) {
this$static._posLimit = this$static._streamPos;
pointerToPostion = this$static._bufferOffset + this$static._posLimit;
if (pointerToPostion > this$static._pointerToLastSafePosition) {
this$static._posLimit = this$static._pointerToLastSafePosition - this$static._bufferOffset;
}
this$static._streamEndWasReached = 1;
return;
}
this$static._streamPos += numReadBytes;
if (this$static._streamPos >= this$static._pos + this$static._keepSizeAfter) {
this$static._posLimit = this$static._streamPos - this$static._keepSizeAfter;
}
}
}
function $ReduceOffsets(this$static, subValue) {
this$static._bufferOffset += subValue;
this$static._posLimit -= subValue;
this$static._pos -= subValue;
this$static._streamPos -= subValue;
}
var CrcTable = (function () {
var i, j, r, CrcTable = [];
for (i = 0; i < 256; ++i) {
r = i;
for (j = 0; j < 8; ++j)
if ((r & 1) != 0) {
r = r >>> 1 ^ -306674912;
} else {
r >>>= 1;
}
CrcTable[i] = r;
}
return CrcTable;
}());
function $Create_3(this$static, historySize, keepAddBufferBefore, matchMaxLen, keepAddBufferAfter) {
var cyclicBufferSize, hs, windowReservSize;
if (historySize < 1073741567) {
this$static._cutValue = 16 + (matchMaxLen >> 1);
windowReservSize = ~~((historySize + keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2) + 256;
$Create_4(this$static, historySize + keepAddBufferBefore, matchMaxLen + keepAddBufferAfter, windowReservSize);
this$static._matchMaxLen = matchMaxLen;
cyclicBufferSize = historySize + 1;
if (this$static._cyclicBufferSize != cyclicBufferSize) {
this$static._son = initDim((this$static._cyclicBufferSize = cyclicBufferSize) * 2);
}
hs = 65536;
if (this$static.HASH_ARRAY) {
hs = historySize - 1;
hs |= hs >> 1;
hs |= hs >> 2;
hs |= hs >> 4;
hs |= hs >> 8;
hs >>= 1;
hs |= 65535;
if (hs > 16777216)
hs >>= 1;
this$static._hashMask = hs;
++hs;
hs += this$static.kFixHashSize;
}
if (hs != this$static._hashSizeSum) {
this$static._hash = initDim(this$static._hashSizeSum = hs);
}
}
}
function $GetMatches(this$static, distances) {
var count, cur, curMatch, curMatch2, curMatch3, cyclicPos, delta, hash2Value, hash3Value, hashValue, len, len0, len1, lenLimit, matchMinPos, maxLen, offset, pby1, ptr0, ptr1, temp;
if (this$static._pos + this$static._matchMaxLen <= this$static._streamPos) {
lenLimit = this$static._matchMaxLen;
} else {
lenLimit = this$static._streamPos - this$static._pos;
if (lenLimit < this$static.kMinMatchCheck) {
$MovePos_0(this$static);
return 0;
}
}
offset = 0;
matchMinPos = this$static._pos > this$static._cyclicBufferSize?this$static._pos - this$static._cyclicBufferSize:0;
cur = this$static._bufferOffset + this$static._pos;
maxLen = 1;
hash2Value = 0;
hash3Value = 0;
if (this$static.HASH_ARRAY) {
temp = CrcTable[this$static._bufferBase[cur] & 255] ^ this$static._bufferBase[cur + 1] & 255;
hash2Value = temp & 1023;
temp ^= (this$static._bufferBase[cur + 2] & 255) << 8;
hash3Value = temp & 65535;
hashValue = (temp ^ CrcTable[this$static._bufferBase[cur + 3] & 255] << 5) & this$static._hashMask;
} else {
hashValue = this$static._bufferBase[cur] & 255 ^ (this$static._bufferBase[cur + 1] & 255) << 8;
}
curMatch = this$static._hash[this$static.kFixHashSize + hashValue] || 0;
if (this$static.HASH_ARRAY) {
curMatch2 = this$static._hash[hash2Value] || 0;
curMatch3 = this$static._hash[1024 + hash3Value] || 0;
this$static._hash[hash2Value] = this$static._pos;
this$static._hash[1024 + hash3Value] = this$static._pos;
if (curMatch2 > matchMinPos) {
if (this$static._bufferBase[this$static._bufferOffset + curMatch2] == this$static._bufferBase[cur]) {
distances[offset++] = maxLen = 2;
distances[offset++] = this$static._pos - curMatch2 - 1;
}
}
if (curMatch3 > matchMinPos) {
if (this$static._bufferBase[this$static._bufferOffset + curMatch3] == this$static._bufferBase[cur]) {
if (curMatch3 == curMatch2) {
offset -= 2;
}
distances[offset++] = maxLen = 3;
distances[offset++] = this$static._pos - curMatch3 - 1;
curMatch2 = curMatch3;
}
}
if (offset != 0 && curMatch2 == curMatch) {
offset -= 2;
maxLen = 1;
}
}
this$static._hash[this$static.kFixHashSize + hashValue] = this$static._pos;
ptr0 = (this$static._cyclicBufferPos << 1) + 1;
ptr1 = this$static._cyclicBufferPos << 1;
len0 = len1 = this$static.kNumHashDirectBytes;
if (this$static.kNumHashDirectBytes != 0) {
if (curMatch > matchMinPos) {
if (this$static._bufferBase[this$static._bufferOffset + curMatch + this$static.kNumHashDirectBytes] != this$static._bufferBase[cur + this$static.kNumHashDirectBytes]) {
distances[offset++] = maxLen = this$static.kNumHashDirectBytes;
distances[offset++] = this$static._pos - curMatch - 1;
}
}
}
count = this$static._cutValue;
while (1) {
if (curMatch <= matchMinPos || count-- == 0) {
this$static._son[ptr0] = this$static._son[ptr1] = 0;
break;
}
delta = this$static._pos - curMatch;
cyclicPos = (delta <= this$static._cyclicBufferPos?this$static._cyclicBufferPos - delta:this$static._cyclicBufferPos - delta + this$static._cyclicBufferSize) << 1;
pby1 = this$static._bufferOffset + curMatch;
len = len0 < len1?len0:len1;
if (this$static._bufferBase[pby1 + len] == this$static._bufferBase[cur + len]) {
while (++len != lenLimit) {
if (this$static._bufferBase[pby1 + len] != this$static._bufferBase[cur + len]) {
break;
}
}
if (maxLen < len) {
distances[offset++] = maxLen = len;
distances[offset++] = delta - 1;
if (len == lenLimit) {
this$static._son[ptr1] = this$static._son[cyclicPos];
this$static._son[ptr0] = this$static._son[cyclicPos + 1];
break;
}
}
}
if ((this$static._bufferBase[pby1 + len] & 255) < (this$static._bufferBase[cur + len] & 255)) {
this$static._son[ptr1] = curMatch;
ptr1 = cyclicPos + 1;
curMatch = this$static._son[ptr1];
len1 = len;
} else {
this$static._son[ptr0] = curMatch;
ptr0 = cyclicPos;
curMatch = this$static._son[ptr0];
len0 = len;
}
}
$MovePos_0(this$static);
return offset;
}
function $Init_5(this$static) {
this$static._bufferOffset = 0;
this$static._pos = 0;
this$static._streamPos = 0;
this$static._streamEndWasReached = 0;
$ReadBlock(this$static);
this$static._cyclicBufferPos = 0;
$ReduceOffsets(this$static, -1);
}
function $MovePos_0(this$static) {
var subValue;
if (++this$static._cyclicBufferPos >= this$static._cyclicBufferSize) {
this$static._cyclicBufferPos = 0;
}
$MovePos_1(this$static);
if (this$static._pos == 1073741823) {
subValue = this$static._pos - this$static._cyclicBufferSize;
$NormalizeLinks(this$static._son, this$static._cyclicBufferSize * 2, subValue);
$NormalizeLinks(this$static._hash, this$static._hashSizeSum, subValue);
$ReduceOffsets(this$static, subValue);
}
}
///NOTE: This is only called after reading one whole gigabyte.
function $NormalizeLinks(items, numItems, subValue) {
var i, value;
for (i = 0; i < numItems; ++i) {
value = items[i] || 0;
if (value <= subValue) {
value = 0;
} else {
value -= subValue;
}
items[i] = value;
}
}
function $SetType(this$static, numHashBytes) {
this$static.HASH_ARRAY = numHashBytes > 2;
if (this$static.HASH_ARRAY) {
this$static.kNumHashDirectBytes = 0;
this$static.kMinMatchCheck = 4;
this$static.kFixHashSize = 66560;
} else {
this$static.kNumHashDirectBytes = 2;
this$static.kMinMatchCheck = 3;
this$static.kFixHashSize = 0;
}
}
function $Skip(this$static, num) {
var count, cur, curMatch, cyclicPos, delta, hash2Value, hash3Value, hashValue, len, len0, len1, lenLimit, matchMinPos, pby1, ptr0, ptr1, temp;
do {
if (this$static._pos + this$static._matchMaxLen <= this$static._streamPos) {
lenLimit = this$static._matchMaxLen;
} else {
lenLimit = this$static._streamPos - this$static._pos;
if (lenLimit < this$static.kMinMatchCheck) {
$MovePos_0(this$static);
continue;
}
}
matchMinPos = this$static._pos > this$static._cyclicBufferSize?this$static._pos - this$static._cyclicBufferSize:0;
cur = this$static._bufferOffset + this$static._pos;
if (this$static.HASH_ARRAY) {
temp = CrcTable[this$static._bufferBase[cur] & 255] ^ this$static._bufferBase[cur + 1] & 255;
hash2Value = temp & 1023;
this$static._hash[hash2Value] = this$static._pos;
temp ^= (this$static._bufferBase[cur + 2] & 255) << 8;
hash3Value = temp & 65535;
this$static._hash[1024 + hash3Value] = this$static._pos;
hashValue = (temp ^ CrcTable[this$static._bufferBase[cur + 3] & 255] << 5) & this$static._hashMask;
} else {
hashValue = this$static._bufferBase[cur] & 255 ^ (this$static._bufferBase[cur + 1] & 255) << 8;
}
curMatch = this$static._hash[this$static.kFixHashSize + hashValue];
this$static._hash[this$static.kFixHashSize + hashValue] = this$static._pos;
ptr0 = (this$static._cyclicBufferPos << 1) + 1;
ptr1 = this$static._cyclicBufferPos << 1;
len0 = len1 = this$static.kNumHashDirectBytes;
count = this$static._cutValue;
while (1) {
if (curMatch <= matchMinPos || count-- == 0) {
this$static._son[ptr0] = this$static._son[ptr1] = 0;
break;
}
delta = this$static._pos - curMatch;
cyclicPos = (delta <= this$static._cyclicBufferPos?this$static._cyclicBufferPos - delta:this$static._cyclicBufferPos - delta + this$static._cyclicBufferSize) << 1;
pby1 = this$static._bufferOffset + curMatch;
len = len0 < len1?len0:len1;
if (this$static._bufferBase[pby1 + len] == this$static._bufferBase[cur + len]) {
while (++len != lenLimit) {
if (this$static._bufferBase[pby1 + len] != this$static._bufferBase[cur + len]) {
break;
}
}
if (len == lenLimit) {
this$static._son[ptr1] = this$static._son[cyclicPos];
this$static._son[ptr0] = this$static._son[cyclicPos + 1];
break;
}
}
if ((this$static._bufferBase[pby1 + len] & 255) < (this$static._bufferBase[cur + len] & 255)) {
this$static._son[ptr1] = curMatch;
ptr1 = cyclicPos + 1;
curMatch = this$static._son[ptr1];
len1 = len;
} else {
this$static._son[ptr0] = curMatch;
ptr0 = cyclicPos;
curMatch = this$static._son[ptr0];
len0 = len;
}
}
$MovePos_0(this$static);
}
while (--num != 0);
}
/** ce */
function GetLenToPosState(len) {
len -= 2;
if (len < 4) {
return len;
}
return 3;
}
function StateUpdateChar(index) {
if (index < 4) {
return 0;
}
if (index < 10) {
return index - 3;
}
return index - 6;
}
/** cs */
function $Chunker_0(this$static, encoder) {
this$static.encoder = encoder;
this$static.decoder = null;
this$static.alive = 1;
return this$static;
}
/** ce */
function $processChunk(this$static) {
if (!this$static.alive) {
throw new Error("bad state");
}
if (this$static.encoder) {
/// do:throw new Error("No encoding");
/** cs */
$processEncoderChunk(this$static);
/** ce */
} else {
throw new Error("No decoding");
}
return this$static.alive;
}
/** cs */
function $processEncoderChunk(this$static) {
$CodeOneBlock(this$static.encoder, this$static.encoder.processedInSize, this$static.encoder.processedOutSize, this$static.encoder.finished);
this$static.inBytesProcessed = this$static.encoder.processedInSize[0];
if (this$static.encoder.finished[0]) {
$ReleaseStreams(this$static.encoder);
this$static.alive = 0;
}
}
/** ce */
/** cs */
var g_FastPos = (function () {
var j, k, slotFast, c = 2, g_FastPos = [0, 1];
for (slotFast = 2; slotFast < 22; ++slotFast) {
k = 1 << (slotFast >> 1) - 1;
for (j = 0; j < k; ++j , ++c)
g_FastPos[c] = slotFast << 24 >> 24;
}
return g_FastPos;
}());
function $Backward(this$static, cur) {
var backCur, backMem, posMem, posPrev;
this$static._optimumEndIndex = cur;
posMem = this$static._optimum[cur].PosPrev;
backMem = this$static._optimum[cur].BackPrev;
do {
if (this$static._optimum[cur].Prev1IsChar) {
$MakeAsChar(this$static._optimum[posMem]);
this$static._optimum[posMem].PosPrev = posMem - 1;
if (this$static._optimum[cur].Prev2) {
this$static._optimum[posMem - 1].Prev1IsChar = 0;
this$static._optimum[posMem - 1].PosPrev = this$static._optimum[cur].PosPrev2;
this$static._optimum[posMem - 1].BackPrev = this$static._optimum[cur].BackPrev2;
}
}
posPrev = posMem;
backCur = backMem;
backMem = this$static._optimum[posPrev].BackPrev;
posMem = this$static._optimum[posPrev].PosPrev;
this$static._optimum[posPrev].BackPrev = backCur;
this$static._optimum[posPrev].PosPrev = cur;
cur = posPrev;
} while (cur > 0);
this$static.backRes = this$static._optimum[0].BackPrev;
this$static._optimumCurrentIndex = this$static._optimum[0].PosPrev;
return this$static._optimumCurrentIndex;
}
function $BaseInit(this$static) {
this$static._state = 0;
this$static._previousByte = 0;
for (var i = 0; i < 4; ++i) {
this$static._repDistances[i] = 0;
}
}
function $CodeOneBlock(this$static, inSize, outSize, finished) {
var baseVal, complexState, curByte, distance, footerBits, i, len, lenToPosState, matchByte, pos, posReduced, posSlot, posState, progressPosValuePrev, subCoder;
inSize[0] = P0_longLit;
outSize[0] = P0_longLit;
finished[0] = 1;
if (this$static._inStream) {
this$static._matchFinder._stream = this$static._inStream;
$Init_5(this$static._matchFinder);
this$static._needReleaseMFStream = 1;
this$static._inStream = null;
}
if (this$static._finished) {
return;
}
this$static._finished = 1;
progressPosValuePrev = this$static.nowPos64;
if (eq(this$static.nowPos64, P0_longLit)) {
if (!$GetNumAvailableBytes(this$static._matchFinder)) {
$Flush(this$static, lowBits_0(this$static.nowPos64));
return;
}
$ReadMatchDistances(this$static);
posState = lowBits_0(this$static.nowPos64) & this$static._posStateMask;
$Encode_3(this$static._rangeEncoder, this$static._isMatch, (this$static._state << 4) + posState, 0);
this$static._state = StateUpdateChar(this$static._state);
curByte = $GetIndexByte(this$static._matchFinder, -this$static._additionalOffset);
$Encode_1($GetSubCoder(this$static._literalEncoder, lowBits_0(this$static.nowPos64), this$static._previousByte), this$static._rangeEncoder, curByte);
this$static._previousByte = curByte;
--this$static._additionalOffset;
this$static.nowPos64 = add(this$static.nowPos64, P1_longLit);
}
if (!$GetNumAvailableBytes(this$static._matchFinder)) {
$Flush(this$static, lowBits_0(this$static.nowPos64));
return;
}
while (1) {
len = $GetOptimum(this$static, lowBits_0(this$static.nowPos64));
pos = this$static.backRes;
posState = lowBits_0(this$static.nowPos64) & this$static._posStateMask;
complexState = (this$static._state << 4) + posState;
if (len == 1 && pos == -1) {
$Encode_3(this$static._rangeEncoder, this$static._isMatch, complexState, 0);
curByte = $GetIndexByte(this$static._matchFinder, -this$static._additionalOffset);
subCoder = $GetSubCoder(this$static._literalEncoder, lowBits_0(this$static.nowPos64), this$static._previousByte);
if (this$static._state < 7) {
$Encode_1(subCoder, this$static._rangeEncoder, curByte);
} else {
matchByte = $GetIndexByte(this$static._matchFinder, -this$static._repDistances[0] - 1 - this$static._additionalOffset);
$EncodeMatched(subCoder, this$static._rangeEncoder, matchByte, curByte);
}
this$static._previousByte = curByte;
this$static._state = StateUpdateChar(this$static._state);
} else {
$Encode_3(this$static._rangeEncoder, this$static._isMatch, complexState, 1);
if (pos < 4) {
$Encode_3(this$static._rangeEncoder, this$static._isRep, this$static._state, 1);
if (!pos) {
$Encode_3(this$static._rangeEncoder, this$static._isRepG0, this$static._state, 0);
if (len == 1) {
$Encode_3(this$static._rangeEncoder, this$static._isRep0Long, complexState, 0);
} else {
$Encode_3(this$static._rangeEncoder, this$static._isRep0Long, complexState, 1);
}
} else {
$Encode_3(this$static._rangeEncoder, this$static._isRepG0, this$static._state, 1);
if (pos == 1) {
$Encode_3(this$static._rangeEncoder, this$static._isRepG1, this$static._state, 0);
} else {
$Encode_3(this$static._rangeEncoder, this$static._isRepG1, this$static._state, 1);
$Encode_3(this$static._rangeEncoder, this$static._isRepG2, this$static._state, pos - 2);
}
}
if (len == 1) {
this$static._state = this$static._state < 7?9:11;
} else {
$Encode_0(this$static._repMatchLenEncoder, this$static._rangeEncoder, len - 2, posState);
this$static._state = this$static._state < 7?8:11;
}
distance = this$static._repDistances[pos];
if (pos != 0) {
for (i = pos; i >= 1; --i) {
this$static._repDistances[i] = this$static._repDistances[i - 1];
}
this$static._repDistances[0] = distance;
}
} else {
$Encode_3(this$static._rangeEncoder, this$static._isRep, this$static._state, 0);
this$static._state = this$static._state < 7?7:10;
$Encode_0(this$static._lenEncoder, this$static._rangeEncoder, len - 2, posState);
pos -= 4;
posSlot = GetPosSlot(pos);
lenToPosState = GetLenToPosState(len);
$Encode_2(this$static._posSlotEncoder[lenToPosState], this$static._rangeEncoder, posSlot);
if (posSlot >= 4) {
footerBits = (posSlot >> 1) - 1;
baseVal = (2 | posSlot & 1) << footerBits;
posReduced = pos - baseVal;
if (posSlot < 14) {
ReverseEncode(this$static._posEncoders, baseVal - posSlot - 1, this$static._rangeEncoder, footerBits, posReduced);
} else {
$EncodeDirectBits(this$static._rangeEncoder, posReduced >> 4, footerBits - 4);
$ReverseEncode(this$static._posAlignEncoder, this$static._rangeEncoder, posReduced & 15);
++this$static._alignPriceCount;
}
}
distance = pos;
for (i = 3; i >= 1; --i) {
this$static._repDistances[i] = this$static._repDistances[i - 1];
}
this$static._repDistances[0] = distance;
++this$static._matchPriceCount;
}
this$static._previousByte = $GetIndexByte(this$static._matchFinder, len - 1 - this$static._additionalOffset);
}
this$static._additionalOffset -= len;
this$static.nowPos64 = add(this$static.nowPos64, fromInt(len));
if (!this$static._additionalOffset) {
if (this$static._matchPriceCount >= 128) {
$FillDistancesPrices(this$static);
}
if (this$static._alignPriceCount >= 16) {
$FillAlignPrices(this$static);
}
inSize[0] = this$static.nowPos64;
outSize[0] = $GetProcessedSizeAdd(this$static._rangeEncoder);
if (!$GetNumAvailableBytes(this$static._matchFinder)) {
$Flush(this$static, lowBits_0(this$static.nowPos64));
return;
}
if (compare(sub(this$static.nowPos64, progressPosValuePrev), [4096, 0]) >= 0) {
this$static._finished = 0;
finished[0] = 0;
return;
}
}
}
}
function $Create_2(this$static) {
var bt, numHashBytes;
if (!this$static._matchFinder) {
bt = {};
numHashBytes = 4;
if (!this$static._matchFinderType) {
numHashBytes = 2;
}
$SetType(bt, numHashBytes);
this$static._matchFinder = bt;
}
$Create_1(this$static._literalEncoder, this$static._numLiteralPosStateBits, this$static._numLiteralContextBits);
if (this$static._dictionarySize == this$static._dictionarySizePrev && this$static._numFastBytesPrev == this$static._numFastBytes) {
return;
}
$Create_3(this$static._matchFinder, this$static._dictionarySize, 4096, this$static._numFastBytes, 274);
this$static._dictionarySizePrev = this$static._dictionarySize;
this$static._numFastBytesPrev = this$static._numFastBytes;
}
function $Encoder(this$static) {
var i;
this$static._repDistances = initDim(4);
this$static._optimum = [];
this$static._rangeEncoder = {};
this$static._isMatch = initDim(192);
this$static._isRep = initDim(12);
this$static._isRepG0 = initDim(12);
this$static._isRepG1 = initDim(12);
this$static._isRepG2 = initDim(12);
this$static._isRep0Long = initDim(192);
this$static._posSlotEncoder = [];
this$static._posEncoders = initDim(114);
this$static._posAlignEncoder = $BitTreeEncoder({}, 4);
this$static._lenEncoder = $Encoder$LenPriceTableEncoder({});
this$static._repMatchLenEncoder = $Encoder$LenPriceTableEncoder({});
this$static._literalEncoder = {};
this$static._matchDistances = [];
this$static._posSlotPrices = [];
this$static._distancesPrices = [];
this$static._alignPrices = initDim(16);
this$static.reps = initDim(4);
this$static.repLens = initDim(4);
this$static.processedInSize = [P0_longLit];
this$static.processedOutSize = [P0_longLit];
this$static.finished = [0];
this$static.properties = initDim(5);
this$static.tempPrices = initDim(128);
this$static._longestMatchLength = 0;
this$static._matchFinderType = 1;
this$static._numDistancePairs = 0;
this$static._numFastBytesPrev = -1;
this$static.backRes = 0;
for (i = 0; i < 4096; ++i) {
this$static._optimum[i] = {};
}
for (i = 0; i < 4; ++i) {
this$static._posSlotEncoder[i] = $BitTreeEncoder({}, 6);
}
return this$static;
}
function $FillAlignPrices(this$static) {
for (var i = 0; i < 16; ++i) {
this$static._alignPrices[i] = $ReverseGetPrice(this$static._posAlignEncoder, i);
}
this$static._alignPriceCount = 0;
}
function $FillDistancesPrices(this$static) {
var baseVal, encoder, footerBits, i, lenToPosState, posSlot, st, st2;
for (i = 4; i < 128; ++i) {
posSlot = GetPosSlot(i);
footerBits = (posSlot >> 1) - 1;
baseVal = (2 | posSlot & 1) << footerBits;
this$static.tempPrices[i] = ReverseGetPrice(this$static._posEncoders, baseVal - posSlot - 1, footerBits, i - baseVal);
}
for (lenToPosState = 0; lenToPosState < 4; ++lenToPosState) {
encoder = this$static._posSlotEncoder[lenToPosState];
st = lenToPosState << 6;
for (posSlot = 0; posSlot < this$static._distTableSize; ++posSlot) {
this$static._posSlotPrices[st + posSlot] = $GetPrice_1(encoder, posSlot);
}
for (posSlot = 14; posSlot < this$static._distTableSize; ++posSlot) {
this$static._posSlotPrices[st + posSlot] += (posSlot >> 1) - 1 - 4 << 6;
}
st2 = lenToPosState * 128;
for (i = 0; i < 4; ++i) {
this$static._distancesPrices[st2 + i] = this$static._posSlotPrices[st + i];
}
for (; i < 128; ++i) {
this$static._distancesPrices[st2 + i] = this$static._posSlotPrices[st + GetPosSlot(i)] + this$static.tempPrices[i];
}
}
this$static._matchPriceCount = 0;
}
function $Flush(this$static, nowPos) {
$ReleaseMFStream(this$static);
$WriteEndMarker(this$static, nowPos & this$static._posStateMask);
for (var i = 0; i < 5; ++i) {
$ShiftLow(this$static._rangeEncoder);
}
}
function $GetOptimum(this$static, position) {
var cur, curAnd1Price, curAndLenCharPrice, curAndLenPrice, curBack, curPrice, currentByte, distance, i, len, lenEnd, lenMain, lenRes, lenTest, lenTest2, lenTestTemp, matchByte, matchPrice, newLen, nextIsChar, nextMatchPrice, nextOptimum, nextRepMatchPrice, normalMatchPrice, numAvailableBytes, numAvailableBytesFull, numDistancePairs, offs, offset, opt, optimum, pos, posPrev, posState, posStateNext, price_4, repIndex, repLen, repMatchPrice, repMaxIndex, shortRepPrice, startLen, state, state2, t, price, price_0, price_1, price_2, price_3;
if (this$static._optimumEndIndex != this$static._optimumCurrentIndex) {
lenRes = this$static._optimum[this$static._optimumCurrentIndex].PosPrev - this$static._optimumCurrentIndex;
this$static.backRes = this$static._optimum[this$static._optimumCurrentIndex].BackPrev;
this$static._optimumCurrentIndex = this$static._optimum[this$static._optimumCurrentIndex].PosPrev;
return lenRes;
}
this$static._optimumCurrentIndex = this$static._optimumEndIndex = 0;
if (this$static._longestMatchWasFound) {
lenMain = this$static._longestMatchLength;
this$static._longestMatchWasFound = 0;
} else {
lenMain = $ReadMatchDistances(this$static);
}
numDistancePairs = this$static._numDistancePairs;
numAvailableBytes = $GetNumAvailableBytes(this$static._matchFinder) + 1;
if (numAvailableBytes < 2) {
this$static.backRes = -1;
return 1;
}
if (numAvailableBytes > 273) {
numAvailableBytes = 273;
}
repMaxIndex = 0;
for (i = 0; i < 4; ++i) {
this$static.reps[i] = this$static._repDistances[i];
this$static.repLens[i] = $GetMatchLen(this$static._matchFinder, -1, this$static.reps[i], 273);
if (this$static.repLens[i] > this$static.repLens[repMaxIndex]) {
repMaxIndex = i;
}
}
if (this$static.repLens[repMaxIndex] >= this$static._numFastBytes) {
this$static.backRes = repMaxIndex;
lenRes = this$static.repLens[repMaxIndex];
$MovePos(this$static, lenRes - 1);
return lenRes;
}
if (lenMain >= this$static._numFastBytes) {
this$static.backRes = this$static._matchDistances[numDistancePairs - 1] + 4;
$MovePos(this$static, lenMain - 1);
return lenMain;
}
currentByte = $GetIndexByte(this$static._matchFinder, -1);
matchByte = $GetIndexByte(this$static._matchFinder, -this$static._repDistances[0] - 1 - 1);
if (lenMain < 2 && currentByte != matchByte && this$static.repLens[repMaxIndex] < 2) {
this$static.backRes = -1;
return 1;
}
this$static._optimum[0].State = this$static._state;
posState = position & this$static._posStateMask;
this$static._optimum[1].Price = ProbPrices[this$static._isMatch[(this$static._state << 4) + posState] >>> 2] + $GetPrice_0($GetSubCoder(this$static._literalEncoder, position, this$static._previousByte), this$static._state >= 7, matchByte, currentByte);
$MakeAsChar(this$static._optimum[1]);
matchPrice = ProbPrices[2048 - this$static._isMatch[(this$static._state << 4) + posState] >>> 2];
repMatchPrice = matchPrice + ProbPrices[2048 - this$static._isRep[this$static._state] >>> 2];
if (matchByte == currentByte) {
shortRepPrice = repMatchPrice + $GetRepLen1Price(this$static, this$static._state, posState);
if (shortRepPrice < this$static._optimum[1].Price) {
this$static._optimum[1].Price = shortRepPrice;
$MakeAsShortRep(this$static._optimum[1]);
}
}
lenEnd = lenMain >= this$static.repLens[repMaxIndex]?lenMain:this$static.repLens[repMaxIndex];
if (lenEnd < 2) {
this$static.backRes = this$static._optimum[1].BackPrev;
return 1;
}
this$static._optimum[1].PosPrev = 0;
this$static._optimum[0].Backs0 = this$static.reps[0];
this$static._optimum[0].Backs1 = this$static.reps[1];
this$static._optimum[0].Backs2 = this$static.reps[2];
this$static._optimum[0].Backs3 = this$static.reps[3];
len = lenEnd;
do {
this$static._optimum[len--].Price = 268435455;
} while (len >= 2);
for (i = 0; i < 4; ++i) {
repLen = this$static.repLens[i];
if (repLen < 2) {
continue;
}
price_4 = repMatchPrice + $GetPureRepPrice(this$static, i, this$static._state, posState);
do {
curAndLenPrice = price_4 + $GetPrice(this$static._repMatchLenEncoder, repLen - 2, posState);
optimum = this$static._optimum[repLen];
if (curAndLenPrice < optimum.Price) {
optimum.Price = curAndLenPrice;
optimum.PosPrev = 0;
optimum.BackPrev = i;
optimum.Prev1IsChar = 0;
}
} while (--repLen >= 2);
}
normalMatchPrice = matchPrice + ProbPrices[this$static._isRep[this$static._state] >>> 2];
len = this$static.repLens[0] >= 2?this$static.repLens[0] + 1:2;
if (len <= lenMain) {
offs = 0;
while (len > this$static._matchDistances[offs]) {
offs += 2;
}
for (;; ++len) {
distance = this$static._matchDistances[offs + 1];
curAndLenPrice = normalMatchPrice + $GetPosLenPrice(this$static, distance, len, posState);
optimum = this$static._optimum[len];
if (curAndLenPrice < optimum.Price) {
optimum.Price = curAndLenPrice;
optimum.PosPrev = 0;
optimum.BackPrev = distance + 4;
optimum.Prev1IsChar = 0;
}
if (len == this$static._matchDistances[offs]) {
offs += 2;
if (offs == numDistancePairs) {
break;
}
}
}
}
cur = 0;
while (1) {
++cur;
if (cur == lenEnd) {
return $Backward(this$static, cur);
}
newLen = $ReadMatchDistances(this$static);
numDistancePairs = this$static._numDistancePairs;
if (newLen >= this$static._numFastBytes) {
this$static._longestMatchLength = newLen;
this$static._longestMatchWasFound = 1;
return $Backward(this$static, cur);
}
++position;
posPrev = this$static._optimum[cur].PosPrev;
if (this$static._optimum[cur].Prev1IsChar) {
--posPrev;
if (this$static._optimum[cur].Prev2) {
state = this$static._optimum[this$static._optimum[cur].PosPrev2].State;
if (this$static._optimum[cur].BackPrev2 < 4) {
state = (state < 7) ? 8 : 11;
} else {
state = (state < 7) ? 7 : 10;
}
} else {
state = this$static._optimum[posPrev].State;
}
state = StateUpdateChar(state);
} else {
state = this$static._optimum[posPrev].State;
}
if (posPrev == cur - 1) {
if (!this$static._optimum[cur].BackPrev) {
state = state < 7?9:11;
} else {
state = StateUpdateChar(state);
}
} else {
if (this$static._optimum[cur].Prev1IsChar && this$static._optimum[cur].Prev2) {
posPrev = this$static._optimum[cur].PosPrev2;
pos = this$static._optimum[cur].BackPrev2;
state = state < 7?8:11;
} else {
pos = this$static._optimum[cur].BackPrev;
if (pos < 4) {
state = state < 7?8:11;
} else {
state = state < 7?7:10;
}
}
opt = this$static._optimum[posPrev];
if (pos < 4) {
if (!pos) {
this$static.reps[0] = opt.Backs0;
this$static.reps[1] = opt.Backs1;
this$static.reps[2] = opt.Backs2;
this$static.reps[3] = opt.Backs3;
} else if (pos == 1) {
this$static.reps[0] = opt.Backs1;
this$static.reps[1] = opt.Backs0;
this$static.reps[2] = opt.Backs2;
this$static.reps[3] = opt.Backs3;
} else if (pos == 2) {
this$static.reps[0] = opt.Backs2;
this$