Skip to content

Instantly share code, notes, and snippets.

@loilo

loilo/base64.js

Last active November 4, 2024 20:42
Show Gist options
  • Save loilo/92220c23567d6ed085a28f2c3e84e311 to your computer and use it in GitHub Desktop.
Save loilo/92220c23567d6ed085a28f2c3e84e311 to your computer and use it in GitHub Desktop.
Download ZIP
URL-Safe LZMA Compression
Raw
readme.md

URL-Safe LZMA Compression

This Gist provides JavaScript functions to compress a string for usage in URLs using a very space-efficient but comparatively slow algorithm. It's great for sharing larger amounts of data as part of a URL.

The raw algorithm is forked from lzma-js, converted to an ES module and with some features stripped off (e.g. async mode, worker support), the URL-safe functionality was added by me.

If you need to compress data very frequently (e.g. on each keystroke of a user), you probably should look out for a faster alternative (e.g. lz-string).

Usage

Note: The JavaScript files of this Gist are using some ES2015 features in general and ES modules in particular. You can safely use them in modern browsers, however using them in Node.js or legacy browsers would need an additional transpile and/or bundling step.

Compress

Let's compress this example JSON data set (you can see the code in action on CodeSandbox):

import { compressUrlSafe } from './lzma-url.js'

const data = {
  id: '0001',
  type: 'donut',
  name: 'Cake',
  ppu: 0.55,
  batters: {
    batter: [
      { id: '1001', type: 'Regular' },
      { id: '1002', type: 'Chocolate' },
      { id: '1003', type: 'Blueberry' },
      { id: '1004', type: "Devil's Food" }
    ]
  },
  topping: [
    { id: '5001', type: 'None' },
    { id: '5002', type: 'Glazed' },
    { id: '5005', type: 'Sugar' },
    { id: '5007', type: 'Powdered Sugar' },
    { id: '5006', type: 'Chocolate with Sprinkles' },
    { id: '5003', type: 'Chocolate' },
    { id: '5004', type: 'Maple' }
  ]
}

const serializedData = JSON.stringify(data)
const compressedSerializedData = compressUrlSafe(serializedData)

console.log(`${serializedData.length} -> ${compressedSerializedData.length} bytes`)

This outputs 456 -> 294 bytes and generates the following compressed string:

  XQAAgADIAQAAAAAAAAA9iIkmgZNThWHvkoxYOhkMap8xuPc5WJAnOm0EWWnOco5kpp0Q6jEiL_ERvnqVST8OmSqcdDKPT_LOC3CazYNsg7FftTjd4Zel5ueEC81Jpd5wHZQR2Or1OaZBQ3T3cv4zYtBAgADqtQSoIb_JFbnNtPzJZzYWb3R6wEDt_nh-9LPC-aOKFlNdD2fxD3YrgY_VF8FHT_gZfYm3QyLnmLTiLMkEzDyXZfIlts_0cuEGCwzFxXr3RqKT4Sn_h8BYuRXcvvLu4BHB_-aH5pg%3D

This example shows a reduction of just ≈35%, however especially when encoding JSON structures (where usually there is a lot of duplicate content), space-efficiency increases greatly for larger data sets (my test dataset of 30 KB went down to just 4.9 KB).

Decompress

Inversely, we can take our generated string from above and convert it back to plain text:

import { decompressUrlSafe } from './lzma-url.js'

const compressedSerializedData = `XQAAgADIAQAAAAAAAAA9iIkmgZNThWHvkoxYOhkMap8xuPc5WJAnOm0EWWnOco5kpp0Q6jEiL_ERvnqVST8OmSqcdDKPT_LOC3CazYNsg7FftTjd4Zel5ueEC81Jpd5wHZQR2Or1OaZBQ3T3cv4zYtBAgADqtQSoIb_JFbnNtPzJZzYWb3R6wEDt_nh-9LPC-aOKFlNdD2fxD3YrgY_VF8FHT_gZfYm3QyLnmLTiLMkEzDyXZfIlts_0cuEGCwzFxXr3RqKT4Sn_h8BYuRXcvvLu4BHB_-aH5pg%3D`

const serializedData = decompressUrlSafe(compressedSerializedData)

The serializedData variable now contains the serialized JSON data:

{"id":"0001","type":"donut","name":"Cake","ppu":0.55,"batters":{"batter":[{"id":"1001","type":"Regular"},{"id":"1002","type":"Chocolate"},{"id":"1003","type":"Blueberry"},{"id":"1004","type":"Devil's Food"}]},"topping":[{"id":"5001","type":"None"},{"id":"5002","type":"Glazed"},{"id":"5005","type":"Sugar"},{"id":"5007","type":"Powdered Sugar"},{"id":"5006","type":"Chocolate with Sprinkles"},{"id":"5003","type":"Chocolate"},{"id":"5004","type":"Maple"}]}

To get back our original data, we'd just have to pass that through JSON.parse().

