mirror of
https://github.com/ksyasuda/SubMiner.git
synced 2026-02-28 06:22:45 -08:00
6458 lines
134 KiB
JavaScript
6458 lines
134 KiB
JavaScript
// @ts-nocheck
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/constants.js
|
|
var END_OF_CENTRAL_DIR_LENGTH = 22;
|
|
var ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH = 20;
|
|
var ZIP64_END_OF_CENTRAL_DIR_LENGTH = 56;
|
|
var ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LENGTH;
|
|
var MAX_DATE = new Date(2107, 11, 31);
|
|
var MIN_DATE = new Date(1980, 0, 1);
|
|
var UNDEFINED_VALUE = void 0;
|
|
var UNDEFINED_TYPE = "undefined";
|
|
var FUNCTION_TYPE = "function";
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/stream-adapter.js
|
|
var StreamAdapter = class {
|
|
constructor(Codec) {
|
|
return class extends TransformStream {
|
|
constructor(_format, options) {
|
|
const codec2 = new Codec(options);
|
|
super({
|
|
transform(chunk, controller) {
|
|
controller.enqueue(codec2.append(chunk));
|
|
},
|
|
flush(controller) {
|
|
const chunk = codec2.flush();
|
|
if (chunk) {
|
|
controller.enqueue(chunk);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/codecs/crc32.js
|
|
var table = [];
|
|
for (let i = 0; i < 256; i++) {
|
|
let t = i;
|
|
for (let j = 0; j < 8; j++) {
|
|
if (t & 1) {
|
|
t = t >>> 1 ^ 3988292384;
|
|
} else {
|
|
t = t >>> 1;
|
|
}
|
|
}
|
|
table[i] = t;
|
|
}
|
|
var Crc32 = class {
|
|
constructor(crc) {
|
|
this.crc = crc || -1;
|
|
}
|
|
append(data) {
|
|
let crc = this.crc | 0;
|
|
for (let offset = 0, length = data.length | 0; offset < length; offset++) {
|
|
crc = crc >>> 8 ^ table[(crc ^ data[offset]) & 255];
|
|
}
|
|
this.crc = crc;
|
|
}
|
|
get() {
|
|
return ~this.crc;
|
|
}
|
|
};
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/crc32-stream.js
|
|
var Crc32Stream = class extends TransformStream {
|
|
constructor() {
|
|
let stream;
|
|
const crc32 = new Crc32();
|
|
super({
|
|
transform(chunk, controller) {
|
|
crc32.append(chunk);
|
|
controller.enqueue(chunk);
|
|
},
|
|
flush() {
|
|
const value = new Uint8Array(4);
|
|
const dataView = new DataView(value.buffer);
|
|
dataView.setUint32(0, crc32.get());
|
|
stream.value = value;
|
|
}
|
|
});
|
|
stream = this;
|
|
}
|
|
};
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/util/encode-text.js
|
|
function encodeText(value) {
|
|
if (typeof TextEncoder == UNDEFINED_TYPE) {
|
|
value = unescape(encodeURIComponent(value));
|
|
const result = new Uint8Array(value.length);
|
|
for (let i = 0; i < result.length; i++) {
|
|
result[i] = value.charCodeAt(i);
|
|
}
|
|
return result;
|
|
} else {
|
|
return new TextEncoder().encode(value);
|
|
}
|
|
}
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/codecs/sjcl.js
|
|
var bitArray = {
|
|
/**
|
|
* Concatenate two bit arrays.
|
|
* @param {bitArray} a1 The first array.
|
|
* @param {bitArray} a2 The second array.
|
|
* @return {bitArray} The concatenation of a1 and a2.
|
|
*/
|
|
concat(a1, a2) {
|
|
if (a1.length === 0 || a2.length === 0) {
|
|
return a1.concat(a2);
|
|
}
|
|
const last = a1[a1.length - 1], shift = bitArray.getPartial(last);
|
|
if (shift === 32) {
|
|
return a1.concat(a2);
|
|
} else {
|
|
return bitArray._shiftRight(a2, shift, last | 0, a1.slice(0, a1.length - 1));
|
|
}
|
|
},
|
|
/**
|
|
* Find the length of an array of bits.
|
|
* @param {bitArray} a The array.
|
|
* @return {Number} The length of a, in bits.
|
|
*/
|
|
bitLength(a) {
|
|
const l = a.length;
|
|
if (l === 0) {
|
|
return 0;
|
|
}
|
|
const x = a[l - 1];
|
|
return (l - 1) * 32 + bitArray.getPartial(x);
|
|
},
|
|
/**
|
|
* Truncate an array.
|
|
* @param {bitArray} a The array.
|
|
* @param {Number} len The length to truncate to, in bits.
|
|
* @return {bitArray} A new array, truncated to len bits.
|
|
*/
|
|
clamp(a, len) {
|
|
if (a.length * 32 < len) {
|
|
return a;
|
|
}
|
|
a = a.slice(0, Math.ceil(len / 32));
|
|
const l = a.length;
|
|
len = len & 31;
|
|
if (l > 0 && len) {
|
|
a[l - 1] = bitArray.partial(len, a[l - 1] & 2147483648 >> len - 1, 1);
|
|
}
|
|
return a;
|
|
},
|
|
/**
|
|
* Make a partial word for a bit array.
|
|
* @param {Number} len The number of bits in the word.
|
|
* @param {Number} x The bits.
|
|
* @param {Number} [_end=0] Pass 1 if x has already been shifted to the high side.
|
|
* @return {Number} The partial word.
|
|
*/
|
|
partial(len, x, _end) {
|
|
if (len === 32) {
|
|
return x;
|
|
}
|
|
return (_end ? x | 0 : x << 32 - len) + len * 1099511627776;
|
|
},
|
|
/**
|
|
* Get the number of bits used by a partial word.
|
|
* @param {Number} x The partial word.
|
|
* @return {Number} The number of bits used by the partial word.
|
|
*/
|
|
getPartial(x) {
|
|
return Math.round(x / 1099511627776) || 32;
|
|
},
|
|
/** Shift an array right.
|
|
* @param {bitArray} a The array to shift.
|
|
* @param {Number} shift The number of bits to shift.
|
|
* @param {Number} [carry=0] A byte to carry in
|
|
* @param {bitArray} [out=[]] An array to prepend to the output.
|
|
* @private
|
|
*/
|
|
_shiftRight(a, shift, carry, out) {
|
|
if (out === void 0) {
|
|
out = [];
|
|
}
|
|
for (; shift >= 32; shift -= 32) {
|
|
out.push(carry);
|
|
carry = 0;
|
|
}
|
|
if (shift === 0) {
|
|
return out.concat(a);
|
|
}
|
|
for (let i = 0; i < a.length; i++) {
|
|
out.push(carry | a[i] >>> shift);
|
|
carry = a[i] << 32 - shift;
|
|
}
|
|
const last2 = a.length ? a[a.length - 1] : 0;
|
|
const shift2 = bitArray.getPartial(last2);
|
|
out.push(bitArray.partial(shift + shift2 & 31, shift + shift2 > 32 ? carry : out.pop(), 1));
|
|
return out;
|
|
}
|
|
};
|
|
var codec = {
|
|
bytes: {
|
|
/** Convert from a bitArray to an array of bytes. */
|
|
fromBits(arr) {
|
|
const bl = bitArray.bitLength(arr);
|
|
const byteLength = bl / 8;
|
|
const out = new Uint8Array(byteLength);
|
|
let tmp;
|
|
for (let i = 0; i < byteLength; i++) {
|
|
if ((i & 3) === 0) {
|
|
tmp = arr[i / 4];
|
|
}
|
|
out[i] = tmp >>> 24;
|
|
tmp <<= 8;
|
|
}
|
|
return out;
|
|
},
|
|
/** Convert from an array of bytes to a bitArray. */
|
|
toBits(bytes) {
|
|
const out = [];
|
|
let i;
|
|
let tmp = 0;
|
|
for (i = 0; i < bytes.length; i++) {
|
|
tmp = tmp << 8 | bytes[i];
|
|
if ((i & 3) === 3) {
|
|
out.push(tmp);
|
|
tmp = 0;
|
|
}
|
|
}
|
|
if (i & 3) {
|
|
out.push(bitArray.partial(8 * (i & 3), tmp));
|
|
}
|
|
return out;
|
|
}
|
|
}
|
|
};
|
|
var hash = {};
|
|
hash.sha1 = class {
|
|
constructor(hash2) {
|
|
const sha1 = this;
|
|
sha1.blockSize = 512;
|
|
sha1._init = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
|
|
sha1._key = [1518500249, 1859775393, 2400959708, 3395469782];
|
|
if (hash2) {
|
|
sha1._h = hash2._h.slice(0);
|
|
sha1._buffer = hash2._buffer.slice(0);
|
|
sha1._length = hash2._length;
|
|
} else {
|
|
sha1.reset();
|
|
}
|
|
}
|
|
/**
|
|
* Reset the hash state.
|
|
* @return this
|
|
*/
|
|
reset() {
|
|
const sha1 = this;
|
|
sha1._h = sha1._init.slice(0);
|
|
sha1._buffer = [];
|
|
sha1._length = 0;
|
|
return sha1;
|
|
}
|
|
/**
|
|
* Input several words to the hash.
|
|
* @param {bitArray|String} data the data to hash.
|
|
* @return this
|
|
*/
|
|
update(data) {
|
|
const sha1 = this;
|
|
if (typeof data === "string") {
|
|
data = codec.utf8String.toBits(data);
|
|
}
|
|
const b = sha1._buffer = bitArray.concat(sha1._buffer, data);
|
|
const ol = sha1._length;
|
|
const nl = sha1._length = ol + bitArray.bitLength(data);
|
|
if (nl > 9007199254740991) {
|
|
throw new Error("Cannot hash more than 2^53 - 1 bits");
|
|
}
|
|
const c = new Uint32Array(b);
|
|
let j = 0;
|
|
for (let i = sha1.blockSize + ol - (sha1.blockSize + ol & sha1.blockSize - 1); i <= nl; i += sha1.blockSize) {
|
|
sha1._block(c.subarray(16 * j, 16 * (j + 1)));
|
|
j += 1;
|
|
}
|
|
b.splice(0, 16 * j);
|
|
return sha1;
|
|
}
|
|
/**
|
|
* Complete hashing and output the hash value.
|
|
* @return {bitArray} The hash value, an array of 5 big-endian words. TODO
|
|
*/
|
|
finalize() {
|
|
const sha1 = this;
|
|
let b = sha1._buffer;
|
|
const h = sha1._h;
|
|
b = bitArray.concat(b, [bitArray.partial(1, 1)]);
|
|
for (let i = b.length + 2; i & 15; i++) {
|
|
b.push(0);
|
|
}
|
|
b.push(Math.floor(sha1._length / 4294967296));
|
|
b.push(sha1._length | 0);
|
|
while (b.length) {
|
|
sha1._block(b.splice(0, 16));
|
|
}
|
|
sha1.reset();
|
|
return h;
|
|
}
|
|
/**
|
|
* The SHA-1 logical functions f(0), f(1), ..., f(79).
|
|
* @private
|
|
*/
|
|
_f(t, b, c, d) {
|
|
if (t <= 19) {
|
|
return b & c | ~b & d;
|
|
} else if (t <= 39) {
|
|
return b ^ c ^ d;
|
|
} else if (t <= 59) {
|
|
return b & c | b & d | c & d;
|
|
} else if (t <= 79) {
|
|
return b ^ c ^ d;
|
|
}
|
|
}
|
|
/**
|
|
* Circular left-shift operator.
|
|
* @private
|
|
*/
|
|
_S(n, x) {
|
|
return x << n | x >>> 32 - n;
|
|
}
|
|
/**
|
|
* Perform one cycle of SHA-1.
|
|
* @param {Uint32Array|bitArray} words one block of words.
|
|
* @private
|
|
*/
|
|
_block(words) {
|
|
const sha1 = this;
|
|
const h = sha1._h;
|
|
const w = Array(80);
|
|
for (let j = 0; j < 16; j++) {
|
|
w[j] = words[j];
|
|
}
|
|
let a = h[0];
|
|
let b = h[1];
|
|
let c = h[2];
|
|
let d = h[3];
|
|
let e = h[4];
|
|
for (let t = 0; t <= 79; t++) {
|
|
if (t >= 16) {
|
|
w[t] = sha1._S(1, w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]);
|
|
}
|
|
const tmp = sha1._S(5, a) + sha1._f(t, b, c, d) + e + w[t] + sha1._key[Math.floor(t / 20)] | 0;
|
|
e = d;
|
|
d = c;
|
|
c = sha1._S(30, b);
|
|
b = a;
|
|
a = tmp;
|
|
}
|
|
h[0] = h[0] + a | 0;
|
|
h[1] = h[1] + b | 0;
|
|
h[2] = h[2] + c | 0;
|
|
h[3] = h[3] + d | 0;
|
|
h[4] = h[4] + e | 0;
|
|
}
|
|
};
|
|
var cipher = {};
|
|
cipher.aes = class {
|
|
constructor(key) {
|
|
const aes = this;
|
|
aes._tables = [[[], [], [], [], []], [[], [], [], [], []]];
|
|
if (!aes._tables[0][0][0]) {
|
|
aes._precompute();
|
|
}
|
|
const sbox = aes._tables[0][4];
|
|
const decTable = aes._tables[1];
|
|
const keyLen = key.length;
|
|
let i, encKey, decKey, rcon = 1;
|
|
if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
|
|
throw new Error("invalid aes key size");
|
|
}
|
|
aes._key = [encKey = key.slice(0), decKey = []];
|
|
for (i = keyLen; i < 4 * keyLen + 28; i++) {
|
|
let tmp = encKey[i - 1];
|
|
if (i % keyLen === 0 || keyLen === 8 && i % keyLen === 4) {
|
|
tmp = sbox[tmp >>> 24] << 24 ^ sbox[tmp >> 16 & 255] << 16 ^ sbox[tmp >> 8 & 255] << 8 ^ sbox[tmp & 255];
|
|
if (i % keyLen === 0) {
|
|
tmp = tmp << 8 ^ tmp >>> 24 ^ rcon << 24;
|
|
rcon = rcon << 1 ^ (rcon >> 7) * 283;
|
|
}
|
|
}
|
|
encKey[i] = encKey[i - keyLen] ^ tmp;
|
|
}
|
|
for (let j = 0; i; j++, i--) {
|
|
const tmp = encKey[j & 3 ? i : i - 4];
|
|
if (i <= 4 || j < 4) {
|
|
decKey[j] = tmp;
|
|
} else {
|
|
decKey[j] = decTable[0][sbox[tmp >>> 24]] ^ decTable[1][sbox[tmp >> 16 & 255]] ^ decTable[2][sbox[tmp >> 8 & 255]] ^ decTable[3][sbox[tmp & 255]];
|
|
}
|
|
}
|
|
}
|
|
// public
|
|
/* Something like this might appear here eventually
|
|
name: "AES",
|
|
blockSize: 4,
|
|
keySizes: [4,6,8],
|
|
*/
|
|
/**
|
|
* Encrypt an array of 4 big-endian words.
|
|
* @param {Array} data The plaintext.
|
|
* @return {Array} The ciphertext.
|
|
*/
|
|
encrypt(data) {
|
|
return this._crypt(data, 0);
|
|
}
|
|
/**
|
|
* Decrypt an array of 4 big-endian words.
|
|
* @param {Array} data The ciphertext.
|
|
* @return {Array} The plaintext.
|
|
*/
|
|
decrypt(data) {
|
|
return this._crypt(data, 1);
|
|
}
|
|
/**
|
|
* Expand the S-box tables.
|
|
*
|
|
* @private
|
|
*/
|
|
_precompute() {
|
|
const encTable = this._tables[0];
|
|
const decTable = this._tables[1];
|
|
const sbox = encTable[4];
|
|
const sboxInv = decTable[4];
|
|
const d = [];
|
|
const th = [];
|
|
let xInv, x2, x4, x8;
|
|
for (let i = 0; i < 256; i++) {
|
|
th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i;
|
|
}
|
|
for (let x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
|
|
let s = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4;
|
|
s = s >> 8 ^ s & 255 ^ 99;
|
|
sbox[x] = s;
|
|
sboxInv[s] = x;
|
|
x8 = d[x4 = d[x2 = d[x]]];
|
|
let tDec = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
|
|
let tEnc = d[s] * 257 ^ s * 16843008;
|
|
for (let i = 0; i < 4; i++) {
|
|
encTable[i][x] = tEnc = tEnc << 24 ^ tEnc >>> 8;
|
|
decTable[i][s] = tDec = tDec << 24 ^ tDec >>> 8;
|
|
}
|
|
}
|
|
for (let i = 0; i < 5; i++) {
|
|
encTable[i] = encTable[i].slice(0);
|
|
decTable[i] = decTable[i].slice(0);
|
|
}
|
|
}
|
|
/**
|
|
* Encryption and decryption core.
|
|
* @param {Array} input Four words to be encrypted or decrypted.
|
|
* @param dir The direction, 0 for encrypt and 1 for decrypt.
|
|
* @return {Array} The four encrypted or decrypted words.
|
|
* @private
|
|
*/
|
|
_crypt(input, dir) {
|
|
if (input.length !== 4) {
|
|
throw new Error("invalid aes block size");
|
|
}
|
|
const key = this._key[dir];
|
|
const nInnerRounds = key.length / 4 - 2;
|
|
const out = [0, 0, 0, 0];
|
|
const table2 = this._tables[dir];
|
|
const t0 = table2[0];
|
|
const t1 = table2[1];
|
|
const t2 = table2[2];
|
|
const t3 = table2[3];
|
|
const sbox = table2[4];
|
|
let a = input[0] ^ key[0];
|
|
let b = input[dir ? 3 : 1] ^ key[1];
|
|
let c = input[2] ^ key[2];
|
|
let d = input[dir ? 1 : 3] ^ key[3];
|
|
let kIndex = 4;
|
|
let a2, b2, c2;
|
|
for (let i = 0; i < nInnerRounds; i++) {
|
|
a2 = t0[a >>> 24] ^ t1[b >> 16 & 255] ^ t2[c >> 8 & 255] ^ t3[d & 255] ^ key[kIndex];
|
|
b2 = t0[b >>> 24] ^ t1[c >> 16 & 255] ^ t2[d >> 8 & 255] ^ t3[a & 255] ^ key[kIndex + 1];
|
|
c2 = t0[c >>> 24] ^ t1[d >> 16 & 255] ^ t2[a >> 8 & 255] ^ t3[b & 255] ^ key[kIndex + 2];
|
|
d = t0[d >>> 24] ^ t1[a >> 16 & 255] ^ t2[b >> 8 & 255] ^ t3[c & 255] ^ key[kIndex + 3];
|
|
kIndex += 4;
|
|
a = a2;
|
|
b = b2;
|
|
c = c2;
|
|
}
|
|
for (let i = 0; i < 4; i++) {
|
|
out[dir ? 3 & -i : i] = sbox[a >>> 24] << 24 ^ sbox[b >> 16 & 255] << 16 ^ sbox[c >> 8 & 255] << 8 ^ sbox[d & 255] ^ key[kIndex++];
|
|
a2 = a;
|
|
a = b;
|
|
b = c;
|
|
c = d;
|
|
d = a2;
|
|
}
|
|
return out;
|
|
}
|
|
};
|
|
var random = {
|
|
/**
|
|
* Generate random words with pure js, cryptographically not as strong & safe as native implementation.
|
|
* @param {TypedArray} typedArray The array to fill.
|
|
* @return {TypedArray} The random values.
|
|
*/
|
|
getRandomValues(typedArray) {
|
|
const words = new Uint32Array(typedArray.buffer);
|
|
const r = (m_w) => {
|
|
let m_z = 987654321;
|
|
const mask = 4294967295;
|
|
return function() {
|
|
m_z = 36969 * (m_z & 65535) + (m_z >> 16) & mask;
|
|
m_w = 18e3 * (m_w & 65535) + (m_w >> 16) & mask;
|
|
const result = ((m_z << 16) + m_w & mask) / 4294967296 + 0.5;
|
|
return result * (Math.random() > 0.5 ? 1 : -1);
|
|
};
|
|
};
|
|
for (let i = 0, rcache; i < typedArray.length; i += 4) {
|
|
const _r = r((rcache || Math.random()) * 4294967296);
|
|
rcache = _r() * 987654071;
|
|
words[i / 4] = _r() * 4294967296 | 0;
|
|
}
|
|
return typedArray;
|
|
}
|
|
};
|
|
var mode = {};
|
|
mode.ctrGladman = class {
|
|
constructor(prf, iv) {
|
|
this._prf = prf;
|
|
this._initIv = iv;
|
|
this._iv = iv;
|
|
}
|
|
reset() {
|
|
this._iv = this._initIv;
|
|
}
|
|
/** Input some data to calculate.
|
|
* @param {bitArray} data the data to process, it must be intergral multiple of 128 bits unless it's the last.
|
|
*/
|
|
update(data) {
|
|
return this.calculate(this._prf, data, this._iv);
|
|
}
|
|
incWord(word) {
|
|
if ((word >> 24 & 255) === 255) {
|
|
let b1 = word >> 16 & 255;
|
|
let b2 = word >> 8 & 255;
|
|
let b3 = word & 255;
|
|
if (b1 === 255) {
|
|
b1 = 0;
|
|
if (b2 === 255) {
|
|
b2 = 0;
|
|
if (b3 === 255) {
|
|
b3 = 0;
|
|
} else {
|
|
++b3;
|
|
}
|
|
} else {
|
|
++b2;
|
|
}
|
|
} else {
|
|
++b1;
|
|
}
|
|
word = 0;
|
|
word += b1 << 16;
|
|
word += b2 << 8;
|
|
word += b3;
|
|
} else {
|
|
word += 1 << 24;
|
|
}
|
|
return word;
|
|
}
|
|
incCounter(counter) {
|
|
if ((counter[0] = this.incWord(counter[0])) === 0) {
|
|
counter[1] = this.incWord(counter[1]);
|
|
}
|
|
}
|
|
calculate(prf, data, iv) {
|
|
let l;
|
|
if (!(l = data.length)) {
|
|
return [];
|
|
}
|
|
const bl = bitArray.bitLength(data);
|
|
for (let i = 0; i < l; i += 4) {
|
|
this.incCounter(iv);
|
|
const e = prf.encrypt(iv);
|
|
data[i] ^= e[0];
|
|
data[i + 1] ^= e[1];
|
|
data[i + 2] ^= e[2];
|
|
data[i + 3] ^= e[3];
|
|
}
|
|
return bitArray.clamp(data, bl);
|
|
}
|
|
};
|
|
var misc = {
|
|
importKey(password) {
|
|
return new misc.hmacSha1(codec.bytes.toBits(password));
|
|
},
|
|
pbkdf2(prf, salt, count, length) {
|
|
count = count || 1e4;
|
|
if (length < 0 || count < 0) {
|
|
throw new Error("invalid params to pbkdf2");
|
|
}
|
|
const byteLength = (length >> 5) + 1 << 2;
|
|
let u, ui, i, j, k;
|
|
const arrayBuffer = new ArrayBuffer(byteLength);
|
|
const out = new DataView(arrayBuffer);
|
|
let outLength = 0;
|
|
const b = bitArray;
|
|
salt = codec.bytes.toBits(salt);
|
|
for (k = 1; outLength < (byteLength || 1); k++) {
|
|
u = ui = prf.encrypt(b.concat(salt, [k]));
|
|
for (i = 1; i < count; i++) {
|
|
ui = prf.encrypt(ui);
|
|
for (j = 0; j < ui.length; j++) {
|
|
u[j] ^= ui[j];
|
|
}
|
|
}
|
|
for (i = 0; outLength < (byteLength || 1) && i < u.length; i++) {
|
|
out.setInt32(outLength, u[i]);
|
|
outLength += 4;
|
|
}
|
|
}
|
|
return arrayBuffer.slice(0, length / 8);
|
|
}
|
|
};
|
|
misc.hmacSha1 = class {
|
|
constructor(key) {
|
|
const hmac = this;
|
|
const Hash = hmac._hash = hash.sha1;
|
|
const exKey = [[], []];
|
|
hmac._baseHash = [new Hash(), new Hash()];
|
|
const bs = hmac._baseHash[0].blockSize / 32;
|
|
if (key.length > bs) {
|
|
key = new Hash().update(key).finalize();
|
|
}
|
|
for (let i = 0; i < bs; i++) {
|
|
exKey[0][i] = key[i] ^ 909522486;
|
|
exKey[1][i] = key[i] ^ 1549556828;
|
|
}
|
|
hmac._baseHash[0].update(exKey[0]);
|
|
hmac._baseHash[1].update(exKey[1]);
|
|
hmac._resultHash = new Hash(hmac._baseHash[0]);
|
|
}
|
|
reset() {
|
|
const hmac = this;
|
|
hmac._resultHash = new hmac._hash(hmac._baseHash[0]);
|
|
hmac._updated = false;
|
|
}
|
|
update(data) {
|
|
const hmac = this;
|
|
hmac._updated = true;
|
|
hmac._resultHash.update(data);
|
|
}
|
|
digest() {
|
|
const hmac = this;
|
|
const w = hmac._resultHash.finalize();
|
|
const result = new hmac._hash(hmac._baseHash[1]).update(w).finalize();
|
|
hmac.reset();
|
|
return result;
|
|
}
|
|
encrypt(data) {
|
|
if (!this._updated) {
|
|
this.update(data);
|
|
return this.digest(data);
|
|
} else {
|
|
throw new Error("encrypt on already updated hmac called!");
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/common-crypto.js
|
|
var GET_RANDOM_VALUES_SUPPORTED = typeof crypto != UNDEFINED_TYPE && typeof crypto.getRandomValues == FUNCTION_TYPE;
|
|
var ERR_INVALID_PASSWORD = "Invalid password";
|
|
var ERR_INVALID_SIGNATURE = "Invalid signature";
|
|
var ERR_ABORT_CHECK_PASSWORD = "zipjs-abort-check-password";
|
|
function getRandomValues(array) {
|
|
if (GET_RANDOM_VALUES_SUPPORTED) {
|
|
return crypto.getRandomValues(array);
|
|
} else {
|
|
return random.getRandomValues(array);
|
|
}
|
|
}
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/aes-crypto-stream.js
|
|
var BLOCK_LENGTH = 16;
|
|
var RAW_FORMAT = "raw";
|
|
var PBKDF2_ALGORITHM = { name: "PBKDF2" };
|
|
var HASH_ALGORITHM = { name: "HMAC" };
|
|
var HASH_FUNCTION = "SHA-1";
|
|
var BASE_KEY_ALGORITHM = Object.assign({ hash: HASH_ALGORITHM }, PBKDF2_ALGORITHM);
|
|
var DERIVED_BITS_ALGORITHM = Object.assign({ iterations: 1e3, hash: { name: HASH_FUNCTION } }, PBKDF2_ALGORITHM);
|
|
var DERIVED_BITS_USAGE = ["deriveBits"];
|
|
var SALT_LENGTH = [8, 12, 16];
|
|
var KEY_LENGTH = [16, 24, 32];
|
|
var SIGNATURE_LENGTH = 10;
|
|
var COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
|
|
var CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
|
|
var subtle = CRYPTO_API_SUPPORTED && crypto.subtle;
|
|
var SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof subtle != UNDEFINED_TYPE;
|
|
var codecBytes = codec.bytes;
|
|
var Aes = cipher.aes;
|
|
var CtrGladman = mode.ctrGladman;
|
|
var HmacSha1 = misc.hmacSha1;
|
|
var IMPORT_KEY_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof subtle.importKey == FUNCTION_TYPE;
|
|
var DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof subtle.deriveBits == FUNCTION_TYPE;
|
|
var AESDecryptionStream = class extends TransformStream {
|
|
constructor({ password, rawPassword, signed, encryptionStrength, checkPasswordOnly }) {
|
|
super({
|
|
start() {
|
|
Object.assign(this, {
|
|
ready: new Promise((resolve) => this.resolveReady = resolve),
|
|
password: encodePassword(password, rawPassword),
|
|
signed,
|
|
strength: encryptionStrength - 1,
|
|
pending: new Uint8Array()
|
|
});
|
|
},
|
|
async transform(chunk, controller) {
|
|
const aesCrypto = this;
|
|
const {
|
|
password: password2,
|
|
strength,
|
|
resolveReady,
|
|
ready
|
|
} = aesCrypto;
|
|
if (password2) {
|
|
await createDecryptionKeys(aesCrypto, strength, password2, subarray(chunk, 0, SALT_LENGTH[strength] + 2));
|
|
chunk = subarray(chunk, SALT_LENGTH[strength] + 2);
|
|
if (checkPasswordOnly) {
|
|
controller.error(new Error(ERR_ABORT_CHECK_PASSWORD));
|
|
} else {
|
|
resolveReady();
|
|
}
|
|
} else {
|
|
await ready;
|
|
}
|
|
const output = new Uint8Array(chunk.length - SIGNATURE_LENGTH - (chunk.length - SIGNATURE_LENGTH) % BLOCK_LENGTH);
|
|
controller.enqueue(append(aesCrypto, chunk, output, 0, SIGNATURE_LENGTH, true));
|
|
},
|
|
async flush(controller) {
|
|
const {
|
|
signed: signed2,
|
|
ctr,
|
|
hmac,
|
|
pending,
|
|
ready
|
|
} = this;
|
|
if (hmac && ctr) {
|
|
await ready;
|
|
const chunkToDecrypt = subarray(pending, 0, pending.length - SIGNATURE_LENGTH);
|
|
const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH);
|
|
let decryptedChunkArray = new Uint8Array();
|
|
if (chunkToDecrypt.length) {
|
|
const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
|
|
hmac.update(encryptedChunk);
|
|
const decryptedChunk = ctr.update(encryptedChunk);
|
|
decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
|
|
}
|
|
if (signed2) {
|
|
const signature = subarray(fromBits(codecBytes, hmac.digest()), 0, SIGNATURE_LENGTH);
|
|
for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
|
|
if (signature[indexSignature] != originalSignature[indexSignature]) {
|
|
throw new Error(ERR_INVALID_SIGNATURE);
|
|
}
|
|
}
|
|
}
|
|
controller.enqueue(decryptedChunkArray);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
var AESEncryptionStream = class extends TransformStream {
|
|
constructor({ password, rawPassword, encryptionStrength }) {
|
|
let stream;
|
|
super({
|
|
start() {
|
|
Object.assign(this, {
|
|
ready: new Promise((resolve) => this.resolveReady = resolve),
|
|
password: encodePassword(password, rawPassword),
|
|
strength: encryptionStrength - 1,
|
|
pending: new Uint8Array()
|
|
});
|
|
},
|
|
async transform(chunk, controller) {
|
|
const aesCrypto = this;
|
|
const {
|
|
password: password2,
|
|
strength,
|
|
resolveReady,
|
|
ready
|
|
} = aesCrypto;
|
|
let preamble = new Uint8Array();
|
|
if (password2) {
|
|
preamble = await createEncryptionKeys(aesCrypto, strength, password2);
|
|
resolveReady();
|
|
} else {
|
|
await ready;
|
|
}
|
|
const output = new Uint8Array(preamble.length + chunk.length - chunk.length % BLOCK_LENGTH);
|
|
output.set(preamble, 0);
|
|
controller.enqueue(append(aesCrypto, chunk, output, preamble.length, 0));
|
|
},
|
|
async flush(controller) {
|
|
const {
|
|
ctr,
|
|
hmac,
|
|
pending,
|
|
ready
|
|
} = this;
|
|
if (hmac && ctr) {
|
|
await ready;
|
|
let encryptedChunkArray = new Uint8Array();
|
|
if (pending.length) {
|
|
const encryptedChunk = ctr.update(toBits(codecBytes, pending));
|
|
hmac.update(encryptedChunk);
|
|
encryptedChunkArray = fromBits(codecBytes, encryptedChunk);
|
|
}
|
|
stream.signature = fromBits(codecBytes, hmac.digest()).slice(0, SIGNATURE_LENGTH);
|
|
controller.enqueue(concat(encryptedChunkArray, stream.signature));
|
|
}
|
|
}
|
|
});
|
|
stream = this;
|
|
}
|
|
};
|
|
function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignature) {
|
|
const {
|
|
ctr,
|
|
hmac,
|
|
pending
|
|
} = aesCrypto;
|
|
const inputLength = input.length - paddingEnd;
|
|
if (pending.length) {
|
|
input = concat(pending, input);
|
|
output = expand(output, inputLength - inputLength % BLOCK_LENGTH);
|
|
}
|
|
let offset;
|
|
for (offset = 0; offset <= inputLength - BLOCK_LENGTH; offset += BLOCK_LENGTH) {
|
|
const inputChunk = toBits(codecBytes, subarray(input, offset, offset + BLOCK_LENGTH));
|
|
if (verifySignature) {
|
|
hmac.update(inputChunk);
|
|
}
|
|
const outputChunk = ctr.update(inputChunk);
|
|
if (!verifySignature) {
|
|
hmac.update(outputChunk);
|
|
}
|
|
output.set(fromBits(codecBytes, outputChunk), offset + paddingStart);
|
|
}
|
|
aesCrypto.pending = subarray(input, offset);
|
|
return output;
|
|
}
|
|
async function createDecryptionKeys(decrypt2, strength, password, preamble) {
|
|
const passwordVerificationKey = await createKeys(decrypt2, strength, password, subarray(preamble, 0, SALT_LENGTH[strength]));
|
|
const passwordVerification = subarray(preamble, SALT_LENGTH[strength]);
|
|
if (passwordVerificationKey[0] != passwordVerification[0] || passwordVerificationKey[1] != passwordVerification[1]) {
|
|
throw new Error(ERR_INVALID_PASSWORD);
|
|
}
|
|
}
|
|
async function createEncryptionKeys(encrypt2, strength, password) {
|
|
const salt = getRandomValues(new Uint8Array(SALT_LENGTH[strength]));
|
|
const passwordVerification = await createKeys(encrypt2, strength, password, salt);
|
|
return concat(salt, passwordVerification);
|
|
}
|
|
async function createKeys(aesCrypto, strength, password, salt) {
|
|
aesCrypto.password = null;
|
|
const baseKey = await importKey(RAW_FORMAT, password, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE);
|
|
const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), baseKey, 8 * (KEY_LENGTH[strength] * 2 + 2));
|
|
const compositeKey = new Uint8Array(derivedBits);
|
|
const key = toBits(codecBytes, subarray(compositeKey, 0, KEY_LENGTH[strength]));
|
|
const authentication = toBits(codecBytes, subarray(compositeKey, KEY_LENGTH[strength], KEY_LENGTH[strength] * 2));
|
|
const passwordVerification = subarray(compositeKey, KEY_LENGTH[strength] * 2);
|
|
Object.assign(aesCrypto, {
|
|
keys: {
|
|
key,
|
|
authentication,
|
|
passwordVerification
|
|
},
|
|
ctr: new CtrGladman(new Aes(key), Array.from(COUNTER_DEFAULT_VALUE)),
|
|
hmac: new HmacSha1(authentication)
|
|
});
|
|
return passwordVerification;
|
|
}
|
|
async function importKey(format, password, algorithm, extractable, keyUsages) {
|
|
if (IMPORT_KEY_SUPPORTED) {
|
|
try {
|
|
return await subtle.importKey(format, password, algorithm, extractable, keyUsages);
|
|
} catch (_error) {
|
|
IMPORT_KEY_SUPPORTED = false;
|
|
return misc.importKey(password);
|
|
}
|
|
} else {
|
|
return misc.importKey(password);
|
|
}
|
|
}
|
|
async function deriveBits(algorithm, baseKey, length) {
|
|
if (DERIVE_BITS_SUPPORTED) {
|
|
try {
|
|
return await subtle.deriveBits(algorithm, baseKey, length);
|
|
} catch (_error) {
|
|
DERIVE_BITS_SUPPORTED = false;
|
|
return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length);
|
|
}
|
|
} else {
|
|
return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length);
|
|
}
|
|
}
|
|
function encodePassword(password, rawPassword) {
|
|
if (rawPassword === UNDEFINED_VALUE) {
|
|
return encodeText(password);
|
|
} else {
|
|
return rawPassword;
|
|
}
|
|
}
|
|
function concat(leftArray, rightArray) {
|
|
let array = leftArray;
|
|
if (leftArray.length + rightArray.length) {
|
|
array = new Uint8Array(leftArray.length + rightArray.length);
|
|
array.set(leftArray, 0);
|
|
array.set(rightArray, leftArray.length);
|
|
}
|
|
return array;
|
|
}
|
|
function expand(inputArray, length) {
|
|
if (length && length > inputArray.length) {
|
|
const array = inputArray;
|
|
inputArray = new Uint8Array(length);
|
|
inputArray.set(array, 0);
|
|
}
|
|
return inputArray;
|
|
}
|
|
function subarray(array, begin, end) {
|
|
return array.subarray(begin, end);
|
|
}
|
|
function fromBits(codecBytes2, chunk) {
|
|
return codecBytes2.fromBits(chunk);
|
|
}
|
|
function toBits(codecBytes2, chunk) {
|
|
return codecBytes2.toBits(chunk);
|
|
}
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/zip-crypto-stream.js
|
|
var HEADER_LENGTH = 12;
|
|
var ZipCryptoDecryptionStream = class extends TransformStream {
|
|
constructor({ password, passwordVerification, checkPasswordOnly }) {
|
|
super({
|
|
start() {
|
|
Object.assign(this, {
|
|
password,
|
|
passwordVerification
|
|
});
|
|
createKeys2(this, password);
|
|
},
|
|
transform(chunk, controller) {
|
|
const zipCrypto = this;
|
|
if (zipCrypto.password) {
|
|
const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH));
|
|
zipCrypto.password = null;
|
|
if (decryptedHeader[HEADER_LENGTH - 1] != zipCrypto.passwordVerification) {
|
|
throw new Error(ERR_INVALID_PASSWORD);
|
|
}
|
|
chunk = chunk.subarray(HEADER_LENGTH);
|
|
}
|
|
if (checkPasswordOnly) {
|
|
controller.error(new Error(ERR_ABORT_CHECK_PASSWORD));
|
|
} else {
|
|
controller.enqueue(decrypt(zipCrypto, chunk));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
var ZipCryptoEncryptionStream = class extends TransformStream {
|
|
constructor({ password, passwordVerification }) {
|
|
super({
|
|
start() {
|
|
Object.assign(this, {
|
|
password,
|
|
passwordVerification
|
|
});
|
|
createKeys2(this, password);
|
|
},
|
|
transform(chunk, controller) {
|
|
const zipCrypto = this;
|
|
let output;
|
|
let offset;
|
|
if (zipCrypto.password) {
|
|
zipCrypto.password = null;
|
|
const header = getRandomValues(new Uint8Array(HEADER_LENGTH));
|
|
header[HEADER_LENGTH - 1] = zipCrypto.passwordVerification;
|
|
output = new Uint8Array(chunk.length + header.length);
|
|
output.set(encrypt(zipCrypto, header), 0);
|
|
offset = HEADER_LENGTH;
|
|
} else {
|
|
output = new Uint8Array(chunk.length);
|
|
offset = 0;
|
|
}
|
|
output.set(encrypt(zipCrypto, chunk), offset);
|
|
controller.enqueue(output);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
function decrypt(target, input) {
|
|
const output = new Uint8Array(input.length);
|
|
for (let index = 0; index < input.length; index++) {
|
|
output[index] = getByte(target) ^ input[index];
|
|
updateKeys(target, output[index]);
|
|
}
|
|
return output;
|
|
}
|
|
function encrypt(target, input) {
|
|
const output = new Uint8Array(input.length);
|
|
for (let index = 0; index < input.length; index++) {
|
|
output[index] = getByte(target) ^ input[index];
|
|
updateKeys(target, input[index]);
|
|
}
|
|
return output;
|
|
}
|
|
function createKeys2(target, password) {
|
|
const keys = [305419896, 591751049, 878082192];
|
|
Object.assign(target, {
|
|
keys,
|
|
crcKey0: new Crc32(keys[0]),
|
|
crcKey2: new Crc32(keys[2])
|
|
});
|
|
for (let index = 0; index < password.length; index++) {
|
|
updateKeys(target, password.charCodeAt(index));
|
|
}
|
|
}
|
|
function updateKeys(target, byte) {
|
|
let [key0, key1, key2] = target.keys;
|
|
target.crcKey0.append([byte]);
|
|
key0 = ~target.crcKey0.get();
|
|
key1 = getInt32(Math.imul(getInt32(key1 + getInt8(key0)), 134775813) + 1);
|
|
target.crcKey2.append([key1 >>> 24]);
|
|
key2 = ~target.crcKey2.get();
|
|
target.keys = [key0, key1, key2];
|
|
}
|
|
function getByte(target) {
|
|
const temp = target.keys[2] | 2;
|
|
return getInt8(Math.imul(temp, temp ^ 1) >>> 8);
|
|
}
|
|
function getInt8(number) {
|
|
return number & 255;
|
|
}
|
|
function getInt32(number) {
|
|
return number & 4294967295;
|
|
}
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/zip-entry-stream.js
|
|
var COMPRESSION_FORMAT = "deflate-raw";
|
|
var DeflateStream = class extends TransformStream {
|
|
constructor(options, { chunkSize, CompressionStream, CompressionStreamNative }) {
|
|
super({});
|
|
const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level } = options;
|
|
const stream = this;
|
|
let crc32Stream, encryptionStream;
|
|
let readable = filterEmptyChunks(super.readable);
|
|
if ((!encrypted || zipCrypto) && signed) {
|
|
crc32Stream = new Crc32Stream();
|
|
readable = pipeThrough(readable, crc32Stream);
|
|
}
|
|
if (compressed) {
|
|
readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStreamNative, CompressionStream);
|
|
}
|
|
if (encrypted) {
|
|
if (zipCrypto) {
|
|
readable = pipeThrough(readable, new ZipCryptoEncryptionStream(options));
|
|
} else {
|
|
encryptionStream = new AESEncryptionStream(options);
|
|
readable = pipeThrough(readable, encryptionStream);
|
|
}
|
|
}
|
|
setReadable(stream, readable, () => {
|
|
let signature;
|
|
if (encrypted && !zipCrypto) {
|
|
signature = encryptionStream.signature;
|
|
}
|
|
if ((!encrypted || zipCrypto) && signed) {
|
|
signature = new DataView(crc32Stream.value.buffer).getUint32(0);
|
|
}
|
|
stream.signature = signature;
|
|
});
|
|
}
|
|
};
|
|
var InflateStream = class extends TransformStream {
|
|
constructor(options, { chunkSize, DecompressionStream, DecompressionStreamNative }) {
|
|
super({});
|
|
const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream } = options;
|
|
let crc32Stream, decryptionStream;
|
|
let readable = filterEmptyChunks(super.readable);
|
|
if (encrypted) {
|
|
if (zipCrypto) {
|
|
readable = pipeThrough(readable, new ZipCryptoDecryptionStream(options));
|
|
} else {
|
|
decryptionStream = new AESDecryptionStream(options);
|
|
readable = pipeThrough(readable, decryptionStream);
|
|
}
|
|
}
|
|
if (compressed) {
|
|
readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize }, DecompressionStreamNative, DecompressionStream);
|
|
}
|
|
if ((!encrypted || zipCrypto) && signed) {
|
|
crc32Stream = new Crc32Stream();
|
|
readable = pipeThrough(readable, crc32Stream);
|
|
}
|
|
setReadable(this, readable, () => {
|
|
if ((!encrypted || zipCrypto) && signed) {
|
|
const dataViewSignature = new DataView(crc32Stream.value.buffer);
|
|
if (signature != dataViewSignature.getUint32(0, false)) {
|
|
throw new Error(ERR_INVALID_SIGNATURE);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
function filterEmptyChunks(readable) {
|
|
return pipeThrough(readable, new TransformStream({
|
|
transform(chunk, controller) {
|
|
if (chunk && chunk.length) {
|
|
controller.enqueue(chunk);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
function setReadable(stream, readable, flush) {
|
|
readable = pipeThrough(readable, new TransformStream({ flush }));
|
|
Object.defineProperty(stream, "readable", {
|
|
get() {
|
|
return readable;
|
|
}
|
|
});
|
|
}
|
|
function pipeThroughCommpressionStream(readable, useCompressionStream, options, CodecStreamNative, CodecStream2) {
|
|
try {
|
|
const CompressionStream = useCompressionStream && CodecStreamNative ? CodecStreamNative : CodecStream2;
|
|
readable = pipeThrough(readable, new CompressionStream(COMPRESSION_FORMAT, options));
|
|
} catch (_error) {
|
|
if (useCompressionStream) {
|
|
try {
|
|
readable = pipeThrough(readable, new CodecStream2(COMPRESSION_FORMAT, options));
|
|
} catch (_error2) {
|
|
return readable;
|
|
}
|
|
} else {
|
|
return readable;
|
|
}
|
|
}
|
|
return readable;
|
|
}
|
|
function pipeThrough(readable, transformStream) {
|
|
return readable.pipeThrough(transformStream);
|
|
}
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/codec-stream.js
|
|
var MESSAGE_EVENT_TYPE = "message";
|
|
var MESSAGE_START = "start";
|
|
var MESSAGE_PULL = "pull";
|
|
var MESSAGE_DATA = "data";
|
|
var MESSAGE_ACK_DATA = "ack";
|
|
var MESSAGE_CLOSE = "close";
|
|
var CODEC_DEFLATE = "deflate";
|
|
var CODEC_INFLATE = "inflate";
|
|
var CodecStream = class extends TransformStream {
|
|
constructor(options, config) {
|
|
super({});
|
|
const codec2 = this;
|
|
const { codecType } = options;
|
|
let Stream;
|
|
if (codecType.startsWith(CODEC_DEFLATE)) {
|
|
Stream = DeflateStream;
|
|
} else if (codecType.startsWith(CODEC_INFLATE)) {
|
|
Stream = InflateStream;
|
|
}
|
|
let outputSize = 0;
|
|
let inputSize = 0;
|
|
const stream = new Stream(options, config);
|
|
const readable = super.readable;
|
|
const inputSizeStream = new TransformStream({
|
|
transform(chunk, controller) {
|
|
if (chunk && chunk.length) {
|
|
inputSize += chunk.length;
|
|
controller.enqueue(chunk);
|
|
}
|
|
},
|
|
flush() {
|
|
Object.assign(codec2, {
|
|
inputSize
|
|
});
|
|
}
|
|
});
|
|
const outputSizeStream = new TransformStream({
|
|
transform(chunk, controller) {
|
|
if (chunk && chunk.length) {
|
|
outputSize += chunk.length;
|
|
controller.enqueue(chunk);
|
|
}
|
|
},
|
|
flush() {
|
|
const { signature } = stream;
|
|
Object.assign(codec2, {
|
|
signature,
|
|
outputSize,
|
|
inputSize
|
|
});
|
|
}
|
|
});
|
|
Object.defineProperty(codec2, "readable", {
|
|
get() {
|
|
return readable.pipeThrough(inputSizeStream).pipeThrough(stream).pipeThrough(outputSizeStream);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
var ChunkStream = class extends TransformStream {
|
|
constructor(chunkSize) {
|
|
let pendingChunk;
|
|
super({
|
|
transform,
|
|
flush(controller) {
|
|
if (pendingChunk && pendingChunk.length) {
|
|
controller.enqueue(pendingChunk);
|
|
}
|
|
}
|
|
});
|
|
function transform(chunk, controller) {
|
|
if (pendingChunk) {
|
|
const newChunk = new Uint8Array(pendingChunk.length + chunk.length);
|
|
newChunk.set(pendingChunk);
|
|
newChunk.set(chunk, pendingChunk.length);
|
|
chunk = newChunk;
|
|
pendingChunk = null;
|
|
}
|
|
if (chunk.length > chunkSize) {
|
|
controller.enqueue(chunk.slice(0, chunkSize));
|
|
transform(chunk.slice(chunkSize), controller);
|
|
} else {
|
|
pendingChunk = chunk;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/z-worker-core.js
|
|
var pendingPullMessages = /* @__PURE__ */ new Map();
|
|
var pendingDataMessages = /* @__PURE__ */ new Map();
|
|
var abortController;
|
|
var messageId = 0;
|
|
var importScriptSupported = true;
|
|
addEventListener(MESSAGE_EVENT_TYPE, ({ data }) => {
|
|
const { type, messageId: messageId2, value, done } = data;
|
|
try {
|
|
if (type == MESSAGE_START) {
|
|
init(data);
|
|
}
|
|
if (type == MESSAGE_DATA) {
|
|
const resolve = pendingPullMessages.get(messageId2);
|
|
pendingPullMessages.delete(messageId2);
|
|
resolve({ value: new Uint8Array(value), done });
|
|
}
|
|
if (type == MESSAGE_ACK_DATA) {
|
|
const resolve = pendingDataMessages.get(messageId2);
|
|
pendingDataMessages.delete(messageId2);
|
|
resolve();
|
|
}
|
|
if (type == MESSAGE_CLOSE) {
|
|
abortController.abort();
|
|
}
|
|
} catch (error) {
|
|
sendErrorMessage(error);
|
|
}
|
|
});
|
|
async function init(message) {
|
|
try {
|
|
const { options, scripts, config } = message;
|
|
if (scripts && scripts.length) {
|
|
try {
|
|
if (importScriptSupported) {
|
|
importScripts.apply(UNDEFINED_VALUE, scripts);
|
|
} else {
|
|
await imporModuleScripts(scripts);
|
|
}
|
|
} catch (_error) {
|
|
importScriptSupported = false;
|
|
await imporModuleScripts(scripts);
|
|
}
|
|
}
|
|
if (self.initCodec) {
|
|
self.initCodec();
|
|
}
|
|
config.CompressionStreamNative = self.CompressionStream;
|
|
config.DecompressionStreamNative = self.DecompressionStream;
|
|
if (self.Deflate) {
|
|
config.CompressionStream = new StreamAdapter(self.Deflate);
|
|
}
|
|
if (self.Inflate) {
|
|
config.DecompressionStream = new StreamAdapter(self.Inflate);
|
|
}
|
|
const strategy = { highWaterMark: 1 };
|
|
const readable = message.readable || new ReadableStream({
|
|
async pull(controller) {
|
|
const result = new Promise((resolve) => pendingPullMessages.set(messageId, resolve));
|
|
sendMessage({ type: MESSAGE_PULL, messageId });
|
|
messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
|
|
const { value, done } = await result;
|
|
controller.enqueue(value);
|
|
if (done) {
|
|
controller.close();
|
|
}
|
|
}
|
|
}, strategy);
|
|
const writable = message.writable || new WritableStream({
|
|
async write(value) {
|
|
let resolveAckData;
|
|
const ackData = new Promise((resolve) => resolveAckData = resolve);
|
|
pendingDataMessages.set(messageId, resolveAckData);
|
|
sendMessage({ type: MESSAGE_DATA, value, messageId });
|
|
messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
|
|
await ackData;
|
|
}
|
|
}, strategy);
|
|
const codecStream = new CodecStream(options, config);
|
|
abortController = new AbortController();
|
|
const { signal } = abortController;
|
|
await readable.pipeThrough(codecStream).pipeThrough(new ChunkStream(config.chunkSize)).pipeTo(writable, { signal, preventClose: true, preventAbort: true });
|
|
await writable.getWriter().close();
|
|
const {
|
|
signature,
|
|
inputSize,
|
|
outputSize
|
|
} = codecStream;
|
|
sendMessage({
|
|
type: MESSAGE_CLOSE,
|
|
result: {
|
|
signature,
|
|
inputSize,
|
|
outputSize
|
|
}
|
|
});
|
|
} catch (error) {
|
|
sendErrorMessage(error);
|
|
}
|
|
}
|
|
async function imporModuleScripts(scripts) {
|
|
for (const script of scripts) {
|
|
await import(script);
|
|
}
|
|
}
|
|
function sendMessage(message) {
|
|
let { value } = message;
|
|
if (value) {
|
|
if (value.length) {
|
|
try {
|
|
value = new Uint8Array(value);
|
|
message.value = value.buffer;
|
|
postMessage(message, [message.value]);
|
|
} catch (_error) {
|
|
postMessage(message);
|
|
}
|
|
} else {
|
|
postMessage(message);
|
|
}
|
|
} else {
|
|
postMessage(message);
|
|
}
|
|
}
|
|
function sendErrorMessage(error = new Error("Unknown error")) {
|
|
const { message, stack, code, name } = error;
|
|
postMessage({ error: { message, stack, code, name } });
|
|
}
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/codecs/deflate.js
|
|
var MAX_BITS = 15;
|
|
var D_CODES = 30;
|
|
var BL_CODES = 19;
|
|
var LENGTH_CODES = 29;
|
|
var LITERALS = 256;
|
|
var L_CODES = LITERALS + 1 + LENGTH_CODES;
|
|
var HEAP_SIZE = 2 * L_CODES + 1;
|
|
var END_BLOCK = 256;
|
|
var MAX_BL_BITS = 7;
|
|
var REP_3_6 = 16;
|
|
var REPZ_3_10 = 17;
|
|
var REPZ_11_138 = 18;
|
|
var Buf_size = 8 * 2;
|
|
var Z_DEFAULT_COMPRESSION = -1;
|
|
var Z_FILTERED = 1;
|
|
var Z_HUFFMAN_ONLY = 2;
|
|
var Z_DEFAULT_STRATEGY = 0;
|
|
var Z_NO_FLUSH = 0;
|
|
var Z_PARTIAL_FLUSH = 1;
|
|
var Z_FULL_FLUSH = 3;
|
|
var Z_FINISH = 4;
|
|
var Z_OK = 0;
|
|
var Z_STREAM_END = 1;
|
|
var Z_NEED_DICT = 2;
|
|
var Z_STREAM_ERROR = -2;
|
|
var Z_DATA_ERROR = -3;
|
|
var Z_BUF_ERROR = -5;
|
|
function extractArray(array) {
|
|
return flatArray(array.map(([length, value]) => new Array(length).fill(value, 0, length)));
|
|
}
|
|
function flatArray(array) {
|
|
return array.reduce((a, b) => a.concat(Array.isArray(b) ? flatArray(b) : b), []);
|
|
}
|
|
var _dist_code = [0, 1, 2, 3].concat(...extractArray([
|
|
[2, 4],
|
|
[2, 5],
|
|
[4, 6],
|
|
[4, 7],
|
|
[8, 8],
|
|
[8, 9],
|
|
[16, 10],
|
|
[16, 11],
|
|
[32, 12],
|
|
[32, 13],
|
|
[64, 14],
|
|
[64, 15],
|
|
[2, 0],
|
|
[1, 16],
|
|
[1, 17],
|
|
[2, 18],
|
|
[2, 19],
|
|
[4, 20],
|
|
[4, 21],
|
|
[8, 22],
|
|
[8, 23],
|
|
[16, 24],
|
|
[16, 25],
|
|
[32, 26],
|
|
[32, 27],
|
|
[64, 28],
|
|
[64, 29]
|
|
]));
|
|
function Tree() {
|
|
const that = this;
|
|
function gen_bitlen(s) {
|
|
const tree = that.dyn_tree;
|
|
const stree = that.stat_desc.static_tree;
|
|
const extra = that.stat_desc.extra_bits;
|
|
const base = that.stat_desc.extra_base;
|
|
const max_length = that.stat_desc.max_length;
|
|
let h;
|
|
let n, m;
|
|
let bits;
|
|
let xbits;
|
|
let f;
|
|
let overflow = 0;
|
|
for (bits = 0; bits <= MAX_BITS; bits++)
|
|
s.bl_count[bits] = 0;
|
|
tree[s.heap[s.heap_max] * 2 + 1] = 0;
|
|
for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
|
|
n = s.heap[h];
|
|
bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
|
|
if (bits > max_length) {
|
|
bits = max_length;
|
|
overflow++;
|
|
}
|
|
tree[n * 2 + 1] = bits;
|
|
if (n > that.max_code)
|
|
continue;
|
|
s.bl_count[bits]++;
|
|
xbits = 0;
|
|
if (n >= base)
|
|
xbits = extra[n - base];
|
|
f = tree[n * 2];
|
|
s.opt_len += f * (bits + xbits);
|
|
if (stree)
|
|
s.static_len += f * (stree[n * 2 + 1] + xbits);
|
|
}
|
|
if (overflow === 0)
|
|
return;
|
|
do {
|
|
bits = max_length - 1;
|
|
while (s.bl_count[bits] === 0)
|
|
bits--;
|
|
s.bl_count[bits]--;
|
|
s.bl_count[bits + 1] += 2;
|
|
s.bl_count[max_length]--;
|
|
overflow -= 2;
|
|
} while (overflow > 0);
|
|
for (bits = max_length; bits !== 0; bits--) {
|
|
n = s.bl_count[bits];
|
|
while (n !== 0) {
|
|
m = s.heap[--h];
|
|
if (m > that.max_code)
|
|
continue;
|
|
if (tree[m * 2 + 1] != bits) {
|
|
s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
|
|
tree[m * 2 + 1] = bits;
|
|
}
|
|
n--;
|
|
}
|
|
}
|
|
}
|
|
function bi_reverse(code, len) {
|
|
let res = 0;
|
|
do {
|
|
res |= code & 1;
|
|
code >>>= 1;
|
|
res <<= 1;
|
|
} while (--len > 0);
|
|
return res >>> 1;
|
|
}
|
|
function gen_codes(tree, max_code, bl_count) {
|
|
const next_code = [];
|
|
let code = 0;
|
|
let bits;
|
|
let n;
|
|
let len;
|
|
for (bits = 1; bits <= MAX_BITS; bits++) {
|
|
next_code[bits] = code = code + bl_count[bits - 1] << 1;
|
|
}
|
|
for (n = 0; n <= max_code; n++) {
|
|
len = tree[n * 2 + 1];
|
|
if (len === 0)
|
|
continue;
|
|
tree[n * 2] = bi_reverse(next_code[len]++, len);
|
|
}
|
|
}
|
|
that.build_tree = function(s) {
|
|
const tree = that.dyn_tree;
|
|
const stree = that.stat_desc.static_tree;
|
|
const elems = that.stat_desc.elems;
|
|
let n, m;
|
|
let max_code = -1;
|
|
let node;
|
|
s.heap_len = 0;
|
|
s.heap_max = HEAP_SIZE;
|
|
for (n = 0; n < elems; n++) {
|
|
if (tree[n * 2] !== 0) {
|
|
s.heap[++s.heap_len] = max_code = n;
|
|
s.depth[n] = 0;
|
|
} else {
|
|
tree[n * 2 + 1] = 0;
|
|
}
|
|
}
|
|
while (s.heap_len < 2) {
|
|
node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
|
|
tree[node * 2] = 1;
|
|
s.depth[node] = 0;
|
|
s.opt_len--;
|
|
if (stree)
|
|
s.static_len -= stree[node * 2 + 1];
|
|
}
|
|
that.max_code = max_code;
|
|
for (n = Math.floor(s.heap_len / 2); n >= 1; n--)
|
|
s.pqdownheap(tree, n);
|
|
node = elems;
|
|
do {
|
|
n = s.heap[1];
|
|
s.heap[1] = s.heap[s.heap_len--];
|
|
s.pqdownheap(tree, 1);
|
|
m = s.heap[1];
|
|
s.heap[--s.heap_max] = n;
|
|
s.heap[--s.heap_max] = m;
|
|
tree[node * 2] = tree[n * 2] + tree[m * 2];
|
|
s.depth[node] = Math.max(s.depth[n], s.depth[m]) + 1;
|
|
tree[n * 2 + 1] = tree[m * 2 + 1] = node;
|
|
s.heap[1] = node++;
|
|
s.pqdownheap(tree, 1);
|
|
} while (s.heap_len >= 2);
|
|
s.heap[--s.heap_max] = s.heap[1];
|
|
gen_bitlen(s);
|
|
gen_codes(tree, that.max_code, s.bl_count);
|
|
};
|
|
}
|
|
Tree._length_code = [0, 1, 2, 3, 4, 5, 6, 7].concat(...extractArray([
|
|
[2, 8],
|
|
[2, 9],
|
|
[2, 10],
|
|
[2, 11],
|
|
[4, 12],
|
|
[4, 13],
|
|
[4, 14],
|
|
[4, 15],
|
|
[8, 16],
|
|
[8, 17],
|
|
[8, 18],
|
|
[8, 19],
|
|
[16, 20],
|
|
[16, 21],
|
|
[16, 22],
|
|
[16, 23],
|
|
[32, 24],
|
|
[32, 25],
|
|
[32, 26],
|
|
[31, 27],
|
|
[1, 28]
|
|
]));
|
|
Tree.base_length = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0];
|
|
Tree.base_dist = [
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
6,
|
|
8,
|
|
12,
|
|
16,
|
|
24,
|
|
32,
|
|
48,
|
|
64,
|
|
96,
|
|
128,
|
|
192,
|
|
256,
|
|
384,
|
|
512,
|
|
768,
|
|
1024,
|
|
1536,
|
|
2048,
|
|
3072,
|
|
4096,
|
|
6144,
|
|
8192,
|
|
12288,
|
|
16384,
|
|
24576
|
|
];
|
|
Tree.d_code = function(dist) {
|
|
return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
|
|
};
|
|
Tree.extra_lbits = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
|
|
Tree.extra_dbits = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
|
|
Tree.extra_blbits = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7];
|
|
Tree.bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
|
function StaticTree(static_tree, extra_bits, extra_base, elems, max_length) {
|
|
const that = this;
|
|
that.static_tree = static_tree;
|
|
that.extra_bits = extra_bits;
|
|
that.extra_base = extra_base;
|
|
that.elems = elems;
|
|
that.max_length = max_length;
|
|
}
|
|
var static_ltree2_first_part = [
|
|
12,
|
|
140,
|
|
76,
|
|
204,
|
|
44,
|
|
172,
|
|
108,
|
|
236,
|
|
28,
|
|
156,
|
|
92,
|
|
220,
|
|
60,
|
|
188,
|
|
124,
|
|
252,
|
|
2,
|
|
130,
|
|
66,
|
|
194,
|
|
34,
|
|
162,
|
|
98,
|
|
226,
|
|
18,
|
|
146,
|
|
82,
|
|
210,
|
|
50,
|
|
178,
|
|
114,
|
|
242,
|
|
10,
|
|
138,
|
|
74,
|
|
202,
|
|
42,
|
|
170,
|
|
106,
|
|
234,
|
|
26,
|
|
154,
|
|
90,
|
|
218,
|
|
58,
|
|
186,
|
|
122,
|
|
250,
|
|
6,
|
|
134,
|
|
70,
|
|
198,
|
|
38,
|
|
166,
|
|
102,
|
|
230,
|
|
22,
|
|
150,
|
|
86,
|
|
214,
|
|
54,
|
|
182,
|
|
118,
|
|
246,
|
|
14,
|
|
142,
|
|
78,
|
|
206,
|
|
46,
|
|
174,
|
|
110,
|
|
238,
|
|
30,
|
|
158,
|
|
94,
|
|
222,
|
|
62,
|
|
190,
|
|
126,
|
|
254,
|
|
1,
|
|
129,
|
|
65,
|
|
193,
|
|
33,
|
|
161,
|
|
97,
|
|
225,
|
|
17,
|
|
145,
|
|
81,
|
|
209,
|
|
49,
|
|
177,
|
|
113,
|
|
241,
|
|
9,
|
|
137,
|
|
73,
|
|
201,
|
|
41,
|
|
169,
|
|
105,
|
|
233,
|
|
25,
|
|
153,
|
|
89,
|
|
217,
|
|
57,
|
|
185,
|
|
121,
|
|
249,
|
|
5,
|
|
133,
|
|
69,
|
|
197,
|
|
37,
|
|
165,
|
|
101,
|
|
229,
|
|
21,
|
|
149,
|
|
85,
|
|
213,
|
|
53,
|
|
181,
|
|
117,
|
|
245,
|
|
13,
|
|
141,
|
|
77,
|
|
205,
|
|
45,
|
|
173,
|
|
109,
|
|
237,
|
|
29,
|
|
157,
|
|
93,
|
|
221,
|
|
61,
|
|
189,
|
|
125,
|
|
253,
|
|
19,
|
|
275,
|
|
147,
|
|
403,
|
|
83,
|
|
339,
|
|
211,
|
|
467,
|
|
51,
|
|
307,
|
|
179,
|
|
435,
|
|
115,
|
|
371,
|
|
243,
|
|
499,
|
|
11,
|
|
267,
|
|
139,
|
|
395,
|
|
75,
|
|
331,
|
|
203,
|
|
459,
|
|
43,
|
|
299,
|
|
171,
|
|
427,
|
|
107,
|
|
363,
|
|
235,
|
|
491,
|
|
27,
|
|
283,
|
|
155,
|
|
411,
|
|
91,
|
|
347,
|
|
219,
|
|
475,
|
|
59,
|
|
315,
|
|
187,
|
|
443,
|
|
123,
|
|
379,
|
|
251,
|
|
507,
|
|
7,
|
|
263,
|
|
135,
|
|
391,
|
|
71,
|
|
327,
|
|
199,
|
|
455,
|
|
39,
|
|
295,
|
|
167,
|
|
423,
|
|
103,
|
|
359,
|
|
231,
|
|
487,
|
|
23,
|
|
279,
|
|
151,
|
|
407,
|
|
87,
|
|
343,
|
|
215,
|
|
471,
|
|
55,
|
|
311,
|
|
183,
|
|
439,
|
|
119,
|
|
375,
|
|
247,
|
|
503,
|
|
15,
|
|
271,
|
|
143,
|
|
399,
|
|
79,
|
|
335,
|
|
207,
|
|
463,
|
|
47,
|
|
303,
|
|
175,
|
|
431,
|
|
111,
|
|
367,
|
|
239,
|
|
495,
|
|
31,
|
|
287,
|
|
159,
|
|
415,
|
|
95,
|
|
351,
|
|
223,
|
|
479,
|
|
63,
|
|
319,
|
|
191,
|
|
447,
|
|
127,
|
|
383,
|
|
255,
|
|
511,
|
|
0,
|
|
64,
|
|
32,
|
|
96,
|
|
16,
|
|
80,
|
|
48,
|
|
112,
|
|
8,
|
|
72,
|
|
40,
|
|
104,
|
|
24,
|
|
88,
|
|
56,
|
|
120,
|
|
4,
|
|
68,
|
|
36,
|
|
100,
|
|
20,
|
|
84,
|
|
52,
|
|
116,
|
|
3,
|
|
131,
|
|
67,
|
|
195,
|
|
35,
|
|
163,
|
|
99,
|
|
227
|
|
];
|
|
var static_ltree2_second_part = extractArray([[144, 8], [112, 9], [24, 7], [8, 8]]);
|
|
StaticTree.static_ltree = flatArray(static_ltree2_first_part.map((value, index) => [value, static_ltree2_second_part[index]]));
|
|
var static_dtree_first_part = [0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10, 26, 6, 22, 14, 30, 1, 17, 9, 25, 5, 21, 13, 29, 3, 19, 11, 27, 7, 23];
|
|
var static_dtree_second_part = extractArray([[30, 5]]);
|
|
StaticTree.static_dtree = flatArray(static_dtree_first_part.map((value, index) => [value, static_dtree_second_part[index]]));
|
|
StaticTree.static_l_desc = new StaticTree(StaticTree.static_ltree, Tree.extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
|
|
StaticTree.static_d_desc = new StaticTree(StaticTree.static_dtree, Tree.extra_dbits, 0, D_CODES, MAX_BITS);
|
|
StaticTree.static_bl_desc = new StaticTree(null, Tree.extra_blbits, 0, BL_CODES, MAX_BL_BITS);
|
|
var MAX_MEM_LEVEL = 9;
|
|
var DEF_MEM_LEVEL = 8;
|
|
function Config(good_length, max_lazy, nice_length, max_chain, func) {
|
|
const that = this;
|
|
that.good_length = good_length;
|
|
that.max_lazy = max_lazy;
|
|
that.nice_length = nice_length;
|
|
that.max_chain = max_chain;
|
|
that.func = func;
|
|
}
|
|
var STORED = 0;
|
|
var FAST = 1;
|
|
var SLOW = 2;
|
|
var config_table = [
|
|
new Config(0, 0, 0, 0, STORED),
|
|
new Config(4, 4, 8, 4, FAST),
|
|
new Config(4, 5, 16, 8, FAST),
|
|
new Config(4, 6, 32, 32, FAST),
|
|
new Config(4, 4, 16, 16, SLOW),
|
|
new Config(8, 16, 32, 32, SLOW),
|
|
new Config(8, 16, 128, 128, SLOW),
|
|
new Config(8, 32, 128, 256, SLOW),
|
|
new Config(32, 128, 258, 1024, SLOW),
|
|
new Config(32, 258, 258, 4096, SLOW)
|
|
];
|
|
var z_errmsg = [
|
|
"need dictionary",
|
|
// Z_NEED_DICT
|
|
// 2
|
|
"stream end",
|
|
// Z_STREAM_END 1
|
|
"",
|
|
// Z_OK 0
|
|
"",
|
|
// Z_ERRNO (-1)
|
|
"stream error",
|
|
// Z_STREAM_ERROR (-2)
|
|
"data error",
|
|
// Z_DATA_ERROR (-3)
|
|
"",
|
|
// Z_MEM_ERROR (-4)
|
|
"buffer error",
|
|
// Z_BUF_ERROR (-5)
|
|
"",
|
|
// Z_VERSION_ERROR (-6)
|
|
""
|
|
];
|
|
var NeedMore = 0;
|
|
var BlockDone = 1;
|
|
var FinishStarted = 2;
|
|
var FinishDone = 3;
|
|
var PRESET_DICT = 32;
|
|
var INIT_STATE = 42;
|
|
var BUSY_STATE = 113;
|
|
var FINISH_STATE = 666;
|
|
var Z_DEFLATED = 8;
|
|
var STORED_BLOCK = 0;
|
|
var STATIC_TREES = 1;
|
|
var DYN_TREES = 2;
|
|
var MIN_MATCH = 3;
|
|
var MAX_MATCH = 258;
|
|
var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
|
|
function smaller(tree, n, m, depth) {
|
|
const tn2 = tree[n * 2];
|
|
const tm2 = tree[m * 2];
|
|
return tn2 < tm2 || tn2 == tm2 && depth[n] <= depth[m];
|
|
}
|
|
function Deflate() {
|
|
const that = this;
|
|
let strm;
|
|
let status;
|
|
let pending_buf_size;
|
|
let last_flush;
|
|
let w_size;
|
|
let w_bits;
|
|
let w_mask;
|
|
let win;
|
|
let window_size;
|
|
let prev;
|
|
let head;
|
|
let ins_h;
|
|
let hash_size;
|
|
let hash_bits;
|
|
let hash_mask;
|
|
let hash_shift;
|
|
let block_start;
|
|
let match_length;
|
|
let prev_match;
|
|
let match_available;
|
|
let strstart;
|
|
let match_start;
|
|
let lookahead;
|
|
let prev_length;
|
|
let max_chain_length;
|
|
let max_lazy_match;
|
|
let level;
|
|
let strategy;
|
|
let good_match;
|
|
let nice_match;
|
|
let dyn_ltree;
|
|
let dyn_dtree;
|
|
let bl_tree;
|
|
const l_desc = new Tree();
|
|
const d_desc = new Tree();
|
|
const bl_desc = new Tree();
|
|
that.depth = [];
|
|
let lit_bufsize;
|
|
let last_lit;
|
|
let matches;
|
|
let last_eob_len;
|
|
let bi_buf;
|
|
let bi_valid;
|
|
that.bl_count = [];
|
|
that.heap = [];
|
|
dyn_ltree = [];
|
|
dyn_dtree = [];
|
|
bl_tree = [];
|
|
function lm_init() {
|
|
window_size = 2 * w_size;
|
|
head[hash_size - 1] = 0;
|
|
for (let i = 0; i < hash_size - 1; i++) {
|
|
head[i] = 0;
|
|
}
|
|
max_lazy_match = config_table[level].max_lazy;
|
|
good_match = config_table[level].good_length;
|
|
nice_match = config_table[level].nice_length;
|
|
max_chain_length = config_table[level].max_chain;
|
|
strstart = 0;
|
|
block_start = 0;
|
|
lookahead = 0;
|
|
match_length = prev_length = MIN_MATCH - 1;
|
|
match_available = 0;
|
|
ins_h = 0;
|
|
}
|
|
function init_block() {
|
|
let i;
|
|
for (i = 0; i < L_CODES; i++)
|
|
dyn_ltree[i * 2] = 0;
|
|
for (i = 0; i < D_CODES; i++)
|
|
dyn_dtree[i * 2] = 0;
|
|
for (i = 0; i < BL_CODES; i++)
|
|
bl_tree[i * 2] = 0;
|
|
dyn_ltree[END_BLOCK * 2] = 1;
|
|
that.opt_len = that.static_len = 0;
|
|
last_lit = matches = 0;
|
|
}
|
|
function tr_init() {
|
|
l_desc.dyn_tree = dyn_ltree;
|
|
l_desc.stat_desc = StaticTree.static_l_desc;
|
|
d_desc.dyn_tree = dyn_dtree;
|
|
d_desc.stat_desc = StaticTree.static_d_desc;
|
|
bl_desc.dyn_tree = bl_tree;
|
|
bl_desc.stat_desc = StaticTree.static_bl_desc;
|
|
bi_buf = 0;
|
|
bi_valid = 0;
|
|
last_eob_len = 8;
|
|
init_block();
|
|
}
|
|
that.pqdownheap = function(tree, k) {
|
|
const heap = that.heap;
|
|
const v = heap[k];
|
|
let j = k << 1;
|
|
while (j <= that.heap_len) {
|
|
if (j < that.heap_len && smaller(tree, heap[j + 1], heap[j], that.depth)) {
|
|
j++;
|
|
}
|
|
if (smaller(tree, v, heap[j], that.depth))
|
|
break;
|
|
heap[k] = heap[j];
|
|
k = j;
|
|
j <<= 1;
|
|
}
|
|
heap[k] = v;
|
|
};
|
|
function scan_tree(tree, max_code) {
|
|
let prevlen = -1;
|
|
let curlen;
|
|
let nextlen = tree[0 * 2 + 1];
|
|
let count = 0;
|
|
let max_count = 7;
|
|
let min_count = 4;
|
|
if (nextlen === 0) {
|
|
max_count = 138;
|
|
min_count = 3;
|
|
}
|
|
tree[(max_code + 1) * 2 + 1] = 65535;
|
|
for (let n = 0; n <= max_code; n++) {
|
|
curlen = nextlen;
|
|
nextlen = tree[(n + 1) * 2 + 1];
|
|
if (++count < max_count && curlen == nextlen) {
|
|
continue;
|
|
} else if (count < min_count) {
|
|
bl_tree[curlen * 2] += count;
|
|
} else if (curlen !== 0) {
|
|
if (curlen != prevlen)
|
|
bl_tree[curlen * 2]++;
|
|
bl_tree[REP_3_6 * 2]++;
|
|
} else if (count <= 10) {
|
|
bl_tree[REPZ_3_10 * 2]++;
|
|
} else {
|
|
bl_tree[REPZ_11_138 * 2]++;
|
|
}
|
|
count = 0;
|
|
prevlen = curlen;
|
|
if (nextlen === 0) {
|
|
max_count = 138;
|
|
min_count = 3;
|
|
} else if (curlen == nextlen) {
|
|
max_count = 6;
|
|
min_count = 3;
|
|
} else {
|
|
max_count = 7;
|
|
min_count = 4;
|
|
}
|
|
}
|
|
}
|
|
function build_bl_tree() {
|
|
let max_blindex;
|
|
scan_tree(dyn_ltree, l_desc.max_code);
|
|
scan_tree(dyn_dtree, d_desc.max_code);
|
|
bl_desc.build_tree(that);
|
|
for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
|
|
if (bl_tree[Tree.bl_order[max_blindex] * 2 + 1] !== 0)
|
|
break;
|
|
}
|
|
that.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
|
|
return max_blindex;
|
|
}
|
|
function put_byte(p) {
|
|
that.pending_buf[that.pending++] = p;
|
|
}
|
|
function put_short(w) {
|
|
put_byte(w & 255);
|
|
put_byte(w >>> 8 & 255);
|
|
}
|
|
function putShortMSB(b) {
|
|
put_byte(b >> 8 & 255);
|
|
put_byte(b & 255 & 255);
|
|
}
|
|
function send_bits(value, length) {
|
|
let val;
|
|
const len = length;
|
|
if (bi_valid > Buf_size - len) {
|
|
val = value;
|
|
bi_buf |= val << bi_valid & 65535;
|
|
put_short(bi_buf);
|
|
bi_buf = val >>> Buf_size - bi_valid;
|
|
bi_valid += len - Buf_size;
|
|
} else {
|
|
bi_buf |= value << bi_valid & 65535;
|
|
bi_valid += len;
|
|
}
|
|
}
|
|
function send_code(c, tree) {
|
|
const c2 = c * 2;
|
|
send_bits(tree[c2] & 65535, tree[c2 + 1] & 65535);
|
|
}
|
|
function send_tree(tree, max_code) {
|
|
let n;
|
|
let prevlen = -1;
|
|
let curlen;
|
|
let nextlen = tree[0 * 2 + 1];
|
|
let count = 0;
|
|
let max_count = 7;
|
|
let min_count = 4;
|
|
if (nextlen === 0) {
|
|
max_count = 138;
|
|
min_count = 3;
|
|
}
|
|
for (n = 0; n <= max_code; n++) {
|
|
curlen = nextlen;
|
|
nextlen = tree[(n + 1) * 2 + 1];
|
|
if (++count < max_count && curlen == nextlen) {
|
|
continue;
|
|
} else if (count < min_count) {
|
|
do {
|
|
send_code(curlen, bl_tree);
|
|
} while (--count !== 0);
|
|
} else if (curlen !== 0) {
|
|
if (curlen != prevlen) {
|
|
send_code(curlen, bl_tree);
|
|
count--;
|
|
}
|
|
send_code(REP_3_6, bl_tree);
|
|
send_bits(count - 3, 2);
|
|
} else if (count <= 10) {
|
|
send_code(REPZ_3_10, bl_tree);
|
|
send_bits(count - 3, 3);
|
|
} else {
|
|
send_code(REPZ_11_138, bl_tree);
|
|
send_bits(count - 11, 7);
|
|
}
|
|
count = 0;
|
|
prevlen = curlen;
|
|
if (nextlen === 0) {
|
|
max_count = 138;
|
|
min_count = 3;
|
|
} else if (curlen == nextlen) {
|
|
max_count = 6;
|
|
min_count = 3;
|
|
} else {
|
|
max_count = 7;
|
|
min_count = 4;
|
|
}
|
|
}
|
|
}
|
|
function send_all_trees(lcodes, dcodes, blcodes) {
|
|
let rank;
|
|
send_bits(lcodes - 257, 5);
|
|
send_bits(dcodes - 1, 5);
|
|
send_bits(blcodes - 4, 4);
|
|
for (rank = 0; rank < blcodes; rank++) {
|
|
send_bits(bl_tree[Tree.bl_order[rank] * 2 + 1], 3);
|
|
}
|
|
send_tree(dyn_ltree, lcodes - 1);
|
|
send_tree(dyn_dtree, dcodes - 1);
|
|
}
|
|
function bi_flush() {
|
|
if (bi_valid == 16) {
|
|
put_short(bi_buf);
|
|
bi_buf = 0;
|
|
bi_valid = 0;
|
|
} else if (bi_valid >= 8) {
|
|
put_byte(bi_buf & 255);
|
|
bi_buf >>>= 8;
|
|
bi_valid -= 8;
|
|
}
|
|
}
|
|
function _tr_align() {
|
|
send_bits(STATIC_TREES << 1, 3);
|
|
send_code(END_BLOCK, StaticTree.static_ltree);
|
|
bi_flush();
|
|
if (1 + last_eob_len + 10 - bi_valid < 9) {
|
|
send_bits(STATIC_TREES << 1, 3);
|
|
send_code(END_BLOCK, StaticTree.static_ltree);
|
|
bi_flush();
|
|
}
|
|
last_eob_len = 7;
|
|
}
|
|
function _tr_tally(dist, lc) {
|
|
let out_length, in_length, dcode;
|
|
that.dist_buf[last_lit] = dist;
|
|
that.lc_buf[last_lit] = lc & 255;
|
|
last_lit++;
|
|
if (dist === 0) {
|
|
dyn_ltree[lc * 2]++;
|
|
} else {
|
|
matches++;
|
|
dist--;
|
|
dyn_ltree[(Tree._length_code[lc] + LITERALS + 1) * 2]++;
|
|
dyn_dtree[Tree.d_code(dist) * 2]++;
|
|
}
|
|
if ((last_lit & 8191) === 0 && level > 2) {
|
|
out_length = last_lit * 8;
|
|
in_length = strstart - block_start;
|
|
for (dcode = 0; dcode < D_CODES; dcode++) {
|
|
out_length += dyn_dtree[dcode * 2] * (5 + Tree.extra_dbits[dcode]);
|
|
}
|
|
out_length >>>= 3;
|
|
if (matches < Math.floor(last_lit / 2) && out_length < Math.floor(in_length / 2))
|
|
return true;
|
|
}
|
|
return last_lit == lit_bufsize - 1;
|
|
}
|
|
function compress_block(ltree, dtree) {
|
|
let dist;
|
|
let lc;
|
|
let lx = 0;
|
|
let code;
|
|
let extra;
|
|
if (last_lit !== 0) {
|
|
do {
|
|
dist = that.dist_buf[lx];
|
|
lc = that.lc_buf[lx];
|
|
lx++;
|
|
if (dist === 0) {
|
|
send_code(lc, ltree);
|
|
} else {
|
|
code = Tree._length_code[lc];
|
|
send_code(code + LITERALS + 1, ltree);
|
|
extra = Tree.extra_lbits[code];
|
|
if (extra !== 0) {
|
|
lc -= Tree.base_length[code];
|
|
send_bits(lc, extra);
|
|
}
|
|
dist--;
|
|
code = Tree.d_code(dist);
|
|
send_code(code, dtree);
|
|
extra = Tree.extra_dbits[code];
|
|
if (extra !== 0) {
|
|
dist -= Tree.base_dist[code];
|
|
send_bits(dist, extra);
|
|
}
|
|
}
|
|
} while (lx < last_lit);
|
|
}
|
|
send_code(END_BLOCK, ltree);
|
|
last_eob_len = ltree[END_BLOCK * 2 + 1];
|
|
}
|
|
function bi_windup() {
|
|
if (bi_valid > 8) {
|
|
put_short(bi_buf);
|
|
} else if (bi_valid > 0) {
|
|
put_byte(bi_buf & 255);
|
|
}
|
|
bi_buf = 0;
|
|
bi_valid = 0;
|
|
}
|
|
function copy_block(buf, len, header) {
|
|
bi_windup();
|
|
last_eob_len = 8;
|
|
if (header) {
|
|
put_short(len);
|
|
put_short(~len);
|
|
}
|
|
that.pending_buf.set(win.subarray(buf, buf + len), that.pending);
|
|
that.pending += len;
|
|
}
|
|
function _tr_stored_block(buf, stored_len, eof) {
|
|
send_bits((STORED_BLOCK << 1) + (eof ? 1 : 0), 3);
|
|
copy_block(buf, stored_len, true);
|
|
}
|
|
function _tr_flush_block(buf, stored_len, eof) {
|
|
let opt_lenb, static_lenb;
|
|
let max_blindex = 0;
|
|
if (level > 0) {
|
|
l_desc.build_tree(that);
|
|
d_desc.build_tree(that);
|
|
max_blindex = build_bl_tree();
|
|
opt_lenb = that.opt_len + 3 + 7 >>> 3;
|
|
static_lenb = that.static_len + 3 + 7 >>> 3;
|
|
if (static_lenb <= opt_lenb)
|
|
opt_lenb = static_lenb;
|
|
} else {
|
|
opt_lenb = static_lenb = stored_len + 5;
|
|
}
|
|
if (stored_len + 4 <= opt_lenb && buf != -1) {
|
|
_tr_stored_block(buf, stored_len, eof);
|
|
} else if (static_lenb == opt_lenb) {
|
|
send_bits((STATIC_TREES << 1) + (eof ? 1 : 0), 3);
|
|
compress_block(StaticTree.static_ltree, StaticTree.static_dtree);
|
|
} else {
|
|
send_bits((DYN_TREES << 1) + (eof ? 1 : 0), 3);
|
|
send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, max_blindex + 1);
|
|
compress_block(dyn_ltree, dyn_dtree);
|
|
}
|
|
init_block();
|
|
if (eof) {
|
|
bi_windup();
|
|
}
|
|
}
|
|
function flush_block_only(eof) {
|
|
_tr_flush_block(block_start >= 0 ? block_start : -1, strstart - block_start, eof);
|
|
block_start = strstart;
|
|
strm.flush_pending();
|
|
}
|
|
function fill_window() {
|
|
let n, m;
|
|
let p;
|
|
let more;
|
|
do {
|
|
more = window_size - lookahead - strstart;
|
|
if (more === 0 && strstart === 0 && lookahead === 0) {
|
|
more = w_size;
|
|
} else if (more == -1) {
|
|
more--;
|
|
} else if (strstart >= w_size + w_size - MIN_LOOKAHEAD) {
|
|
win.set(win.subarray(w_size, w_size + w_size), 0);
|
|
match_start -= w_size;
|
|
strstart -= w_size;
|
|
block_start -= w_size;
|
|
n = hash_size;
|
|
p = n;
|
|
do {
|
|
m = head[--p] & 65535;
|
|
head[p] = m >= w_size ? m - w_size : 0;
|
|
} while (--n !== 0);
|
|
n = w_size;
|
|
p = n;
|
|
do {
|
|
m = prev[--p] & 65535;
|
|
prev[p] = m >= w_size ? m - w_size : 0;
|
|
} while (--n !== 0);
|
|
more += w_size;
|
|
}
|
|
if (strm.avail_in === 0)
|
|
return;
|
|
n = strm.read_buf(win, strstart + lookahead, more);
|
|
lookahead += n;
|
|
if (lookahead >= MIN_MATCH) {
|
|
ins_h = win[strstart] & 255;
|
|
ins_h = (ins_h << hash_shift ^ win[strstart + 1] & 255) & hash_mask;
|
|
}
|
|
} while (lookahead < MIN_LOOKAHEAD && strm.avail_in !== 0);
|
|
}
|
|
function deflate_stored(flush) {
|
|
let max_block_size = 65535;
|
|
let max_start;
|
|
if (max_block_size > pending_buf_size - 5) {
|
|
max_block_size = pending_buf_size - 5;
|
|
}
|
|
while (true) {
|
|
if (lookahead <= 1) {
|
|
fill_window();
|
|
if (lookahead === 0 && flush == Z_NO_FLUSH)
|
|
return NeedMore;
|
|
if (lookahead === 0)
|
|
break;
|
|
}
|
|
strstart += lookahead;
|
|
lookahead = 0;
|
|
max_start = block_start + max_block_size;
|
|
if (strstart === 0 || strstart >= max_start) {
|
|
lookahead = strstart - max_start;
|
|
strstart = max_start;
|
|
flush_block_only(false);
|
|
if (strm.avail_out === 0)
|
|
return NeedMore;
|
|
}
|
|
if (strstart - block_start >= w_size - MIN_LOOKAHEAD) {
|
|
flush_block_only(false);
|
|
if (strm.avail_out === 0)
|
|
return NeedMore;
|
|
}
|
|
}
|
|
flush_block_only(flush == Z_FINISH);
|
|
if (strm.avail_out === 0)
|
|
return flush == Z_FINISH ? FinishStarted : NeedMore;
|
|
return flush == Z_FINISH ? FinishDone : BlockDone;
|
|
}
|
|
function longest_match(cur_match) {
|
|
let chain_length = max_chain_length;
|
|
let scan = strstart;
|
|
let match;
|
|
let len;
|
|
let best_len = prev_length;
|
|
const limit = strstart > w_size - MIN_LOOKAHEAD ? strstart - (w_size - MIN_LOOKAHEAD) : 0;
|
|
let _nice_match = nice_match;
|
|
const wmask = w_mask;
|
|
const strend = strstart + MAX_MATCH;
|
|
let scan_end1 = win[scan + best_len - 1];
|
|
let scan_end = win[scan + best_len];
|
|
if (prev_length >= good_match) {
|
|
chain_length >>= 2;
|
|
}
|
|
if (_nice_match > lookahead)
|
|
_nice_match = lookahead;
|
|
do {
|
|
match = cur_match;
|
|
if (win[match + best_len] != scan_end || win[match + best_len - 1] != scan_end1 || win[match] != win[scan] || win[++match] != win[scan + 1])
|
|
continue;
|
|
scan += 2;
|
|
match++;
|
|
do {
|
|
} while (win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && win[++scan] == win[++match] && scan < strend);
|
|
len = MAX_MATCH - (strend - scan);
|
|
scan = strend - MAX_MATCH;
|
|
if (len > best_len) {
|
|
match_start = cur_match;
|
|
best_len = len;
|
|
if (len >= _nice_match)
|
|
break;
|
|
scan_end1 = win[scan + best_len - 1];
|
|
scan_end = win[scan + best_len];
|
|
}
|
|
} while ((cur_match = prev[cur_match & wmask] & 65535) > limit && --chain_length !== 0);
|
|
if (best_len <= lookahead)
|
|
return best_len;
|
|
return lookahead;
|
|
}
|
|
function deflate_fast(flush) {
|
|
let hash_head = 0;
|
|
let bflush;
|
|
while (true) {
|
|
if (lookahead < MIN_LOOKAHEAD) {
|
|
fill_window();
|
|
if (lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
|
|
return NeedMore;
|
|
}
|
|
if (lookahead === 0)
|
|
break;
|
|
}
|
|
if (lookahead >= MIN_MATCH) {
|
|
ins_h = (ins_h << hash_shift ^ win[strstart + (MIN_MATCH - 1)] & 255) & hash_mask;
|
|
hash_head = head[ins_h] & 65535;
|
|
prev[strstart & w_mask] = head[ins_h];
|
|
head[ins_h] = strstart;
|
|
}
|
|
if (hash_head !== 0 && (strstart - hash_head & 65535) <= w_size - MIN_LOOKAHEAD) {
|
|
if (strategy != Z_HUFFMAN_ONLY) {
|
|
match_length = longest_match(hash_head);
|
|
}
|
|
}
|
|
if (match_length >= MIN_MATCH) {
|
|
bflush = _tr_tally(strstart - match_start, match_length - MIN_MATCH);
|
|
lookahead -= match_length;
|
|
if (match_length <= max_lazy_match && lookahead >= MIN_MATCH) {
|
|
match_length--;
|
|
do {
|
|
strstart++;
|
|
ins_h = (ins_h << hash_shift ^ win[strstart + (MIN_MATCH - 1)] & 255) & hash_mask;
|
|
hash_head = head[ins_h] & 65535;
|
|
prev[strstart & w_mask] = head[ins_h];
|
|
head[ins_h] = strstart;
|
|
} while (--match_length !== 0);
|
|
strstart++;
|
|
} else {
|
|
strstart += match_length;
|
|
match_length = 0;
|
|
ins_h = win[strstart] & 255;
|
|
ins_h = (ins_h << hash_shift ^ win[strstart + 1] & 255) & hash_mask;
|
|
}
|
|
} else {
|
|
bflush = _tr_tally(0, win[strstart] & 255);
|
|
lookahead--;
|
|
strstart++;
|
|
}
|
|
if (bflush) {
|
|
flush_block_only(false);
|
|
if (strm.avail_out === 0)
|
|
return NeedMore;
|
|
}
|
|
}
|
|
flush_block_only(flush == Z_FINISH);
|
|
if (strm.avail_out === 0) {
|
|
if (flush == Z_FINISH)
|
|
return FinishStarted;
|
|
else
|
|
return NeedMore;
|
|
}
|
|
return flush == Z_FINISH ? FinishDone : BlockDone;
|
|
}
|
|
function deflate_slow(flush) {
|
|
let hash_head = 0;
|
|
let bflush;
|
|
let max_insert;
|
|
while (true) {
|
|
if (lookahead < MIN_LOOKAHEAD) {
|
|
fill_window();
|
|
if (lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
|
|
return NeedMore;
|
|
}
|
|
if (lookahead === 0)
|
|
break;
|
|
}
|
|
if (lookahead >= MIN_MATCH) {
|
|
ins_h = (ins_h << hash_shift ^ win[strstart + (MIN_MATCH - 1)] & 255) & hash_mask;
|
|
hash_head = head[ins_h] & 65535;
|
|
prev[strstart & w_mask] = head[ins_h];
|
|
head[ins_h] = strstart;
|
|
}
|
|
prev_length = match_length;
|
|
prev_match = match_start;
|
|
match_length = MIN_MATCH - 1;
|
|
if (hash_head !== 0 && prev_length < max_lazy_match && (strstart - hash_head & 65535) <= w_size - MIN_LOOKAHEAD) {
|
|
if (strategy != Z_HUFFMAN_ONLY) {
|
|
match_length = longest_match(hash_head);
|
|
}
|
|
if (match_length <= 5 && (strategy == Z_FILTERED || match_length == MIN_MATCH && strstart - match_start > 4096)) {
|
|
match_length = MIN_MATCH - 1;
|
|
}
|
|
}
|
|
if (prev_length >= MIN_MATCH && match_length <= prev_length) {
|
|
max_insert = strstart + lookahead - MIN_MATCH;
|
|
bflush = _tr_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
|
|
lookahead -= prev_length - 1;
|
|
prev_length -= 2;
|
|
do {
|
|
if (++strstart <= max_insert) {
|
|
ins_h = (ins_h << hash_shift ^ win[strstart + (MIN_MATCH - 1)] & 255) & hash_mask;
|
|
hash_head = head[ins_h] & 65535;
|
|
prev[strstart & w_mask] = head[ins_h];
|
|
head[ins_h] = strstart;
|
|
}
|
|
} while (--prev_length !== 0);
|
|
match_available = 0;
|
|
match_length = MIN_MATCH - 1;
|
|
strstart++;
|
|
if (bflush) {
|
|
flush_block_only(false);
|
|
if (strm.avail_out === 0)
|
|
return NeedMore;
|
|
}
|
|
} else if (match_available !== 0) {
|
|
bflush = _tr_tally(0, win[strstart - 1] & 255);
|
|
if (bflush) {
|
|
flush_block_only(false);
|
|
}
|
|
strstart++;
|
|
lookahead--;
|
|
if (strm.avail_out === 0)
|
|
return NeedMore;
|
|
} else {
|
|
match_available = 1;
|
|
strstart++;
|
|
lookahead--;
|
|
}
|
|
}
|
|
if (match_available !== 0) {
|
|
bflush = _tr_tally(0, win[strstart - 1] & 255);
|
|
match_available = 0;
|
|
}
|
|
flush_block_only(flush == Z_FINISH);
|
|
if (strm.avail_out === 0) {
|
|
if (flush == Z_FINISH)
|
|
return FinishStarted;
|
|
else
|
|
return NeedMore;
|
|
}
|
|
return flush == Z_FINISH ? FinishDone : BlockDone;
|
|
}
|
|
function deflateReset(strm2) {
|
|
strm2.total_in = strm2.total_out = 0;
|
|
strm2.msg = null;
|
|
that.pending = 0;
|
|
that.pending_out = 0;
|
|
status = BUSY_STATE;
|
|
last_flush = Z_NO_FLUSH;
|
|
tr_init();
|
|
lm_init();
|
|
return Z_OK;
|
|
}
|
|
that.deflateInit = function(strm2, _level, bits, _method, memLevel, _strategy) {
|
|
if (!_method)
|
|
_method = Z_DEFLATED;
|
|
if (!memLevel)
|
|
memLevel = DEF_MEM_LEVEL;
|
|
if (!_strategy)
|
|
_strategy = Z_DEFAULT_STRATEGY;
|
|
strm2.msg = null;
|
|
if (_level == Z_DEFAULT_COMPRESSION)
|
|
_level = 6;
|
|
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || _method != Z_DEFLATED || bits < 9 || bits > 15 || _level < 0 || _level > 9 || _strategy < 0 || _strategy > Z_HUFFMAN_ONLY) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
strm2.dstate = that;
|
|
w_bits = bits;
|
|
w_size = 1 << w_bits;
|
|
w_mask = w_size - 1;
|
|
hash_bits = memLevel + 7;
|
|
hash_size = 1 << hash_bits;
|
|
hash_mask = hash_size - 1;
|
|
hash_shift = Math.floor((hash_bits + MIN_MATCH - 1) / MIN_MATCH);
|
|
win = new Uint8Array(w_size * 2);
|
|
prev = [];
|
|
head = [];
|
|
lit_bufsize = 1 << memLevel + 6;
|
|
that.pending_buf = new Uint8Array(lit_bufsize * 4);
|
|
pending_buf_size = lit_bufsize * 4;
|
|
that.dist_buf = new Uint16Array(lit_bufsize);
|
|
that.lc_buf = new Uint8Array(lit_bufsize);
|
|
level = _level;
|
|
strategy = _strategy;
|
|
return deflateReset(strm2);
|
|
};
|
|
that.deflateEnd = function() {
|
|
if (status != INIT_STATE && status != BUSY_STATE && status != FINISH_STATE) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
that.lc_buf = null;
|
|
that.dist_buf = null;
|
|
that.pending_buf = null;
|
|
head = null;
|
|
prev = null;
|
|
win = null;
|
|
that.dstate = null;
|
|
return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
|
|
};
|
|
that.deflateParams = function(strm2, _level, _strategy) {
|
|
let err = Z_OK;
|
|
if (_level == Z_DEFAULT_COMPRESSION) {
|
|
_level = 6;
|
|
}
|
|
if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > Z_HUFFMAN_ONLY) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (config_table[level].func != config_table[_level].func && strm2.total_in !== 0) {
|
|
err = strm2.deflate(Z_PARTIAL_FLUSH);
|
|
}
|
|
if (level != _level) {
|
|
level = _level;
|
|
max_lazy_match = config_table[level].max_lazy;
|
|
good_match = config_table[level].good_length;
|
|
nice_match = config_table[level].nice_length;
|
|
max_chain_length = config_table[level].max_chain;
|
|
}
|
|
strategy = _strategy;
|
|
return err;
|
|
};
|
|
that.deflateSetDictionary = function(_strm, dictionary, dictLength) {
|
|
let length = dictLength;
|
|
let n, index = 0;
|
|
if (!dictionary || status != INIT_STATE)
|
|
return Z_STREAM_ERROR;
|
|
if (length < MIN_MATCH)
|
|
return Z_OK;
|
|
if (length > w_size - MIN_LOOKAHEAD) {
|
|
length = w_size - MIN_LOOKAHEAD;
|
|
index = dictLength - length;
|
|
}
|
|
win.set(dictionary.subarray(index, index + length), 0);
|
|
strstart = length;
|
|
block_start = length;
|
|
ins_h = win[0] & 255;
|
|
ins_h = (ins_h << hash_shift ^ win[1] & 255) & hash_mask;
|
|
for (n = 0; n <= length - MIN_MATCH; n++) {
|
|
ins_h = (ins_h << hash_shift ^ win[n + (MIN_MATCH - 1)] & 255) & hash_mask;
|
|
prev[n & w_mask] = head[ins_h];
|
|
head[ins_h] = n;
|
|
}
|
|
return Z_OK;
|
|
};
|
|
that.deflate = function(_strm, flush) {
|
|
let i, header, level_flags, old_flush, bstate;
|
|
if (flush > Z_FINISH || flush < 0) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (!_strm.next_out || !_strm.next_in && _strm.avail_in !== 0 || status == FINISH_STATE && flush != Z_FINISH) {
|
|
_strm.msg = z_errmsg[Z_NEED_DICT - Z_STREAM_ERROR];
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (_strm.avail_out === 0) {
|
|
_strm.msg = z_errmsg[Z_NEED_DICT - Z_BUF_ERROR];
|
|
return Z_BUF_ERROR;
|
|
}
|
|
strm = _strm;
|
|
old_flush = last_flush;
|
|
last_flush = flush;
|
|
if (status == INIT_STATE) {
|
|
header = Z_DEFLATED + (w_bits - 8 << 4) << 8;
|
|
level_flags = (level - 1 & 255) >> 1;
|
|
if (level_flags > 3)
|
|
level_flags = 3;
|
|
header |= level_flags << 6;
|
|
if (strstart !== 0)
|
|
header |= PRESET_DICT;
|
|
header += 31 - header % 31;
|
|
status = BUSY_STATE;
|
|
putShortMSB(header);
|
|
}
|
|
if (that.pending !== 0) {
|
|
strm.flush_pending();
|
|
if (strm.avail_out === 0) {
|
|
last_flush = -1;
|
|
return Z_OK;
|
|
}
|
|
} else if (strm.avail_in === 0 && flush <= old_flush && flush != Z_FINISH) {
|
|
strm.msg = z_errmsg[Z_NEED_DICT - Z_BUF_ERROR];
|
|
return Z_BUF_ERROR;
|
|
}
|
|
if (status == FINISH_STATE && strm.avail_in !== 0) {
|
|
_strm.msg = z_errmsg[Z_NEED_DICT - Z_BUF_ERROR];
|
|
return Z_BUF_ERROR;
|
|
}
|
|
if (strm.avail_in !== 0 || lookahead !== 0 || flush != Z_NO_FLUSH && status != FINISH_STATE) {
|
|
bstate = -1;
|
|
switch (config_table[level].func) {
|
|
case STORED:
|
|
bstate = deflate_stored(flush);
|
|
break;
|
|
case FAST:
|
|
bstate = deflate_fast(flush);
|
|
break;
|
|
case SLOW:
|
|
bstate = deflate_slow(flush);
|
|
break;
|
|
default:
|
|
}
|
|
if (bstate == FinishStarted || bstate == FinishDone) {
|
|
status = FINISH_STATE;
|
|
}
|
|
if (bstate == NeedMore || bstate == FinishStarted) {
|
|
if (strm.avail_out === 0) {
|
|
last_flush = -1;
|
|
}
|
|
return Z_OK;
|
|
}
|
|
if (bstate == BlockDone) {
|
|
if (flush == Z_PARTIAL_FLUSH) {
|
|
_tr_align();
|
|
} else {
|
|
_tr_stored_block(0, 0, false);
|
|
if (flush == Z_FULL_FLUSH) {
|
|
for (i = 0; i < hash_size; i++)
|
|
head[i] = 0;
|
|
}
|
|
}
|
|
strm.flush_pending();
|
|
if (strm.avail_out === 0) {
|
|
last_flush = -1;
|
|
return Z_OK;
|
|
}
|
|
}
|
|
}
|
|
if (flush != Z_FINISH)
|
|
return Z_OK;
|
|
return Z_STREAM_END;
|
|
};
|
|
}
|
|
function ZStream() {
|
|
const that = this;
|
|
that.next_in_index = 0;
|
|
that.next_out_index = 0;
|
|
that.avail_in = 0;
|
|
that.total_in = 0;
|
|
that.avail_out = 0;
|
|
that.total_out = 0;
|
|
}
|
|
ZStream.prototype = {
|
|
deflateInit(level, bits) {
|
|
const that = this;
|
|
that.dstate = new Deflate();
|
|
if (!bits)
|
|
bits = MAX_BITS;
|
|
return that.dstate.deflateInit(that, level, bits);
|
|
},
|
|
deflate(flush) {
|
|
const that = this;
|
|
if (!that.dstate) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
return that.dstate.deflate(that, flush);
|
|
},
|
|
deflateEnd() {
|
|
const that = this;
|
|
if (!that.dstate)
|
|
return Z_STREAM_ERROR;
|
|
const ret = that.dstate.deflateEnd();
|
|
that.dstate = null;
|
|
return ret;
|
|
},
|
|
deflateParams(level, strategy) {
|
|
const that = this;
|
|
if (!that.dstate)
|
|
return Z_STREAM_ERROR;
|
|
return that.dstate.deflateParams(that, level, strategy);
|
|
},
|
|
deflateSetDictionary(dictionary, dictLength) {
|
|
const that = this;
|
|
if (!that.dstate)
|
|
return Z_STREAM_ERROR;
|
|
return that.dstate.deflateSetDictionary(that, dictionary, dictLength);
|
|
},
|
|
// Read a new buffer from the current input stream, update the
|
|
// total number of bytes read. All deflate() input goes through
|
|
// this function so some applications may wish to modify it to avoid
|
|
// allocating a large strm->next_in buffer and copying from it.
|
|
// (See also flush_pending()).
|
|
read_buf(buf, start, size) {
|
|
const that = this;
|
|
let len = that.avail_in;
|
|
if (len > size)
|
|
len = size;
|
|
if (len === 0)
|
|
return 0;
|
|
that.avail_in -= len;
|
|
buf.set(that.next_in.subarray(that.next_in_index, that.next_in_index + len), start);
|
|
that.next_in_index += len;
|
|
that.total_in += len;
|
|
return len;
|
|
},
|
|
// Flush as much pending output as possible. All deflate() output goes
|
|
// through this function so some applications may wish to modify it
|
|
// to avoid allocating a large strm->next_out buffer and copying into it.
|
|
// (See also read_buf()).
|
|
flush_pending() {
|
|
const that = this;
|
|
let len = that.dstate.pending;
|
|
if (len > that.avail_out)
|
|
len = that.avail_out;
|
|
if (len === 0)
|
|
return;
|
|
that.next_out.set(that.dstate.pending_buf.subarray(that.dstate.pending_out, that.dstate.pending_out + len), that.next_out_index);
|
|
that.next_out_index += len;
|
|
that.dstate.pending_out += len;
|
|
that.total_out += len;
|
|
that.avail_out -= len;
|
|
that.dstate.pending -= len;
|
|
if (that.dstate.pending === 0) {
|
|
that.dstate.pending_out = 0;
|
|
}
|
|
}
|
|
};
|
|
function ZipDeflate(options) {
|
|
const that = this;
|
|
const z = new ZStream();
|
|
const bufsize = getMaximumCompressedSize(options && options.chunkSize ? options.chunkSize : 64 * 1024);
|
|
const flush = Z_NO_FLUSH;
|
|
const buf = new Uint8Array(bufsize);
|
|
let level = options ? options.level : Z_DEFAULT_COMPRESSION;
|
|
if (typeof level == "undefined")
|
|
level = Z_DEFAULT_COMPRESSION;
|
|
z.deflateInit(level);
|
|
z.next_out = buf;
|
|
that.append = function(data, onprogress) {
|
|
let err, array, lastIndex = 0, bufferIndex = 0, bufferSize = 0;
|
|
const buffers = [];
|
|
if (!data.length)
|
|
return;
|
|
z.next_in_index = 0;
|
|
z.next_in = data;
|
|
z.avail_in = data.length;
|
|
do {
|
|
z.next_out_index = 0;
|
|
z.avail_out = bufsize;
|
|
err = z.deflate(flush);
|
|
if (err != Z_OK)
|
|
throw new Error("deflating: " + z.msg);
|
|
if (z.next_out_index)
|
|
if (z.next_out_index == bufsize)
|
|
buffers.push(new Uint8Array(buf));
|
|
else
|
|
buffers.push(buf.subarray(0, z.next_out_index));
|
|
bufferSize += z.next_out_index;
|
|
if (onprogress && z.next_in_index > 0 && z.next_in_index != lastIndex) {
|
|
onprogress(z.next_in_index);
|
|
lastIndex = z.next_in_index;
|
|
}
|
|
} while (z.avail_in > 0 || z.avail_out === 0);
|
|
if (buffers.length > 1) {
|
|
array = new Uint8Array(bufferSize);
|
|
buffers.forEach(function(chunk) {
|
|
array.set(chunk, bufferIndex);
|
|
bufferIndex += chunk.length;
|
|
});
|
|
} else {
|
|
array = buffers[0] ? new Uint8Array(buffers[0]) : new Uint8Array();
|
|
}
|
|
return array;
|
|
};
|
|
that.flush = function() {
|
|
let err, array, bufferIndex = 0, bufferSize = 0;
|
|
const buffers = [];
|
|
do {
|
|
z.next_out_index = 0;
|
|
z.avail_out = bufsize;
|
|
err = z.deflate(Z_FINISH);
|
|
if (err != Z_STREAM_END && err != Z_OK)
|
|
throw new Error("deflating: " + z.msg);
|
|
if (bufsize - z.avail_out > 0)
|
|
buffers.push(buf.slice(0, z.next_out_index));
|
|
bufferSize += z.next_out_index;
|
|
} while (z.avail_in > 0 || z.avail_out === 0);
|
|
z.deflateEnd();
|
|
array = new Uint8Array(bufferSize);
|
|
buffers.forEach(function(chunk) {
|
|
array.set(chunk, bufferIndex);
|
|
bufferIndex += chunk.length;
|
|
});
|
|
return array;
|
|
};
|
|
}
|
|
function getMaximumCompressedSize(uncompressedSize) {
|
|
return uncompressedSize + 5 * (Math.floor(uncompressedSize / 16383) + 1);
|
|
}
|
|
|
|
// node_modules/@zip.js/zip.js/lib/core/streams/codecs/inflate.js
|
|
var MAX_BITS2 = 15;
|
|
var Z_OK2 = 0;
|
|
var Z_STREAM_END2 = 1;
|
|
var Z_NEED_DICT2 = 2;
|
|
var Z_STREAM_ERROR2 = -2;
|
|
var Z_DATA_ERROR2 = -3;
|
|
var Z_MEM_ERROR = -4;
|
|
var Z_BUF_ERROR2 = -5;
|
|
var inflate_mask = [
|
|
0,
|
|
1,
|
|
3,
|
|
7,
|
|
15,
|
|
31,
|
|
63,
|
|
127,
|
|
255,
|
|
511,
|
|
1023,
|
|
2047,
|
|
4095,
|
|
8191,
|
|
16383,
|
|
32767,
|
|
65535
|
|
];
|
|
var MANY = 1440;
|
|
var Z_NO_FLUSH2 = 0;
|
|
var Z_FINISH2 = 4;
|
|
var fixed_bl = 9;
|
|
var fixed_bd = 5;
|
|
var fixed_tl = [
|
|
96,
|
|
7,
|
|
256,
|
|
0,
|
|
8,
|
|
80,
|
|
0,
|
|
8,
|
|
16,
|
|
84,
|
|
8,
|
|
115,
|
|
82,
|
|
7,
|
|
31,
|
|
0,
|
|
8,
|
|
112,
|
|
0,
|
|
8,
|
|
48,
|
|
0,
|
|
9,
|
|
192,
|
|
80,
|
|
7,
|
|
10,
|
|
0,
|
|
8,
|
|
96,
|
|
0,
|
|
8,
|
|
32,
|
|
0,
|
|
9,
|
|
160,
|
|
0,
|
|
8,
|
|
0,
|
|
0,
|
|
8,
|
|
128,
|
|
0,
|
|
8,
|
|
64,
|
|
0,
|
|
9,
|
|
224,
|
|
80,
|
|
7,
|
|
6,
|
|
0,
|
|
8,
|
|
88,
|
|
0,
|
|
8,
|
|
24,
|
|
0,
|
|
9,
|
|
144,
|
|
83,
|
|
7,
|
|
59,
|
|
0,
|
|
8,
|
|
120,
|
|
0,
|
|
8,
|
|
56,
|
|
0,
|
|
9,
|
|
208,
|
|
81,
|
|
7,
|
|
17,
|
|
0,
|
|
8,
|
|
104,
|
|
0,
|
|
8,
|
|
40,
|
|
0,
|
|
9,
|
|
176,
|
|
0,
|
|
8,
|
|
8,
|
|
0,
|
|
8,
|
|
136,
|
|
0,
|
|
8,
|
|
72,
|
|
0,
|
|
9,
|
|
240,
|
|
80,
|
|
7,
|
|
4,
|
|
0,
|
|
8,
|
|
84,
|
|
0,
|
|
8,
|
|
20,
|
|
85,
|
|
8,
|
|
227,
|
|
83,
|
|
7,
|
|
43,
|
|
0,
|
|
8,
|
|
116,
|
|
0,
|
|
8,
|
|
52,
|
|
0,
|
|
9,
|
|
200,
|
|
81,
|
|
7,
|
|
13,
|
|
0,
|
|
8,
|
|
100,
|
|
0,
|
|
8,
|
|
36,
|
|
0,
|
|
9,
|
|
168,
|
|
0,
|
|
8,
|
|
4,
|
|
0,
|
|
8,
|
|
132,
|
|
0,
|
|
8,
|
|
68,
|
|
0,
|
|
9,
|
|
232,
|
|
80,
|
|
7,
|
|
8,
|
|
0,
|
|
8,
|
|
92,
|
|
0,
|
|
8,
|
|
28,
|
|
0,
|
|
9,
|
|
152,
|
|
84,
|
|
7,
|
|
83,
|
|
0,
|
|
8,
|
|
124,
|
|
0,
|
|
8,
|
|
60,
|
|
0,
|
|
9,
|
|
216,
|
|
82,
|
|
7,
|
|
23,
|
|
0,
|
|
8,
|
|
108,
|
|
0,
|
|
8,
|
|
44,
|
|
0,
|
|
9,
|
|
184,
|
|
0,
|
|
8,
|
|
12,
|
|
0,
|
|
8,
|
|
140,
|
|
0,
|
|
8,
|
|
76,
|
|
0,
|
|
9,
|
|
248,
|
|
80,
|
|
7,
|
|
3,
|
|
0,
|
|
8,
|
|
82,
|
|
0,
|
|
8,
|
|
18,
|
|
85,
|
|
8,
|
|
163,
|
|
83,
|
|
7,
|
|
35,
|
|
0,
|
|
8,
|
|
114,
|
|
0,
|
|
8,
|
|
50,
|
|
0,
|
|
9,
|
|
196,
|
|
81,
|
|
7,
|
|
11,
|
|
0,
|
|
8,
|
|
98,
|
|
0,
|
|
8,
|
|
34,
|
|
0,
|
|
9,
|
|
164,
|
|
0,
|
|
8,
|
|
2,
|
|
0,
|
|
8,
|
|
130,
|
|
0,
|
|
8,
|
|
66,
|
|
0,
|
|
9,
|
|
228,
|
|
80,
|
|
7,
|
|
7,
|
|
0,
|
|
8,
|
|
90,
|
|
0,
|
|
8,
|
|
26,
|
|
0,
|
|
9,
|
|
148,
|
|
84,
|
|
7,
|
|
67,
|
|
0,
|
|
8,
|
|
122,
|
|
0,
|
|
8,
|
|
58,
|
|
0,
|
|
9,
|
|
212,
|
|
82,
|
|
7,
|
|
19,
|
|
0,
|
|
8,
|
|
106,
|
|
0,
|
|
8,
|
|
42,
|
|
0,
|
|
9,
|
|
180,
|
|
0,
|
|
8,
|
|
10,
|
|
0,
|
|
8,
|
|
138,
|
|
0,
|
|
8,
|
|
74,
|
|
0,
|
|
9,
|
|
244,
|
|
80,
|
|
7,
|
|
5,
|
|
0,
|
|
8,
|
|
86,
|
|
0,
|
|
8,
|
|
22,
|
|
192,
|
|
8,
|
|
0,
|
|
83,
|
|
7,
|
|
51,
|
|
0,
|
|
8,
|
|
118,
|
|
0,
|
|
8,
|
|
54,
|
|
0,
|
|
9,
|
|
204,
|
|
81,
|
|
7,
|
|
15,
|
|
0,
|
|
8,
|
|
102,
|
|
0,
|
|
8,
|
|
38,
|
|
0,
|
|
9,
|
|
172,
|
|
0,
|
|
8,
|
|
6,
|
|
0,
|
|
8,
|
|
134,
|
|
0,
|
|
8,
|
|
70,
|
|
0,
|
|
9,
|
|
236,
|
|
80,
|
|
7,
|
|
9,
|
|
0,
|
|
8,
|
|
94,
|
|
0,
|
|
8,
|
|
30,
|
|
0,
|
|
9,
|
|
156,
|
|
84,
|
|
7,
|
|
99,
|
|
0,
|
|
8,
|
|
126,
|
|
0,
|
|
8,
|
|
62,
|
|
0,
|
|
9,
|
|
220,
|
|
82,
|
|
7,
|
|
27,
|
|
0,
|
|
8,
|
|
110,
|
|
0,
|
|
8,
|
|
46,
|
|
0,
|
|
9,
|
|
188,
|
|
0,
|
|
8,
|
|
14,
|
|
0,
|
|
8,
|
|
142,
|
|
0,
|
|
8,
|
|
78,
|
|
0,
|
|
9,
|
|
252,
|
|
96,
|
|
7,
|
|
256,
|
|
0,
|
|
8,
|
|
81,
|
|
0,
|
|
8,
|
|
17,
|
|
85,
|
|
8,
|
|
131,
|
|
82,
|
|
7,
|
|
31,
|
|
0,
|
|
8,
|
|
113,
|
|
0,
|
|
8,
|
|
49,
|
|
0,
|
|
9,
|
|
194,
|
|
80,
|
|
7,
|
|
10,
|
|
0,
|
|
8,
|
|
97,
|
|
0,
|
|
8,
|
|
33,
|
|
0,
|
|
9,
|
|
162,
|
|
0,
|
|
8,
|
|
1,
|
|
0,
|
|
8,
|
|
129,
|
|
0,
|
|
8,
|
|
65,
|
|
0,
|
|
9,
|
|
226,
|
|
80,
|
|
7,
|
|
6,
|
|
0,
|
|
8,
|
|
89,
|
|
0,
|
|
8,
|
|
25,
|
|
0,
|
|
9,
|
|
146,
|
|
83,
|
|
7,
|
|
59,
|
|
0,
|
|
8,
|
|
121,
|
|
0,
|
|
8,
|
|
57,
|
|
0,
|
|
9,
|
|
210,
|
|
81,
|
|
7,
|
|
17,
|
|
0,
|
|
8,
|
|
105,
|
|
0,
|
|
8,
|
|
41,
|
|
0,
|
|
9,
|
|
178,
|
|
0,
|
|
8,
|
|
9,
|
|
0,
|
|
8,
|
|
137,
|
|
0,
|
|
8,
|
|
73,
|
|
0,
|
|
9,
|
|
242,
|
|
80,
|
|
7,
|
|
4,
|
|
0,
|
|
8,
|
|
85,
|
|
0,
|
|
8,
|
|
21,
|
|
80,
|
|
8,
|
|
258,
|
|
83,
|
|
7,
|
|
43,
|
|
0,
|
|
8,
|
|
117,
|
|
0,
|
|
8,
|
|
53,
|
|
0,
|
|
9,
|
|
202,
|
|
81,
|
|
7,
|
|
13,
|
|
0,
|
|
8,
|
|
101,
|
|
0,
|
|
8,
|
|
37,
|
|
0,
|
|
9,
|
|
170,
|
|
0,
|
|
8,
|
|
5,
|
|
0,
|
|
8,
|
|
133,
|
|
0,
|
|
8,
|
|
69,
|
|
0,
|
|
9,
|
|
234,
|
|
80,
|
|
7,
|
|
8,
|
|
0,
|
|
8,
|
|
93,
|
|
0,
|
|
8,
|
|
29,
|
|
0,
|
|
9,
|
|
154,
|
|
84,
|
|
7,
|
|
83,
|
|
0,
|
|
8,
|
|
125,
|
|
0,
|
|
8,
|
|
61,
|
|
0,
|
|
9,
|
|
218,
|
|
82,
|
|
7,
|
|
23,
|
|
0,
|
|
8,
|
|
109,
|
|
0,
|
|
8,
|
|
45,
|
|
0,
|
|
9,
|
|
186,
|
|
0,
|
|
8,
|
|
13,
|
|
0,
|
|
8,
|
|
141,
|
|
0,
|
|
8,
|
|
77,
|
|
0,
|
|
9,
|
|
250,
|
|
80,
|
|
7,
|
|
3,
|
|
0,
|
|
8,
|
|
83,
|
|
0,
|
|
8,
|
|
19,
|
|
85,
|
|
8,
|
|
195,
|
|
83,
|
|
7,
|
|
35,
|
|
0,
|
|
8,
|
|
115,
|
|
0,
|
|
8,
|
|
51,
|
|
0,
|
|
9,
|
|
198,
|
|
81,
|
|
7,
|
|
11,
|
|
0,
|
|
8,
|
|
99,
|
|
0,
|
|
8,
|
|
35,
|
|
0,
|
|
9,
|
|
166,
|
|
0,
|
|
8,
|
|
3,
|
|
0,
|
|
8,
|
|
131,
|
|
0,
|
|
8,
|
|
67,
|
|
0,
|
|
9,
|
|
230,
|
|
80,
|
|
7,
|
|
7,
|
|
0,
|
|
8,
|
|
91,
|
|
0,
|
|
8,
|
|
27,
|
|
0,
|
|
9,
|
|
150,
|
|
84,
|
|
7,
|
|
67,
|
|
0,
|
|
8,
|
|
123,
|
|
0,
|
|
8,
|
|
59,
|
|
0,
|
|
9,
|
|
214,
|
|
82,
|
|
7,
|
|
19,
|
|
0,
|
|
8,
|
|
107,
|
|
0,
|
|
8,
|
|
43,
|
|
0,
|
|
9,
|
|
182,
|
|
0,
|
|
8,
|
|
11,
|
|
0,
|
|
8,
|
|
139,
|
|
0,
|
|
8,
|
|
75,
|
|
0,
|
|
9,
|
|
246,
|
|
80,
|
|
7,
|
|
5,
|
|
0,
|
|
8,
|
|
87,
|
|
0,
|
|
8,
|
|
23,
|
|
192,
|
|
8,
|
|
0,
|
|
83,
|
|
7,
|
|
51,
|
|
0,
|
|
8,
|
|
119,
|
|
0,
|
|
8,
|
|
55,
|
|
0,
|
|
9,
|
|
206,
|
|
81,
|
|
7,
|
|
15,
|
|
0,
|
|
8,
|
|
103,
|
|
0,
|
|
8,
|
|
39,
|
|
0,
|
|
9,
|
|
174,
|
|
0,
|
|
8,
|
|
7,
|
|
0,
|
|
8,
|
|
135,
|
|
0,
|
|
8,
|
|
71,
|
|
0,
|
|
9,
|
|
238,
|
|
80,
|
|
7,
|
|
9,
|
|
0,
|
|
8,
|
|
95,
|
|
0,
|
|
8,
|
|
31,
|
|
0,
|
|
9,
|
|
158,
|
|
84,
|
|
7,
|
|
99,
|
|
0,
|
|
8,
|
|
127,
|
|
0,
|
|
8,
|
|
63,
|
|
0,
|
|
9,
|
|
222,
|
|
82,
|
|
7,
|
|
27,
|
|
0,
|
|
8,
|
|
111,
|
|
0,
|
|
8,
|
|
47,
|
|
0,
|
|
9,
|
|
190,
|
|
0,
|
|
8,
|
|
15,
|
|
0,
|
|
8,
|
|
143,
|
|
0,
|
|
8,
|
|
79,
|
|
0,
|
|
9,
|
|
254,
|
|
96,
|
|
7,
|
|
256,
|
|
0,
|
|
8,
|
|
80,
|
|
0,
|
|
8,
|
|
16,
|
|
84,
|
|
8,
|
|
115,
|
|
82,
|
|
7,
|
|
31,
|
|
0,
|
|
8,
|
|
112,
|
|
0,
|
|
8,
|
|
48,
|
|
0,
|
|
9,
|
|
193,
|
|
80,
|
|
7,
|
|
10,
|
|
0,
|
|
8,
|
|
96,
|
|
0,
|
|
8,
|
|
32,
|
|
0,
|
|
9,
|
|
161,
|
|
0,
|
|
8,
|
|
0,
|
|
0,
|
|
8,
|
|
128,
|
|
0,
|
|
8,
|
|
64,
|
|
0,
|
|
9,
|
|
225,
|
|
80,
|
|
7,
|
|
6,
|
|
0,
|
|
8,
|
|
88,
|
|
0,
|
|
8,
|
|
24,
|
|
0,
|
|
9,
|
|
145,
|
|
83,
|
|
7,
|
|
59,
|
|
0,
|
|
8,
|
|
120,
|
|
0,
|
|
8,
|
|
56,
|
|
0,
|
|
9,
|
|
209,
|
|
81,
|
|
7,
|
|
17,
|
|
0,
|
|
8,
|
|
104,
|
|
0,
|
|
8,
|
|
40,
|
|
0,
|
|
9,
|
|
177,
|
|
0,
|
|
8,
|
|
8,
|
|
0,
|
|
8,
|
|
136,
|
|
0,
|
|
8,
|
|
72,
|
|
0,
|
|
9,
|
|
241,
|
|
80,
|
|
7,
|
|
4,
|
|
0,
|
|
8,
|
|
84,
|
|
0,
|
|
8,
|
|
20,
|
|
85,
|
|
8,
|
|
227,
|
|
83,
|
|
7,
|
|
43,
|
|
0,
|
|
8,
|
|
116,
|
|
0,
|
|
8,
|
|
52,
|
|
0,
|
|
9,
|
|
201,
|
|
81,
|
|
7,
|
|
13,
|
|
0,
|
|
8,
|
|
100,
|
|
0,
|
|
8,
|
|
36,
|
|
0,
|
|
9,
|
|
169,
|
|
0,
|
|
8,
|
|
4,
|
|
0,
|
|
8,
|
|
132,
|
|
0,
|
|
8,
|
|
68,
|
|
0,
|
|
9,
|
|
233,
|
|
80,
|
|
7,
|
|
8,
|
|
0,
|
|
8,
|
|
92,
|
|
0,
|
|
8,
|
|
28,
|
|
0,
|
|
9,
|
|
153,
|
|
84,
|
|
7,
|
|
83,
|
|
0,
|
|
8,
|
|
124,
|
|
0,
|
|
8,
|
|
60,
|
|
0,
|
|
9,
|
|
217,
|
|
82,
|
|
7,
|
|
23,
|
|
0,
|
|
8,
|
|
108,
|
|
0,
|
|
8,
|
|
44,
|
|
0,
|
|
9,
|
|
185,
|
|
0,
|
|
8,
|
|
12,
|
|
0,
|
|
8,
|
|
140,
|
|
0,
|
|
8,
|
|
76,
|
|
0,
|
|
9,
|
|
249,
|
|
80,
|
|
7,
|
|
3,
|
|
0,
|
|
8,
|
|
82,
|
|
0,
|
|
8,
|
|
18,
|
|
85,
|
|
8,
|
|
163,
|
|
83,
|
|
7,
|
|
35,
|
|
0,
|
|
8,
|
|
114,
|
|
0,
|
|
8,
|
|
50,
|
|
0,
|
|
9,
|
|
197,
|
|
81,
|
|
7,
|
|
11,
|
|
0,
|
|
8,
|
|
98,
|
|
0,
|
|
8,
|
|
34,
|
|
0,
|
|
9,
|
|
165,
|
|
0,
|
|
8,
|
|
2,
|
|
0,
|
|
8,
|
|
130,
|
|
0,
|
|
8,
|
|
66,
|
|
0,
|
|
9,
|
|
229,
|
|
80,
|
|
7,
|
|
7,
|
|
0,
|
|
8,
|
|
90,
|
|
0,
|
|
8,
|
|
26,
|
|
0,
|
|
9,
|
|
149,
|
|
84,
|
|
7,
|
|
67,
|
|
0,
|
|
8,
|
|
122,
|
|
0,
|
|
8,
|
|
58,
|
|
0,
|
|
9,
|
|
213,
|
|
82,
|
|
7,
|
|
19,
|
|
0,
|
|
8,
|
|
106,
|
|
0,
|
|
8,
|
|
42,
|
|
0,
|
|
9,
|
|
181,
|
|
0,
|
|
8,
|
|
10,
|
|
0,
|
|
8,
|
|
138,
|
|
0,
|
|
8,
|
|
74,
|
|
0,
|
|
9,
|
|
245,
|
|
80,
|
|
7,
|
|
5,
|
|
0,
|
|
8,
|
|
86,
|
|
0,
|
|
8,
|
|
22,
|
|
192,
|
|
8,
|
|
0,
|
|
83,
|
|
7,
|
|
51,
|
|
0,
|
|
8,
|
|
118,
|
|
0,
|
|
8,
|
|
54,
|
|
0,
|
|
9,
|
|
205,
|
|
81,
|
|
7,
|
|
15,
|
|
0,
|
|
8,
|
|
102,
|
|
0,
|
|
8,
|
|
38,
|
|
0,
|
|
9,
|
|
173,
|
|
0,
|
|
8,
|
|
6,
|
|
0,
|
|
8,
|
|
134,
|
|
0,
|
|
8,
|
|
70,
|
|
0,
|
|
9,
|
|
237,
|
|
80,
|
|
7,
|
|
9,
|
|
0,
|
|
8,
|
|
94,
|
|
0,
|
|
8,
|
|
30,
|
|
0,
|
|
9,
|
|
157,
|
|
84,
|
|
7,
|
|
99,
|
|
0,
|
|
8,
|
|
126,
|
|
0,
|
|
8,
|
|
62,
|
|
0,
|
|
9,
|
|
221,
|
|
82,
|
|
7,
|
|
27,
|
|
0,
|
|
8,
|
|
110,
|
|
0,
|
|
8,
|
|
46,
|
|
0,
|
|
9,
|
|
189,
|
|
0,
|
|
8,
|
|
14,
|
|
0,
|
|
8,
|
|
142,
|
|
0,
|
|
8,
|
|
78,
|
|
0,
|
|
9,
|
|
253,
|
|
96,
|
|
7,
|
|
256,
|
|
0,
|
|
8,
|
|
81,
|
|
0,
|
|
8,
|
|
17,
|
|
85,
|
|
8,
|
|
131,
|
|
82,
|
|
7,
|
|
31,
|
|
0,
|
|
8,
|
|
113,
|
|
0,
|
|
8,
|
|
49,
|
|
0,
|
|
9,
|
|
195,
|
|
80,
|
|
7,
|
|
10,
|
|
0,
|
|
8,
|
|
97,
|
|
0,
|
|
8,
|
|
33,
|
|
0,
|
|
9,
|
|
163,
|
|
0,
|
|
8,
|
|
1,
|
|
0,
|
|
8,
|
|
129,
|
|
0,
|
|
8,
|
|
65,
|
|
0,
|
|
9,
|
|
227,
|
|
80,
|
|
7,
|
|
6,
|
|
0,
|
|
8,
|
|
89,
|
|
0,
|
|
8,
|
|
25,
|
|
0,
|
|
9,
|
|
147,
|
|
83,
|
|
7,
|
|
59,
|
|
0,
|
|
8,
|
|
121,
|
|
0,
|
|
8,
|
|
57,
|
|
0,
|
|
9,
|
|
211,
|
|
81,
|
|
7,
|
|
17,
|
|
0,
|
|
8,
|
|
105,
|
|
0,
|
|
8,
|
|
41,
|
|
0,
|
|
9,
|
|
179,
|
|
0,
|
|
8,
|
|
9,
|
|
0,
|
|
8,
|
|
137,
|
|
0,
|
|
8,
|
|
73,
|
|
0,
|
|
9,
|
|
243,
|
|
80,
|
|
7,
|
|
4,
|
|
0,
|
|
8,
|
|
85,
|
|
0,
|
|
8,
|
|
21,
|
|
80,
|
|
8,
|
|
258,
|
|
83,
|
|
7,
|
|
43,
|
|
0,
|
|
8,
|
|
117,
|
|
0,
|
|
8,
|
|
53,
|
|
0,
|
|
9,
|
|
203,
|
|
81,
|
|
7,
|
|
13,
|
|
0,
|
|
8,
|
|
101,
|
|
0,
|
|
8,
|
|
37,
|
|
0,
|
|
9,
|
|
171,
|
|
0,
|
|
8,
|
|
5,
|
|
0,
|
|
8,
|
|
133,
|
|
0,
|
|
8,
|
|
69,
|
|
0,
|
|
9,
|
|
235,
|
|
80,
|
|
7,
|
|
8,
|
|
0,
|
|
8,
|
|
93,
|
|
0,
|
|
8,
|
|
29,
|
|
0,
|
|
9,
|
|
155,
|
|
84,
|
|
7,
|
|
83,
|
|
0,
|
|
8,
|
|
125,
|
|
0,
|
|
8,
|
|
61,
|
|
0,
|
|
9,
|
|
219,
|
|
82,
|
|
7,
|
|
23,
|
|
0,
|
|
8,
|
|
109,
|
|
0,
|
|
8,
|
|
45,
|
|
0,
|
|
9,
|
|
187,
|
|
0,
|
|
8,
|
|
13,
|
|
0,
|
|
8,
|
|
141,
|
|
0,
|
|
8,
|
|
77,
|
|
0,
|
|
9,
|
|
251,
|
|
80,
|
|
7,
|
|
3,
|
|
0,
|
|
8,
|
|
83,
|
|
0,
|
|
8,
|
|
19,
|
|
85,
|
|
8,
|
|
195,
|
|
83,
|
|
7,
|
|
35,
|
|
0,
|
|
8,
|
|
115,
|
|
0,
|
|
8,
|
|
51,
|
|
0,
|
|
9,
|
|
199,
|
|
81,
|
|
7,
|
|
11,
|
|
0,
|
|
8,
|
|
99,
|
|
0,
|
|
8,
|
|
35,
|
|
0,
|
|
9,
|
|
167,
|
|
0,
|
|
8,
|
|
3,
|
|
0,
|
|
8,
|
|
131,
|
|
0,
|
|
8,
|
|
67,
|
|
0,
|
|
9,
|
|
231,
|
|
80,
|
|
7,
|
|
7,
|
|
0,
|
|
8,
|
|
91,
|
|
0,
|
|
8,
|
|
27,
|
|
0,
|
|
9,
|
|
151,
|
|
84,
|
|
7,
|
|
67,
|
|
0,
|
|
8,
|
|
123,
|
|
0,
|
|
8,
|
|
59,
|
|
0,
|
|
9,
|
|
215,
|
|
82,
|
|
7,
|
|
19,
|
|
0,
|
|
8,
|
|
107,
|
|
0,
|
|
8,
|
|
43,
|
|
0,
|
|
9,
|
|
183,
|
|
0,
|
|
8,
|
|
11,
|
|
0,
|
|
8,
|
|
139,
|
|
0,
|
|
8,
|
|
75,
|
|
0,
|
|
9,
|
|
247,
|
|
80,
|
|
7,
|
|
5,
|
|
0,
|
|
8,
|
|
87,
|
|
0,
|
|
8,
|
|
23,
|
|
192,
|
|
8,
|
|
0,
|
|
83,
|
|
7,
|
|
51,
|
|
0,
|
|
8,
|
|
119,
|
|
0,
|
|
8,
|
|
55,
|
|
0,
|
|
9,
|
|
207,
|
|
81,
|
|
7,
|
|
15,
|
|
0,
|
|
8,
|
|
103,
|
|
0,
|
|
8,
|
|
39,
|
|
0,
|
|
9,
|
|
175,
|
|
0,
|
|
8,
|
|
7,
|
|
0,
|
|
8,
|
|
135,
|
|
0,
|
|
8,
|
|
71,
|
|
0,
|
|
9,
|
|
239,
|
|
80,
|
|
7,
|
|
9,
|
|
0,
|
|
8,
|
|
95,
|
|
0,
|
|
8,
|
|
31,
|
|
0,
|
|
9,
|
|
159,
|
|
84,
|
|
7,
|
|
99,
|
|
0,
|
|
8,
|
|
127,
|
|
0,
|
|
8,
|
|
63,
|
|
0,
|
|
9,
|
|
223,
|
|
82,
|
|
7,
|
|
27,
|
|
0,
|
|
8,
|
|
111,
|
|
0,
|
|
8,
|
|
47,
|
|
0,
|
|
9,
|
|
191,
|
|
0,
|
|
8,
|
|
15,
|
|
0,
|
|
8,
|
|
143,
|
|
0,
|
|
8,
|
|
79,
|
|
0,
|
|
9,
|
|
255
|
|
];
|
|
var fixed_td = [
|
|
80,
|
|
5,
|
|
1,
|
|
87,
|
|
5,
|
|
257,
|
|
83,
|
|
5,
|
|
17,
|
|
91,
|
|
5,
|
|
4097,
|
|
81,
|
|
5,
|
|
5,
|
|
89,
|
|
5,
|
|
1025,
|
|
85,
|
|
5,
|
|
65,
|
|
93,
|
|
5,
|
|
16385,
|
|
80,
|
|
5,
|
|
3,
|
|
88,
|
|
5,
|
|
513,
|
|
84,
|
|
5,
|
|
33,
|
|
92,
|
|
5,
|
|
8193,
|
|
82,
|
|
5,
|
|
9,
|
|
90,
|
|
5,
|
|
2049,
|
|
86,
|
|
5,
|
|
129,
|
|
192,
|
|
5,
|
|
24577,
|
|
80,
|
|
5,
|
|
2,
|
|
87,
|
|
5,
|
|
385,
|
|
83,
|
|
5,
|
|
25,
|
|
91,
|
|
5,
|
|
6145,
|
|
81,
|
|
5,
|
|
7,
|
|
89,
|
|
5,
|
|
1537,
|
|
85,
|
|
5,
|
|
97,
|
|
93,
|
|
5,
|
|
24577,
|
|
80,
|
|
5,
|
|
4,
|
|
88,
|
|
5,
|
|
769,
|
|
84,
|
|
5,
|
|
49,
|
|
92,
|
|
5,
|
|
12289,
|
|
82,
|
|
5,
|
|
13,
|
|
90,
|
|
5,
|
|
3073,
|
|
86,
|
|
5,
|
|
193,
|
|
192,
|
|
5,
|
|
24577
|
|
];
|
|
var cplens = [
|
|
// Copy lengths for literal codes 257..285
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
8,
|
|
9,
|
|
10,
|
|
11,
|
|
13,
|
|
15,
|
|
17,
|
|
19,
|
|
23,
|
|
27,
|
|
31,
|
|
35,
|
|
43,
|
|
51,
|
|
59,
|
|
67,
|
|
83,
|
|
99,
|
|
115,
|
|
131,
|
|
163,
|
|
195,
|
|
227,
|
|
258,
|
|
0,
|
|
0
|
|
];
|
|
var cplext = [
|
|
// Extra bits for literal codes 257..285
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
0,
|
|
112,
|
|
112
|
|
// 112==invalid
|
|
];
|
|
var cpdist = [
|
|
// Copy offsets for distance codes 0..29
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
7,
|
|
9,
|
|
13,
|
|
17,
|
|
25,
|
|
33,
|
|
49,
|
|
65,
|
|
97,
|
|
129,
|
|
193,
|
|
257,
|
|
385,
|
|
513,
|
|
769,
|
|
1025,
|
|
1537,
|
|
2049,
|
|
3073,
|
|
4097,
|
|
6145,
|
|
8193,
|
|
12289,
|
|
16385,
|
|
24577
|
|
];
|
|
var cpdext = [
|
|
// Extra bits for distance codes
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
5,
|
|
5,
|
|
6,
|
|
6,
|
|
7,
|
|
7,
|
|
8,
|
|
8,
|
|
9,
|
|
9,
|
|
10,
|
|
10,
|
|
11,
|
|
11,
|
|
12,
|
|
12,
|
|
13,
|
|
13
|
|
];
|
|
var BMAX = 15;
|
|
function InfTree() {
|
|
const that = this;
|
|
let hn;
|
|
let v;
|
|
let c;
|
|
let r;
|
|
let u;
|
|
let x;
|
|
function huft_build(b, bindex, n, s, d, e, t, m, hp, hn2, v2) {
|
|
let a;
|
|
let f;
|
|
let g;
|
|
let h;
|
|
let i;
|
|
let j;
|
|
let k;
|
|
let l;
|
|
let mask;
|
|
let p;
|
|
let q;
|
|
let w;
|
|
let xp;
|
|
let y;
|
|
let z;
|
|
p = 0;
|
|
i = n;
|
|
do {
|
|
c[b[bindex + p]]++;
|
|
p++;
|
|
i--;
|
|
} while (i !== 0);
|
|
if (c[0] == n) {
|
|
t[0] = -1;
|
|
m[0] = 0;
|
|
return Z_OK2;
|
|
}
|
|
l = m[0];
|
|
for (j = 1; j <= BMAX; j++)
|
|
if (c[j] !== 0)
|
|
break;
|
|
k = j;
|
|
if (l < j) {
|
|
l = j;
|
|
}
|
|
for (i = BMAX; i !== 0; i--) {
|
|
if (c[i] !== 0)
|
|
break;
|
|
}
|
|
g = i;
|
|
if (l > i) {
|
|
l = i;
|
|
}
|
|
m[0] = l;
|
|
for (y = 1 << j; j < i; j++, y <<= 1) {
|
|
if ((y -= c[j]) < 0) {
|
|
return Z_DATA_ERROR2;
|
|
}
|
|
}
|
|
if ((y -= c[i]) < 0) {
|
|
return Z_DATA_ERROR2;
|
|
}
|
|
c[i] += y;
|
|
x[1] = j = 0;
|
|
p = 1;
|
|
xp = 2;
|
|
while (--i !== 0) {
|
|
x[xp] = j += c[p];
|
|
xp++;
|
|
p++;
|
|
}
|
|
i = 0;
|
|
p = 0;
|
|
do {
|
|
if ((j = b[bindex + p]) !== 0) {
|
|
v2[x[j]++] = i;
|
|
}
|
|
p++;
|
|
} while (++i < n);
|
|
n = x[g];
|
|
x[0] = i = 0;
|
|
p = 0;
|
|
h = -1;
|
|
w = -l;
|
|
u[0] = 0;
|
|
q = 0;
|
|
z = 0;
|
|
for (; k <= g; k++) {
|
|
a = c[k];
|
|
while (a-- !== 0) {
|
|
while (k > w + l) {
|
|
h++;
|
|
w += l;
|
|
z = g - w;
|
|
z = z > l ? l : z;
|
|
if ((f = 1 << (j = k - w)) > a + 1) {
|
|
f -= a + 1;
|
|
xp = k;
|
|
if (j < z) {
|
|
while (++j < z) {
|
|
if ((f <<= 1) <= c[++xp])
|
|
break;
|
|
f -= c[xp];
|
|
}
|
|
}
|
|
}
|
|
z = 1 << j;
|
|
if (hn2[0] + z > MANY) {
|
|
return Z_DATA_ERROR2;
|
|
}
|
|
u[h] = q = /* hp+ */
|
|
hn2[0];
|
|
hn2[0] += z;
|
|
if (h !== 0) {
|
|
x[h] = i;
|
|
r[0] = /* (byte) */
|
|
j;
|
|
r[1] = /* (byte) */
|
|
l;
|
|
j = i >>> w - l;
|
|
r[2] = /* (int) */
|
|
q - u[h - 1] - j;
|
|
hp.set(r, (u[h - 1] + j) * 3);
|
|
} else {
|
|
t[0] = q;
|
|
}
|
|
}
|
|
r[1] = /* (byte) */
|
|
k - w;
|
|
if (p >= n) {
|
|
r[0] = 128 + 64;
|
|
} else if (v2[p] < s) {
|
|
r[0] = /* (byte) */
|
|
v2[p] < 256 ? 0 : 32 + 64;
|
|
r[2] = v2[p++];
|
|
} else {
|
|
r[0] = /* (byte) */
|
|
e[v2[p] - s] + 16 + 64;
|
|
r[2] = d[v2[p++] - s];
|
|
}
|
|
f = 1 << k - w;
|
|
for (j = i >>> w; j < z; j += f) {
|
|
hp.set(r, (q + j) * 3);
|
|
}
|
|
for (j = 1 << k - 1; (i & j) !== 0; j >>>= 1) {
|
|
i ^= j;
|
|
}
|
|
i ^= j;
|
|
mask = (1 << w) - 1;
|
|
while ((i & mask) != x[h]) {
|
|
h--;
|
|
w -= l;
|
|
mask = (1 << w) - 1;
|
|
}
|
|
}
|
|
}
|
|
return y !== 0 && g != 1 ? Z_BUF_ERROR2 : Z_OK2;
|
|
}
|
|
function initWorkArea(vsize) {
|
|
let i;
|
|
if (!hn) {
|
|
hn = [];
|
|
v = [];
|
|
c = new Int32Array(BMAX + 1);
|
|
r = [];
|
|
u = new Int32Array(BMAX);
|
|
x = new Int32Array(BMAX + 1);
|
|
}
|
|
if (v.length < vsize) {
|
|
v = [];
|
|
}
|
|
for (i = 0; i < vsize; i++) {
|
|
v[i] = 0;
|
|
}
|
|
for (i = 0; i < BMAX + 1; i++) {
|
|
c[i] = 0;
|
|
}
|
|
for (i = 0; i < 3; i++) {
|
|
r[i] = 0;
|
|
}
|
|
u.set(c.subarray(0, BMAX), 0);
|
|
x.set(c.subarray(0, BMAX + 1), 0);
|
|
}
|
|
that.inflate_trees_bits = function(c2, bb, tb, hp, z) {
|
|
let result;
|
|
initWorkArea(19);
|
|
hn[0] = 0;
|
|
result = huft_build(c2, 0, 19, 19, null, null, tb, bb, hp, hn, v);
|
|
if (result == Z_DATA_ERROR2) {
|
|
z.msg = "oversubscribed dynamic bit lengths tree";
|
|
} else if (result == Z_BUF_ERROR2 || bb[0] === 0) {
|
|
z.msg = "incomplete dynamic bit lengths tree";
|
|
result = Z_DATA_ERROR2;
|
|
}
|
|
return result;
|
|
};
|
|
that.inflate_trees_dynamic = function(nl, nd, c2, bl, bd, tl, td, hp, z) {
|
|
let result;
|
|
initWorkArea(288);
|
|
hn[0] = 0;
|
|
result = huft_build(c2, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
|
|
if (result != Z_OK2 || bl[0] === 0) {
|
|
if (result == Z_DATA_ERROR2) {
|
|
z.msg = "oversubscribed literal/length tree";
|
|
} else if (result != Z_MEM_ERROR) {
|
|
z.msg = "incomplete literal/length tree";
|
|
result = Z_DATA_ERROR2;
|
|
}
|
|
return result;
|
|
}
|
|
initWorkArea(288);
|
|
result = huft_build(c2, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
|
|
if (result != Z_OK2 || bd[0] === 0 && nl > 257) {
|
|
if (result == Z_DATA_ERROR2) {
|
|
z.msg = "oversubscribed distance tree";
|
|
} else if (result == Z_BUF_ERROR2) {
|
|
z.msg = "incomplete distance tree";
|
|
result = Z_DATA_ERROR2;
|
|
} else if (result != Z_MEM_ERROR) {
|
|
z.msg = "empty distance tree with lengths";
|
|
result = Z_DATA_ERROR2;
|
|
}
|
|
return result;
|
|
}
|
|
return Z_OK2;
|
|
};
|
|
}
|
|
InfTree.inflate_trees_fixed = function(bl, bd, tl, td) {
|
|
bl[0] = fixed_bl;
|
|
bd[0] = fixed_bd;
|
|
tl[0] = fixed_tl;
|
|
td[0] = fixed_td;
|
|
return Z_OK2;
|
|
};
|
|
var START = 0;
|
|
var LEN = 1;
|
|
var LENEXT = 2;
|
|
var DIST = 3;
|
|
var DISTEXT = 4;
|
|
var COPY = 5;
|
|
var LIT = 6;
|
|
var WASH = 7;
|
|
var END = 8;
|
|
var BADCODE = 9;
|
|
function InfCodes() {
|
|
const that = this;
|
|
let mode2;
|
|
let len = 0;
|
|
let tree;
|
|
let tree_index = 0;
|
|
let need = 0;
|
|
let lit = 0;
|
|
let get = 0;
|
|
let dist = 0;
|
|
let lbits = 0;
|
|
let dbits = 0;
|
|
let ltree;
|
|
let ltree_index = 0;
|
|
let dtree;
|
|
let dtree_index = 0;
|
|
function inflate_fast(bl, bd, tl, tl_index, td, td_index, s, z) {
|
|
let t;
|
|
let tp;
|
|
let tp_index;
|
|
let e;
|
|
let b;
|
|
let k;
|
|
let p;
|
|
let n;
|
|
let q;
|
|
let m;
|
|
let ml;
|
|
let md;
|
|
let c;
|
|
let d;
|
|
let r;
|
|
let tp_index_t_3;
|
|
p = z.next_in_index;
|
|
n = z.avail_in;
|
|
b = s.bitb;
|
|
k = s.bitk;
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
ml = inflate_mask[bl];
|
|
md = inflate_mask[bd];
|
|
do {
|
|
while (k < 20) {
|
|
n--;
|
|
b |= (z.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
t = b & ml;
|
|
tp = tl;
|
|
tp_index = tl_index;
|
|
tp_index_t_3 = (tp_index + t) * 3;
|
|
if ((e = tp[tp_index_t_3]) === 0) {
|
|
b >>= tp[tp_index_t_3 + 1];
|
|
k -= tp[tp_index_t_3 + 1];
|
|
s.win[q++] = /* (byte) */
|
|
tp[tp_index_t_3 + 2];
|
|
m--;
|
|
continue;
|
|
}
|
|
do {
|
|
b >>= tp[tp_index_t_3 + 1];
|
|
k -= tp[tp_index_t_3 + 1];
|
|
if ((e & 16) !== 0) {
|
|
e &= 15;
|
|
c = tp[tp_index_t_3 + 2] + /* (int) */
|
|
(b & inflate_mask[e]);
|
|
b >>= e;
|
|
k -= e;
|
|
while (k < 15) {
|
|
n--;
|
|
b |= (z.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
t = b & md;
|
|
tp = td;
|
|
tp_index = td_index;
|
|
tp_index_t_3 = (tp_index + t) * 3;
|
|
e = tp[tp_index_t_3];
|
|
do {
|
|
b >>= tp[tp_index_t_3 + 1];
|
|
k -= tp[tp_index_t_3 + 1];
|
|
if ((e & 16) !== 0) {
|
|
e &= 15;
|
|
while (k < e) {
|
|
n--;
|
|
b |= (z.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
d = tp[tp_index_t_3 + 2] + (b & inflate_mask[e]);
|
|
b >>= e;
|
|
k -= e;
|
|
m -= c;
|
|
if (q >= d) {
|
|
r = q - d;
|
|
if (q - r > 0 && 2 > q - r) {
|
|
s.win[q++] = s.win[r++];
|
|
s.win[q++] = s.win[r++];
|
|
c -= 2;
|
|
} else {
|
|
s.win.set(s.win.subarray(r, r + 2), q);
|
|
q += 2;
|
|
r += 2;
|
|
c -= 2;
|
|
}
|
|
} else {
|
|
r = q - d;
|
|
do {
|
|
r += s.end;
|
|
} while (r < 0);
|
|
e = s.end - r;
|
|
if (c > e) {
|
|
c -= e;
|
|
if (q - r > 0 && e > q - r) {
|
|
do {
|
|
s.win[q++] = s.win[r++];
|
|
} while (--e !== 0);
|
|
} else {
|
|
s.win.set(s.win.subarray(r, r + e), q);
|
|
q += e;
|
|
r += e;
|
|
e = 0;
|
|
}
|
|
r = 0;
|
|
}
|
|
}
|
|
if (q - r > 0 && c > q - r) {
|
|
do {
|
|
s.win[q++] = s.win[r++];
|
|
} while (--c !== 0);
|
|
} else {
|
|
s.win.set(s.win.subarray(r, r + c), q);
|
|
q += c;
|
|
r += c;
|
|
c = 0;
|
|
}
|
|
break;
|
|
} else if ((e & 64) === 0) {
|
|
t += tp[tp_index_t_3 + 2];
|
|
t += b & inflate_mask[e];
|
|
tp_index_t_3 = (tp_index + t) * 3;
|
|
e = tp[tp_index_t_3];
|
|
} else {
|
|
z.msg = "invalid distance code";
|
|
c = z.avail_in - n;
|
|
c = k >> 3 < c ? k >> 3 : c;
|
|
n += c;
|
|
p -= c;
|
|
k -= c << 3;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return Z_DATA_ERROR2;
|
|
}
|
|
} while (true);
|
|
break;
|
|
}
|
|
if ((e & 64) === 0) {
|
|
t += tp[tp_index_t_3 + 2];
|
|
t += b & inflate_mask[e];
|
|
tp_index_t_3 = (tp_index + t) * 3;
|
|
if ((e = tp[tp_index_t_3]) === 0) {
|
|
b >>= tp[tp_index_t_3 + 1];
|
|
k -= tp[tp_index_t_3 + 1];
|
|
s.win[q++] = /* (byte) */
|
|
tp[tp_index_t_3 + 2];
|
|
m--;
|
|
break;
|
|
}
|
|
} else if ((e & 32) !== 0) {
|
|
c = z.avail_in - n;
|
|
c = k >> 3 < c ? k >> 3 : c;
|
|
n += c;
|
|
p -= c;
|
|
k -= c << 3;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return Z_STREAM_END2;
|
|
} else {
|
|
z.msg = "invalid literal/length code";
|
|
c = z.avail_in - n;
|
|
c = k >> 3 < c ? k >> 3 : c;
|
|
n += c;
|
|
p -= c;
|
|
k -= c << 3;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return Z_DATA_ERROR2;
|
|
}
|
|
} while (true);
|
|
} while (m >= 258 && n >= 10);
|
|
c = z.avail_in - n;
|
|
c = k >> 3 < c ? k >> 3 : c;
|
|
n += c;
|
|
p -= c;
|
|
k -= c << 3;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return Z_OK2;
|
|
}
|
|
that.init = function(bl, bd, tl, tl_index, td, td_index) {
|
|
mode2 = START;
|
|
lbits = /* (byte) */
|
|
bl;
|
|
dbits = /* (byte) */
|
|
bd;
|
|
ltree = tl;
|
|
ltree_index = tl_index;
|
|
dtree = td;
|
|
dtree_index = td_index;
|
|
tree = null;
|
|
};
|
|
that.proc = function(s, z, r) {
|
|
let j;
|
|
let tindex;
|
|
let e;
|
|
let b = 0;
|
|
let k = 0;
|
|
let p = 0;
|
|
let n;
|
|
let q;
|
|
let m;
|
|
let f;
|
|
p = z.next_in_index;
|
|
n = z.avail_in;
|
|
b = s.bitb;
|
|
k = s.bitk;
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
while (true) {
|
|
switch (mode2) {
|
|
// waiting for "i:"=input, "o:"=output, "x:"=nothing
|
|
case START:
|
|
if (m >= 258 && n >= 10) {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
r = inflate_fast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, s, z);
|
|
p = z.next_in_index;
|
|
n = z.avail_in;
|
|
b = s.bitb;
|
|
k = s.bitk;
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
if (r != Z_OK2) {
|
|
mode2 = r == Z_STREAM_END2 ? WASH : BADCODE;
|
|
break;
|
|
}
|
|
}
|
|
need = lbits;
|
|
tree = ltree;
|
|
tree_index = ltree_index;
|
|
mode2 = LEN;
|
|
/* falls through */
|
|
case LEN:
|
|
j = need;
|
|
while (k < j) {
|
|
if (n !== 0)
|
|
r = Z_OK2;
|
|
else {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
tindex = (tree_index + (b & inflate_mask[j])) * 3;
|
|
b >>>= tree[tindex + 1];
|
|
k -= tree[tindex + 1];
|
|
e = tree[tindex];
|
|
if (e === 0) {
|
|
lit = tree[tindex + 2];
|
|
mode2 = LIT;
|
|
break;
|
|
}
|
|
if ((e & 16) !== 0) {
|
|
get = e & 15;
|
|
len = tree[tindex + 2];
|
|
mode2 = LENEXT;
|
|
break;
|
|
}
|
|
if ((e & 64) === 0) {
|
|
need = e;
|
|
tree_index = tindex / 3 + tree[tindex + 2];
|
|
break;
|
|
}
|
|
if ((e & 32) !== 0) {
|
|
mode2 = WASH;
|
|
break;
|
|
}
|
|
mode2 = BADCODE;
|
|
z.msg = "invalid literal/length code";
|
|
r = Z_DATA_ERROR2;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
case LENEXT:
|
|
j = get;
|
|
while (k < j) {
|
|
if (n !== 0)
|
|
r = Z_OK2;
|
|
else {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
len += b & inflate_mask[j];
|
|
b >>= j;
|
|
k -= j;
|
|
need = dbits;
|
|
tree = dtree;
|
|
tree_index = dtree_index;
|
|
mode2 = DIST;
|
|
/* falls through */
|
|
case DIST:
|
|
j = need;
|
|
while (k < j) {
|
|
if (n !== 0)
|
|
r = Z_OK2;
|
|
else {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
tindex = (tree_index + (b & inflate_mask[j])) * 3;
|
|
b >>= tree[tindex + 1];
|
|
k -= tree[tindex + 1];
|
|
e = tree[tindex];
|
|
if ((e & 16) !== 0) {
|
|
get = e & 15;
|
|
dist = tree[tindex + 2];
|
|
mode2 = DISTEXT;
|
|
break;
|
|
}
|
|
if ((e & 64) === 0) {
|
|
need = e;
|
|
tree_index = tindex / 3 + tree[tindex + 2];
|
|
break;
|
|
}
|
|
mode2 = BADCODE;
|
|
z.msg = "invalid distance code";
|
|
r = Z_DATA_ERROR2;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
case DISTEXT:
|
|
j = get;
|
|
while (k < j) {
|
|
if (n !== 0)
|
|
r = Z_OK2;
|
|
else {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
dist += b & inflate_mask[j];
|
|
b >>= j;
|
|
k -= j;
|
|
mode2 = COPY;
|
|
/* falls through */
|
|
case COPY:
|
|
f = q - dist;
|
|
while (f < 0) {
|
|
f += s.end;
|
|
}
|
|
while (len !== 0) {
|
|
if (m === 0) {
|
|
if (q == s.end && s.read !== 0) {
|
|
q = 0;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
}
|
|
if (m === 0) {
|
|
s.write = q;
|
|
r = s.inflate_flush(z, r);
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
if (q == s.end && s.read !== 0) {
|
|
q = 0;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
}
|
|
if (m === 0) {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
}
|
|
}
|
|
s.win[q++] = s.win[f++];
|
|
m--;
|
|
if (f == s.end)
|
|
f = 0;
|
|
len--;
|
|
}
|
|
mode2 = START;
|
|
break;
|
|
case LIT:
|
|
if (m === 0) {
|
|
if (q == s.end && s.read !== 0) {
|
|
q = 0;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
}
|
|
if (m === 0) {
|
|
s.write = q;
|
|
r = s.inflate_flush(z, r);
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
if (q == s.end && s.read !== 0) {
|
|
q = 0;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
}
|
|
if (m === 0) {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
}
|
|
}
|
|
r = Z_OK2;
|
|
s.win[q++] = /* (byte) */
|
|
lit;
|
|
m--;
|
|
mode2 = START;
|
|
break;
|
|
case WASH:
|
|
if (k > 7) {
|
|
k -= 8;
|
|
n++;
|
|
p--;
|
|
}
|
|
s.write = q;
|
|
r = s.inflate_flush(z, r);
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
if (s.read != s.write) {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
mode2 = END;
|
|
/* falls through */
|
|
case END:
|
|
r = Z_STREAM_END2;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
case BADCODE:
|
|
r = Z_DATA_ERROR2;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
default:
|
|
r = Z_STREAM_ERROR2;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
}
|
|
};
|
|
that.free = function() {
|
|
};
|
|
}
|
|
var border = [
|
|
// Order of the bit length code lengths
|
|
16,
|
|
17,
|
|
18,
|
|
0,
|
|
8,
|
|
7,
|
|
9,
|
|
6,
|
|
10,
|
|
5,
|
|
11,
|
|
4,
|
|
12,
|
|
3,
|
|
13,
|
|
2,
|
|
14,
|
|
1,
|
|
15
|
|
];
|
|
var TYPE = 0;
|
|
var LENS = 1;
|
|
var STORED2 = 2;
|
|
var TABLE = 3;
|
|
var BTREE = 4;
|
|
var DTREE = 5;
|
|
var CODES = 6;
|
|
var DRY = 7;
|
|
var DONELOCKS = 8;
|
|
var BADBLOCKS = 9;
|
|
function InfBlocks(z, w) {
|
|
const that = this;
|
|
let mode2 = TYPE;
|
|
let left = 0;
|
|
let table2 = 0;
|
|
let index = 0;
|
|
let blens;
|
|
const bb = [0];
|
|
const tb = [0];
|
|
const codes = new InfCodes();
|
|
let last = 0;
|
|
let hufts = new Int32Array(MANY * 3);
|
|
const check = 0;
|
|
const inftree = new InfTree();
|
|
that.bitk = 0;
|
|
that.bitb = 0;
|
|
that.win = new Uint8Array(w);
|
|
that.end = w;
|
|
that.read = 0;
|
|
that.write = 0;
|
|
that.reset = function(z2, c) {
|
|
if (c)
|
|
c[0] = check;
|
|
if (mode2 == CODES) {
|
|
codes.free(z2);
|
|
}
|
|
mode2 = TYPE;
|
|
that.bitk = 0;
|
|
that.bitb = 0;
|
|
that.read = that.write = 0;
|
|
};
|
|
that.reset(z, null);
|
|
that.inflate_flush = function(z2, r) {
|
|
let n;
|
|
let p;
|
|
let q;
|
|
p = z2.next_out_index;
|
|
q = that.read;
|
|
n = /* (int) */
|
|
(q <= that.write ? that.write : that.end) - q;
|
|
if (n > z2.avail_out)
|
|
n = z2.avail_out;
|
|
if (n !== 0 && r == Z_BUF_ERROR2)
|
|
r = Z_OK2;
|
|
z2.avail_out -= n;
|
|
z2.total_out += n;
|
|
z2.next_out.set(that.win.subarray(q, q + n), p);
|
|
p += n;
|
|
q += n;
|
|
if (q == that.end) {
|
|
q = 0;
|
|
if (that.write == that.end)
|
|
that.write = 0;
|
|
n = that.write - q;
|
|
if (n > z2.avail_out)
|
|
n = z2.avail_out;
|
|
if (n !== 0 && r == Z_BUF_ERROR2)
|
|
r = Z_OK2;
|
|
z2.avail_out -= n;
|
|
z2.total_out += n;
|
|
z2.next_out.set(that.win.subarray(q, q + n), p);
|
|
p += n;
|
|
q += n;
|
|
}
|
|
z2.next_out_index = p;
|
|
that.read = q;
|
|
return r;
|
|
};
|
|
that.proc = function(z2, r) {
|
|
let t;
|
|
let b;
|
|
let k;
|
|
let p;
|
|
let n;
|
|
let q;
|
|
let m;
|
|
let i;
|
|
p = z2.next_in_index;
|
|
n = z2.avail_in;
|
|
b = that.bitb;
|
|
k = that.bitk;
|
|
q = that.write;
|
|
m = /* (int) */
|
|
q < that.read ? that.read - q - 1 : that.end - q;
|
|
while (true) {
|
|
let bl, bd, tl, td, bl_, bd_, tl_, td_;
|
|
switch (mode2) {
|
|
case TYPE:
|
|
while (k < 3) {
|
|
if (n !== 0) {
|
|
r = Z_OK2;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
n--;
|
|
b |= (z2.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
t = /* (int) */
|
|
b & 7;
|
|
last = t & 1;
|
|
switch (t >>> 1) {
|
|
case 0:
|
|
b >>>= 3;
|
|
k -= 3;
|
|
t = k & 7;
|
|
b >>>= t;
|
|
k -= t;
|
|
mode2 = LENS;
|
|
break;
|
|
case 1:
|
|
bl = [];
|
|
bd = [];
|
|
tl = [[]];
|
|
td = [[]];
|
|
InfTree.inflate_trees_fixed(bl, bd, tl, td);
|
|
codes.init(bl[0], bd[0], tl[0], 0, td[0], 0);
|
|
b >>>= 3;
|
|
k -= 3;
|
|
mode2 = CODES;
|
|
break;
|
|
case 2:
|
|
b >>>= 3;
|
|
k -= 3;
|
|
mode2 = TABLE;
|
|
break;
|
|
case 3:
|
|
b >>>= 3;
|
|
k -= 3;
|
|
mode2 = BADBLOCKS;
|
|
z2.msg = "invalid block type";
|
|
r = Z_DATA_ERROR2;
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
break;
|
|
case LENS:
|
|
while (k < 32) {
|
|
if (n !== 0) {
|
|
r = Z_OK2;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
n--;
|
|
b |= (z2.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
if ((~b >>> 16 & 65535) != (b & 65535)) {
|
|
mode2 = BADBLOCKS;
|
|
z2.msg = "invalid stored block lengths";
|
|
r = Z_DATA_ERROR2;
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
left = b & 65535;
|
|
b = k = 0;
|
|
mode2 = left !== 0 ? STORED2 : last !== 0 ? DRY : TYPE;
|
|
break;
|
|
case STORED2:
|
|
if (n === 0) {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
if (m === 0) {
|
|
if (q == that.end && that.read !== 0) {
|
|
q = 0;
|
|
m = /* (int) */
|
|
q < that.read ? that.read - q - 1 : that.end - q;
|
|
}
|
|
if (m === 0) {
|
|
that.write = q;
|
|
r = that.inflate_flush(z2, r);
|
|
q = that.write;
|
|
m = /* (int) */
|
|
q < that.read ? that.read - q - 1 : that.end - q;
|
|
if (q == that.end && that.read !== 0) {
|
|
q = 0;
|
|
m = /* (int) */
|
|
q < that.read ? that.read - q - 1 : that.end - q;
|
|
}
|
|
if (m === 0) {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
}
|
|
}
|
|
r = Z_OK2;
|
|
t = left;
|
|
if (t > n)
|
|
t = n;
|
|
if (t > m)
|
|
t = m;
|
|
that.win.set(z2.read_buf(p, t), q);
|
|
p += t;
|
|
n -= t;
|
|
q += t;
|
|
m -= t;
|
|
if ((left -= t) !== 0)
|
|
break;
|
|
mode2 = last !== 0 ? DRY : TYPE;
|
|
break;
|
|
case TABLE:
|
|
while (k < 14) {
|
|
if (n !== 0) {
|
|
r = Z_OK2;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
n--;
|
|
b |= (z2.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
table2 = t = b & 16383;
|
|
if ((t & 31) > 29 || (t >> 5 & 31) > 29) {
|
|
mode2 = BADBLOCKS;
|
|
z2.msg = "too many length or distance symbols";
|
|
r = Z_DATA_ERROR2;
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
t = 258 + (t & 31) + (t >> 5 & 31);
|
|
if (!blens || blens.length < t) {
|
|
blens = [];
|
|
} else {
|
|
for (i = 0; i < t; i++) {
|
|
blens[i] = 0;
|
|
}
|
|
}
|
|
b >>>= 14;
|
|
k -= 14;
|
|
index = 0;
|
|
mode2 = BTREE;
|
|
/* falls through */
|
|
case BTREE:
|
|
while (index < 4 + (table2 >>> 10)) {
|
|
while (k < 3) {
|
|
if (n !== 0) {
|
|
r = Z_OK2;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
n--;
|
|
b |= (z2.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
blens[border[index++]] = b & 7;
|
|
b >>>= 3;
|
|
k -= 3;
|
|
}
|
|
while (index < 19) {
|
|
blens[border[index++]] = 0;
|
|
}
|
|
bb[0] = 7;
|
|
t = inftree.inflate_trees_bits(blens, bb, tb, hufts, z2);
|
|
if (t != Z_OK2) {
|
|
r = t;
|
|
if (r == Z_DATA_ERROR2) {
|
|
blens = null;
|
|
mode2 = BADBLOCKS;
|
|
}
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
index = 0;
|
|
mode2 = DTREE;
|
|
/* falls through */
|
|
case DTREE:
|
|
while (true) {
|
|
t = table2;
|
|
if (index >= 258 + (t & 31) + (t >> 5 & 31)) {
|
|
break;
|
|
}
|
|
let j, c;
|
|
t = bb[0];
|
|
while (k < t) {
|
|
if (n !== 0) {
|
|
r = Z_OK2;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
n--;
|
|
b |= (z2.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
t = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 1];
|
|
c = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 2];
|
|
if (c < 16) {
|
|
b >>>= t;
|
|
k -= t;
|
|
blens[index++] = c;
|
|
} else {
|
|
i = c == 18 ? 7 : c - 14;
|
|
j = c == 18 ? 11 : 3;
|
|
while (k < t + i) {
|
|
if (n !== 0) {
|
|
r = Z_OK2;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
n--;
|
|
b |= (z2.read_byte(p++) & 255) << k;
|
|
k += 8;
|
|
}
|
|
b >>>= t;
|
|
k -= t;
|
|
j += b & inflate_mask[i];
|
|
b >>>= i;
|
|
k -= i;
|
|
i = index;
|
|
t = table2;
|
|
if (i + j > 258 + (t & 31) + (t >> 5 & 31) || c == 16 && i < 1) {
|
|
blens = null;
|
|
mode2 = BADBLOCKS;
|
|
z2.msg = "invalid bit length repeat";
|
|
r = Z_DATA_ERROR2;
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
c = c == 16 ? blens[i - 1] : 0;
|
|
do {
|
|
blens[i++] = c;
|
|
} while (--j !== 0);
|
|
index = i;
|
|
}
|
|
}
|
|
tb[0] = -1;
|
|
bl_ = [];
|
|
bd_ = [];
|
|
tl_ = [];
|
|
td_ = [];
|
|
bl_[0] = 9;
|
|
bd_[0] = 6;
|
|
t = table2;
|
|
t = inftree.inflate_trees_dynamic(257 + (t & 31), 1 + (t >> 5 & 31), blens, bl_, bd_, tl_, td_, hufts, z2);
|
|
if (t != Z_OK2) {
|
|
if (t == Z_DATA_ERROR2) {
|
|
blens = null;
|
|
mode2 = BADBLOCKS;
|
|
}
|
|
r = t;
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
codes.init(bl_[0], bd_[0], hufts, tl_[0], hufts, td_[0]);
|
|
mode2 = CODES;
|
|
/* falls through */
|
|
case CODES:
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
if ((r = codes.proc(that, z2, r)) != Z_STREAM_END2) {
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
r = Z_OK2;
|
|
codes.free(z2);
|
|
p = z2.next_in_index;
|
|
n = z2.avail_in;
|
|
b = that.bitb;
|
|
k = that.bitk;
|
|
q = that.write;
|
|
m = /* (int) */
|
|
q < that.read ? that.read - q - 1 : that.end - q;
|
|
if (last === 0) {
|
|
mode2 = TYPE;
|
|
break;
|
|
}
|
|
mode2 = DRY;
|
|
/* falls through */
|
|
case DRY:
|
|
that.write = q;
|
|
r = that.inflate_flush(z2, r);
|
|
q = that.write;
|
|
m = /* (int) */
|
|
q < that.read ? that.read - q - 1 : that.end - q;
|
|
if (that.read != that.write) {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
mode2 = DONELOCKS;
|
|
/* falls through */
|
|
case DONELOCKS:
|
|
r = Z_STREAM_END2;
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
case BADBLOCKS:
|
|
r = Z_DATA_ERROR2;
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
default:
|
|
r = Z_STREAM_ERROR2;
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z2.avail_in = n;
|
|
z2.total_in += p - z2.next_in_index;
|
|
z2.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z2, r);
|
|
}
|
|
}
|
|
};
|
|
that.free = function(z2) {
|
|
that.reset(z2, null);
|
|
that.win = null;
|
|
hufts = null;
|
|
};
|
|
that.set_dictionary = function(d, start, n) {
|
|
that.win.set(d.subarray(start, start + n), 0);
|
|
that.read = that.write = n;
|
|
};
|
|
that.sync_point = function() {
|
|
return mode2 == LENS ? 1 : 0;
|
|
};
|
|
}
|
|
var PRESET_DICT2 = 32;
|
|
var Z_DEFLATED2 = 8;
|
|
var METHOD = 0;
|
|
var FLAG = 1;
|
|
var DICT4 = 2;
|
|
var DICT3 = 3;
|
|
var DICT2 = 4;
|
|
var DICT1 = 5;
|
|
var DICT0 = 6;
|
|
var BLOCKS = 7;
|
|
var DONE = 12;
|
|
var BAD = 13;
|
|
var mark = [0, 0, 255, 255];
|
|
function Inflate() {
|
|
const that = this;
|
|
that.mode = 0;
|
|
that.method = 0;
|
|
that.was = [0];
|
|
that.need = 0;
|
|
that.marker = 0;
|
|
that.wbits = 0;
|
|
function inflateReset(z) {
|
|
if (!z || !z.istate)
|
|
return Z_STREAM_ERROR2;
|
|
z.total_in = z.total_out = 0;
|
|
z.msg = null;
|
|
z.istate.mode = BLOCKS;
|
|
z.istate.blocks.reset(z, null);
|
|
return Z_OK2;
|
|
}
|
|
that.inflateEnd = function(z) {
|
|
if (that.blocks)
|
|
that.blocks.free(z);
|
|
that.blocks = null;
|
|
return Z_OK2;
|
|
};
|
|
that.inflateInit = function(z, w) {
|
|
z.msg = null;
|
|
that.blocks = null;
|
|
if (w < 8 || w > 15) {
|
|
that.inflateEnd(z);
|
|
return Z_STREAM_ERROR2;
|
|
}
|
|
that.wbits = w;
|
|
z.istate.blocks = new InfBlocks(z, 1 << w);
|
|
inflateReset(z);
|
|
return Z_OK2;
|
|
};
|
|
that.inflate = function(z, f) {
|
|
let r;
|
|
let b;
|
|
if (!z || !z.istate || !z.next_in)
|
|
return Z_STREAM_ERROR2;
|
|
const istate = z.istate;
|
|
f = f == Z_FINISH2 ? Z_BUF_ERROR2 : Z_OK2;
|
|
r = Z_BUF_ERROR2;
|
|
while (true) {
|
|
switch (istate.mode) {
|
|
case METHOD:
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
if (((istate.method = z.read_byte(z.next_in_index++)) & 15) != Z_DEFLATED2) {
|
|
istate.mode = BAD;
|
|
z.msg = "unknown compression method";
|
|
istate.marker = 5;
|
|
break;
|
|
}
|
|
if ((istate.method >> 4) + 8 > istate.wbits) {
|
|
istate.mode = BAD;
|
|
z.msg = "invalid win size";
|
|
istate.marker = 5;
|
|
break;
|
|
}
|
|
istate.mode = FLAG;
|
|
/* falls through */
|
|
case FLAG:
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
b = z.read_byte(z.next_in_index++) & 255;
|
|
if (((istate.method << 8) + b) % 31 !== 0) {
|
|
istate.mode = BAD;
|
|
z.msg = "incorrect header check";
|
|
istate.marker = 5;
|
|
break;
|
|
}
|
|
if ((b & PRESET_DICT2) === 0) {
|
|
istate.mode = BLOCKS;
|
|
break;
|
|
}
|
|
istate.mode = DICT4;
|
|
/* falls through */
|
|
case DICT4:
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
istate.need = (z.read_byte(z.next_in_index++) & 255) << 24 & 4278190080;
|
|
istate.mode = DICT3;
|
|
/* falls through */
|
|
case DICT3:
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
istate.need += (z.read_byte(z.next_in_index++) & 255) << 16 & 16711680;
|
|
istate.mode = DICT2;
|
|
/* falls through */
|
|
case DICT2:
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
istate.need += (z.read_byte(z.next_in_index++) & 255) << 8 & 65280;
|
|
istate.mode = DICT1;
|
|
/* falls through */
|
|
case DICT1:
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
istate.need += z.read_byte(z.next_in_index++) & 255;
|
|
istate.mode = DICT0;
|
|
return Z_NEED_DICT2;
|
|
case DICT0:
|
|
istate.mode = BAD;
|
|
z.msg = "need dictionary";
|
|
istate.marker = 0;
|
|
return Z_STREAM_ERROR2;
|
|
case BLOCKS:
|
|
r = istate.blocks.proc(z, r);
|
|
if (r == Z_DATA_ERROR2) {
|
|
istate.mode = BAD;
|
|
istate.marker = 0;
|
|
break;
|
|
}
|
|
if (r == Z_OK2) {
|
|
r = f;
|
|
}
|
|
if (r != Z_STREAM_END2) {
|
|
return r;
|
|
}
|
|
r = f;
|
|
istate.blocks.reset(z, istate.was);
|
|
istate.mode = DONE;
|
|
/* falls through */
|
|
case DONE:
|
|
z.avail_in = 0;
|
|
return Z_STREAM_END2;
|
|
case BAD:
|
|
return Z_DATA_ERROR2;
|
|
default:
|
|
return Z_STREAM_ERROR2;
|
|
}
|
|
}
|
|
};
|
|
that.inflateSetDictionary = function(z, dictionary, dictLength) {
|
|
let index = 0, length = dictLength;
|
|
if (!z || !z.istate || z.istate.mode != DICT0)
|
|
return Z_STREAM_ERROR2;
|
|
const istate = z.istate;
|
|
if (length >= 1 << istate.wbits) {
|
|
length = (1 << istate.wbits) - 1;
|
|
index = dictLength - length;
|
|
}
|
|
istate.blocks.set_dictionary(dictionary, index, length);
|
|
istate.mode = BLOCKS;
|
|
return Z_OK2;
|
|
};
|
|
that.inflateSync = function(z) {
|
|
let n;
|
|
let p;
|
|
let m;
|
|
let r, w;
|
|
if (!z || !z.istate)
|
|
return Z_STREAM_ERROR2;
|
|
const istate = z.istate;
|
|
if (istate.mode != BAD) {
|
|
istate.mode = BAD;
|
|
istate.marker = 0;
|
|
}
|
|
if ((n = z.avail_in) === 0)
|
|
return Z_BUF_ERROR2;
|
|
p = z.next_in_index;
|
|
m = istate.marker;
|
|
while (n !== 0 && m < 4) {
|
|
if (z.read_byte(p) == mark[m]) {
|
|
m++;
|
|
} else if (z.read_byte(p) !== 0) {
|
|
m = 0;
|
|
} else {
|
|
m = 4 - m;
|
|
}
|
|
p++;
|
|
n--;
|
|
}
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
z.avail_in = n;
|
|
istate.marker = m;
|
|
if (m != 4) {
|
|
return Z_DATA_ERROR2;
|
|
}
|
|
r = z.total_in;
|
|
w = z.total_out;
|
|
inflateReset(z);
|
|
z.total_in = r;
|
|
z.total_out = w;
|
|
istate.mode = BLOCKS;
|
|
return Z_OK2;
|
|
};
|
|
that.inflateSyncPoint = function(z) {
|
|
if (!z || !z.istate || !z.istate.blocks)
|
|
return Z_STREAM_ERROR2;
|
|
return z.istate.blocks.sync_point();
|
|
};
|
|
}
|
|
function ZStream2() {
|
|
}
|
|
ZStream2.prototype = {
|
|
inflateInit(bits) {
|
|
const that = this;
|
|
that.istate = new Inflate();
|
|
if (!bits)
|
|
bits = MAX_BITS2;
|
|
return that.istate.inflateInit(that, bits);
|
|
},
|
|
inflate(f) {
|
|
const that = this;
|
|
if (!that.istate)
|
|
return Z_STREAM_ERROR2;
|
|
return that.istate.inflate(that, f);
|
|
},
|
|
inflateEnd() {
|
|
const that = this;
|
|
if (!that.istate)
|
|
return Z_STREAM_ERROR2;
|
|
const ret = that.istate.inflateEnd(that);
|
|
that.istate = null;
|
|
return ret;
|
|
},
|
|
inflateSync() {
|
|
const that = this;
|
|
if (!that.istate)
|
|
return Z_STREAM_ERROR2;
|
|
return that.istate.inflateSync(that);
|
|
},
|
|
inflateSetDictionary(dictionary, dictLength) {
|
|
const that = this;
|
|
if (!that.istate)
|
|
return Z_STREAM_ERROR2;
|
|
return that.istate.inflateSetDictionary(that, dictionary, dictLength);
|
|
},
|
|
read_byte(start) {
|
|
const that = this;
|
|
return that.next_in[start];
|
|
},
|
|
read_buf(start, size) {
|
|
const that = this;
|
|
return that.next_in.subarray(start, start + size);
|
|
}
|
|
};
|
|
function ZipInflate(options) {
|
|
const that = this;
|
|
const z = new ZStream2();
|
|
const bufsize = options && options.chunkSize ? Math.floor(options.chunkSize * 2) : 128 * 1024;
|
|
const flush = Z_NO_FLUSH2;
|
|
const buf = new Uint8Array(bufsize);
|
|
let nomoreinput = false;
|
|
z.inflateInit();
|
|
z.next_out = buf;
|
|
that.append = function(data, onprogress) {
|
|
const buffers = [];
|
|
let err, array, lastIndex = 0, bufferIndex = 0, bufferSize = 0;
|
|
if (data.length === 0)
|
|
return;
|
|
z.next_in_index = 0;
|
|
z.next_in = data;
|
|
z.avail_in = data.length;
|
|
do {
|
|
z.next_out_index = 0;
|
|
z.avail_out = bufsize;
|
|
if (z.avail_in === 0 && !nomoreinput) {
|
|
z.next_in_index = 0;
|
|
nomoreinput = true;
|
|
}
|
|
err = z.inflate(flush);
|
|
if (nomoreinput && err === Z_BUF_ERROR2) {
|
|
if (z.avail_in !== 0)
|
|
throw new Error("inflating: bad input");
|
|
} else if (err !== Z_OK2 && err !== Z_STREAM_END2)
|
|
throw new Error("inflating: " + z.msg);
|
|
if ((nomoreinput || err === Z_STREAM_END2) && z.avail_in === data.length)
|
|
throw new Error("inflating: bad input");
|
|
if (z.next_out_index)
|
|
if (z.next_out_index === bufsize)
|
|
buffers.push(new Uint8Array(buf));
|
|
else
|
|
buffers.push(buf.subarray(0, z.next_out_index));
|
|
bufferSize += z.next_out_index;
|
|
if (onprogress && z.next_in_index > 0 && z.next_in_index != lastIndex) {
|
|
onprogress(z.next_in_index);
|
|
lastIndex = z.next_in_index;
|
|
}
|
|
} while (z.avail_in > 0 || z.avail_out === 0);
|
|
if (buffers.length > 1) {
|
|
array = new Uint8Array(bufferSize);
|
|
buffers.forEach(function(chunk) {
|
|
array.set(chunk, bufferIndex);
|
|
bufferIndex += chunk.length;
|
|
});
|
|
} else {
|
|
array = buffers[0] ? new Uint8Array(buffers[0]) : new Uint8Array();
|
|
}
|
|
return array;
|
|
};
|
|
that.flush = function() {
|
|
z.inflateEnd();
|
|
};
|
|
}
|
|
|
|
// node_modules/@zip.js/zip.js/lib/z-worker.js
|
|
self.initCodec = () => {
|
|
self.Deflate = ZipDeflate;
|
|
self.Inflate = ZipInflate;
|
|
};
|
|
//# sourceMappingURL=z-worker.js.map
|