Raw
base64.js
/**
* Convert between Uint8Array and Base64 strings
* Allows for any encoded JS string to be converted (as opposed to atob()/btoa() which only supports latin1)
*
* Original implementation by madmurphy on MDN
* @see https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Solution_1_–_JavaScript%27s_UTF-16_%3E_base64
*/
function b64ToUint6(nChr) {
return nChr > 64 && nChr < 91
? nChr - 65
: nChr > 96 && nChr < 123
? nChr - 71
: nChr > 47 && nChr < 58
? nChr + 4
: nChr === 43
? 62
: nChr === 47
? 63
: 0
}
export function decodeToArray(base64string, blockSize) {
var sB64Enc = base64string.replace(/[^A-Za-z0-9\+\/]/g, ''),
nInLen = sB64Enc.length,
nOutLen = blockSize
? Math.ceil(((nInLen * 3 + 1) >>> 2) / blockSize) * blockSize
: (nInLen * 3 + 1) >>> 2,
aBytes = new Uint8Array(nOutLen)
for (
var nMod3, nMod4, nUint24 = 0, nOutIdx = 0, nInIdx = 0;
nInIdx < nInLen;
nInIdx++
) {
nMod4 = nInIdx & 3
nUint24 |= b64ToUint6(sB64Enc.charCodeAt(nInIdx)) << (18 - 6 * nMod4)
if (nMod4 === 3 || nInLen - nInIdx === 1) {
for (nMod3 = 0; nMod3 < 3 && nOutIdx < nOutLen; nMod3++, nOutIdx++) {
aBytes[nOutIdx] = (nUint24 >>> ((16 >>> nMod3) & 24)) & 255
}
nUint24 = 0
}
}
return aBytes
}
function uint6ToB64(nUint6) {
return nUint6 < 26
? nUint6 + 65
: nUint6 < 52
? nUint6 + 71
: nUint6 < 62
? nUint6 - 4
: nUint6 === 62
? 43
: nUint6 === 63
? 47
: 65
}
export function encodeFromArray(bytes) {
var eqLen = (3 - (bytes.length % 3)) % 3,
sB64Enc = ''
for (
var nMod3, nLen = bytes.length, nUint24 = 0, nIdx = 0;
nIdx < nLen;
nIdx++
) {
nMod3 = nIdx % 3
/* Uncomment the following line in order to split the output in lines 76-character long: */
/*
if (nIdx > 0 && (nIdx * 4 / 3) % 76 === 0) { sB64Enc += "\r\n"; }
*/
nUint24 |= bytes[nIdx] << ((16 >>> nMod3) & 24)
if (nMod3 === 2 || bytes.length - nIdx === 1) {
sB64Enc += String.fromCharCode(
uint6ToB64((nUint24 >>> 18) & 63),
uint6ToB64((nUint24 >>> 12) & 63),
uint6ToB64((nUint24 >>> 6) & 63),
uint6ToB64(nUint24 & 63)
)
nUint24 = 0
}
}
return eqLen === 0
? sB64Enc
: sB64Enc.substring(0, sB64Enc.length - eqLen) + (eqLen === 1 ? '=' : '==')
}
/**
* URL-safe variants of Base64 conversion functions (aka base64url)
* @see https://tools.ietf.org/html/rfc4648#section-5
*/
export function encodeFromArrayUrlSafe(bytes) {
return encodeURIComponent(
encodeFromArray(bytes)
.replace(/\+/g, '-')
.replace(/\//g, '_')
)
}
export function decodeToArrayUrlSafe(base64string) {
return decodeToArray(
decodeURIComponent(base64string)
.replace(/-/g, '+')
.replace(/_/g, '/')
)
}
Raw
lzma-url.js
/*
The LZMA impementation is forked from https://npm.is/lzma-js, converted to an ES module and with some features stripped off (e.g. async mode, worker support)
Here's the according MIT license:
© 2016 Nathan Rugg <[email protected]>
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
import * as base64 from './base64.js'
const __4294967296 = 4294967296,
N1_longLit = [4294967295, -__4294967296],
MIN_VALUE = [0, -9223372036854775808],
P0_longLit = [0, 0],
P1_longLit = [1, 0]
function add(a, b) {
return create(a[0] + b[0], a[1] + b[1])
}
function initDim(len) {
// NOTE: This is MUCH faster than "initDim(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 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)
)
}
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]
}
function eq(a, b) {
return a[0] == b[0] && a[1] == b[1]
}
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)
}
}
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
}
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
}
function $read(this$static) {
if (this$static.pos >= this$static.count) return -1
return this$static.buf[this$static.pos++] & 255
}
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
}
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
}
function $write(this$static, b) {
this$static.buf[this$static.count++] = (b << 24) >> 24
}
function $write_0(this$static, buf, off, len) {
arraycopy(buf, off, this$static.buf, this$static.count, len)
this$static.count += len
}
function $getChars(this$static, srcBegin, srcEnd, dst, dstBegin) {
var srcIdx
for (srcIdx = srcBegin; srcIdx < srcEnd; ++srcIdx) {
dst[dstBegin++] = this$static.charCodeAt(srcIdx)
}
}
function arraycopy(src, srcOfs, dest, destOfs, len) {
for (var i = 0; i < len; ++i) {
dest[destOfs + i] = src[srcOfs + i]
}
}
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
encoder._posStateMask = 3
}
function $init(this$static, input, output, length_0, mode, enableEndMark) {
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 = enableEndMark
$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, enableEndMark) {
this$static.output = $ByteArrayOutputStream({})
$init(
this$static,
$ByteArrayInputStream({}, data),
this$static.output,
fromInt(data.length),
mode,
enableEndMark
)
return this$static
}
function $init_0(this$static, input, output) {
var decoder,
hex_length = '',
i,
properties = [],
r,
tmp_length
for (i = 0; i < 5; ++i) {
r = $read(input)
if (r == -1) throw new Error('truncated input')
properties[i] = (r << 24) >> 24
}
decoder = $Decoder({})
if (!$SetDecoderProperties(decoder, properties)) {
throw new Error('corrupted input')
}
for (i = 0; i < 64; i += 8) {
r = $read(input)
if (r == -1) throw new Error('truncated input')
r = r.toString(16)
if (r.length == 1) r = '0' + r
hex_length = r + '' + hex_length
}
// Was the length set in the header (if it was compressed from a stream, the length is all f"s).
if (/^0+$|^f+$/i.test(hex_length)) {
// The length is unknown, so set to -1.
this$static.length_0 = N1_longLit
} else {
// NOTE: If there is a problem with the decoder because of the length, you can always set the length to -1 (N1_longLit) which means unknown.
tmp_length = parseInt(hex_length, 16)
// If the length is too long to handle, just set it to unknown.
if (tmp_length > 4294967295) {
this$static.length_0 = N1_longLit
} else {
this$static.length_0 = fromInt(tmp_length)
}
}
this$static.chunker = $CodeInChunks(
decoder,
input,
output,
this$static.length_0
)
}
function $LZMAByteArrayDecompressor(this$static, data) {
this$static.output = $ByteArrayOutputStream({})
$init_0(this$static, $ByteArrayInputStream({}, data), this$static.output)
return this$static
}
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)
}
function $CopyBlock(this$static, distance, len) {
var pos = this$static._pos - distance - 1
if (pos < 0) {
pos += this$static._windowSize
}
for (; len != 0; --len) {
if (pos >= this$static._windowSize) {
pos = 0
}
this$static._buffer[this$static._pos++] = this$static._buffer[pos++]
if (this$static._pos >= this$static._windowSize) {
$Flush_0(this$static)
}
}
}
function $Create_5(this$static, windowSize) {
if (this$static._buffer == null || this$static._windowSize != windowSize) {
this$static._buffer = initDim(windowSize)
}
this$static._windowSize = windowSize
this$static._pos = 0
this$static._streamPos = 0
}
function $Flush_0(this$static) {
var size = this$static._pos - this$static._streamPos
if (!size) {
return
}
$write_0(
this$static._stream,
this$static._buffer,
this$static._streamPos,
size
)
if (this$static._pos >= this$static._windowSize) {
this$static._pos = 0
}
this$static._streamPos = this$static._pos
}
function $GetByte(this$static, distance) {
var pos = this$static._pos - distance - 1
if (pos < 0) {
pos += this$static._windowSize
}
return this$static._buffer[pos]
}
function $PutByte(this$static, b) {
this$static._buffer[this$static._pos++] = b
if (this$static._pos >= this$static._windowSize) {
$Flush_0(this$static)
}
}
function $ReleaseStream(this$static) {
$Flush_0(this$static)
this$static._stream = null
}
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
}
function $Chunker_0(this$static, encoder) {
this$static.encoder = encoder
this$static.decoder = null
this$static.alive = 1
return this$static
}
function $Chunker(this$static, decoder) {
this$static.decoder = decoder
this$static.encoder = null
this$static.alive = 1
return this$static
}
function $processChunk(this$static) {
if (!this$static.alive) {
throw new Error('bad state')
}
if (this$static.encoder) {
$processEncoderChunk(this$static)
} else {
$processDecoderChunk(this$static)
}
return this$static.alive
}
function $processDecoderChunk(this$static) {
var result = $CodeOneChunk(this$static.decoder)
if (result == -1) {
throw new Error('corrupted input')
}
this$static.inBytesProcessed = N1_longLit
this$static.outBytesProcessed = this$static.decoder.nowPos64
if (
result ||
(compare(this$static.decoder.outSize, P0_longLit) >= 0 &&
compare(this$static.decoder.nowPos64, this$static.decoder.outSize) >= 0)
) {
$Flush_0(this$static.decoder.m_OutWindow)
$ReleaseStream(this$static.decoder.m_OutWindow)
this$static.decoder.m_RangeDecoder.Stream = null
this$static.alive = 0
}
}
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
}
}
function $CodeInChunks(this$static, inStream, outStream, outSize) {
this$static.m_RangeDecoder.Stream = inStream
$ReleaseStream(this$static.m_OutWindow)
this$static.m_OutWindow._stream = outStream
$Init_1(this$static)
this$static.state = 0
this$static.rep0 = 0
this$static.rep1 = 0
this$static.rep2 = 0
this$static.rep3 = 0
this$static.outSize = outSize
this$static.nowPos64 = P0_longLit
this$static.prevByte = 0
return $Chunker({}, this$static)
}
function $CodeOneChunk(this$static) {
var decoder2, distance, len, numDirectBits, posSlot, posState
posState = lowBits_0(this$static.nowPos64) & this$static.m_PosStateMask
if (
!$DecodeBit(
this$static.m_RangeDecoder,
this$static.m_IsMatchDecoders,
(this$static.state << 4) + posState
)
) {
decoder2 = $GetDecoder(
this$static.m_LiteralDecoder,
lowBits_0(this$static.nowPos64),
this$static.prevByte
)
if (this$static.state < 7) {
this$static.prevByte = $DecodeNormal(decoder2, this$static.m_RangeDecoder)
} else {
this$static.prevByte = $DecodeWithMatchByte(
decoder2,
this$static.m_RangeDecoder,
$GetByte(this$static.m_OutWindow, this$static.rep0)
)
}
$PutByte(this$static.m_OutWindow, this$static.prevByte)
this$static.state = StateUpdateChar(this$static.state)
this$static.nowPos64 = add(this$static.nowPos64, P1_longLit)
} else {
if (
$DecodeBit(
this$static.m_RangeDecoder,
this$static.m_IsRepDecoders,
this$static.state
)
) {
len = 0
if (
!$DecodeBit(
this$static.m_RangeDecoder,
this$static.m_IsRepG0Decoders,
this$static.state
)
) {
if (
!$DecodeBit(
this$static.m_RangeDecoder,
this$static.m_IsRep0LongDecoders,
(this$static.state << 4) + posState
)
) {
this$static.state = this$static.state < 7 ? 9 : 11
len = 1
}
} else {
if (
!$DecodeBit(
this$static.m_RangeDecoder,
this$static.m_IsRepG1Decoders,
this$static.state
)
) {
distance = this$static.rep1
} else {
if (
!$DecodeBit(
this$static.m_RangeDecoder,
this$static.m_IsRepG2Decoders,
this$static.state
)
) {
distance = this$static.rep2
} else {
distance = this$static.rep3
this$static.rep3 = this$static.rep2
}
this$static.rep2 = this$static.rep1
}
this$static.rep1 = this$static.rep0
this$static.rep0 = distance
}
if (!len) {
len =
$Decode(
this$static.m_RepLenDecoder,
this$static.m_RangeDecoder,
posState
) + 2
this$static.state = this$static.state < 7 ? 8 : 11
}
} else {
this$static.rep3 = this$static.rep2
this$static.rep2 = this$static.rep1
this$static.rep1 = this$static.rep0
len =
2 +
$Decode(this$static.m_LenDecoder, this$static.m_RangeDecoder, posState)
this$static.state = this$static.state < 7 ? 7 : 10
posSlot = $Decode_0(
this$static.m_PosSlotDecoder[GetLenToPosState(len)],
this$static.m_RangeDecoder
)
if (posSlot >= 4) {
numDirectBits = (posSlot >> 1) - 1
this$static.rep0 = (2 | (posSlot & 1)) << numDirectBits
if (posSlot < 14) {
this$static.rep0 += ReverseDecode(
this$static.m_PosDecoders,
this$static.rep0 - posSlot - 1,
this$static.m_RangeDecoder,
numDirectBits
)
} else {
this$static.rep0 +=
$DecodeDirectBits(this$static.m_RangeDecoder, numDirectBits - 4) <<
4
this$static.rep0 += $ReverseDecode(
this$static.m_PosAlignDecoder,
this$static.m_RangeDecoder
)
if (this$static.rep0 < 0) {
if (this$static.rep0 == -1) {
return 1
}
return -1
}
}
} else this$static.rep0 = posSlot
}
if (
compare(fromInt(this$static.rep0), this$static.nowPos64) >= 0 ||
this$static.rep0 >= this$static.m_DictionarySizeCheck
) {
return -1
}
$CopyBlock(this$static.m_OutWindow, this$static.rep0, len)
this$static.nowPos64 = add(this$static.nowPos64, fromInt(len))
this$static.prevByte = $GetByte(this$static.m_OutWindow, 0)
}
return 0
}
function $Decoder(this$static) {
this$static.m_OutWindow = {}
this$static.m_RangeDecoder = {}
this$static.m_IsMatchDecoders = initDim(192)
this$static.m_IsRepDecoders = initDim(12)
this$static.m_IsRepG0Decoders = initDim(12)
this$static.m_IsRepG1Decoders = initDim(12)
this$static.m_IsRepG2Decoders = initDim(12)
this$static.m_IsRep0LongDecoders = initDim(192)
this$static.m_PosSlotDecoder = initDim(4)
this$static.m_PosDecoders = initDim(114)
this$static.m_PosAlignDecoder = $BitTreeDecoder({}, 4)
this$static.m_LenDecoder = $Decoder$LenDecoder({})
this$static.m_RepLenDecoder = $Decoder$LenDecoder({})
this$static.m_LiteralDecoder = {}
for (var i = 0; i < 4; ++i) {
this$static.m_PosSlotDecoder[i] = $BitTreeDecoder({}, 6)
}
return this$static
}
function $Init_1(this$static) {
this$static.m_OutWindow._streamPos = 0
this$static.m_OutWindow._pos = 0
InitBitModels(this$static.m_IsMatchDecoders)
InitBitModels(this$static.m_IsRep0LongDecoders)
InitBitModels(this$static.m_IsRepDecoders)
InitBitModels(this$static.m_IsRepG0Decoders)
InitBitModels(this$static.m_IsRepG1Decoders)
InitBitModels(this$static.m_IsRepG2Decoders)
InitBitModels(this$static.m_PosDecoders)
$Init_0(this$static.m_LiteralDecoder)
for (var i = 0; i < 4; ++i) {
InitBitModels(this$static.m_PosSlotDecoder[i].Models)
}
$Init(this$static.m_LenDecoder)
$Init(this$static.m_RepLenDecoder)
InitBitModels(this$static.m_PosAlignDecoder.Models)
$Init_8(this$static.m_RangeDecoder)
}
function $SetDecoderProperties(this$static, properties) {
var dictionarySize, i, lc, lp, pb, remainder, val
if (properties.length < 5) return 0
val = properties[0] & 255
lc = val % 9
remainder = ~~(val / 9)
lp = remainder % 5
pb = ~~(remainder / 5)
dictionarySize = 0
for (i = 0; i < 4; ++i) {
dictionarySize += (properties[1 + i] & 255) << (i * 8)
}
// NOTE: If the input is bad, it might call for an insanely large dictionary size, which would crash the script.
if (dictionarySize > 99999999 || !$SetLcLpPb(this$static, lc, lp, pb)) {
return 0
}
return $SetDictionarySize(this$static, dictionarySize)
}
function $SetDictionarySize(this$static, dictionarySize) {
if (dictionarySize < 0) {
return 0
}
if (this$static.m_DictionarySize != dictionarySize) {
this$static.m_DictionarySize = dictionarySize
this$static.m_DictionarySizeCheck = Math.max(
this$static.m_DictionarySize,
1
)
$Create_5(
this$static.m_OutWindow,
Math.max(this$static.m_DictionarySizeCheck, 4096)
)
}
return 1
}
function $SetLcLpPb(this$static, lc, lp, pb) {
if (lc > 8 || lp > 4 || pb > 4) {
return 0
}
$Create_0(this$static.m_LiteralDecoder, lp, lc)
var numPosStates = 1 << pb
$Create(this$static.m_LenDecoder, numPosStates)
$Create(this$static.m_RepLenDecoder, numPosStates)
this$static.m_PosStateMask = numPosStates - 1
return 1
}
function $Create(this$static, numPosStates) {
for (
;
this$static.m_NumPosStates < numPosStates;
++this$static.m_NumPosStates
) {
this$static.m_LowCoder[this$static.m_NumPosStates] = $BitTreeDecoder({}, 3)
this$static.m_MidCoder[this$static.m_NumPosStates] = $BitTreeDecoder({}, 3)
}
}
function $Decode(this$static, rangeDecoder, posState) {
if (!$DecodeBit(rangeDecoder, this$static.m_Choice, 0)) {
return $Decode_0(this$static.m_LowCoder[posState], rangeDecoder)
}
var symbol = 8
if (!$DecodeBit(rangeDecoder, this$static.m_Choice, 1)) {
symbol += $Decode_0(this$static.m_MidCoder[posState], rangeDecoder)
} else {
symbol += 8 + $Decode_0(this$static.m_HighCoder, rangeDecoder)
}
return symbol
}
function $Decoder$LenDecoder(this$static) {
this$static.m_Choice = initDim(2)
this$static.m_LowCoder = initDim(16)
this$static.m_MidCoder = initDim(16)
this$static.m_HighCoder = $BitTreeDecoder({}, 8)
this$static.m_NumPosStates = 0
return this$static
}
function $Init(this$static) {
InitBitModels(this$static.m_Choice)
for (var posState = 0; posState < this$static.m_NumPosStates; ++posState) {
InitBitModels(this$static.m_LowCoder[posState].Models)
InitBitModels(this$static.m_MidCoder[posState].Models)
}
InitBitModels(this$static.m_HighCoder.Models)
}
function $Create_0(this$static, numPosBits, numPrevBits) {
var i, numStates
if (
this$static.m_Coders != null &&
this$static.m_NumPrevBits == numPrevBits &&
this$static.m_NumPosBits == numPosBits
)
return
this$static.m_NumPosBits = numPosBits
this$static.m_PosMask = (1 << numPosBits) - 1
this$static.m_NumPrevBits = numPrevBits
numStates = 1 << (this$static.m_NumPrevBits + this$static.m_NumPosBits)
this$static.m_Coders = initDim(numStates)
for (i = 0; i < numStates; ++i)
this$static.m_Coders[i] = $Decoder$LiteralDecoder$Decoder2({})
}
function $GetDecoder(this$static, pos, prevByte) {
return this$static.m_Coders[
((pos & this$static.m_PosMask) << this$static.m_NumPrevBits) +
((prevByte & 255) >>> (8 - this$static.m_NumPrevBits))
]
}
function $Init_0(this$static) {
var i, numStates
numStates = 1 << (this$static.m_NumPrevBits + this$static.m_NumPosBits)
for (i = 0; i < numStates; ++i) {
InitBitModels(this$static.m_Coders[i].m_Decoders)
}
}
function $DecodeNormal(this$static, rangeDecoder) {
var symbol = 1
do {
symbol =
(symbol << 1) | $DecodeBit(rangeDecoder, this$static.m_Decoders, symbol)
} while (symbol < 256)
return (symbol << 24) >> 24
}
function $DecodeWithMatchByte(this$static, rangeDecoder, matchByte) {
var bit,
matchBit,
symbol = 1
do {
matchBit = (matchByte >> 7) & 1
matchByte <<= 1
bit = $DecodeBit(
rangeDecoder,
this$static.m_Decoders,
((1 + matchBit) << 8) + symbol
)
symbol = (symbol << 1) | bit
if (matchBit != bit) {
while (symbol < 256) {
symbol =
(symbol << 1) |
$DecodeBit(rangeDecoder, this$static.m_Decoders, symbol)
}
break
}
} while (symbol < 256)
return (symbol << 24) >> 24
}
function $Decoder$LiteralDecoder$Decoder2(this$static) {
this$static.m_Decoders = initDim(768)
return this$static
}
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$static.reps[1] = opt.Backs0
this$static.reps[2] = opt.Backs1
this$static.reps[3] = opt.Backs3
} else {
this$static.reps[0] = opt.Backs3
this$static.reps[1] = opt.Backs0
this$static.reps[2] = opt.Backs1
this$static.reps[3] = opt.Backs2
}
} else {
this$static.reps[0] = pos - 4
this$static.reps[1] = opt.Backs0
this$static.reps[2] = opt.Backs1
this$static.reps[3] = opt.Backs2
}
}
this$static._optimum[cur].State = state
this$static._optimum[cur].Backs0 = this$static.reps[0]
this$static._optimum[cur].Backs1 = this$static.reps[1]
this$static._optimum[cur].Backs2 = this$static.reps[2]
this$static._optimum[cur].Backs3 = this$static.reps[3]
curPrice = this$static._optimum[cur].Price
currentByte = $GetIndexByte(this$static._matchFinder, -1)
matchByte = $GetIndexByte(
this$static._matchFinder,
-this$static.reps[0] - 1 - 1
)
posState = position & this$static._posStateMask
curAnd1Price =
curPrice +
ProbPrices[this$static._isMatch[(state << 4) + posState] >>> 2] +
$GetPrice_0(
$GetSubCoder(
this$static._literalEncoder,
position,
$GetIndexByte(this$static._matchFinder, -2)
),
state >= 7,
matchByte,
currentByte
)
nextOptimum = this$static._optimum[cur + 1]
nextIsChar = 0
if (curAnd1Price < nextOptimum.Price) {
nextOptimum.Price = curAnd1Price
nextOptimum.PosPrev = cur
nextOptimum.BackPrev = -1
nextOptimum.Prev1IsChar = 0
nextIsChar = 1
}
matchPrice =
curPrice +
ProbPrices[(2048 - this$static._isMatch[(state << 4) + posState]) >>> 2]
repMatchPrice =
matchPrice + ProbPrices[(2048 - this$static._isRep[state]) >>> 2]
if (
matchByte == currentByte &&
!(nextOptimum.PosPrev < cur && !nextOptimum.BackPrev)
) {
shortRepPrice =
repMatchPrice +
(ProbPrices[this$static._isRepG0[state] >>> 2] +
ProbPrices[this$static._isRep0Long[(state << 4) + posState] >>> 2])
if (shortRepPrice <= nextOptimum.Price) {
nextOptimum.Price = shortRepPrice
nextOptimum.PosPrev = cur
nextOptimum.BackPrev = 0
nextOptimum.Prev1IsChar = 0
nextIsChar = 1
}
}
numAvailableBytesFull = $GetNumAvailableBytes(this$static._matchFinder) + 1
numAvailableBytesFull =
4095 - cur < numAvailableBytesFull ? 4095 - cur : numAvailableBytesFull
numAvailableBytes = numAvailableBytesFull
if (numAvailableBytes < 2) {
continue
}
if (numAvailableBytes > this$static._numFastBytes) {
numAvailableBytes = this$static._numFastBytes
}
if (!nextIsChar && matchByte != currentByte) {
t = Math.min(numAvailableBytesFull - 1, this$static._numFastBytes)
lenTest2 = $GetMatchLen(
this$static._matchFinder,
0,
this$static.reps[0],
t
)
if (lenTest2 >= 2) {
state2 = StateUpdateChar(state)
posStateNext = (position + 1) & this$static._posStateMask
nextRepMatchPrice =
curAnd1Price +
ProbPrices[
(2048 - this$static._isMatch[(state2 << 4) + posStateNext]) >>> 2
] +
ProbPrices[(2048 - this$static._isRep[state2]) >>> 2]
offset = cur + 1 + lenTest2
while (lenEnd < offset) {
this$static._optimum[++lenEnd].Price = 268435455
}
curAndLenPrice =
nextRepMatchPrice +
((price = $GetPrice(
this$static._repMatchLenEncoder,
lenTest2 - 2,
posStateNext
)),
price + $GetPureRepPrice(this$static, 0, state2, posStateNext))
optimum = this$static._optimum[offset]
if (curAndLenPrice < optimum.Price) {
optimum.Price = curAndLenPrice
optimum.PosPrev = cur + 1
optimum.BackPrev = 0
optimum.Prev1IsChar = 1
optimum.Prev2 = 0
}
}
}
startLen = 2
for (repIndex = 0; repIndex < 4; ++repIndex) {
lenTest = $GetMatchLen(
this$static._matchFinder,
-1,
this$static.reps[repIndex],
numAvailableBytes
)
if (lenTest < 2) {
continue
}
lenTestTemp = lenTest
do {
while (lenEnd < cur + lenTest) {
this$static._optimum[++lenEnd].Price = 268435455
}
curAndLenPrice =
repMatchPrice +
((price_0 = $GetPrice(
this$static._repMatchLenEncoder,
lenTest - 2,
posState
)),
price_0 + $GetPureRepPrice(this$static, repIndex, state, posState))
optimum = this$static._optimum[cur + lenTest]
if (curAndLenPrice < optimum.Price) {
optimum.Price = curAndLenPrice
optimum.PosPrev = cur
optimum.BackPrev = repIndex
optimum.Prev1IsChar = 0
}
} while (--lenTest >= 2)
lenTest = lenTestTemp
if (!repIndex) {
startLen = lenTest + 1
}
if (lenTest < numAvailableBytesFull) {
t = Math.min(
numAvailableBytesFull - 1 - lenTest,
this$static._numFastBytes
)
lenTest2 = $GetMatchLen(
this$static._matchFinder,
lenTest,
this$static.reps[repIndex],
t
)
if (lenTest2 >= 2) {
state2 = state < 7 ? 8 : 11
posStateNext = (position + lenTest) & this$static._posStateMask
curAndLenCharPrice =
repMatchPrice +
((price_1 = $GetPrice(
this$static._repMatchLenEncoder,
lenTest - 2,
posState
)),
price_1 +
$GetPureRepPrice(this$static, repIndex, state, posState)) +
ProbPrices[
this$static._isMatch[(state2 << 4) + posStateNext] >>> 2
] +
$GetPrice_0(
$GetSubCoder(
this$static._literalEncoder,
position + lenTest,
$GetIndexByte(this$static._matchFinder, lenTest - 1 - 1)
),
1,
$GetIndexByte(
this$static._matchFinder,
lenTest - 1 - (this$static.reps[repIndex] + 1)
),
$GetIndexByte(this$static._matchFinder, lenTest - 1)
)
state2 = StateUpdateChar(state2)
posStateNext = (position + lenTest + 1) & this$static._posStateMask
nextMatchPrice =
curAndLenCharPrice +
ProbPrices[
(2048 - this$static._isMatch[(state2 << 4) + posStateNext]) >>> 2
]
nextRepMatchPrice =
nextMatchPrice +
ProbPrices[(2048 - this$static._isRep[state2]) >>> 2]
offset = lenTest + 1 + lenTest2
while (lenEnd < cur + offset) {
this$static._optimum[++lenEnd].Price = 268435455
}
curAndLenPrice =
nextRepMatchPrice +
((price_2 = $GetPrice(
this$static._repMatchLenEncoder,
lenTest2 - 2,
posStateNext
)),
price_2 + $GetPureRepPrice(this$static, 0, state2, posStateNext))
optimum = this$static._optimum[cur + offset]
if (curAndLenPrice < optimum.Price) {
optimum.Price = curAndLenPrice
optimum.PosPrev = cur + lenTest + 1
optimum.BackPrev = 0
optimum.Prev1IsChar = 1
optimum.Prev2 = 1
optimum.PosPrev2 = cur
optimum.BackPrev2 = repIndex
}
}
}
}
if (newLen > numAvailableBytes) {
newLen = numAvailableBytes
for (
numDistancePairs = 0;
newLen > this$static._matchDistances[numDistancePairs];
numDistancePairs += 2
) {}
this$static._matchDistances[numDistancePairs] = newLen
numDistancePairs += 2
}
if (newLen >= startLen) {
normalMatchPrice =
matchPrice + ProbPrices[this$static._isRep[state] >>> 2]
while (lenEnd < cur + newLen) {
this$static._optimum[++lenEnd].Price = 268435455
}
offs = 0
while (startLen > this$static._matchDistances[offs]) {
offs += 2
}
for (lenTest = startLen; ; ++lenTest) {
curBack = this$static._matchDistances[offs + 1]
curAndLenPrice =
normalMatchPrice +
$GetPosLenPrice(this$static, curBack, lenTest, posState)
optimum = this$static._optimum[cur + lenTest]
if (curAndLenPrice < optimum.Price) {
optimum.Price = curAndLenPrice
optimum.PosPrev = cur
optimum.BackPrev = curBack + 4
optimum.Prev1IsChar = 0
}
if (lenTest == this$static._matchDistances[offs]) {
if (lenTest < numAvailableBytesFull) {
t = Math.min(
numAvailableBytesFull - 1 - lenTest,
this$static._numFastBytes
)
lenTest2 = $GetMatchLen(
this$static._matchFinder,
lenTest,
curBack,
t
)
if (lenTest2 >= 2) {
state2 = state < 7 ? 7 : 10
posStateNext = (position + lenTest) & this$static._posStateMask
curAndLenCharPrice =
curAndLenPrice +
ProbPrices[
this$static._isMatch[(state2 << 4) + posStateNext] >>> 2
] +
$GetPrice_0(
$GetSubCoder(
this$static._literalEncoder,
position + lenTest,
$GetIndexByte(this$static._matchFinder, lenTest - 1 - 1)
),
1,
$GetIndexByte(
this$static._matchFinder,
lenTest - (curBack + 1) - 1
),
$GetIndexByte(this$static._matchFinder, lenTest - 1)
)
state2 = StateUpdateChar(state2)
posStateNext =
(position + lenTest + 1) & this$static._posStateMask
nextMatchPrice =
curAndLenCharPrice +
ProbPrices[
(2048 -
this$static._isMatch[(state2 << 4) + posStateNext]) >>>
2
]
nextRepMatchPrice =
nextMatchPrice +
ProbPrices[(2048 - this$static._isRep[state2]) >>> 2]
offset = lenTest + 1 + lenTest2
while (lenEnd < cur + offset) {
this$static._optimum[++lenEnd].Price = 268435455
}
curAndLenPrice =
nextRepMatchPrice +
((price_3 = $GetPrice(
this$static._repMatchLenEncoder,
lenTest2 - 2,
posStateNext
)),
price_3 +
$GetPureRepPrice(this$static, 0, state2, posStateNext))
optimum = this$static._optimum[cur + offset]
if (curAndLenPrice < optimum.Price) {
optimum.Price = curAndLenPrice
optimum.PosPrev = cur + lenTest + 1
optimum.BackPrev = 0
optimum.Prev1IsChar = 1
optimum.Prev2 = 1
optimum.PosPrev2 = cur
optimum.BackPrev2 = curBack + 4
}
}
}
offs += 2
if (offs == numDistancePairs) break
}
}
}
}
}
function $GetPosLenPrice(this$static, pos, len, posState) {
var price,
lenToPosState = GetLenToPosState(len)
if (pos < 128) {
price = this$static._distancesPrices[lenToPosState * 128 + pos]
} else {
price =
this$static._posSlotPrices[(lenToPosState << 6) + GetPosSlot2(pos)] +
this$static._alignPrices[pos & 15]
}
return price + $GetPrice(this$static._lenEncoder, len - 2, posState)
}
function $GetPureRepPrice(this$static, repIndex, state, posState) {
var price
if (!repIndex) {
price = ProbPrices[this$static._isRepG0[state] >>> 2]
price +=
ProbPrices[
(2048 - this$static._isRep0Long[(state << 4) + posState]) >>> 2
]
} else {
price = ProbPrices[(2048 - this$static._isRepG0[state]) >>> 2]
if (repIndex == 1) {
price += ProbPrices[this$static._isRepG1[state] >>> 2]
} else {
price += ProbPrices[(2048 - this$static._isRepG1[state]) >>> 2]
price += GetPrice(this$static._isRepG2[state], repIndex - 2)
}
}
return price
}
function $GetRepLen1Price(this$static, state, posState) {
return (
ProbPrices[this$static._isRepG0[state] >>> 2] +
ProbPrices[this$static._isRep0Long[(state << 4) + posState] >>> 2]
)
}
function $Init_4(this$static) {
$BaseInit(this$static)
$Init_9(this$static._rangeEncoder)
InitBitModels(this$static._isMatch)
InitBitModels(this$static._isRep0Long)
InitBitModels(this$static._isRep)
InitBitModels(this$static._isRepG0)
InitBitModels(this$static._isRepG1)
InitBitModels(this$static._isRepG2)
InitBitModels(this$static._posEncoders)
$Init_3(this$static._literalEncoder)
for (var i = 0; i < 4; ++i) {
InitBitModels(this$static._posSlotEncoder[i].Models)
}
$Init_2(this$static._lenEncoder, 1 << this$static._posStateBits)
$Init_2(this$static._repMatchLenEncoder, 1 << this$static._posStateBits)
InitBitModels(this$static._posAlignEncoder.Models)
this$static._longestMatchWasFound = 0
this$static._optimumEndIndex = 0
this$static._optimumCurrentIndex = 0
this$static._additionalOffset = 0
}
function $MovePos(this$static, num) {
if (num > 0) {
$Skip(this$static._matchFinder, num)
this$static._additionalOffset += num
}
}
function $ReadMatchDistances(this$static) {
var lenRes = 0
this$static._numDistancePairs = $GetMatches(
this$static._matchFinder,
this$static._matchDistances
)
if (this$static._numDistancePairs > 0) {
lenRes = this$static._matchDistances[this$static._numDistancePairs - 2]
if (lenRes == this$static._numFastBytes)
lenRes += $GetMatchLen(
this$static._matchFinder,
lenRes - 1,
this$static._matchDistances[this$static._numDistancePairs - 1],
273 - lenRes
)
}
++this$static._additionalOffset
return lenRes
}
function $ReleaseMFStream(this$static) {
if (this$static._matchFinder && this$static._needReleaseMFStream) {
this$static._matchFinder._stream = null
this$static._needReleaseMFStream = 0
}
}
function $ReleaseStreams(this$static) {
$ReleaseMFStream(this$static)
this$static._rangeEncoder.Stream = null
}
function $SetDictionarySize_0(this$static, dictionarySize) {
this$static._dictionarySize = dictionarySize
for (var dicLogSize = 0; dictionarySize > 1 << dicLogSize; ++dicLogSize) {}
this$static._distTableSize = dicLogSize * 2
}
function $SetMatchFinder(this$static, matchFinderIndex) {
var matchFinderIndexPrev = this$static._matchFinderType
this$static._matchFinderType = matchFinderIndex
if (
this$static._matchFinder &&
matchFinderIndexPrev != this$static._matchFinderType
) {
this$static._dictionarySizePrev = -1
this$static._matchFinder = null
}
}
function $WriteCoderProperties(this$static, outStream) {
this$static.properties[0] =
(((this$static._posStateBits * 5 + this$static._numLiteralPosStateBits) *
9 +
this$static._numLiteralContextBits) <<
24) >>
24
for (var i = 0; i < 4; ++i) {
this$static.properties[1 + i] =
((this$static._dictionarySize >> (8 * i)) << 24) >> 24
}
$write_0(outStream, this$static.properties, 0, 5)
}
function $WriteEndMarker(this$static, posState) {
if (!this$static._writeEndMark) {
return
}
$Encode_3(
this$static._rangeEncoder,
this$static._isMatch,
(this$static._state << 4) + posState,
1
)
$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, 0, posState)
var lenToPosState = GetLenToPosState(2)
$Encode_2(
this$static._posSlotEncoder[lenToPosState],
this$static._rangeEncoder,
63
)
$EncodeDirectBits(this$static._rangeEncoder, 67108863, 26)
$ReverseEncode(this$static._posAlignEncoder, this$static._rangeEncoder, 15)
}
function GetPosSlot(pos) {
if (pos < 2048) {
return g_FastPos[pos]
}
if (pos < 2097152) {
return g_FastPos[pos >> 10] + 20
}
return g_FastPos[pos >> 20] + 40
}
function GetPosSlot2(pos) {
if (pos < 131072) {
return g_FastPos[pos >> 6] + 12
}
if (pos < 134217728) {
return g_FastPos[pos >> 16] + 32
}
return g_FastPos[pos >> 26] + 52
}
function $Encode(this$static, rangeEncoder, symbol, posState) {
if (symbol < 8) {
$Encode_3(rangeEncoder, this$static._choice, 0, 0)
$Encode_2(this$static._lowCoder[posState], rangeEncoder, symbol)
} else {
symbol -= 8
$Encode_3(rangeEncoder, this$static._choice, 0, 1)
if (symbol < 8) {
$Encode_3(rangeEncoder, this$static._choice, 1, 0)
$Encode_2(this$static._midCoder[posState], rangeEncoder, symbol)
} else {
$Encode_3(rangeEncoder, this$static._choice, 1, 1)
$Encode_2(this$static._highCoder, rangeEncoder, symbol - 8)
}
}
}
function $Encoder$LenEncoder(this$static) {
this$static._choice = initDim(2)
this$static._lowCoder = initDim(16)
this$static._midCoder = initDim(16)
this$static._highCoder = $BitTreeEncoder({}, 8)
for (var posState = 0; posState < 16; ++posState) {
this$static._lowCoder[posState] = $BitTreeEncoder({}, 3)
this$static._midCoder[posState] = $BitTreeEncoder({}, 3)
}
return this$static
}
function $Init_2(this$static, numPosStates) {
InitBitModels(this$static._choice)
for (var posState = 0; posState < numPosStates; ++posState) {
InitBitModels(this$static._lowCoder[posState].Models)
InitBitModels(this$static._midCoder[posState].Models)
}
InitBitModels(this$static._highCoder.Models)
}
function $SetPrices(this$static, posState, numSymbols, prices, st) {
var a0, a1, b0, b1, i
a0 = ProbPrices[this$static._choice[0] >>> 2]
a1 = ProbPrices[(2048 - this$static._choice[0]) >>> 2]
b0 = a1 + ProbPrices[this$static._choice[1] >>> 2]
b1 = a1 + ProbPrices[(2048 - this$static._choice[1]) >>> 2]
i = 0
for (i = 0; i < 8; ++i) {
if (i >= numSymbols) return
prices[st + i] = a0 + $GetPrice_1(this$static._lowCoder[posState], i)
}
for (; i < 16; ++i) {
if (i >= numSymbols) return
prices[st + i] = b0 + $GetPrice_1(this$static._midCoder[posState], i - 8)
}
for (; i < numSymbols; ++i) {
prices[st + i] = b1 + $GetPrice_1(this$static._highCoder, i - 8 - 8)
}
}
function $Encode_0(this$static, rangeEncoder, symbol, posState) {
$Encode(this$static, rangeEncoder, symbol, posState)
if (--this$static._counters[posState] == 0) {
$SetPrices(
this$static,
posState,
this$static._tableSize,
this$static._prices,
posState * 272
)
this$static._counters[posState] = this$static._tableSize
}
}
function $Encoder$LenPriceTableEncoder(this$static) {
$Encoder$LenEncoder(this$static)
this$static._prices = []
this$static._counters = []
return this$static
}
function $GetPrice(this$static, symbol, posState) {
return this$static._prices[posState * 272 + symbol]
}
function $UpdateTables(this$static, numPosStates) {
for (var posState = 0; posState < numPosStates; ++posState) {
$SetPrices(
this$static,
posState,
this$static._tableSize,
this$static._prices,
posState * 272
)
this$static._counters[posState] = this$static._tableSize
}
}
function $Create_1(this$static, numPosBits, numPrevBits) {
var i, numStates
if (
this$static.m_Coders != null &&
this$static.m_NumPrevBits == numPrevBits &&
this$static.m_NumPosBits == numPosBits
) {
return
}
this$static.m_NumPosBits = numPosBits
this$static.m_PosMask = (1 << numPosBits) - 1
this$static.m_NumPrevBits = numPrevBits
numStates = 1 << (this$static.m_NumPrevBits + this$static.m_NumPosBits)
this$static.m_Coders = initDim(numStates)
for (i = 0; i < numStates; ++i) {
this$static.m_Coders[i] = $Encoder$LiteralEncoder$Encoder2({})
}
}
function $GetSubCoder(this$static, pos, prevByte) {
return this$static.m_Coders[
((pos & this$static.m_PosMask) << this$static.m_NumPrevBits) +
((prevByte & 255) >>> (8 - this$static.m_NumPrevBits))
]
}
function $Init_3(this$static) {
var i,
numStates = 1 << (this$static.m_NumPrevBits + this$static.m_NumPosBits)
for (i = 0; i < numStates; ++i) {
InitBitModels(this$static.m_Coders[i].m_Encoders)
}
}
function $Encode_1(this$static, rangeEncoder, symbol) {
var bit,
i,
context = 1
for (i = 7; i >= 0; --i) {
bit = (symbol >> i) & 1
$Encode_3(rangeEncoder, this$static.m_Encoders, context, bit)
context = (context << 1) | bit
}
}
function $EncodeMatched(this$static, rangeEncoder, matchByte, symbol) {
var bit,
i,
matchBit,
state,
same = 1,
context = 1
for (i = 7; i >= 0; --i) {
bit = (symbol >> i) & 1
state = context
if (same) {
matchBit = (matchByte >> i) & 1
state += (1 + matchBit) << 8
same = matchBit == bit
}
$Encode_3(rangeEncoder, this$static.m_Encoders, state, bit)
context = (context << 1) | bit
}
}
function $Encoder$LiteralEncoder$Encoder2(this$static) {
this$static.m_Encoders = initDim(768)
return this$static
}
function $GetPrice_0(this$static, matchMode, matchByte, symbol) {
var bit,
context = 1,
i = 7,
matchBit,
price = 0
if (matchMode) {
for (; i >= 0; --i) {
matchBit = (matchByte >> i) & 1
bit = (symbol >> i) & 1
price += GetPrice(
this$static.m_Encoders[((1 + matchBit) << 8) + context],
bit
)
context = (context << 1) | bit
if (matchBit != bit) {
--i
break
}
}
}
for (; i >= 0; --i) {
bit = (symbol >> i) & 1
price += GetPrice(this$static.m_Encoders[context], bit)
context = (context << 1) | bit
}
return price
}
function $MakeAsChar(this$static) {
this$static.BackPrev = -1
this$static.Prev1IsChar = 0
}
function $MakeAsShortRep(this$static) {
this$static.BackPrev = 0
this$static.Prev1IsChar = 0
}
function $BitTreeDecoder(this$static, numBitLevels) {
this$static.NumBitLevels = numBitLevels
this$static.Models = initDim(1 << numBitLevels)
return this$static
}
function $Decode_0(this$static, rangeDecoder) {
var bitIndex,
m = 1
for (bitIndex = this$static.NumBitLevels; bitIndex != 0; --bitIndex) {
m = (m << 1) + $DecodeBit(rangeDecoder, this$static.Models, m)
}
return m - (1 << this$static.NumBitLevels)
}
function $ReverseDecode(this$static, rangeDecoder) {
var bit,
bitIndex,
m = 1,
symbol = 0
for (bitIndex = 0; bitIndex < this$static.NumBitLevels; ++bitIndex) {
bit = $DecodeBit(rangeDecoder, this$static.Models, m)
m <<= 1
m += bit
symbol |= bit << bitIndex
}
return symbol
}
function ReverseDecode(Models, startIndex, rangeDecoder, NumBitLevels) {
var bit,
bitIndex,
m = 1,
symbol = 0
for (bitIndex = 0; bitIndex < NumBitLevels; ++bitIndex) {
bit = $DecodeBit(rangeDecoder, Models, startIndex + m)
m <<= 1
m += bit
symbol |= bit << bitIndex
}
return symbol
}
function $BitTreeEncoder(this$static, numBitLevels) {
this$static.NumBitLevels = numBitLevels
this$static.Models = initDim(1 << numBitLevels)
return this$static
}
function $Encode_2(this$static, rangeEncoder, symbol) {
var bit,
bitIndex,
m = 1
for (bitIndex = this$static.NumBitLevels; bitIndex != 0; ) {
--bitIndex
bit = (symbol >>> bitIndex) & 1
$Encode_3(rangeEncoder, this$static.Models, m, bit)
m = (m << 1) | bit
}
}
function $GetPrice_1(this$static, symbol) {
var bit,
bitIndex,
m = 1,
price = 0
for (bitIndex = this$static.NumBitLevels; bitIndex != 0; ) {
--bitIndex
bit = (symbol >>> bitIndex) & 1
price += GetPrice(this$static.Models[m], bit)
m = (m << 1) + bit
}
return price
}
function $ReverseEncode(this$static, rangeEncoder, symbol) {
var bit,
i,
m = 1
for (i = 0; i < this$static.NumBitLevels; ++i) {
bit = symbol & 1
$Encode_3(rangeEncoder, this$static.Models, m, bit)
m = (m << 1) | bit
symbol >>= 1
}
}
function $ReverseGetPrice(this$static, symbol) {
var bit,
i,
m = 1,
price = 0
for (i = this$static.NumBitLevels; i != 0; --i) {
bit = symbol & 1
symbol >>>= 1
price += GetPrice(this$static.Models[m], bit)
m = (m << 1) | bit
}
return price
}
function ReverseEncode(Models, startIndex, rangeEncoder, NumBitLevels, symbol) {
var bit,
i,
m = 1
for (i = 0; i < NumBitLevels; ++i) {
bit = symbol & 1
$Encode_3(rangeEncoder, Models, startIndex + m, bit)
m = (m << 1) | bit
symbol >>= 1
}
}
function ReverseGetPrice(Models, startIndex, NumBitLevels, symbol) {
var bit,
i,
m = 1,
price = 0
for (i = NumBitLevels; i != 0; --i) {
bit = symbol & 1
symbol >>>= 1
price += ProbPrices[(((Models[startIndex + m] - bit) ^ -bit) & 2047) >>> 2]
m = (m << 1) | bit
}
return price
}
function $DecodeBit(this$static, probs, index) {
var newBound,
prob = probs[index]
newBound = (this$static.Range >>> 11) * prob
if ((this$static.Code ^ -2147483648) < (newBound ^ -2147483648)) {
this$static.Range = newBound
probs[index] = ((prob + ((2048 - prob) >>> 5)) << 16) >> 16
if (!(this$static.Range & -16777216)) {
this$static.Code = (this$static.Code << 8) | $read(this$static.Stream)
this$static.Range <<= 8
}
return 0
} else {
this$static.Range -= newBound
this$static.Code -= newBound
probs[index] = ((prob - (prob >>> 5)) << 16) >> 16
if (!(this$static.Range & -16777216)) {
this$static.Code = (this$static.Code << 8) | $read(this$static.Stream)
this$static.Range <<= 8
}
return 1
}
}
function $DecodeDirectBits(this$static, numTotalBits) {
var i,
t,
result = 0
for (i = numTotalBits; i != 0; --i) {
this$static.Range >>>= 1
t = (this$static.Code - this$static.Range) >>> 31
this$static.Code -= this$static.Range & (t - 1)
result = (result << 1) | (1 - t)
if (!(this$static.Range & -16777216)) {
this$static.Code = (this$static.Code << 8) | $read(this$static.Stream)
this$static.Range <<= 8
}
}
return result
}
function $Init_8(this$static) {
this$static.Code = 0
this$static.Range = -1
for (var i = 0; i < 5; ++i) {
this$static.Code = (this$static.Code << 8) | $read(this$static.Stream)
}
}
function InitBitModels(probs) {
for (var i = probs.length - 1; i >= 0; --i) {
probs[i] = 1024
}
}
var ProbPrices = (function() {
var end,
i,
j,
start,
ProbPrices = []
for (i = 8; i >= 0; --i) {
start = 1 << (9 - i - 1)
end = 1 << (9 - i)
for (j = start; j < end; ++j) {
ProbPrices[j] = (i << 6) + (((end - j) << 6) >>> (9 - i - 1))
}
}
return ProbPrices
})()
function $Encode_3(this$static, probs, index, symbol) {
var newBound,
prob = probs[index]
newBound = (this$static.Range >>> 11) * prob
if (!symbol) {
this$static.Range = newBound
probs[index] = ((prob + ((2048 - prob) >>> 5)) << 16) >> 16
} else {
this$static.Low = add(
this$static.Low,
and(fromInt(newBound), [4294967295, 0])
)
this$static.Range -= newBound
probs[index] = ((prob - (prob >>> 5)) << 16) >> 16
}
if (!(this$static.Range & -16777216)) {
this$static.Range <<= 8
$ShiftLow(this$static)
}
}
function $EncodeDirectBits(this$static, v, numTotalBits) {
for (var i = numTotalBits - 1; i >= 0; --i) {
this$static.Range >>>= 1
if (((v >>> i) & 1) == 1) {
this$static.Low = add(this$static.Low, fromInt(this$static.Range))
}
if (!(this$static.Range & -16777216)) {
this$static.Range <<= 8
$ShiftLow(this$static)
}
}
}
function $GetProcessedSizeAdd(this$static) {
return add(add(fromInt(this$static._cacheSize), this$static._position), [
4,
0
])
}
function $Init_9(this$static) {
this$static._position = P0_longLit
this$static.Low = P0_longLit
this$static.Range = -1
this$static._cacheSize = 1
this$static._cache = 0
}
function $ShiftLow(this$static) {
var temp,
LowHi = lowBits_0(shru(this$static.Low, 32))
if (LowHi != 0 || compare(this$static.Low, [4278190080, 0]) < 0) {
this$static._position = add(
this$static._position,
fromInt(this$static._cacheSize)
)
temp = this$static._cache
do {
$write(this$static.Stream, temp + LowHi)
temp = 255
} while (--this$static._cacheSize != 0)
this$static._cache = lowBits_0(this$static.Low) >>> 24
}
++this$static._cacheSize
this$static.Low = shl(and(this$static.Low, [16777215, 0]), 8)
}
function GetPrice(Prob, symbol) {
return ProbPrices[(((Prob - symbol) ^ -symbol) & 2047) >>> 2]
}
function decode(utf) {
var i = 0,
j = 0,
x,
y,
z,
l = utf.length,
buf = [],
charCodes = []
for (; i < l; ++i, ++j) {
x = utf[i] & 255
if (!(x & 128)) {
if (!x) {
// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf
}
charCodes[j] = x
} else if ((x & 224) == 192) {
if (i + 1 >= l) {
// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf
}
y = utf[++i] & 255
if ((y & 192) != 128) {
// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf
}
charCodes[j] = ((x & 31) << 6) | (y & 63)
} else if ((x & 240) == 224) {
if (i + 2 >= l) {
// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf
}
y = utf[++i] & 255
if ((y & 192) != 128) {
// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf
}
z = utf[++i] & 255
if ((z & 192) != 128) {
// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf
}
charCodes[j] = ((x & 15) << 12) | ((y & 63) << 6) | (z & 63)
} else {
// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf
}
if (j == 16383) {
buf.push(String.fromCharCode.apply(String, charCodes))
j = -1
}
}
if (j > 0) {
charCodes.length = j
buf.push(String.fromCharCode.apply(String, charCodes))
}
return buf.join('')
}
function encode(s) {
var ch,
chars = [],
data,
elen = 0,
i,
l = s.length
// Be able to handle binary arrays and buffers.
if (typeof s == 'object') {
return s
} else {
$getChars(s, 0, l, chars, 0)
}
// Add extra spaces in the array to break up the unicode symbols.
for (i = 0; i < l; ++i) {
ch = chars[i]
if (ch >= 1 && ch <= 127) {
++elen
} else if (!ch || (ch >= 128 && ch <= 2047)) {
elen += 2
} else {
elen += 3
}
}
data = []
elen = 0
for (i = 0; i < l; ++i) {
ch = chars[i]
if (ch >= 1 && ch <= 127) {
data[elen++] = (ch << 24) >> 24
} else if (!ch || (ch >= 128 && ch <= 2047)) {
data[elen++] = ((192 | ((ch >> 6) & 31)) << 24) >> 24
data[elen++] = ((128 | (ch & 63)) << 24) >> 24
} else {
data[elen++] = ((224 | ((ch >> 12) & 15)) << 24) >> 24
data[elen++] = ((128 | ((ch >> 6) & 63)) << 24) >> 24
data[elen++] = ((128 | (ch & 63)) << 24) >> 24
}
}
return data
}
// s is dictionarySize
// f is fb
// m is matchFinder
// NOTE: Because some values are always the same, they have been removed.
// lc is always 3
// lp is always 0
// pb is always 2
const modes = [
{ s: 16, f: 64, m: 0 },
{ s: 20, f: 64, m: 0 },
{ s: 19, f: 64, m: 1 },
{ s: 20, f: 64, m: 1 },
{ s: 21, f: 128, m: 1 },
{ s: 22, f: 128, m: 1 },
{ s: 23, f: 128, m: 1 },
{ s: 24, f: 255, m: 1 },
{ s: 25, f: 255, m: 1 }
]
function get_mode_obj(mode) {
return modes[mode - 1] || modes[6]
}
/**
* Compress a string with the LZMA algorithm
*
* @param {string} value The string to be compressed
* @param {object} options
* @param {1|2|3|4|5|6|7|8|9} options.mode Which mode to use (1 through 9, defaults to 7)
* @param {boolean} options.enableEndMark Whether to write an end mark
* @returns {string}
*/
export function compress(value, { mode = 7, enableEndMark = true } = {}) {
var this$static = {}
this$static.c = $LZMAByteArrayCompressor(
{},
encode(value),
get_mode_obj(mode),
enableEndMark
)
while ($processChunk(this$static.c.chunker));
return $toByteArray(this$static.c.output)
}
/**
* Compress a string with the LZMA algorithm to URL-safe characters
*
* @param {string} value The string to be compressed
* @param {object} options
* @param {1|2|3|4|5|6|7|8|9} options.mode Which mode to use (1 through 9, defaults to 7)
* @param {boolean} options.enableEndMark Whether to write an end mark
* @returns {string}
*/
export function compressUrlSafe(
string,
{ mode = 7, enableEndMark = true } = {}
) {
const compressedString = compress(string, { mode, enableEndMark })
const compressedBytes = new Uint8Array(compressedString)
return base64.encodeFromArrayUrlSafe(compressedBytes)
}
/**
* Decompress a string compressed with the LZMA algorithm
*
* @param {number[]|Int8Array} bytes The int8 array created by the compress() function
* @returns {string}
*/
export function decompress(bytes) {
var this$static = {}
this$static.d = $LZMAByteArrayDecompressor({}, bytes)
while ($processChunk(this$static.d.chunker));
return decode($toByteArray(this$static.d.output))
}
/**
* Decompress a string compressed with the URL-safe compress function
*
* @param {string} string The URL-safe string generated by the compressUrlSafe() function
* @returns {string}
*/
export function decompressUrlSafe(string) {
return decompress(new Int8Array(base64.decodeToArrayUrlSafe(string)))
}
@Codezigineer
Copy link

Without base64 at all:

const __4294967296 = 4294967296,
  N1_longLit = [4294967295, -__4294967296],
  MIN_VALUE = [0, -9223372036854775808],
  P0_longLit = [0, 0],
  P1_longLit = [1, 0]

function add(a, b) {
  return create(a[0] + b[0], a[1] + b[1])
}

function initDim(len) {
  // NOTE: This is MUCH faster than "initDim(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 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)
  )
}
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]
}
function eq(a, b) {
  return a[0] == b[0] && a[1] == b[1]
}
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)
  }
}
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
}
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
}
function $read(this$static) {
  if (this$static.pos >= this$static.count) return -1
  return this$static.buf[this$static.pos++] & 255
}
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
}
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
}
function $write(this$static, b) {
  this$static.buf[this$static.count++] = (b << 24) >> 24
}
function $write_0(this$static, buf, off, len) {
  arraycopy(buf, off, this$static.buf, this$static.count, len)
  this$static.count += len
}
function $getChars(this$static, srcBegin, srcEnd, dst, dstBegin) {
  var srcIdx
  for (srcIdx = srcBegin; srcIdx < srcEnd; ++srcIdx) {
    dst[dstBegin++] = this$static.charCodeAt(srcIdx)
  }
}
function arraycopy(src, srcOfs, dest, destOfs, len) {
  for (var i = 0; i < len; ++i) {
    dest[destOfs + i] = src[srcOfs + i]
  }
}
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
  encoder._posStateMask = 3
}

function $init(this$static, input, output, length_0, mode, enableEndMark) {
  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 = enableEndMark
  $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, enableEndMark) {
  this$static.output = $ByteArrayOutputStream({})
  $init(
    this$static,
    $ByteArrayInputStream({}, data),
    this$static.output,
    fromInt(data.length),
    mode,
    enableEndMark
  )
  return this$static
}
function $init_0(this$static, input, output) {
  var decoder,
    hex_length = '',
    i,
    properties = [],
    r,
    tmp_length

  for (i = 0; i < 5; ++i) {
    r = $read(input)
    if (r == -1) throw new Error('truncated input')
    properties[i] = (r << 24) >> 24
  }

  decoder = $Decoder({})
  if (!$SetDecoderProperties(decoder, properties)) {
    throw new Error('corrupted input')
  }
  for (i = 0; i < 64; i += 8) {
    r = $read(input)
    if (r == -1) throw new Error('truncated input')
    r = r.toString(16)
    if (r.length == 1) r = '0' + r
    hex_length = r + '' + hex_length
  }

  // Was the length set in the header (if it was compressed from a stream, the length is all f"s).
  if (/^0+$|^f+$/i.test(hex_length)) {
    // The length is unknown, so set to -1.
    this$static.length_0 = N1_longLit
  } else {
    // NOTE: If there is a problem with the decoder because of the length, you can always set the length to -1 (N1_longLit) which means unknown.
    tmp_length = parseInt(hex_length, 16)
    // If the length is too long to handle, just set it to unknown.
    if (tmp_length > 4294967295) {
      this$static.length_0 = N1_longLit
    } else {
      this$static.length_0 = fromInt(tmp_length)
    }
  }

  this$static.chunker = $CodeInChunks(
    decoder,
    input,
    output,
    this$static.length_0
  )
}

function $LZMAByteArrayDecompressor(this$static, data) {
  this$static.output = $ByteArrayOutputStream({})
  $init_0(this$static, $ByteArrayInputStream({}, data), this$static.output)
  return this$static
}
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)
}
function $CopyBlock(this$static, distance, len) {
  var pos = this$static._pos - distance - 1
  if (pos < 0) {
    pos += this$static._windowSize
  }
  for (; len != 0; --len) {
    if (pos >= this$static._windowSize) {
      pos = 0
    }
    this$static._buffer[this$static._pos++] = this$static._buffer[pos++]
    if (this$static._pos >= this$static._windowSize) {
      $Flush_0(this$static)
    }
  }
}

function $Create_5(this$static, windowSize) {
  if (this$static._buffer == null || this$static._windowSize != windowSize) {
    this$static._buffer = initDim(windowSize)
  }
  this$static._windowSize = windowSize
  this$static._pos = 0
  this$static._streamPos = 0
}

function $Flush_0(this$static) {
  var size = this$static._pos - this$static._streamPos
  if (!size) {
    return
  }
  $write_0(
    this$static._stream,
    this$static._buffer,
    this$static._streamPos,
    size
  )
  if (this$static._pos >= this$static._windowSize) {
    this$static._pos = 0
  }
  this$static._streamPos = this$static._pos
}

function $GetByte(this$static, distance) {
  var pos = this$static._pos - distance - 1
  if (pos < 0) {
    pos += this$static._windowSize
  }
  return this$static._buffer[pos]
}

function $PutByte(this$static, b) {
  this$static._buffer[this$static._pos++] = b
  if (this$static._pos >= this$static._windowSize) {
    $Flush_0(this$static)
  }
}

function $ReleaseStream(this$static) {
  $Flush_0(this$static)
  this$static._stream = null
}
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
}
function $Chunker_0(this$static, encoder) {
  this$static.encoder = encoder
  this$static.decoder = null
  this$static.alive = 1
  return this$static
}
function $Chunker(this$static, decoder) {
  this$static.decoder = decoder
  this$static.encoder = null
  this$static.alive = 1
  return this$static
}
function $processChunk(this$static) {
  if (!this$static.alive) {
    throw new Error('bad state')
  }

  if (this$static.encoder) {
    $processEncoderChunk(this$static)
  } else {
    $processDecoderChunk(this$static)
  }

  return this$static.alive
}
function $processDecoderChunk(this$static) {
  var result = $CodeOneChunk(this$static.decoder)
  if (result == -1) {
    throw new Error('corrupted input')
  }
  this$static.inBytesProcessed = N1_longLit
  this$static.outBytesProcessed = this$static.decoder.nowPos64
  if (
    result ||
    (compare(this$static.decoder.outSize, P0_longLit) >= 0 &&
      compare(this$static.decoder.nowPos64, this$static.decoder.outSize) >= 0)
  ) {
    $Flush_0(this$static.decoder.m_OutWindow)
    $ReleaseStream(this$static.decoder.m_OutWindow)
    this$static.decoder.m_RangeDecoder.Stream = null
    this$static.alive = 0
  }
}
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
  }
}
function $CodeInChunks(this$static, inStream, outStream, outSize) {
  this$static.m_RangeDecoder.Stream = inStream
  $ReleaseStream(this$static.m_OutWindow)
  this$static.m_OutWindow._stream = outStream
  $Init_1(this$static)
  this$static.state = 0
  this$static.rep0 = 0
  this$static.rep1 = 0
  this$static.rep2 = 0
  this$static.rep3 = 0
  this$static.outSize = outSize
  this$static.nowPos64 = P0_longLit
  this$static.prevByte = 0
  return $Chunker({}, this$static)
}

function $CodeOneChunk(this$static) {
  var decoder2, distance, len, numDirectBits, posSlot, posState
  posState = lowBits_0(this$static.nowPos64) & this$static.m_PosStateMask
  if (
    !$DecodeBit(
      this$static.m_RangeDecoder,
      this$static.m_IsMatchDecoders,
      (this$static.state << 4) + posState
    )
  ) {
    decoder2 = $GetDecoder(
      this$static.m_LiteralDecoder,
      lowBits_0(this$static.nowPos64),
      this$static.prevByte
    )
    if (this$static.state < 7) {
      this$static.prevByte = $DecodeNormal(decoder2, this$static.m_RangeDecoder)
    } else {
      this$static.prevByte = $DecodeWithMatchByte(
        decoder2,
        this$static.m_RangeDecoder,
        $GetByte(this$static.m_OutWindow, this$static.rep0)
      )
    }
    $PutByte(this$static.m_OutWindow, this$static.prevByte)
    this$static.state = StateUpdateChar(this$static.state)
    this$static.nowPos64 = add(this$static.nowPos64, P1_longLit)
  } else {
    if (
      $DecodeBit(
        this$static.m_RangeDecoder,
        this$static.m_IsRepDecoders,
        this$static.state
      )
    ) {
      len = 0
      if (
        !$DecodeBit(
          this$static.m_RangeDecoder,
          this$static.m_IsRepG0Decoders,
          this$static.state
        )
      ) {
        if (
          !$DecodeBit(
            this$static.m_RangeDecoder,
            this$static.m_IsRep0LongDecoders,
            (this$static.state << 4) + posState
          )
        ) {
          this$static.state = this$static.state < 7 ? 9 : 11
          len = 1
        }
      } else {
        if (
          !$DecodeBit(
            this$static.m_RangeDecoder,
            this$static.m_IsRepG1Decoders,
            this$static.state
          )
        ) {
          distance = this$static.rep1
        } else {
          if (
            !$DecodeBit(
              this$static.m_RangeDecoder,
              this$static.m_IsRepG2Decoders,
              this$static.state
            )
          ) {
            distance = this$static.rep2
          } else {
            distance = this$static.rep3
            this$static.rep3 = this$static.rep2
          }
          this$static.rep2 = this$static.rep1
        }
        this$static.rep1 = this$static.rep0
        this$static.rep0 = distance
      }
      if (!len) {
        len =
          $Decode(
            this$static.m_RepLenDecoder,
            this$static.m_RangeDecoder,
            posState
          ) + 2
        this$static.state = this$static.state < 7 ? 8 : 11
      }
    } else {
      this$static.rep3 = this$static.rep2
      this$static.rep2 = this$static.rep1
      this$static.rep1 = this$static.rep0
      len =
        2 +
        $Decode(this$static.m_LenDecoder, this$static.m_RangeDecoder, posState)
      this$static.state = this$static.state < 7 ? 7 : 10
      posSlot = $Decode_0(
        this$static.m_PosSlotDecoder[GetLenToPosState(len)],
        this$static.m_RangeDecoder
      )
      if (posSlot >= 4) {
        numDirectBits = (posSlot >> 1) - 1
        this$static.rep0 = (2 | (posSlot & 1)) << numDirectBits
        if (posSlot < 14) {
          this$static.rep0 += ReverseDecode(
            this$static.m_PosDecoders,
            this$static.rep0 - posSlot - 1,
            this$static.m_RangeDecoder,
            numDirectBits
          )
        } else {
          this$static.rep0 +=
            $DecodeDirectBits(this$static.m_RangeDecoder, numDirectBits - 4) <<
            4
          this$static.rep0 += $ReverseDecode(
            this$static.m_PosAlignDecoder,
            this$static.m_RangeDecoder
          )
          if (this$static.rep0 < 0) {
            if (this$static.rep0 == -1) {
              return 1
            }
            return -1
          }
        }
      } else this$static.rep0 = posSlot
    }
    if (
      compare(fromInt(this$static.rep0), this$static.nowPos64) >= 0 ||
      this$static.rep0 >= this$static.m_DictionarySizeCheck
    ) {
      return -1
    }
    $CopyBlock(this$static.m_OutWindow, this$static.rep0, len)
    this$static.nowPos64 = add(this$static.nowPos64, fromInt(len))
    this$static.prevByte = $GetByte(this$static.m_OutWindow, 0)
  }
  return 0
}

function $Decoder(this$static) {
  this$static.m_OutWindow = {}
  this$static.m_RangeDecoder = {}
  this$static.m_IsMatchDecoders = initDim(192)
  this$static.m_IsRepDecoders = initDim(12)
  this$static.m_IsRepG0Decoders = initDim(12)
  this$static.m_IsRepG1Decoders = initDim(12)
  this$static.m_IsRepG2Decoders = initDim(12)
  this$static.m_IsRep0LongDecoders = initDim(192)
  this$static.m_PosSlotDecoder = initDim(4)
  this$static.m_PosDecoders = initDim(114)
  this$static.m_PosAlignDecoder = $BitTreeDecoder({}, 4)
  this$static.m_LenDecoder = $Decoder$LenDecoder({})
  this$static.m_RepLenDecoder = $Decoder$LenDecoder({})
  this$static.m_LiteralDecoder = {}
  for (var i = 0; i < 4; ++i) {
    this$static.m_PosSlotDecoder[i] = $BitTreeDecoder({}, 6)
  }
  return this$static
}

function $Init_1(this$static) {
  this$static.m_OutWindow._streamPos = 0
  this$static.m_OutWindow._pos = 0
  InitBitModels(this$static.m_IsMatchDecoders)
  InitBitModels(this$static.m_IsRep0LongDecoders)
  InitBitModels(this$static.m_IsRepDecoders)
  InitBitModels(this$static.m_IsRepG0Decoders)
  InitBitModels(this$static.m_IsRepG1Decoders)
  InitBitModels(this$static.m_IsRepG2Decoders)
  InitBitModels(this$static.m_PosDecoders)
  $Init_0(this$static.m_LiteralDecoder)
  for (var i = 0; i < 4; ++i) {
    InitBitModels(this$static.m_PosSlotDecoder[i].Models)
  }
  $Init(this$static.m_LenDecoder)
  $Init(this$static.m_RepLenDecoder)
  InitBitModels(this$static.m_PosAlignDecoder.Models)
  $Init_8(this$static.m_RangeDecoder)
}

function $SetDecoderProperties(this$static, properties) {
  var dictionarySize, i, lc, lp, pb, remainder, val
  if (properties.length < 5) return 0
  val = properties[0] & 255
  lc = val % 9
  remainder = ~~(val / 9)
  lp = remainder % 5
  pb = ~~(remainder / 5)
  dictionarySize = 0
  for (i = 0; i < 4; ++i) {
    dictionarySize += (properties[1 + i] & 255) << (i * 8)
  }
  // NOTE: If the input is bad, it might call for an insanely large dictionary size, which would crash the script.
  if (dictionarySize > 99999999 || !$SetLcLpPb(this$static, lc, lp, pb)) {
    return 0
  }
  return $SetDictionarySize(this$static, dictionarySize)
}

function $SetDictionarySize(this$static, dictionarySize) {
  if (dictionarySize < 0) {
    return 0
  }
  if (this$static.m_DictionarySize != dictionarySize) {
    this$static.m_DictionarySize = dictionarySize
    this$static.m_DictionarySizeCheck = Math.max(
      this$static.m_DictionarySize,
      1
    )
    $Create_5(
      this$static.m_OutWindow,
      Math.max(this$static.m_DictionarySizeCheck, 4096)
    )
  }
  return 1
}

function $SetLcLpPb(this$static, lc, lp, pb) {
  if (lc > 8 || lp > 4 || pb > 4) {
    return 0
  }
  $Create_0(this$static.m_LiteralDecoder, lp, lc)
  var numPosStates = 1 << pb
  $Create(this$static.m_LenDecoder, numPosStates)
  $Create(this$static.m_RepLenDecoder, numPosStates)
  this$static.m_PosStateMask = numPosStates - 1
  return 1
}

function $Create(this$static, numPosStates) {
  for (
    ;
    this$static.m_NumPosStates < numPosStates;
    ++this$static.m_NumPosStates
  ) {
    this$static.m_LowCoder[this$static.m_NumPosStates] = $BitTreeDecoder({}, 3)
    this$static.m_MidCoder[this$static.m_NumPosStates] = $BitTreeDecoder({}, 3)
  }
}

function $Decode(this$static, rangeDecoder, posState) {
  if (!$DecodeBit(rangeDecoder, this$static.m_Choice, 0)) {
    return $Decode_0(this$static.m_LowCoder[posState], rangeDecoder)
  }
  var symbol = 8
  if (!$DecodeBit(rangeDecoder, this$static.m_Choice, 1)) {
    symbol += $Decode_0(this$static.m_MidCoder[posState], rangeDecoder)
  } else {
    symbol += 8 + $Decode_0(this$static.m_HighCoder, rangeDecoder)
  }
  return symbol
}

function $Decoder$LenDecoder(this$static) {
  this$static.m_Choice = initDim(2)
  this$static.m_LowCoder = initDim(16)
  this$static.m_MidCoder = initDim(16)
  this$static.m_HighCoder = $BitTreeDecoder({}, 8)
  this$static.m_NumPosStates = 0
  return this$static
}

function $Init(this$static) {
  InitBitModels(this$static.m_Choice)
  for (var posState = 0; posState < this$static.m_NumPosStates; ++posState) {
    InitBitModels(this$static.m_LowCoder[posState].Models)
    InitBitModels(this$static.m_MidCoder[posState].Models)
  }
  InitBitModels(this$static.m_HighCoder.Models)
}

function $Create_0(this$static, numPosBits, numPrevBits) {
  var i, numStates
  if (
    this$static.m_Coders != null &&
    this$static.m_NumPrevBits == numPrevBits &&
    this$static.m_NumPosBits == numPosBits
  )
    return
  this$static.m_NumPosBits = numPosBits
  this$static.m_PosMask = (1 << numPosBits) - 1
  this$static.m_NumPrevBits = numPrevBits
  numStates = 1 << (this$static.m_NumPrevBits + this$static.m_NumPosBits)
  this$static.m_Coders = initDim(numStates)
  for (i = 0; i < numStates; ++i)
    this$static.m_Coders[i] = $Decoder$LiteralDecoder$Decoder2({})
}

function $GetDecoder(this$static, pos, prevByte) {
  return this$static.m_Coders[
    ((pos & this$static.m_PosMask) << this$static.m_NumPrevBits) +
      ((prevByte & 255) >>> (8 - this$static.m_NumPrevBits))
  ]
}

function $Init_0(this$static) {
  var i, numStates
  numStates = 1 << (this$static.m_NumPrevBits + this$static.m_NumPosBits)
  for (i = 0; i < numStates; ++i) {
    InitBitModels(this$static.m_Coders[i].m_Decoders)
  }
}

function $DecodeNormal(this$static, rangeDecoder) {
  var symbol = 1
  do {
    symbol =
      (symbol << 1) | $DecodeBit(rangeDecoder, this$static.m_Decoders, symbol)
  } while (symbol < 256)
  return (symbol << 24) >> 24
}

function $DecodeWithMatchByte(this$static, rangeDecoder, matchByte) {
  var bit,
    matchBit,
    symbol = 1
  do {
    matchBit = (matchByte >> 7) & 1
    matchByte <<= 1
    bit = $DecodeBit(
      rangeDecoder,
      this$static.m_Decoders,
      ((1 + matchBit) << 8) + symbol
    )
    symbol = (symbol << 1) | bit
    if (matchBit != bit) {
      while (symbol < 256) {
        symbol =
          (symbol << 1) |
          $DecodeBit(rangeDecoder, this$static.m_Decoders, symbol)
      }
      break
    }
  } while (symbol < 256)
  return (symbol << 24) >> 24
}

function $Decoder$LiteralDecoder$Decoder2(this$static) {
  this$static.m_Decoders = initDim(768)
  return this$static
}
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$static.reps[1] = opt.Backs0
          this$static.reps[2] = opt.Backs1
          this$static.reps[3] = opt.Backs3
        } else {
          this$static.reps[0] = opt.Backs3
          this$static.reps[1] = opt.Backs0
          this$static.reps[2] = opt.Backs1
          this$static.reps[3] = opt.Backs2
        }
      } else {
        this$static.reps[0] = pos - 4
        this$static.reps[1] = opt.Backs0
        this$static.reps[2] = opt.Backs1
        this$static.reps[3] = opt.Backs2
      }
    }
    this$static._optimum[cur].State = state
    this$static._optimum[cur].Backs0 = this$static.reps[0]
    this$static._optimum[cur].Backs1 = this$static.reps[1]
    this$static._optimum[cur].Backs2 = this$static.reps[2]
    this$static._optimum[cur].Backs3 = this$static.reps[3]
    curPrice = this$static._optimum[cur].Price
    currentByte = $GetIndexByte(this$static._matchFinder, -1)
    matchByte = $GetIndexByte(
      this$static._matchFinder,
      -this$static.reps[0] - 1 - 1
    )
    posState = position & this$static._posStateMask
    curAnd1Price =
      curPrice +
      ProbPrices[this$static._isMatch[(state << 4) + posState] >>> 2] +
      $GetPrice_0(
        $GetSubCoder(
          this$static._literalEncoder,
          position,
          $GetIndexByte(this$static._matchFinder, -2)
        ),
        state >= 7,
        matchByte,
        currentByte
      )
    nextOptimum = this$static._optimum[cur + 1]
    nextIsChar = 0
    if (curAnd1Price < nextOptimum.Price) {
      nextOptimum.Price = curAnd1Price
      nextOptimum.PosPrev = cur
      nextOptimum.BackPrev = -1
      nextOptimum.Prev1IsChar = 0
      nextIsChar = 1
    }
    matchPrice =
      curPrice +
      ProbPrices[(2048 - this$static._isMatch[(state << 4) + posState]) >>> 2]
    repMatchPrice =
      matchPrice + ProbPrices[(2048 - this$static._isRep[state]) >>> 2]
    if (
      matchByte == currentByte &&
      !(nextOptimum.PosPrev < cur && !nextOptimum.BackPrev)
    ) {
      shortRepPrice =
        repMatchPrice +
        (ProbPrices[this$static._isRepG0[state] >>> 2] +
          ProbPrices[this$static._isRep0Long[(state << 4) + posState] >>> 2])
      if (shortRepPrice <= nextOptimum.Price) {
        nextOptimum.Price = shortRepPrice
        nextOptimum.PosPrev = cur
        nextOptimum.BackPrev = 0
        nextOptimum.Prev1IsChar = 0
        nextIsChar = 1
      }
    }
    numAvailableBytesFull = $GetNumAvailableBytes(this$static._matchFinder) + 1
    numAvailableBytesFull =
      4095 - cur < numAvailableBytesFull ? 4095 - cur : numAvailableBytesFull
    numAvailableBytes = numAvailableBytesFull
    if (numAvailableBytes < 2) {
      continue
    }
    if (numAvailableBytes > this$static._numFastBytes) {
      numAvailableBytes = this$static._numFastBytes
    }
    if (!nextIsChar && matchByte != currentByte) {
      t = Math.min(numAvailableBytesFull - 1, this$static._numFastBytes)
      lenTest2 = $GetMatchLen(
        this$static._matchFinder,
        0,
        this$static.reps[0],
        t
      )
      if (lenTest2 >= 2) {
        state2 = StateUpdateChar(state)
        posStateNext = (position + 1) & this$static._posStateMask
        nextRepMatchPrice =
          curAnd1Price +
          ProbPrices[
            (2048 - this$static._isMatch[(state2 << 4) + posStateNext]) >>> 2
          ] +
          ProbPrices[(2048 - this$static._isRep[state2]) >>> 2]
        offset = cur + 1 + lenTest2
        while (lenEnd < offset) {
          this$static._optimum[++lenEnd].Price = 268435455
        }
        curAndLenPrice =
          nextRepMatchPrice +
          ((price = $GetPrice(
            this$static._repMatchLenEncoder,
            lenTest2 - 2,
            posStateNext
          )),
          price + $GetPureRepPrice(this$static, 0, state2, posStateNext))
        optimum = this$static._optimum[offset]
        if (curAndLenPrice < optimum.Price) {
          optimum.Price = curAndLenPrice
          optimum.PosPrev = cur + 1
          optimum.BackPrev = 0
          optimum.Prev1IsChar = 1
          optimum.Prev2 = 0
        }
      }
    }
    startLen = 2
    for (repIndex = 0; repIndex < 4; ++repIndex) {
      lenTest = $GetMatchLen(
        this$static._matchFinder,
        -1,
        this$static.reps[repIndex],
        numAvailableBytes
      )
      if (lenTest < 2) {
        continue
      }
      lenTestTemp = lenTest
      do {
        while (lenEnd < cur + lenTest) {
          this$static._optimum[++lenEnd].Price = 268435455
        }
        curAndLenPrice =
          repMatchPrice +
          ((price_0 = $GetPrice(
            this$static._repMatchLenEncoder,
            lenTest - 2,
            posState
          )),
          price_0 + $GetPureRepPrice(this$static, repIndex, state, posState))
        optimum = this$static._optimum[cur + lenTest]
        if (curAndLenPrice < optimum.Price) {
          optimum.Price = curAndLenPrice
          optimum.PosPrev = cur
          optimum.BackPrev = repIndex
          optimum.Prev1IsChar = 0
        }
      } while (--lenTest >= 2)
      lenTest = lenTestTemp
      if (!repIndex) {
        startLen = lenTest + 1
      }
      if (lenTest < numAvailableBytesFull) {
        t = Math.min(
          numAvailableBytesFull - 1 - lenTest,
          this$static._numFastBytes
        )
        lenTest2 = $GetMatchLen(
          this$static._matchFinder,
          lenTest,
          this$static.reps[repIndex],
          t
        )
        if (lenTest2 >= 2) {
          state2 = state < 7 ? 8 : 11
          posStateNext = (position + lenTest) & this$static._posStateMask
          curAndLenCharPrice =
            repMatchPrice +
            ((price_1 = $GetPrice(
              this$static._repMatchLenEncoder,
              lenTest - 2,
              posState
            )),
            price_1 +
              $GetPureRepPrice(this$static, repIndex, state, posState)) +
            ProbPrices[
              this$static._isMatch[(state2 << 4) + posStateNext] >>> 2
            ] +
            $GetPrice_0(
              $GetSubCoder(
                this$static._literalEncoder,
                position + lenTest,
                $GetIndexByte(this$static._matchFinder, lenTest - 1 - 1)
              ),
              1,
              $GetIndexByte(
                this$static._matchFinder,
                lenTest - 1 - (this$static.reps[repIndex] + 1)
              ),
              $GetIndexByte(this$static._matchFinder, lenTest - 1)
            )
          state2 = StateUpdateChar(state2)
          posStateNext = (position + lenTest + 1) & this$static._posStateMask
          nextMatchPrice =
            curAndLenCharPrice +
            ProbPrices[
              (2048 - this$static._isMatch[(state2 << 4) + posStateNext]) >>> 2
            ]
          nextRepMatchPrice =
            nextMatchPrice +
            ProbPrices[(2048 - this$static._isRep[state2]) >>> 2]
          offset = lenTest + 1 + lenTest2
          while (lenEnd < cur + offset) {
            this$static._optimum[++lenEnd].Price = 268435455
          }
          curAndLenPrice =
            nextRepMatchPrice +
            ((price_2 = $GetPrice(
              this$static._repMatchLenEncoder,
              lenTest2 - 2,
              posStateNext
            )),
            price_2 + $GetPureRepPrice(this$static, 0, state2, posStateNext))
          optimum = this$static._optimum[cur + offset]
          if (curAndLenPrice < optimum.Price) {
            optimum.Price = curAndLenPrice
            optimum.PosPrev = cur + lenTest + 1
            optimum.BackPrev = 0
            optimum.Prev1IsChar = 1
            optimum.Prev2 = 1
            optimum.PosPrev2 = cur
            optimum.BackPrev2 = repIndex
          }
        }
      }
    }
    if (newLen > numAvailableBytes) {
      newLen = numAvailableBytes
      for (
        numDistancePairs = 0;
        newLen > this$static._matchDistances[numDistancePairs];
        numDistancePairs += 2
      ) {}
      this$static._matchDistances[numDistancePairs] = newLen
      numDistancePairs += 2
    }
    if (newLen >= startLen) {
      normalMatchPrice =
        matchPrice + ProbPrices[this$static._isRep[state] >>> 2]
      while (lenEnd < cur + newLen) {
        this$static._optimum[++lenEnd].Price = 268435455
      }
      offs = 0
      while (startLen > this$static._matchDistances[offs]) {
        offs += 2
      }
      for (lenTest = startLen; ; ++lenTest) {
        curBack = this$static._matchDistances[offs + 1]
        curAndLenPrice =
          normalMatchPrice +
          $GetPosLenPrice(this$static, curBack, lenTest, posState)
        optimum = this$static._optimum[cur + lenTest]
        if (curAndLenPrice < optimum.Price) {
          optimum.Price = curAndLenPrice
          optimum.PosPrev = cur
          optimum.BackPrev = curBack + 4
          optimum.Prev1IsChar = 0
        }
        if (lenTest == this$static._matchDistances[offs]) {
          if (lenTest < numAvailableBytesFull) {
            t = Math.min(
              numAvailableBytesFull - 1 - lenTest,
              this$static._numFastBytes
            )
            lenTest2 = $GetMatchLen(
              this$static._matchFinder,
              lenTest,
              curBack,
              t
            )
            if (lenTest2 >= 2) {
              state2 = state < 7 ? 7 : 10
              posStateNext = (position + lenTest) & this$static._posStateMask
              curAndLenCharPrice =
                curAndLenPrice +
                ProbPrices[
                  this$static._isMatch[(state2 << 4) + posStateNext] >>> 2
                ] +
                $GetPrice_0(
                  $GetSubCoder(
                    this$static._literalEncoder,
                    position + lenTest,
                    $GetIndexByte(this$static._matchFinder, lenTest - 1 - 1)
                  ),
                  1,
                  $GetIndexByte(
                    this$static._matchFinder,
                    lenTest - (curBack + 1) - 1
                  ),
                  $GetIndexByte(this$static._matchFinder, lenTest - 1)
                )
              state2 = StateUpdateChar(state2)
              posStateNext =
                (position + lenTest + 1) & this$static._posStateMask
              nextMatchPrice =
                curAndLenCharPrice +
                ProbPrices[
                  (2048 -
                    this$static._isMatch[(state2 << 4) + posStateNext]) >>>
                    2
                ]
              nextRepMatchPrice =
                nextMatchPrice +
                ProbPrices[(2048 - this$static._isRep[state2]) >>> 2]
              offset = lenTest + 1 + lenTest2
              while (lenEnd < cur + offset) {
                this$static._optimum[++lenEnd].Price = 268435455
              }
              curAndLenPrice =
                nextRepMatchPrice +
                ((price_3 = $GetPrice(
                  this$static._repMatchLenEncoder,
                  lenTest2 - 2,
                  posStateNext
                )),
                price_3 +
                  $GetPureRepPrice(this$static, 0, state2, posStateNext))
              optimum = this$static._optimum[cur + offset]
              if (curAndLenPrice < optimum.Price) {
                optimum.Price = curAndLenPrice
                optimum.PosPrev = cur + lenTest + 1
                optimum.BackPrev = 0
                optimum.Prev1IsChar = 1
                optimum.Prev2 = 1
                optimum.PosPrev2 = cur
                optimum.BackPrev2 = curBack + 4
              }
            }
          }
          offs += 2
          if (offs == numDistancePairs) break
        }
      }
    }
  }
}

function $GetPosLenPrice(this$static, pos, len, posState) {
  var price,
    lenToPosState = GetLenToPosState(len)
  if (pos < 128) {
    price = this$static._distancesPrices[lenToPosState * 128 + pos]
  } else {
    price =
      this$static._posSlotPrices[(lenToPosState << 6) + GetPosSlot2(pos)] +
      this$static._alignPrices[pos & 15]
  }
  return price + $GetPrice(this$static._lenEncoder, len - 2, posState)
}

function $GetPureRepPrice(this$static, repIndex, state, posState) {
  var price
  if (!repIndex) {
    price = ProbPrices[this$static._isRepG0[state] >>> 2]
    price +=
      ProbPrices[
        (2048 - this$static._isRep0Long[(state << 4) + posState]) >>> 2
      ]
  } else {
    price = ProbPrices[(2048 - this$static._isRepG0[state]) >>> 2]
    if (repIndex == 1) {
      price += ProbPrices[this$static._isRepG1[state] >>> 2]
    } else {
      price += ProbPrices[(2048 - this$static._isRepG1[state]) >>> 2]
      price += GetPrice(this$static._isRepG2[state], repIndex - 2)
    }
  }
  return price
}

function $GetRepLen1Price(this$static, state, posState) {
  return (
    ProbPrices[this$static._isRepG0[state] >>> 2] +
    ProbPrices[this$static._isRep0Long[(state << 4) + posState] >>> 2]
  )
}

function $Init_4(this$static) {
  $BaseInit(this$static)
  $Init_9(this$static._rangeEncoder)
  InitBitModels(this$static._isMatch)
  InitBitModels(this$static._isRep0Long)
  InitBitModels(this$static._isRep)
  InitBitModels(this$static._isRepG0)
  InitBitModels(this$static._isRepG1)
  InitBitModels(this$static._isRepG2)
  InitBitModels(this$static._posEncoders)
  $Init_3(this$static._literalEncoder)
  for (var i = 0; i < 4; ++i) {
    InitBitModels(this$static._posSlotEncoder[i].Models)
  }
  $Init_2(this$static._lenEncoder, 1 << this$static._posStateBits)
  $Init_2(this$static._repMatchLenEncoder, 1 << this$static._posStateBits)
  InitBitModels(this$static._posAlignEncoder.Models)
  this$static._longestMatchWasFound = 0
  this$static._optimumEndIndex = 0
  this$static._optimumCurrentIndex = 0
  this$static._additionalOffset = 0
}

function $MovePos(this$static, num) {
  if (num > 0) {
    $Skip(this$static._matchFinder, num)
    this$static._additionalOffset += num
  }
}

function $ReadMatchDistances(this$static) {
  var lenRes = 0
  this$static._numDistancePairs = $GetMatches(
    this$static._matchFinder,
    this$static._matchDistances
  )
  if (this$static._numDistancePairs > 0) {
    lenRes = this$static._matchDistances[this$static._numDistancePairs - 2]
    if (lenRes == this$static._numFastBytes)
      lenRes += $GetMatchLen(
        this$static._matchFinder,
        lenRes - 1,
        this$static._matchDistances[this$static._numDistancePairs - 1],
        273 - lenRes
      )
  }
  ++this$static._additionalOffset
  return lenRes
}

function $ReleaseMFStream(this$static) {
  if (this$static._matchFinder && this$static._needReleaseMFStream) {
    this$static._matchFinder._stream = null
    this$static._needReleaseMFStream = 0
  }
}

function $ReleaseStreams(this$static) {
  $ReleaseMFStream(this$static)
  this$static._rangeEncoder.Stream = null
}

function $SetDictionarySize_0(this$static, dictionarySize) {
  this$static._dictionarySize = dictionarySize
  for (var dicLogSize = 0; dictionarySize > 1 << dicLogSize; ++dicLogSize) {}
  this$static._distTableSize = dicLogSize * 2
}

function $SetMatchFinder(this$static, matchFinderIndex) {
  var matchFinderIndexPrev = this$static._matchFinderType
  this$static._matchFinderType = matchFinderIndex
  if (
    this$static._matchFinder &&
    matchFinderIndexPrev != this$static._matchFinderType
  ) {
    this$static._dictionarySizePrev = -1
    this$static._matchFinder = null
  }
}

function $WriteCoderProperties(this$static, outStream) {
  this$static.properties[0] =
    (((this$static._posStateBits * 5 + this$static._numLiteralPosStateBits) *
      9 +
      this$static._numLiteralContextBits) <<
      24) >>
    24
  for (var i = 0; i < 4; ++i) {
    this$static.properties[1 + i] =
      ((this$static._dictionarySize >> (8 * i)) << 24) >> 24
  }
  $write_0(outStream, this$static.properties, 0, 5)
}

function $WriteEndMarker(this$static, posState) {
  if (!this$static._writeEndMark) {
    return
  }
  $Encode_3(
    this$static._rangeEncoder,
    this$static._isMatch,
    (this$static._state << 4) + posState,
    1
  )
  $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, 0, posState)
  var lenToPosState = GetLenToPosState(2)
  $Encode_2(
    this$static._posSlotEncoder[lenToPosState],
    this$static._rangeEncoder,
    63
  )
  $EncodeDirectBits(this$static._rangeEncoder, 67108863, 26)
  $ReverseEncode(this$static._posAlignEncoder, this$static._rangeEncoder, 15)
}

function GetPosSlot(pos) {
  if (pos < 2048) {
    return g_FastPos[pos]
  }
  if (pos < 2097152) {
    return g_FastPos[pos >> 10] + 20
  }
  return g_FastPos[pos >> 20] + 40
}

function GetPosSlot2(pos) {
  if (pos < 131072) {
    return g_FastPos[pos >> 6] + 12
  }
  if (pos < 134217728) {
    return g_FastPos[pos >> 16] + 32
  }
  return g_FastPos[pos >> 26] + 52
}

function $Encode(this$static, rangeEncoder, symbol, posState) {
  if (symbol < 8) {
    $Encode_3(rangeEncoder, this$static._choice, 0, 0)
    $Encode_2(this$static._lowCoder[posState], rangeEncoder, symbol)
  } else {
    symbol -= 8
    $Encode_3(rangeEncoder, this$static._choice, 0, 1)
    if (symbol < 8) {
      $Encode_3(rangeEncoder, this$static._choice, 1, 0)
      $Encode_2(this$static._midCoder[posState], rangeEncoder, symbol)
    } else {
      $Encode_3(rangeEncoder, this$static._choice, 1, 1)
      $Encode_2(this$static._highCoder, rangeEncoder, symbol - 8)
    }
  }
}

function $Encoder$LenEncoder(this$static) {
  this$static._choice = initDim(2)
  this$static._lowCoder = initDim(16)
  this$static._midCoder = initDim(16)
  this$static._highCoder = $BitTreeEncoder({}, 8)
  for (var posState = 0; posState < 16; ++posState) {
    this$static._lowCoder[posState] = $BitTreeEncoder({}, 3)
    this$static._midCoder[posState] = $BitTreeEncoder({}, 3)
  }
  return this$static
}

function $Init_2(this$static, numPosStates) {
  InitBitModels(this$static._choice)
  for (var posState = 0; posState < numPosStates; ++posState) {
    InitBitModels(this$static._lowCoder[posState].Models)
    InitBitModels(this$static._midCoder[posState].Models)
  }
  InitBitModels(this$static._highCoder.Models)
}

function $SetPrices(this$static, posState, numSymbols, prices, st) {
  var a0, a1, b0, b1, i
  a0 = ProbPrices[this$static._choice[0] >>> 2]
  a1 = ProbPrices[(2048 - this$static._choice[0]) >>> 2]
  b0 = a1 + ProbPrices[this$static._choice[1] >>> 2]
  b1 = a1 + ProbPrices[(2048 - this$static._choice[1]) >>> 2]
  i = 0
  for (i = 0; i < 8; ++i) {
    if (i >= numSymbols) return
    prices[st + i] = a0 + $GetPrice_1(this$static._lowCoder[posState], i)
  }
  for (; i < 16; ++i) {
    if (i >= numSymbols) return
    prices[st + i] = b0 + $GetPrice_1(this$static._midCoder[posState], i - 8)
  }
  for (; i < numSymbols; ++i) {
    prices[st + i] = b1 + $GetPrice_1(this$static._highCoder, i - 8 - 8)
  }
}

function $Encode_0(this$static, rangeEncoder, symbol, posState) {
  $Encode(this$static, rangeEncoder, symbol, posState)
  if (--this$static._counters[posState] == 0) {
    $SetPrices(
      this$static,
      posState,
      this$static._tableSize,
      this$static._prices,
      posState * 272
    )
    this$static._counters[posState] = this$static._tableSize
  }
}

function $Encoder$LenPriceTableEncoder(this$static) {
  $Encoder$LenEncoder(this$static)
  this$static._prices = []
  this$static._counters = []
  return this$static
}

function $GetPrice(this$static, symbol, posState) {
  return this$static._prices[posState * 272 + symbol]
}

function $UpdateTables(this$static, numPosStates) {
  for (var posState = 0; posState < numPosStates; ++posState) {
    $SetPrices(
      this$static,
      posState,
      this$static._tableSize,
      this$static._prices,
      posState * 272
    )
    this$static._counters[posState] = this$static._tableSize
  }
}

function $Create_1(this$static, numPosBits, numPrevBits) {
  var i, numStates
  if (
    this$static.m_Coders != null &&
    this$static.m_NumPrevBits == numPrevBits &&
    this$static.m_NumPosBits == numPosBits
  ) {
    return
  }
  this$static.m_NumPosBits = numPosBits
  this$static.m_PosMask = (1 << numPosBits) - 1
  this$static.m_NumPrevBits = numPrevBits
  numStates = 1 << (this$static.m_NumPrevBits + this$static.m_NumPosBits)
  this$static.m_Coders = initDim(numStates)
  for (i = 0; i < numStates; ++i) {
    this$static.m_Coders[i] = $Encoder$LiteralEncoder$Encoder2({})
  }
}

function $GetSubCoder(this$static, pos, prevByte) {
  return this$static.m_Coders[
    ((pos & this$static.m_PosMask) << this$static.m_NumPrevBits) +
      ((prevByte & 255) >>> (8 - this$static.m_NumPrevBits))
  ]
}

function $Init_3(this$static) {
  var i,
    numStates = 1 << (this$static.m_NumPrevBits + this$static.m_NumPosBits)
  for (i = 0; i < numStates; ++i) {
    InitBitModels(this$static.m_Coders[i].m_Encoders)
  }
}

function $Encode_1(this$static, rangeEncoder, symbol) {
  var bit,
    i,
    context = 1
  for (i = 7; i >= 0; --i) {
    bit = (symbol >> i) & 1
    $Encode_3(rangeEncoder, this$static.m_Encoders, context, bit)
    context = (context << 1) | bit
  }
}

function $EncodeMatched(this$static, rangeEncoder, matchByte, symbol) {
  var bit,
    i,
    matchBit,
    state,
    same = 1,
    context = 1
  for (i = 7; i >= 0; --i) {
    bit = (symbol >> i) & 1
    state = context
    if (same) {
      matchBit = (matchByte >> i) & 1
      state += (1 + matchBit) << 8
      same = matchBit == bit
    }
    $Encode_3(rangeEncoder, this$static.m_Encoders, state, bit)
    context = (context << 1) | bit
  }
}

function $Encoder$LiteralEncoder$Encoder2(this$static) {
  this$static.m_Encoders = initDim(768)
  return this$static
}

function $GetPrice_0(this$static, matchMode, matchByte, symbol) {
  var bit,
    context = 1,
    i = 7,
    matchBit,
    price = 0
  if (matchMode) {
    for (; i >= 0; --i) {
      matchBit = (matchByte >> i) & 1
      bit = (symbol >> i) & 1
      price += GetPrice(
        this$static.m_Encoders[((1 + matchBit) << 8) + context],
        bit
      )
      context = (context << 1) | bit
      if (matchBit != bit) {
        --i
        break
      }
    }
  }
  for (; i >= 0; --i) {
    bit = (symbol >> i) & 1
    price += GetPrice(this$static.m_Encoders[context], bit)
    context = (context << 1) | bit
  }
  return price
}

function $MakeAsChar(this$static) {
  this$static.BackPrev = -1
  this$static.Prev1IsChar = 0
}

function $MakeAsShortRep(this$static) {
  this$static.BackPrev = 0
  this$static.Prev1IsChar = 0
}
function $BitTreeDecoder(this$static, numBitLevels) {
  this$static.NumBitLevels = numBitLevels
  this$static.Models = initDim(1 << numBitLevels)
  return this$static
}

function $Decode_0(this$static, rangeDecoder) {
  var bitIndex,
    m = 1
  for (bitIndex = this$static.NumBitLevels; bitIndex != 0; --bitIndex) {
    m = (m << 1) + $DecodeBit(rangeDecoder, this$static.Models, m)
  }
  return m - (1 << this$static.NumBitLevels)
}

function $ReverseDecode(this$static, rangeDecoder) {
  var bit,
    bitIndex,
    m = 1,
    symbol = 0
  for (bitIndex = 0; bitIndex < this$static.NumBitLevels; ++bitIndex) {
    bit = $DecodeBit(rangeDecoder, this$static.Models, m)
    m <<= 1
    m += bit
    symbol |= bit << bitIndex
  }
  return symbol
}

function ReverseDecode(Models, startIndex, rangeDecoder, NumBitLevels) {
  var bit,
    bitIndex,
    m = 1,
    symbol = 0
  for (bitIndex = 0; bitIndex < NumBitLevels; ++bitIndex) {
    bit = $DecodeBit(rangeDecoder, Models, startIndex + m)
    m <<= 1
    m += bit
    symbol |= bit << bitIndex
  }
  return symbol
}
function $BitTreeEncoder(this$static, numBitLevels) {
  this$static.NumBitLevels = numBitLevels
  this$static.Models = initDim(1 << numBitLevels)
  return this$static
}

function $Encode_2(this$static, rangeEncoder, symbol) {
  var bit,
    bitIndex,
    m = 1
  for (bitIndex = this$static.NumBitLevels; bitIndex != 0; ) {
    --bitIndex
    bit = (symbol >>> bitIndex) & 1
    $Encode_3(rangeEncoder, this$static.Models, m, bit)
    m = (m << 1) | bit
  }
}

function $GetPrice_1(this$static, symbol) {
  var bit,
    bitIndex,
    m = 1,
    price = 0
  for (bitIndex = this$static.NumBitLevels; bitIndex != 0; ) {
    --bitIndex
    bit = (symbol >>> bitIndex) & 1
    price += GetPrice(this$static.Models[m], bit)
    m = (m << 1) + bit
  }
  return price
}

function $ReverseEncode(this$static, rangeEncoder, symbol) {
  var bit,
    i,
    m = 1
  for (i = 0; i < this$static.NumBitLevels; ++i) {
    bit = symbol & 1
    $Encode_3(rangeEncoder, this$static.Models, m, bit)
    m = (m << 1) | bit
    symbol >>= 1
  }
}

function $ReverseGetPrice(this$static, symbol) {
  var bit,
    i,
    m = 1,
    price = 0
  for (i = this$static.NumBitLevels; i != 0; --i) {
    bit = symbol & 1
    symbol >>>= 1
    price += GetPrice(this$static.Models[m], bit)
    m = (m << 1) | bit
  }
  return price
}

function ReverseEncode(Models, startIndex, rangeEncoder, NumBitLevels, symbol) {
  var bit,
    i,
    m = 1
  for (i = 0; i < NumBitLevels; ++i) {
    bit = symbol & 1
    $Encode_3(rangeEncoder, Models, startIndex + m, bit)
    m = (m << 1) | bit
    symbol >>= 1
  }
}

function ReverseGetPrice(Models, startIndex, NumBitLevels, symbol) {
  var bit,
    i,
    m = 1,
    price = 0
  for (i = NumBitLevels; i != 0; --i) {
    bit = symbol & 1
    symbol >>>= 1
    price += ProbPrices[(((Models[startIndex + m] - bit) ^ -bit) & 2047) >>> 2]
    m = (m << 1) | bit
  }
  return price
}
function $DecodeBit(this$static, probs, index) {
  var newBound,
    prob = probs[index]
  newBound = (this$static.Range >>> 11) * prob
  if ((this$static.Code ^ -2147483648) < (newBound ^ -2147483648)) {
    this$static.Range = newBound
    probs[index] = ((prob + ((2048 - prob) >>> 5)) << 16) >> 16
    if (!(this$static.Range & -16777216)) {
      this$static.Code = (this$static.Code << 8) | $read(this$static.Stream)
      this$static.Range <<= 8
    }
    return 0
  } else {
    this$static.Range -= newBound
    this$static.Code -= newBound
    probs[index] = ((prob - (prob >>> 5)) << 16) >> 16
    if (!(this$static.Range & -16777216)) {
      this$static.Code = (this$static.Code << 8) | $read(this$static.Stream)
      this$static.Range <<= 8
    }
    return 1
  }
}

function $DecodeDirectBits(this$static, numTotalBits) {
  var i,
    t,
    result = 0
  for (i = numTotalBits; i != 0; --i) {
    this$static.Range >>>= 1
    t = (this$static.Code - this$static.Range) >>> 31
    this$static.Code -= this$static.Range & (t - 1)
    result = (result << 1) | (1 - t)
    if (!(this$static.Range & -16777216)) {
      this$static.Code = (this$static.Code << 8) | $read(this$static.Stream)
      this$static.Range <<= 8
    }
  }
  return result
}

function $Init_8(this$static) {
  this$static.Code = 0
  this$static.Range = -1
  for (var i = 0; i < 5; ++i) {
    this$static.Code = (this$static.Code << 8) | $read(this$static.Stream)
  }
}
function InitBitModels(probs) {
  for (var i = probs.length - 1; i >= 0; --i) {
    probs[i] = 1024
  }
}
var ProbPrices = (function() {
  var end,
    i,
    j,
    start,
    ProbPrices = []
  for (i = 8; i >= 0; --i) {
    start = 1 << (9 - i - 1)
    end = 1 << (9 - i)
    for (j = start; j < end; ++j) {
      ProbPrices[j] = (i << 6) + (((end - j) << 6) >>> (9 - i - 1))
    }
  }
  return ProbPrices
})()

function $Encode_3(this$static, probs, index, symbol) {
  var newBound,
    prob = probs[index]
  newBound = (this$static.Range >>> 11) * prob
  if (!symbol) {
    this$static.Range = newBound
    probs[index] = ((prob + ((2048 - prob) >>> 5)) << 16) >> 16
  } else {
    this$static.Low = add(
      this$static.Low,
      and(fromInt(newBound), [4294967295, 0])
    )
    this$static.Range -= newBound
    probs[index] = ((prob - (prob >>> 5)) << 16) >> 16
  }
  if (!(this$static.Range & -16777216)) {
    this$static.Range <<= 8
    $ShiftLow(this$static)
  }
}

function $EncodeDirectBits(this$static, v, numTotalBits) {
  for (var i = numTotalBits - 1; i >= 0; --i) {
    this$static.Range >>>= 1
    if (((v >>> i) & 1) == 1) {
      this$static.Low = add(this$static.Low, fromInt(this$static.Range))
    }
    if (!(this$static.Range & -16777216)) {
      this$static.Range <<= 8
      $ShiftLow(this$static)
    }
  }
}

function $GetProcessedSizeAdd(this$static) {
  return add(add(fromInt(this$static._cacheSize), this$static._position), [
    4,
    0
  ])
}

function $Init_9(this$static) {
  this$static._position = P0_longLit
  this$static.Low = P0_longLit
  this$static.Range = -1
  this$static._cacheSize = 1
  this$static._cache = 0
}

function $ShiftLow(this$static) {
  var temp,
    LowHi = lowBits_0(shru(this$static.Low, 32))
  if (LowHi != 0 || compare(this$static.Low, [4278190080, 0]) < 0) {
    this$static._position = add(
      this$static._position,
      fromInt(this$static._cacheSize)
    )
    temp = this$static._cache
    do {
      $write(this$static.Stream, temp + LowHi)
      temp = 255
    } while (--this$static._cacheSize != 0)
    this$static._cache = lowBits_0(this$static.Low) >>> 24
  }
  ++this$static._cacheSize
  this$static.Low = shl(and(this$static.Low, [16777215, 0]), 8)
}

function GetPrice(Prob, symbol) {
  return ProbPrices[(((Prob - symbol) ^ -symbol) & 2047) >>> 2]
}
function decode(utf) {
  var i = 0,
    j = 0,
    x,
    y,
    z,
    l = utf.length,
    buf = [],
    charCodes = []
  for (; i < l; ++i, ++j) {
    x = utf[i] & 255
    if (!(x & 128)) {
      if (!x) {
        // It appears that this is binary data, so it cannot be converted to a string, so just send it back.
        return utf
      }
      charCodes[j] = x
    } else if ((x & 224) == 192) {
      if (i + 1 >= l) {
        // It appears that this is binary data, so it cannot be converted to a string, so just send it back.
        return utf
      }
      y = utf[++i] & 255
      if ((y & 192) != 128) {
        // It appears that this is binary data, so it cannot be converted to a string, so just send it back.
        return utf
      }
      charCodes[j] = ((x & 31) << 6) | (y & 63)
    } else if ((x & 240) == 224) {
      if (i + 2 >= l) {
        // It appears that this is binary data, so it cannot be converted to a string, so just send it back.
        return utf
      }
      y = utf[++i] & 255
      if ((y & 192) != 128) {
        // It appears that this is binary data, so it cannot be converted to a string, so just send it back.
        return utf
      }
      z = utf[++i] & 255
      if ((z & 192) != 128) {
        // It appears that this is binary data, so it cannot be converted to a string, so just send it back.
        return utf
      }
      charCodes[j] = ((x & 15) << 12) | ((y & 63) << 6) | (z & 63)
    } else {
      // It appears that this is binary data, so it cannot be converted to a string, so just send it back.
      return utf
    }
    if (j == 16383) {
      buf.push(String.fromCharCode.apply(String, charCodes))
      j = -1
    }
  }
  if (j > 0) {
    charCodes.length = j
    buf.push(String.fromCharCode.apply(String, charCodes))
  }
  return buf.join('')
}
function encode(s) {
  var ch,
    chars = [],
    data,
    elen = 0,
    i,
    l = s.length
  // Be able to handle binary arrays and buffers.
  if (typeof s == 'object') {
    return s
  } else {
    $getChars(s, 0, l, chars, 0)
  }
  // Add extra spaces in the array to break up the unicode symbols.
  for (i = 0; i < l; ++i) {
    ch = chars[i]
    if (ch >= 1 && ch <= 127) {
      ++elen
    } else if (!ch || (ch >= 128 && ch <= 2047)) {
      elen += 2
    } else {
      elen += 3
    }
  }
  data = []
  elen = 0
  for (i = 0; i < l; ++i) {
    ch = chars[i]
    if (ch >= 1 && ch <= 127) {
      data[elen++] = (ch << 24) >> 24
    } else if (!ch || (ch >= 128 && ch <= 2047)) {
      data[elen++] = ((192 | ((ch >> 6) & 31)) << 24) >> 24
      data[elen++] = ((128 | (ch & 63)) << 24) >> 24
    } else {
      data[elen++] = ((224 | ((ch >> 12) & 15)) << 24) >> 24
      data[elen++] = ((128 | ((ch >> 6) & 63)) << 24) >> 24
      data[elen++] = ((128 | (ch & 63)) << 24) >> 24
    }
  }
  return data
}
// s is dictionarySize
// f is fb
// m is matchFinder
// NOTE: Because some values are always the same, they have been removed.
// lc is always 3
// lp is always 0
// pb is always 2
const modes = [
  { s: 16, f: 64, m: 0 },
  { s: 20, f: 64, m: 0 },
  { s: 19, f: 64, m: 1 },
  { s: 20, f: 64, m: 1 },
  { s: 21, f: 128, m: 1 },
  { s: 22, f: 128, m: 1 },
  { s: 23, f: 128, m: 1 },
  { s: 24, f: 255, m: 1 },
  { s: 25, f: 255, m: 1 }
]

function get_mode_obj(mode) {
  return modes[mode - 1] || modes[6]
}

/**
 * Compress a string with the LZMA algorithm
 *
 * @param {string}            value                 The string to be compressed
 * @param {object}            options
 * @param {1|2|3|4|5|6|7|8|9} options.mode          Which mode to use (1 through 9, defaults to 7)
 * @param {boolean}           options.enableEndMark Whether to write an end mark
 * @returns {string}
 */
export function compress(value, { mode = 7, enableEndMark = true } = {}) {
  var this$static = {}

  this$static.c = $LZMAByteArrayCompressor(
    {},
    encode(value),
    get_mode_obj(mode),
    enableEndMark
  )
  while ($processChunk(this$static.c.chunker));
  return $toByteArray(this$static.c.output)
}

/**
 * Decompress a string compressed with the LZMA algorithm
 *
 * @param {number[]|Int8Array} bytes The int8 array created by the compress() function
 * @returns {string}
 */
export function decompress(bytes) {
  var this$static = {}

  this$static.d = $LZMAByteArrayDecompressor({}, bytes)
  while ($processChunk(this$static.d.chunker));
  return decode($toByteArray(this$static.d.output))
}

@flou-ainan
Copy link

Hey dude, I've came to same results using other method. Just for sharing, soon it will be avaliable on github.

I though that no one had this idea before so started doing it myself.
All base conversions were implemented by myself based on a mongodb shortID code that I've came across in the past and forked to fit my needs.
Intead of using LZMA I've searched for a JavaScript Gzip implementation, and after most of the hard job were already done I've searched for compressing data into URLs and found your gist.
This project is a part of this one
Then when I finished my code, I tested your data for benchmarking and curiously they reached the same result with your data

My testing results:

-----
Test Data:     |      length: 456 
{"id":"0001","type":"donut","name":"Cake","ppu":0.55,"batters":{"batter":[{"id":"1001","type":"Regular"},{"id":"1002","type":"Chocolate"},{"id":"1003","type":"Blueberry"},{"id":"1004","type":"Devil's Food"}]},"topping":[{"id":"5001","type":"None"},{"id":"5002","type":"Glazed"},{"id":"5005","type":"Sugar"},{"id":"5007","type":"Powdered Sugar"},{"id":"5006","type":"Chocolate with Sprinkles"},{"id":"5003","type":"Chocolate"},{"id":"5004","type":"Maple"}]}
-----
-----
Ziped Bytes Array:     |      length: 220 
31,139,8,0,150,29,44,102,0,3,125,144,203,10,194,48,16,69,127,165,204,198,77,145,250,136,66,151,42,186,82,196,46,197,69,52,67,27,140,73,72,19,165,150,254,187,17,133,24,20,119,185,156,195,100,238,180,192,25,228,144,101,217,0,82,176,141,70,159,152,146,206,250,40,233,229,25,231,244,140,62,105,237,32,207,250,132,164,112,164,214,162,169,33,111,223,79,200,247,237,107,210,32,154,180,195,210,9,106,160,75,3,30,6,60,175,212,73,9,106,49,18,70,65,152,9,135,71,52,166,137,132,113,16,22,120,229,162,87,39,75,165,24,116,135,206,3,165,53,151,101,216,136,68,27,109,148,252,248,141,68,235,172,4,189,35,139,40,9,180,112,229,103,19,15,167,1,110,213,141,161,65,150,124,91,147,31,125,147,27,183,85,82,104,195,229,89,96,29,249,163,191,247,33,81,253,53,213,2,159,189,31,235,221,89,114,200,1,0,0
-----
-----
Hexadecimal String:     |      length: 440 
1f8b0800961d2c6600037d90cb0ac23010457fa5ccc64d91fa8842972aba52c42ec54534431b8c494813a596febb1185181477b99cc364eeb4c019e49065d90052b08d469f9892cefa28e9e519e7f48c3e69ed20cffa84a470a4d6a2a9216fdf4fc8f7ed6bd2209ab4c3d2096aa04b031e063cafd449096a311246419809874734a6898471101678e5a257274ba5187487ce03a5359765d888441b6d94fcf88d44ebac04bd238b2809b470e567130fa7016ed58da141967c5b931f7d931bb7555268c3e559601df9a3bff72151fd35d5029fbd1febdd5972c8010000
-----
-----
Base 64 string:     |      length: 294 
7UI809otb6o00TSgOMH2c115vWncNASh!Ex2BOGWkIgKNkkQgNKcikwjFpr!KN6561hTKpP3peWQM1DAA6np05aMzkqvC9be!yzFVhDDZ8M!quQwP$G4F72ARGaF8m$vjYzTXmLi89GQMZ89qG1b0NU6fa$kigBGch96gpw9xQsQFEC4sh0muemylOtbFhxQxYU3Fjmnpty8h1JJBfPUzkjHH0iZ8UIE2rhMVmsj3Ws1rJmdEk6mv5Kj7TSj6XtlkCz3VlBw7vCzL$sxkvQRRgavLh$HTlBOO04000
-----
-----
Hex String from Base 64:     |      length: 441 
1f8b0800961d2c6600037d90cb0ac23010457fa5ccc64d91fa8842972aba52c42ec54534431b8c494813a596febb1185181477b99cc364eeb4c019e49065d90052b08d469f9892cefa28e9e519e7f48c3e69ed20cffa84a470a4d6a2a9216fdf4fc8f7ed6bd2209ab4c3d2096aa04b031e063cafd449096a311246419809874734a6898471101678e5a257274ba5187487ce03a5359765d888441b6d94fcf88d44ebac04bd238b2809b470e567130fa7016ed58da141967c5b931f7d931bb7555268c3e559601df9a3bff72151fd35d5029fbd1febdd5972c80100000
-----
-----
Ziped Bytes Array from hex string:     |      length: 220 
31,139,8,0,150,29,44,102,0,3,125,144,203,10,194,48,16,69,127,165,204,198,77,145,250,136,66,151,42,186,82,196,46,197,69,52,67,27,140,73,72,19,165,150,254,187,17,133,24,20,119,185,156,195,100,238,180,192,25,228,144,101,217,0,82,176,141,70,159,152,146,206,250,40,233,229,25,231,244,140,62,105,237,32,207,250,132,164,112,164,214,162,169,33,111,223,79,200,247,237,107,210,32,154,180,195,210,9,106,160,75,3,30,6,60,175,212,73,9,106,49,18,70,65,152,9,135,71,52,166,137,132,113,16,22,120,229,162,87,39,75,165,24,116,135,206,3,165,53,151,101,216,136,68,27,109,148,252,248,141,68,235,172,4,189,35,139,40,9,180,112,229,103,19,15,167,1,110,213,141,161,65,150,124,91,147,31,125,147,27,183,85,82,104,195,229,89,96,29,249,163,191,247,33,81,253,53,213,2,159,189,31,235,221,89,114,200,1,0,0
-----
-----
Original Data:     |      length: 456 
{"id":"0001","type":"donut","name":"Cake","ppu":0.55,"batters":{"batter":[{"id":"1001","type":"Regular"},{"id":"1002","type":"Chocolate"},{"id":"1003","type":"Blueberry"},{"id":"1004","type":"Devil's Food"}]},"topping":[{"id":"5001","type":"None"},{"id":"5002","type":"Glazed"},{"id":"5005","type":"Sugar"},{"id":"5007","type":"Powdered Sugar"},{"id":"5006","type":"Chocolate with Sprinkles"},{"id":"5003","type":"Chocolate"},{"id":"5004","type":"Maple"}]}
-----
{
  id: '0001',
  type: 'donut',
  name: 'Cake',
  ppu: 0.55,
  batters: { batter: [ [Object], [Object], [Object], [Object] ] },
  topping: [
    { id: '5001', type: 'None' },
    { id: '5002', type: 'Glazed' },
    { id: '5005', type: 'Sugar' },
    { id: '5007', type: 'Powdered Sugar' },
    { id: '5006', type: 'Chocolate with Sprinkles' },
    { id: '5003', type: 'Chocolate' },
    { id: '5004', type: 'Maple' }
  ]
}

This test can be acessed here

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment