1630 lines
56 KiB
JavaScript
1630 lines
56 KiB
JavaScript
// Module ID: 12638
|
|
// Function ID: 97779
|
|
// Name: err
|
|
// Dependencies: [12639, 12635, 12640, 12641, 12642]
|
|
|
|
// Module 12638 (err)
|
|
const require = arg1;
|
|
const dependencyMap = arg6;
|
|
function err(state, arg1) {
|
|
state.msg = require(12639)[arg1];
|
|
return arg1;
|
|
}
|
|
function rank(last_flush) {
|
|
let num = 0;
|
|
if (last_flush > 4) {
|
|
num = 9;
|
|
}
|
|
return (last_flush << 1) - num;
|
|
}
|
|
function zero(arg0) {
|
|
let diff = arg0.length - 1;
|
|
if (diff >= 0) {
|
|
do {
|
|
arg0[diff] = 0;
|
|
diff = diff - 1;
|
|
} while (diff >= 0);
|
|
}
|
|
}
|
|
function flush_pending(strm) {
|
|
const state = strm.state;
|
|
let avail_out = state.pending;
|
|
if (avail_out > strm.avail_out) {
|
|
avail_out = strm.avail_out;
|
|
}
|
|
if (0 !== avail_out) {
|
|
const obj = require(12635) /* _has */;
|
|
obj.arraySet(strm.output, state.pending_buf, state.pending_out, avail_out, strm.next_out);
|
|
strm.next_out = strm.next_out + avail_out;
|
|
state.pending_out = state.pending_out + avail_out;
|
|
strm.total_out = strm.total_out + avail_out;
|
|
strm.avail_out = strm.avail_out - avail_out;
|
|
state.pending = state.pending - avail_out;
|
|
if (0 === state.pending) {
|
|
state.pending_out = 0;
|
|
}
|
|
}
|
|
}
|
|
function flush_block_only(state, arg1) {
|
|
let num = -1;
|
|
if (state.block_start >= 0) {
|
|
num = state.block_start;
|
|
}
|
|
require(12640) /* zero */._tr_flush_block(state, num, state.strstart - state.block_start, arg1);
|
|
state.block_start = state.strstart;
|
|
flush_pending(state.strm);
|
|
}
|
|
function put_byte(state, arg1) {
|
|
state.pending = +state.pending + 1;
|
|
state.pending_buf[+state.pending] = arg1;
|
|
}
|
|
function putShortMSB(state, arg1) {
|
|
state.pending = +state.pending + 1;
|
|
state.pending_buf[+state.pending] = arg1 >>> 8 & 255;
|
|
state.pending = +state.pending + 1;
|
|
state.pending_buf[+state.pending] = 255 & arg1;
|
|
}
|
|
function longest_match(strstart, arg1) {
|
|
let max_chain_length;
|
|
let nice_match;
|
|
let prev;
|
|
let prev_length;
|
|
let w_mask;
|
|
({ max_chain_length, strstart, prev_length, nice_match } = strstart);
|
|
let num = 0;
|
|
if (strstart.strstart > strstart.w_size - 262) {
|
|
num = strstart.strstart - (strstart.w_size - 262);
|
|
}
|
|
const _window = strstart.window;
|
|
const sum = strstart.strstart + 258;
|
|
let tmp4 = max_chain_length;
|
|
({ w_mask, prev } = strstart);
|
|
if (strstart.prev_length >= strstart.good_match) {
|
|
tmp4 = max_chain_length >> 2;
|
|
}
|
|
const diff = sum - 258;
|
|
let tmp6 = arg1;
|
|
let diff2 = tmp4;
|
|
let tmp9 = strstart;
|
|
let tmp10 = prev_length;
|
|
let tmp11 = tmp2;
|
|
let tmp12 = tmp3;
|
|
if (nice_match > strstart.lookahead) {
|
|
nice_match = strstart.lookahead;
|
|
tmp6 = arg1;
|
|
diff2 = tmp4;
|
|
tmp9 = strstart;
|
|
tmp10 = prev_length;
|
|
tmp11 = tmp2;
|
|
tmp12 = tmp3;
|
|
}
|
|
while (true) {
|
|
let tmp13 = tmp7;
|
|
let tmp14 = tmp9;
|
|
let tmp15 = tmp10;
|
|
let tmp16 = tmp11;
|
|
let tmp17 = tmp12;
|
|
if (_window[tmp6 + tmp10] === tmp12) {
|
|
tmp13 = tmp7;
|
|
tmp14 = tmp9;
|
|
tmp15 = tmp10;
|
|
tmp16 = tmp11;
|
|
tmp17 = tmp12;
|
|
if (_window[tmp6 + tmp10 - 1] === tmp11) {
|
|
tmp13 = tmp7;
|
|
tmp14 = tmp9;
|
|
tmp15 = tmp10;
|
|
tmp16 = tmp11;
|
|
tmp17 = tmp12;
|
|
if (_window[tmp6] === _window[tmp9]) {
|
|
let sum1 = tmp6 + 1;
|
|
tmp13 = tmp7;
|
|
tmp14 = tmp9;
|
|
tmp15 = tmp10;
|
|
tmp16 = tmp11;
|
|
tmp17 = tmp12;
|
|
if (_window[sum1] === _window[tmp9 + 1]) {
|
|
let sum2 = tmp9 + 2;
|
|
let sum3 = sum1 + 1;
|
|
let sum4 = sum2 + 1;
|
|
let sum5 = sum3 + 1;
|
|
let tmp20 = sum4;
|
|
while (_window[sum4] === _window[sum5]) {
|
|
let sum6 = sum4 + 1;
|
|
let sum7 = sum5 + 1;
|
|
tmp20 = sum6;
|
|
if (_window[sum6] !== _window[sum7]) {
|
|
break;
|
|
} else {
|
|
let sum8 = sum6 + 1;
|
|
let sum9 = sum7 + 1;
|
|
tmp20 = sum8;
|
|
if (_window[sum8] !== _window[sum9]) {
|
|
break;
|
|
} else {
|
|
let sum10 = sum8 + 1;
|
|
let sum11 = sum9 + 1;
|
|
tmp20 = sum10;
|
|
if (_window[sum10] !== _window[sum11]) {
|
|
break;
|
|
} else {
|
|
let sum12 = sum10 + 1;
|
|
let sum13 = sum11 + 1;
|
|
tmp20 = sum12;
|
|
if (_window[sum12] !== _window[sum13]) {
|
|
break;
|
|
} else {
|
|
let sum14 = sum12 + 1;
|
|
let sum15 = sum13 + 1;
|
|
tmp20 = sum14;
|
|
if (_window[sum14] !== _window[sum15]) {
|
|
break;
|
|
} else {
|
|
let sum16 = sum14 + 1;
|
|
let sum17 = sum15 + 1;
|
|
tmp20 = sum16;
|
|
if (_window[sum16] !== _window[sum17]) {
|
|
break;
|
|
} else {
|
|
let sum18 = sum16 + 1;
|
|
sum3 = sum17 + 1;
|
|
tmp20 = sum18;
|
|
if (_window[sum18] !== _window[sum3]) {
|
|
break;
|
|
} else {
|
|
sum2 = sum18;
|
|
tmp20 = sum18;
|
|
if (sum18 >= sum) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let diff1 = 258 - (sum - tmp20);
|
|
tmp13 = diff1;
|
|
tmp14 = diff;
|
|
tmp15 = tmp10;
|
|
tmp16 = tmp11;
|
|
tmp17 = tmp12;
|
|
if (diff1 > tmp10) {
|
|
strstart.match_start = tmp6;
|
|
let lookahead = diff1;
|
|
if (diff1 >= nice_match) {
|
|
break;
|
|
} else {
|
|
let sum19 = diff + diff1;
|
|
tmp16 = _window[sum19 - 1];
|
|
tmp17 = _window[sum19];
|
|
tmp13 = diff1;
|
|
tmp14 = diff;
|
|
tmp15 = diff1;
|
|
}
|
|
}
|
|
if (lookahead > strstart.lookahead) {
|
|
lookahead = strstart.lookahead;
|
|
}
|
|
return lookahead;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tmp6 = prev[tmp6 & w_mask];
|
|
lookahead = tmp15;
|
|
if (tmp6 <= num) {
|
|
break;
|
|
} else {
|
|
diff2 = diff2 - 1;
|
|
tmp7 = tmp13;
|
|
tmp9 = tmp14;
|
|
tmp10 = tmp15;
|
|
tmp11 = tmp16;
|
|
tmp12 = tmp17;
|
|
lookahead = tmp15;
|
|
if (0 == diff2) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function fill_window(state) {
|
|
let _window;
|
|
let strm;
|
|
const w_size = state.w_size;
|
|
while (true) {
|
|
let diff = state.window_size - state.lookahead - state.strstart;
|
|
let sum = diff;
|
|
if (state.strstart >= w_size + (w_size - 262)) {
|
|
let tmp27 = require;
|
|
let tmp28 = dependencyMap;
|
|
let obj = require(12635) /* _has */;
|
|
let tmp29 = obj;
|
|
let tmp30 = w_size;
|
|
let tmp31 = w_size;
|
|
let num4 = 0;
|
|
let arraySetResult = obj.arraySet(state.window, state.window, w_size, w_size, 0);
|
|
state.match_start = state.match_start - w_size;
|
|
state.strstart = state.strstart - w_size;
|
|
state.block_start = state.block_start - w_size;
|
|
let hash_size = state.hash_size;
|
|
let diff1 = hash_size;
|
|
do {
|
|
hash_size = hash_size - 1;
|
|
let tmp3 = state.head[hash_size];
|
|
let num = 0;
|
|
if (tmp3 >= w_size) {
|
|
num = tmp3 - w_size;
|
|
}
|
|
state.head[hash_size] = num;
|
|
diff1 = diff1 - 1;
|
|
let tmp5 = w_size;
|
|
let diff3 = w_size;
|
|
} while (diff1);
|
|
do {
|
|
let diff2 = tmp5 - 1;
|
|
let tmp8 = state.prev[diff2];
|
|
let num2 = 0;
|
|
if (tmp8 >= w_size) {
|
|
num2 = tmp8 - w_size;
|
|
}
|
|
state.prev[diff2] = num2;
|
|
diff3 = diff3 - 1;
|
|
tmp5 = diff2;
|
|
} while (diff3);
|
|
sum = diff + w_size;
|
|
let tmp9 = diff2;
|
|
let tmp10 = tmp8;
|
|
}
|
|
if (0 === state.strm.avail_in) {
|
|
break;
|
|
} else {
|
|
({ strm, window: _window } = state);
|
|
let sum1 = state.strstart + state.lookahead;
|
|
let avail_in = strm.avail_in;
|
|
if (avail_in > sum) {
|
|
avail_in = sum;
|
|
}
|
|
let num3 = 0;
|
|
if (0 === avail_in) {
|
|
state.lookahead = state.lookahead;
|
|
if (state.lookahead + state.insert >= 3) {
|
|
let diff4 = state.strstart - state.insert;
|
|
state.ins_h = state.window[diff4];
|
|
state.ins_h = (state.ins_h << state.hash_shift ^ state.window[diff4 + 1]) & state.hash_mask;
|
|
let tmp42 = diff4;
|
|
if (state.insert) {
|
|
state.ins_h = (state.ins_h << state.hash_shift ^ state.window[diff4 + 3 - 1]) & state.hash_mask;
|
|
state.prev[diff4 & state.w_mask] = state.head[state.ins_h];
|
|
state.head[state.ins_h] = diff4;
|
|
let sum2 = diff4 + 1;
|
|
state.insert = state.insert - 1;
|
|
let sum3 = sum2;
|
|
let tmp24 = sum2;
|
|
if (state.lookahead + state.insert >= 3) {
|
|
let tmp25 = sum3;
|
|
while (state.insert) {
|
|
state.ins_h = (state.ins_h << state.hash_shift ^ state.window[sum3 + 3 - 1]) & state.hash_mask;
|
|
state.prev[sum3 & state.w_mask] = state.head[state.ins_h];
|
|
state.head[state.ins_h] = sum3;
|
|
sum3 = sum3 + 1;
|
|
state.insert = state.insert - 1;
|
|
let tmp26 = sum3;
|
|
if (state.lookahead + state.insert < 3) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (state.lookahead >= 262) {
|
|
break;
|
|
} else if (0 === state.strm.avail_in) {
|
|
break;
|
|
}
|
|
} else {
|
|
strm.avail_in = strm.avail_in - avail_in;
|
|
let tmp34 = require;
|
|
let tmp35 = dependencyMap;
|
|
let obj2 = require(12635) /* _has */;
|
|
let tmp36 = obj2;
|
|
let tmp37 = _window;
|
|
let tmp38 = avail_in;
|
|
let tmp39 = sum1;
|
|
arraySetResult = obj2.arraySet(_window, strm.input, strm.next_in, avail_in, sum1);
|
|
if (1 === strm.state.wrap) {
|
|
let tmp16 = require;
|
|
let tmp17 = dependencyMap;
|
|
let tmp18 = _window;
|
|
let tmp19 = avail_in;
|
|
let tmp20 = sum1;
|
|
strm.adler = require(12641) /* adler32 */(strm.adler, _window, avail_in, sum1);
|
|
} else if (2 === strm.state.wrap) {
|
|
let tmp11 = require;
|
|
let tmp12 = dependencyMap;
|
|
let tmp13 = _window;
|
|
let tmp14 = avail_in;
|
|
let tmp15 = sum1;
|
|
strm.adler = require(12642)(strm.adler, _window, avail_in, sum1);
|
|
}
|
|
strm.next_in = strm.next_in + avail_in;
|
|
strm.total_in = strm.total_in + avail_in;
|
|
let tmp21 = avail_in;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function deflate_fast(lookahead) {
|
|
while (true) {
|
|
if (lookahead.lookahead < 262) {
|
|
let tmp = fill_window;
|
|
let tmp2 = fill_window(lookahead);
|
|
if (lookahead.lookahead < 262) {
|
|
if (0 === arg1) {
|
|
break;
|
|
}
|
|
}
|
|
if (0 === lookahead.lookahead) {
|
|
let num2 = 2;
|
|
if (lookahead.strstart < 2) {
|
|
num2 = lookahead.strstart;
|
|
}
|
|
lookahead.insert = num2;
|
|
let num3 = 4;
|
|
if (4 === arg1) {
|
|
let tmp17 = flush_block_only;
|
|
let flag = true;
|
|
let tmp18 = flush_block_only(lookahead, true);
|
|
if (0 === lookahead.strm.avail_out) {
|
|
num3 = 3;
|
|
}
|
|
let num4 = num3;
|
|
} else {
|
|
num4 = 2;
|
|
if (lookahead.last_lit) {
|
|
let tmp15 = flush_block_only;
|
|
let tmp16 = flush_block_only(lookahead, false);
|
|
num4 = 2;
|
|
if (0 === lookahead.strm.avail_out) {
|
|
num4 = 1;
|
|
}
|
|
}
|
|
}
|
|
return num4;
|
|
}
|
|
}
|
|
let num = 0;
|
|
if (lookahead.lookahead >= 3) {
|
|
lookahead.ins_h = (lookahead.ins_h << lookahead.hash_shift ^ lookahead.window[lookahead.strstart + 3 - 1]) & lookahead.hash_mask;
|
|
let tmp3 = lookahead.head[lookahead.ins_h];
|
|
lookahead.prev[lookahead.strstart & lookahead.w_mask] = tmp3;
|
|
lookahead.head[lookahead.ins_h] = lookahead.strstart;
|
|
num = tmp3;
|
|
}
|
|
let tmp4 = 0 !== num && lookahead.strstart - num <= lookahead.w_size - 262;
|
|
if (tmp4) {
|
|
let tmp5 = longest_match;
|
|
lookahead.match_length = longest_match(lookahead, num);
|
|
}
|
|
if (lookahead.match_length >= 3) {
|
|
let tmp9 = require;
|
|
let tmp10 = dependencyMap;
|
|
let obj2 = require(12640) /* zero */;
|
|
let _tr_tallyResult = obj2._tr_tally(lookahead, lookahead.strstart - lookahead.match_start, lookahead.match_length - 3);
|
|
lookahead.lookahead = lookahead.lookahead - lookahead.match_length;
|
|
if (lookahead.match_length <= lookahead.max_lazy_match) {
|
|
if (lookahead.lookahead >= 3) {
|
|
lookahead.match_length = lookahead.match_length - 1;
|
|
do {
|
|
lookahead.strstart = lookahead.strstart + 1;
|
|
lookahead.ins_h = (lookahead.ins_h << lookahead.hash_shift ^ lookahead.window[lookahead.strstart + 3 - 1]) & lookahead.hash_mask;
|
|
lookahead.prev[lookahead.strstart & lookahead.w_mask] = lookahead.head[lookahead.ins_h];
|
|
lookahead.head[lookahead.ins_h] = lookahead.strstart;
|
|
diff = lookahead.match_length - 1;
|
|
lookahead.match_length = diff;
|
|
} while (0 != diff);
|
|
lookahead.strstart = lookahead.strstart + 1;
|
|
let _tr_tallyResult1 = _tr_tallyResult;
|
|
}
|
|
}
|
|
lookahead.strstart = lookahead.strstart + lookahead.match_length;
|
|
lookahead.match_length = 0;
|
|
lookahead.ins_h = lookahead.window[lookahead.strstart];
|
|
lookahead.ins_h = (lookahead.ins_h << lookahead.hash_shift ^ lookahead.window[lookahead.strstart + 1]) & lookahead.hash_mask;
|
|
_tr_tallyResult1 = _tr_tallyResult;
|
|
} else {
|
|
let tmp6 = require;
|
|
let tmp7 = dependencyMap;
|
|
let obj = require(12640) /* zero */;
|
|
_tr_tallyResult1 = obj._tr_tally(lookahead, 0, lookahead.window[lookahead.strstart]);
|
|
lookahead.lookahead = lookahead.lookahead - 1;
|
|
lookahead.strstart = lookahead.strstart + 1;
|
|
}
|
|
if (!_tr_tallyResult1) {
|
|
continue;
|
|
} else {
|
|
let tmp13 = flush_block_only;
|
|
let tmp14 = flush_block_only(lookahead, false);
|
|
if (0 !== lookahead.strm.avail_out) {
|
|
continue;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
return 1;
|
|
}
|
|
function deflate_slow(lookahead) {
|
|
while (true) {
|
|
if (lookahead.lookahead < 262) {
|
|
let tmp = fill_window;
|
|
let tmp2 = fill_window(lookahead);
|
|
if (lookahead.lookahead < 262) {
|
|
if (0 === arg1) {
|
|
break;
|
|
}
|
|
}
|
|
if (0 === lookahead.lookahead) {
|
|
if (lookahead.match_available) {
|
|
let tmp26 = require;
|
|
let tmp27 = dependencyMap;
|
|
let obj3 = require(12640) /* zero */;
|
|
let _tr_tallyResult = obj3._tr_tally(lookahead, 0, lookahead.window[lookahead.strstart - 1]);
|
|
lookahead.match_available = 0;
|
|
}
|
|
let num2 = 2;
|
|
if (lookahead.strstart < 2) {
|
|
num2 = lookahead.strstart;
|
|
}
|
|
lookahead.insert = num2;
|
|
let num3 = 4;
|
|
if (4 === arg1) {
|
|
let tmp31 = flush_block_only;
|
|
let flag = true;
|
|
let tmp32 = flush_block_only(lookahead, true);
|
|
if (0 === lookahead.strm.avail_out) {
|
|
num3 = 3;
|
|
}
|
|
let num4 = num3;
|
|
} else {
|
|
num4 = 2;
|
|
if (lookahead.last_lit) {
|
|
let tmp29 = flush_block_only;
|
|
let tmp30 = flush_block_only(lookahead, false);
|
|
num4 = 2;
|
|
if (0 === lookahead.strm.avail_out) {
|
|
num4 = 1;
|
|
}
|
|
}
|
|
}
|
|
return num4;
|
|
}
|
|
}
|
|
let num = 0;
|
|
if (lookahead.lookahead >= 3) {
|
|
lookahead.ins_h = (lookahead.ins_h << lookahead.hash_shift ^ lookahead.window[lookahead.strstart + 3 - 1]) & lookahead.hash_mask;
|
|
let tmp3 = lookahead.head[lookahead.ins_h];
|
|
lookahead.prev[lookahead.strstart & lookahead.w_mask] = tmp3;
|
|
lookahead.head[lookahead.ins_h] = lookahead.strstart;
|
|
num = tmp3;
|
|
}
|
|
({ match_length: lookahead.prev_length, match_start: lookahead.prev_match } = lookahead);
|
|
lookahead.match_length = 2;
|
|
let tmp4 = 0 !== num && lookahead.prev_length < lookahead.max_lazy_match && lookahead.strstart - num <= lookahead.w_size - 262;
|
|
if (tmp4) {
|
|
let tmp5 = longest_match;
|
|
lookahead.match_length = longest_match(lookahead, num);
|
|
let tmp6 = lookahead.match_length <= 5;
|
|
if (tmp6) {
|
|
let tmp7 = 1 === lookahead.strategy;
|
|
if (!tmp7) {
|
|
let tmp8 = 3 === lookahead.match_length && lookahead.strstart - lookahead.match_start > 4096;
|
|
tmp7 = tmp8;
|
|
}
|
|
tmp6 = tmp7;
|
|
}
|
|
if (tmp6) {
|
|
lookahead.match_length = 2;
|
|
}
|
|
}
|
|
if (lookahead.prev_length >= 3) {
|
|
if (lookahead.match_length <= lookahead.prev_length) {
|
|
let diff = lookahead.strstart + lookahead.lookahead - 3;
|
|
let tmp16 = require;
|
|
let tmp17 = dependencyMap;
|
|
let obj2 = require(12640) /* zero */;
|
|
let _tr_tallyResult1 = obj2._tr_tally(lookahead, lookahead.strstart - 1 - lookahead.prev_match, lookahead.prev_length - 3);
|
|
lookahead.lookahead = lookahead.lookahead - (lookahead.prev_length - 1);
|
|
lookahead.prev_length = lookahead.prev_length - 2;
|
|
let tmp19 = num;
|
|
do {
|
|
let sum = lookahead.strstart + 1;
|
|
lookahead.strstart = sum;
|
|
if (sum <= diff) {
|
|
lookahead.ins_h = (lookahead.ins_h << lookahead.hash_shift ^ lookahead.window[lookahead.strstart + 3 - 1]) & lookahead.hash_mask;
|
|
let tmp33 = lookahead.head[lookahead.ins_h];
|
|
lookahead.prev[lookahead.strstart & lookahead.w_mask] = tmp33;
|
|
lookahead.head[lookahead.ins_h] = lookahead.strstart;
|
|
let tmp34 = tmp33;
|
|
}
|
|
diff1 = lookahead.prev_length - 1;
|
|
lookahead.prev_length = diff1;
|
|
} while (0 != diff1);
|
|
lookahead.match_available = 0;
|
|
lookahead.match_length = 2;
|
|
lookahead.strstart = lookahead.strstart + 1;
|
|
let tmp35 = diff;
|
|
let tmp36 = _tr_tallyResult1;
|
|
if (!_tr_tallyResult1) {
|
|
continue;
|
|
} else {
|
|
let tmp22 = flush_block_only;
|
|
let tmp23 = flush_block_only(lookahead, false);
|
|
let tmp24 = _tr_tallyResult1;
|
|
let tmp25 = diff;
|
|
if (0 !== lookahead.strm.avail_out) {
|
|
continue;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if (lookahead.match_available) {
|
|
let tmp9 = require;
|
|
let tmp10 = dependencyMap;
|
|
let obj = require(12640) /* zero */;
|
|
let _tr_tallyResult2 = obj._tr_tally(lookahead, 0, lookahead.window[lookahead.strstart - 1]);
|
|
if (_tr_tallyResult2) {
|
|
let tmp12 = flush_block_only;
|
|
let tmp13 = flush_block_only(lookahead, false);
|
|
}
|
|
lookahead.strstart = lookahead.strstart + 1;
|
|
lookahead.lookahead = lookahead.lookahead - 1;
|
|
let tmp14 = _tr_tallyResult2;
|
|
if (0 !== lookahead.strm.avail_out) {
|
|
continue;
|
|
} else {
|
|
return 1;
|
|
}
|
|
} else {
|
|
lookahead.match_available = 1;
|
|
lookahead.strstart = lookahead.strstart + 1;
|
|
lookahead.lookahead = lookahead.lookahead - 1;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
return 1;
|
|
}
|
|
class Config {
|
|
constructor(arg0, arg1, arg2, arg3, arg4) {
|
|
this.good_length = arg0;
|
|
this.max_lazy = arg1;
|
|
this.nice_length = arg2;
|
|
this.max_chain = arg3;
|
|
this.func = arg4;
|
|
return;
|
|
}
|
|
}
|
|
function DeflateState() {
|
|
this.strm = null;
|
|
this.status = 0;
|
|
this.pending_buf = null;
|
|
this.pending_buf_size = 0;
|
|
this.pending_out = 0;
|
|
this.pending = 0;
|
|
this.wrap = 0;
|
|
this.gzhead = null;
|
|
this.gzindex = 0;
|
|
this.method = 8;
|
|
this.last_flush = -1;
|
|
this.w_size = 0;
|
|
this.w_bits = 0;
|
|
this.w_mask = 0;
|
|
this.window = null;
|
|
this.window_size = 0;
|
|
this.prev = null;
|
|
this.head = null;
|
|
this.ins_h = 0;
|
|
this.hash_size = 0;
|
|
this.hash_bits = 0;
|
|
this.hash_mask = 0;
|
|
this.hash_shift = 0;
|
|
this.block_start = 0;
|
|
this.match_length = 0;
|
|
this.prev_match = 0;
|
|
this.match_available = 0;
|
|
this.strstart = 0;
|
|
this.match_start = 0;
|
|
this.lookahead = 0;
|
|
this.prev_length = 0;
|
|
this.max_chain_length = 0;
|
|
this.max_lazy_match = 0;
|
|
this.level = 0;
|
|
this.strategy = 0;
|
|
this.good_match = 0;
|
|
this.nice_match = 0;
|
|
const buf16 = new require(12635) /* _has */.Buf16(1146);
|
|
this.dyn_ltree = buf16;
|
|
const buf161 = new require(12635) /* _has */.Buf16(122);
|
|
this.dyn_dtree = buf161;
|
|
const buf162 = new require(12635) /* _has */.Buf16(78);
|
|
this.bl_tree = buf162;
|
|
zero(this.dyn_ltree);
|
|
zero(this.dyn_dtree);
|
|
zero(this.bl_tree);
|
|
this.l_desc = null;
|
|
this.d_desc = null;
|
|
this.bl_desc = null;
|
|
const buf163 = new require(12635) /* _has */.Buf16(16);
|
|
this.bl_count = buf163;
|
|
const buf164 = new require(12635) /* _has */.Buf16(573);
|
|
this.heap = buf164;
|
|
zero(this.heap);
|
|
this.heap_len = 0;
|
|
this.heap_max = 0;
|
|
const buf165 = new require(12635) /* _has */.Buf16(573);
|
|
this.depth = buf165;
|
|
zero(this.depth);
|
|
this.l_buf = 0;
|
|
this.lit_bufsize = 0;
|
|
this.last_lit = 0;
|
|
this.d_buf = 0;
|
|
this.opt_len = 0;
|
|
this.static_len = 0;
|
|
this.matches = 0;
|
|
this.insert = 0;
|
|
this.bi_buf = 0;
|
|
this.bi_valid = 0;
|
|
}
|
|
function deflateResetKeep(state) {
|
|
if (state) {
|
|
if (state.state) {
|
|
state.total_out = 0;
|
|
state.total_in = 0;
|
|
state.data_type = 2;
|
|
state = state.state;
|
|
state.pending = 0;
|
|
state.pending_out = 0;
|
|
if (state.wrap < 0) {
|
|
state.wrap = -state.wrap;
|
|
}
|
|
let num4 = 42;
|
|
if (!state.wrap) {
|
|
num4 = 113;
|
|
}
|
|
state.status = num4;
|
|
let num5 = 1;
|
|
if (2 === state.wrap) {
|
|
num5 = 0;
|
|
}
|
|
state.adler = num5;
|
|
state.last_flush = 0;
|
|
require(12640) /* zero */._tr_init(state);
|
|
let num = 0;
|
|
const obj = require(12640) /* zero */;
|
|
}
|
|
return num;
|
|
}
|
|
num = -2;
|
|
err(state, -2);
|
|
}
|
|
function deflateReset(state) {
|
|
const tmp = deflateResetKeep(state);
|
|
if (0 === tmp) {
|
|
state = state.state;
|
|
state.window_size = 2 * state.w_size;
|
|
zero(state.head);
|
|
state.max_lazy_match = items[state.level].max_lazy;
|
|
state.good_match = items[state.level].good_length;
|
|
state.nice_match = items[state.level].nice_length;
|
|
state.max_chain_length = items[state.level].max_chain;
|
|
state.strstart = 0;
|
|
state.block_start = 0;
|
|
state.lookahead = 0;
|
|
state.insert = 0;
|
|
state.prev_length = 2;
|
|
state.match_length = 2;
|
|
state.match_available = 0;
|
|
state.ins_h = 0;
|
|
}
|
|
return tmp;
|
|
}
|
|
function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
|
|
let num = level;
|
|
if (strm) {
|
|
if (-1 === num) {
|
|
num = 6;
|
|
}
|
|
if (windowBits < 0) {
|
|
let num7 = -windowBits;
|
|
let num6 = 0;
|
|
} else {
|
|
num6 = 1;
|
|
num7 = windowBits;
|
|
if (windowBits > 15) {
|
|
num7 = windowBits - 16;
|
|
num6 = 2;
|
|
}
|
|
}
|
|
if (memLevel >= 1) {
|
|
if (memLevel <= 9) {
|
|
if (8 === method) {
|
|
if (num7 >= 8) {
|
|
if (num7 <= 15) {
|
|
if (num >= 0) {
|
|
if (num <= 9) {
|
|
if (strategy >= 0) {
|
|
if (strategy <= 4) {
|
|
if (8 === num7) {
|
|
num7 = 9;
|
|
}
|
|
const prototype = DeflateState.prototype;
|
|
const tmp4 = new DeflateState();
|
|
strm.state = tmp4;
|
|
tmp4.strm = strm;
|
|
tmp4.wrap = num6;
|
|
tmp4.gzhead = null;
|
|
tmp4.w_bits = num7;
|
|
tmp4.w_size = 1 << tmp4.w_bits;
|
|
tmp4.w_mask = tmp4.w_size - 1;
|
|
tmp4.hash_bits = memLevel + 7;
|
|
tmp4.hash_size = 1 << tmp4.hash_bits;
|
|
tmp4.hash_mask = tmp4.hash_size - 1;
|
|
tmp4.hash_shift = ~~(tmp4.hash_bits + 3 - 1) / 3;
|
|
const Buf8 = require(12635) /* _has */.Buf8;
|
|
const prototype2 = Buf8.prototype;
|
|
const buf8 = new Buf8(2 * tmp4.w_size);
|
|
tmp4.window = buf8;
|
|
const Buf16 = require(12635) /* _has */.Buf16;
|
|
const prototype3 = Buf16.prototype;
|
|
const buf16 = new Buf16(tmp4.hash_size);
|
|
tmp4.head = buf16;
|
|
const Buf162 = require(12635) /* _has */.Buf16;
|
|
const prototype4 = Buf162.prototype;
|
|
const buf162 = new Buf162(tmp4.w_size);
|
|
tmp4.prev = buf162;
|
|
tmp4.lit_bufsize = 1 << memLevel + 6;
|
|
tmp4.pending_buf_size = 4 * tmp4.lit_bufsize;
|
|
const Buf82 = require(12635) /* _has */.Buf8;
|
|
const prototype5 = Buf82.prototype;
|
|
const buf82 = new Buf82(tmp4.pending_buf_size);
|
|
tmp4.pending_buf = buf82;
|
|
tmp4.d_buf = tmp4.lit_bufsize;
|
|
tmp4.l_buf = 3 * tmp4.lit_bufsize;
|
|
tmp4.level = num;
|
|
tmp4.strategy = strategy;
|
|
tmp4.method = method;
|
|
return deflateReset(strm);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
err(strm, -2);
|
|
return -2;
|
|
} else {
|
|
return -2;
|
|
}
|
|
}
|
|
const config = new Config(0, 0, 0, 0, function deflate_stored(pending_buf_size) {
|
|
let num = 65535;
|
|
if (65535 > pending_buf_size.pending_buf_size - 5) {
|
|
num = pending_buf_size.pending_buf_size - 5;
|
|
}
|
|
while (true) {
|
|
let tmp = num;
|
|
if (pending_buf_size.lookahead <= 1) {
|
|
let tmp2 = fill_window;
|
|
let tmp3 = fill_window(pending_buf_size);
|
|
if (0 === pending_buf_size.lookahead) {
|
|
if (0 === arg1) {
|
|
break;
|
|
}
|
|
}
|
|
if (0 === pending_buf_size.lookahead) {
|
|
pending_buf_size.insert = 0;
|
|
let num2 = 4;
|
|
if (4 === arg1) {
|
|
let tmp9 = flush_block_only;
|
|
let flag = true;
|
|
let tmp10 = flush_block_only(pending_buf_size, true);
|
|
if (0 === pending_buf_size.strm.avail_out) {
|
|
num2 = 3;
|
|
}
|
|
let num3 = num2;
|
|
} else {
|
|
num3 = 1;
|
|
if (pending_buf_size.strstart > pending_buf_size.block_start) {
|
|
let tmp7 = flush_block_only;
|
|
let tmp8 = flush_block_only(pending_buf_size, false);
|
|
let avail_out = pending_buf_size.strm.avail_out;
|
|
num3 = 1;
|
|
}
|
|
}
|
|
return num3;
|
|
}
|
|
}
|
|
pending_buf_size.strstart = pending_buf_size.strstart + pending_buf_size.lookahead;
|
|
pending_buf_size.lookahead = 0;
|
|
let sum = pending_buf_size.block_start + num;
|
|
if (0 === pending_buf_size.strstart) {
|
|
pending_buf_size.lookahead = pending_buf_size.strstart - sum;
|
|
pending_buf_size.strstart = sum;
|
|
let tmp5 = flush_block_only;
|
|
let tmp6 = flush_block_only(pending_buf_size, false);
|
|
if (0 === pending_buf_size.strm.avail_out) {
|
|
return 1;
|
|
}
|
|
}
|
|
if (pending_buf_size.strstart - pending_buf_size.block_start < pending_buf_size.w_size - 262) {
|
|
continue;
|
|
} else {
|
|
let tmp11 = flush_block_only;
|
|
let tmp12 = flush_block_only(pending_buf_size, false);
|
|
num = tmp;
|
|
if (0 !== pending_buf_size.strm.avail_out) {
|
|
continue;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
return 1;
|
|
});
|
|
const items = [config, , , , , , , , , ];
|
|
const config1 = new Config(4, 4, 8, 4, deflate_fast);
|
|
items[1] = config1;
|
|
const config2 = new Config(4, 5, 16, 8, deflate_fast);
|
|
items[2] = config2;
|
|
const config3 = new Config(4, 6, 32, 32, deflate_fast);
|
|
items[3] = config3;
|
|
const config4 = new Config(4, 4, 16, 16, deflate_slow);
|
|
items[4] = config4;
|
|
const config5 = new Config(8, 16, 32, 32, deflate_slow);
|
|
items[5] = config5;
|
|
const config6 = new Config(8, 16, 128, 128, deflate_slow);
|
|
items[6] = config6;
|
|
const config7 = new Config(8, 32, 128, 256, deflate_slow);
|
|
items[7] = config7;
|
|
const config8 = new Config(32, 128, 258, 1024, deflate_slow);
|
|
items[8] = config8;
|
|
const config9 = new Config(32, 258, 258, 4096, deflate_slow);
|
|
items[9] = config9;
|
|
arg5.deflateInit = function deflateInit(strm, level) {
|
|
return deflateInit2(strm, level, 8, 15, 8, 0);
|
|
};
|
|
arg5.deflateInit2 = deflateInit2;
|
|
arg5.deflateReset = deflateReset;
|
|
arg5.deflateResetKeep = deflateResetKeep;
|
|
arg5.deflateSetHeader = function deflateSetHeader(strm, header) {
|
|
let num = -2;
|
|
let num2 = -2;
|
|
if (strm) {
|
|
num2 = num;
|
|
if (strm.state) {
|
|
if (2 === strm.state.wrap) {
|
|
strm.state.gzhead = header;
|
|
num = 0;
|
|
}
|
|
num2 = num;
|
|
}
|
|
}
|
|
return num2;
|
|
};
|
|
arg5.deflate = function deflate(state, last_flush) {
|
|
if (state) {
|
|
if (state.state) {
|
|
if (last_flush <= 5) {
|
|
if (last_flush >= 0) {
|
|
state = state.state;
|
|
if (state.output) {
|
|
if (state.input) {
|
|
state.strm = state;
|
|
state.last_flush = last_flush;
|
|
if (42 === state.status) {
|
|
if (2 === state.wrap) {
|
|
state.adler = 0;
|
|
put_byte(state, 31);
|
|
put_byte(state, 139);
|
|
put_byte(state, 8);
|
|
if (state.gzhead) {
|
|
let num25 = 0;
|
|
if (state.gzhead.text) {
|
|
num25 = 1;
|
|
}
|
|
let num26 = 0;
|
|
if (state.gzhead.hcrc) {
|
|
num26 = 2;
|
|
}
|
|
let num27 = 0;
|
|
if (state.gzhead.extra) {
|
|
num27 = 4;
|
|
}
|
|
let num28 = 0;
|
|
if (state.gzhead.name) {
|
|
num28 = 8;
|
|
}
|
|
let num29 = 0;
|
|
if (state.gzhead.comment) {
|
|
num29 = 16;
|
|
}
|
|
tmp12(state, num25 + num26 + num27 + num28 + num29);
|
|
put_byte(state, 255 & state.gzhead.time);
|
|
put_byte(state, state.gzhead.time >> 8 & 255);
|
|
put_byte(state, state.gzhead.time >> 16 & 255);
|
|
put_byte(state, state.gzhead.time >> 24 & 255);
|
|
let num34 = 2;
|
|
if (9 !== state.level) {
|
|
if (state.strategy >= 2) {
|
|
let num35 = 4;
|
|
} else {
|
|
num35 = 0;
|
|
}
|
|
num34 = num35;
|
|
}
|
|
put_byte(state, num34);
|
|
put_byte(state, 255 & state.gzhead.os);
|
|
if (tmp30) {
|
|
put_byte(state, 255 & state.gzhead.extra.length);
|
|
put_byte(state, state.gzhead.extra.length >> 8 & 255);
|
|
}
|
|
if (state.gzhead.hcrc) {
|
|
state.adler = require(12642)(state.adler, state.pending_buf, state.pending, 0);
|
|
}
|
|
state.gzindex = 0;
|
|
state.status = 69;
|
|
const tmp22 = put_byte;
|
|
tmp30 = state.gzhead.extra && state.gzhead.extra.length;
|
|
} else {
|
|
tmp12(state, 0);
|
|
tmp12(state, 0);
|
|
tmp12(state, 0);
|
|
tmp12(state, 0);
|
|
tmp12(state, 0);
|
|
let num21 = 2;
|
|
if (9 !== state.level) {
|
|
if (state.strategy >= 2) {
|
|
let num22 = 4;
|
|
} else {
|
|
num22 = 0;
|
|
}
|
|
num21 = num22;
|
|
}
|
|
tmp12(state, num21);
|
|
put_byte(state, 3);
|
|
state.status = 113;
|
|
}
|
|
} else {
|
|
let num5 = 0;
|
|
let diff = state.w_bits - 8;
|
|
if (state.strategy < 2) {
|
|
num5 = 0;
|
|
if (state.level >= 2) {
|
|
let num7 = 1;
|
|
if (state.level >= 6) {
|
|
let num8 = 3;
|
|
if (6 === state.level) {
|
|
num8 = 2;
|
|
}
|
|
num7 = num8;
|
|
}
|
|
num5 = num7;
|
|
}
|
|
}
|
|
diff = 8 + (diff << 4) << 8 | num5 << 6;
|
|
let tmp2 = diff;
|
|
if (0 !== state.strstart) {
|
|
tmp2 = diff | 32;
|
|
}
|
|
state.status = 113;
|
|
putShortMSB(state, tmp2 + (31 - tmp2 % 31));
|
|
if (0 !== state.strstart) {
|
|
putShortMSB(state, state.adler >>> 16);
|
|
putShortMSB(state, 65535 & state.adler);
|
|
}
|
|
state.adler = 1;
|
|
}
|
|
}
|
|
if (69 === state.status) {
|
|
if (state.gzhead.extra) {
|
|
const pending = state.pending;
|
|
let pending2 = pending;
|
|
if (state.gzindex < (65535 & state.gzhead.extra.length)) {
|
|
if (state.pending !== state.pending_buf_size) {
|
|
put_byte(state, 255 & state.gzhead.extra[state.gzindex]);
|
|
state.gzindex = state.gzindex + 1;
|
|
pending2 = tmp42;
|
|
while (state.gzindex < (65535 & state.gzhead.extra.length)) {
|
|
if (state.pending !== state.pending_buf_size) {
|
|
continue;
|
|
} else {
|
|
let tmp46 = state.gzhead.hcrc && state.pending > tmp45;
|
|
if (tmp46) {
|
|
let tmp47 = require;
|
|
let tmp48 = dependencyMap;
|
|
let num44 = 4;
|
|
let tmp49 = tmp45;
|
|
state.adler = require(12642)(state.adler, state.pending_buf, state.pending - tmp45, tmp45);
|
|
}
|
|
let tmp50 = flush_pending;
|
|
let tmp51 = flush_pending(state);
|
|
pending2 = state.pending;
|
|
if (state.pending === state.pending_buf_size) {
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
} else {
|
|
if (tmp36) {
|
|
state.adler = require(12642)(state.adler, state.pending_buf, state.pending - pending, pending);
|
|
}
|
|
flush_pending(state);
|
|
pending2 = state.pending;
|
|
tmp36 = state.gzhead.hcrc && state.pending > pending;
|
|
}
|
|
}
|
|
if (tmp52) {
|
|
state.adler = require(12642)(state.adler, state.pending_buf, state.pending - pending2, pending2);
|
|
}
|
|
if (state.gzindex === state.gzhead.extra.length) {
|
|
state.gzindex = 0;
|
|
state.status = 73;
|
|
}
|
|
tmp52 = state.gzhead.hcrc && state.pending > pending2;
|
|
} else {
|
|
state.status = 73;
|
|
}
|
|
}
|
|
if (73 === state.status) {
|
|
if (state.gzhead.name) {
|
|
let pending3 = state.pending;
|
|
while (true) {
|
|
let tmp56 = pending3;
|
|
if (state.pending !== state.pending_buf_size) {
|
|
let num53 = 0;
|
|
if (state.gzindex < state.gzhead.name.length) {
|
|
let name = state.gzhead.name;
|
|
let tmp63 = +state.gzindex;
|
|
state.gzindex = tmp63 + 1;
|
|
num53 = 255 & name.charCodeAt(tmp63);
|
|
}
|
|
let tmp64 = put_byte;
|
|
let tmp65 = put_byte(state, num53);
|
|
let num52 = num53;
|
|
pending3 = tmp56;
|
|
let pending4 = tmp56;
|
|
if (0 === num53) {
|
|
break;
|
|
}
|
|
} else {
|
|
let tmp57 = state.gzhead.hcrc && state.pending > pending3;
|
|
if (tmp57) {
|
|
let tmp58 = require;
|
|
let tmp59 = dependencyMap;
|
|
let tmp60 = pending3;
|
|
state.adler = require(12642)(state.adler, state.pending_buf, state.pending - pending3, pending3);
|
|
}
|
|
let tmp61 = flush_pending;
|
|
let tmp62 = flush_pending(state);
|
|
pending4 = state.pending;
|
|
num52 = 1;
|
|
if (state.pending === state.pending_buf_size) {
|
|
break;
|
|
}
|
|
}
|
|
let tmp66 = state.gzhead.hcrc && state.pending > pending4;
|
|
if (tmp66) {
|
|
let tmp67 = require;
|
|
let tmp68 = dependencyMap;
|
|
let tmp69 = pending4;
|
|
state.adler = require(12642)(state.adler, state.pending_buf, state.pending - pending4, pending4);
|
|
}
|
|
if (0 === num52) {
|
|
state.gzindex = 0;
|
|
let num54 = 91;
|
|
state.status = 91;
|
|
}
|
|
}
|
|
} else {
|
|
state.status = 91;
|
|
}
|
|
}
|
|
if (91 === state.status) {
|
|
if (state.gzhead.comment) {
|
|
let pending5 = state.pending;
|
|
while (true) {
|
|
let tmp70 = pending5;
|
|
if (state.pending !== state.pending_buf_size) {
|
|
let num61 = 0;
|
|
if (state.gzindex < state.gzhead.comment.length) {
|
|
let comment = state.gzhead.comment;
|
|
let tmp77 = +state.gzindex;
|
|
state.gzindex = tmp77 + 1;
|
|
num61 = 255 & comment.charCodeAt(tmp77);
|
|
}
|
|
let tmp78 = put_byte;
|
|
let tmp79 = put_byte(state, num61);
|
|
let num60 = num61;
|
|
pending5 = tmp70;
|
|
let pending6 = tmp70;
|
|
if (0 === num61) {
|
|
break;
|
|
}
|
|
} else {
|
|
let tmp71 = state.gzhead.hcrc && state.pending > pending5;
|
|
if (tmp71) {
|
|
let tmp72 = require;
|
|
let tmp73 = dependencyMap;
|
|
let tmp74 = pending5;
|
|
state.adler = require(12642)(state.adler, state.pending_buf, state.pending - pending5, pending5);
|
|
}
|
|
let tmp75 = flush_pending;
|
|
let tmp76 = flush_pending(state);
|
|
pending6 = state.pending;
|
|
num60 = 1;
|
|
if (state.pending === state.pending_buf_size) {
|
|
break;
|
|
}
|
|
}
|
|
let tmp80 = state.gzhead.hcrc && state.pending > pending6;
|
|
if (tmp80) {
|
|
let tmp81 = require;
|
|
let tmp82 = dependencyMap;
|
|
let tmp83 = pending6;
|
|
state.adler = require(12642)(state.adler, state.pending_buf, state.pending - pending6, pending6);
|
|
}
|
|
if (0 === num60) {
|
|
let num62 = 103;
|
|
state.status = 103;
|
|
}
|
|
}
|
|
} else {
|
|
state.status = 103;
|
|
}
|
|
}
|
|
if (state.status === 103) {
|
|
if (state.gzhead.hcrc) {
|
|
if (state.pending + 2 > state.pending_buf_size) {
|
|
flush_pending(state);
|
|
}
|
|
if (state.pending + 2 <= state.pending_buf_size) {
|
|
put_byte(state, 255 & state.adler);
|
|
put_byte(state, state.adler >> 8 & 255);
|
|
state.adler = 0;
|
|
state.status = 113;
|
|
}
|
|
} else {
|
|
state.status = 113;
|
|
}
|
|
}
|
|
if (0 !== state.pending) {
|
|
flush_pending(state);
|
|
if (0 === state.avail_out) {
|
|
state.last_flush = -1;
|
|
return 0;
|
|
}
|
|
} else if (0 === state.avail_in) {
|
|
if (tmp90 <= rank(state.last_flush)) {
|
|
if (4 !== last_flush) {
|
|
err(state, -5);
|
|
return -5;
|
|
}
|
|
}
|
|
tmp90 = rank(last_flush);
|
|
}
|
|
if (state.status === 666) {
|
|
if (0 !== state.avail_in) {
|
|
diff = err;
|
|
diff = err(state, -5);
|
|
return -5;
|
|
}
|
|
}
|
|
if (0 === state.avail_in) {
|
|
let num85 = 0;
|
|
if (4 === last_flush) {
|
|
let num93 = 1;
|
|
let num94 = 1;
|
|
if (state.wrap > 0) {
|
|
if (2 === state.wrap) {
|
|
diff = put_byte;
|
|
diff = put_byte(state, 255 & state.adler);
|
|
diff = put_byte(state, state.adler >> 8 & 255);
|
|
diff = put_byte(state, state.adler >> 16 & 255);
|
|
diff = put_byte(state, state.adler >> 24 & 255);
|
|
diff = put_byte(state, 255 & state.total_in);
|
|
diff = put_byte(state, state.total_in >> 8 & 255);
|
|
diff = put_byte(state, state.total_in >> 16 & 255);
|
|
diff = put_byte(state, state.total_in >> 24 & 255);
|
|
} else {
|
|
diff = putShortMSB;
|
|
diff = putShortMSB(state, state.adler >>> 16);
|
|
diff = putShortMSB(state, 65535 & state.adler);
|
|
}
|
|
diff = flush_pending;
|
|
diff = flush_pending(state);
|
|
if (state.wrap > 0) {
|
|
state.wrap = -state.wrap;
|
|
}
|
|
if (0 !== state.pending) {
|
|
num93 = 0;
|
|
}
|
|
num94 = num93;
|
|
}
|
|
num85 = num94;
|
|
}
|
|
return num85;
|
|
}
|
|
if (2 === state.strategy) {
|
|
while (true) {
|
|
if (0 === state.lookahead) {
|
|
diff = fill_window;
|
|
diff = fill_window(state);
|
|
if (0 === state.lookahead) {
|
|
break;
|
|
}
|
|
}
|
|
state.match_length = 0;
|
|
diff = require;
|
|
diff = dependencyMap;
|
|
let obj4 = require(12640) /* zero */;
|
|
state.lookahead = state.lookahead - 1;
|
|
state.strstart = state.strstart + 1;
|
|
if (!obj4._tr_tally(state, 0, state.window[state.strstart])) {
|
|
continue;
|
|
} else {
|
|
diff = flush_block_only;
|
|
diff = flush_block_only(state, false);
|
|
let num77 = 1;
|
|
}
|
|
let funcResult = num77;
|
|
}
|
|
num77 = 1;
|
|
if (0 !== last_flush) {
|
|
state.insert = 0;
|
|
let num78 = 4;
|
|
if (4 === last_flush) {
|
|
diff = flush_block_only;
|
|
diff = flush_block_only(state, true);
|
|
if (0 === state.strm.avail_out) {
|
|
num78 = 3;
|
|
}
|
|
let num79 = num78;
|
|
} else {
|
|
num79 = 2;
|
|
if (state.last_lit) {
|
|
diff = flush_block_only;
|
|
diff = flush_block_only(state, false);
|
|
num79 = 2;
|
|
if (0 === state.strm.avail_out) {
|
|
num79 = 1;
|
|
}
|
|
}
|
|
}
|
|
diff = num79;
|
|
}
|
|
} else if (3 === state.strategy) {
|
|
const _window = state.window;
|
|
while (true) {
|
|
if (state.lookahead <= 258) {
|
|
diff = fill_window;
|
|
diff = fill_window(state);
|
|
if (state.lookahead > 258) {
|
|
if (0 === state.lookahead) {
|
|
state.insert = 0;
|
|
let num75 = 4;
|
|
if (4 === last_flush) {
|
|
diff = flush_block_only;
|
|
let flag2 = true;
|
|
diff = flush_block_only(state, true);
|
|
if (0 === state.strm.avail_out) {
|
|
num75 = 3;
|
|
}
|
|
let num76 = num75;
|
|
} else {
|
|
num76 = 2;
|
|
if (state.last_lit) {
|
|
diff = flush_block_only;
|
|
diff = flush_block_only(state, false);
|
|
num76 = 2;
|
|
if (0 === state.strm.avail_out) {
|
|
num76 = 1;
|
|
}
|
|
}
|
|
}
|
|
diff = num76;
|
|
}
|
|
} else {
|
|
let num74 = 1;
|
|
if (0 === last_flush) {
|
|
break;
|
|
}
|
|
}
|
|
funcResult = num74;
|
|
}
|
|
state.match_length = 0;
|
|
diff = tmp97;
|
|
diff = tmp98;
|
|
diff = tmp99;
|
|
if (state.lookahead >= 3) {
|
|
diff = tmp97;
|
|
diff = tmp98;
|
|
diff = tmp99;
|
|
if (state.strstart > 0) {
|
|
diff = state.strstart - 1;
|
|
diff = _window[diff];
|
|
diff = diff + 1;
|
|
diff = tmp99;
|
|
if (diff === _window[diff]) {
|
|
diff = diff + 1;
|
|
diff = tmp99;
|
|
if (diff === _window[diff]) {
|
|
diff = diff + 1;
|
|
diff = tmp99;
|
|
if (diff === _window[diff]) {
|
|
diff = state.strstart + 258;
|
|
diff = diff + 1;
|
|
while (diff === _window[diff]) {
|
|
diff = diff + 1;
|
|
if (diff !== _window[diff]) {
|
|
break;
|
|
} else {
|
|
diff = diff + 1;
|
|
if (diff !== _window[diff]) {
|
|
break;
|
|
} else {
|
|
diff = diff + 1;
|
|
if (diff !== _window[diff]) {
|
|
break;
|
|
} else {
|
|
diff = diff + 1;
|
|
if (diff !== _window[diff]) {
|
|
break;
|
|
} else {
|
|
diff = diff + 1;
|
|
if (diff !== _window[diff]) {
|
|
break;
|
|
} else {
|
|
diff = diff + 1;
|
|
if (diff !== _window[diff]) {
|
|
break;
|
|
} else {
|
|
diff = diff + 1;
|
|
if (diff !== _window[diff]) {
|
|
break;
|
|
} else if (diff >= diff) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
state.match_length = 258 - (diff - diff);
|
|
if (state.match_length > state.lookahead) {
|
|
state.match_length = state.lookahead;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (state.match_length >= 3) {
|
|
diff = require;
|
|
diff = dependencyMap;
|
|
let obj3 = require(12640) /* zero */;
|
|
diff = obj3._tr_tally(state, 1, state.match_length - 3);
|
|
state.lookahead = state.lookahead - state.match_length;
|
|
state.strstart = state.strstart + state.match_length;
|
|
state.match_length = 0;
|
|
} else {
|
|
diff = require;
|
|
diff = dependencyMap;
|
|
let obj2 = require(12640) /* zero */;
|
|
diff = obj2._tr_tally(state, 0, state.window[state.strstart]);
|
|
state.lookahead = state.lookahead - 1;
|
|
state.strstart = state.strstart + 1;
|
|
}
|
|
tmp97 = diff;
|
|
tmp98 = diff;
|
|
tmp99 = diff;
|
|
if (!diff) {
|
|
continue;
|
|
} else {
|
|
diff = flush_block_only;
|
|
diff = flush_block_only(state, false);
|
|
tmp97 = diff;
|
|
tmp98 = diff;
|
|
tmp99 = diff;
|
|
num74 = 1;
|
|
if (0 === state.strm.avail_out) {
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
funcResult = items[state.level].func(state, last_flush);
|
|
const obj = items[state.level];
|
|
}
|
|
diff = 3 !== funcResult;
|
|
if (diff) {
|
|
diff = 4 !== funcResult;
|
|
}
|
|
if (!diff) {
|
|
state.status = 666;
|
|
}
|
|
if (1 !== funcResult) {
|
|
if (3 !== funcResult) {
|
|
if (2 === funcResult) {
|
|
if (1 === last_flush) {
|
|
diff = require;
|
|
diff = dependencyMap;
|
|
diff = require(12640) /* zero */._tr_align(state);
|
|
const obj6 = require(12640) /* zero */;
|
|
} else if (5 !== last_flush) {
|
|
diff = require;
|
|
diff = dependencyMap;
|
|
const obj5 = require(12640) /* zero */;
|
|
diff = obj5;
|
|
diff = state;
|
|
diff = obj5._tr_stored_block(state, 0, 0, false);
|
|
if (3 === last_flush) {
|
|
diff = zero;
|
|
diff = zero(state.head);
|
|
if (0 === state.lookahead) {
|
|
state.strstart = 0;
|
|
state.block_start = 0;
|
|
state.insert = 0;
|
|
}
|
|
}
|
|
}
|
|
diff = flush_pending;
|
|
diff = flush_pending(state);
|
|
if (0 === state.avail_out) {
|
|
state.last_flush = -1;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (0 === state.avail_out) {
|
|
state.last_flush = -1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
let num99 = -5;
|
|
diff = err;
|
|
if (0 !== state.avail_out) {
|
|
num99 = -2;
|
|
}
|
|
diff = diff(state, num99);
|
|
return num99;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (state) {
|
|
diff = err;
|
|
diff = err(state, -2);
|
|
}
|
|
return -2;
|
|
};
|
|
arg5.deflateEnd = function deflateEnd(state) {
|
|
let num = -2;
|
|
if (state) {
|
|
num = -2;
|
|
if (state.state) {
|
|
const status = state.state.status;
|
|
if (42 !== status) {
|
|
if (69 !== status) {
|
|
if (73 !== status) {
|
|
if (91 !== status) {
|
|
if (status !== 103) {
|
|
err(state, -2);
|
|
let num10 = -2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
state.state = null;
|
|
num10 = 0;
|
|
if (status === 113) {
|
|
err(state, -3);
|
|
num10 = -3;
|
|
}
|
|
}
|
|
}
|
|
return num;
|
|
};
|
|
arg5.deflateSetDictionary = function deflateSetDictionary(strm, dictionary) {
|
|
let avail_in;
|
|
let input;
|
|
let next_in;
|
|
if (strm) {
|
|
if (strm.state) {
|
|
const state = strm.state;
|
|
const wrap = state.wrap;
|
|
if (2 !== wrap) {
|
|
if (1 !== wrap) {
|
|
if (!state.lookahead) {
|
|
if (tmp24) {
|
|
strm.adler = require(12641) /* adler32 */(strm.adler, dictionary, length, 0);
|
|
}
|
|
state.wrap = 0;
|
|
let tmp5 = dictionary;
|
|
let w_size = length;
|
|
if (length >= state.w_size) {
|
|
if (0 === wrap) {
|
|
zero(state.head);
|
|
state.strstart = 0;
|
|
state.block_start = 0;
|
|
state.insert = 0;
|
|
}
|
|
const Buf8 = require(12635) /* _has */.Buf8;
|
|
const prototype = Buf8.prototype;
|
|
const buf8 = new Buf8(state.w_size);
|
|
const obj = require(12635) /* _has */;
|
|
obj.arraySet(buf8, dictionary, length - state.w_size, state.w_size, 0);
|
|
w_size = state.w_size;
|
|
tmp5 = buf8;
|
|
}
|
|
strm.avail_in = w_size;
|
|
strm.next_in = 0;
|
|
strm.input = tmp5;
|
|
({ avail_in, next_in, input } = strm);
|
|
fill_window(state);
|
|
if (state.lookahead >= 3) {
|
|
let strstart = state.strstart;
|
|
let diff = state.lookahead - 2;
|
|
do {
|
|
do {
|
|
state.ins_h = (state.ins_h << state.hash_shift ^ state.window[strstart + 3 - 1]) & state.hash_mask;
|
|
state.prev[strstart & state.w_mask] = state.head[state.ins_h];
|
|
state.head[state.ins_h] = strstart;
|
|
let sum = strstart + 1;
|
|
diff = diff - 1;
|
|
strstart = sum;
|
|
} while (diff);
|
|
state.strstart = sum;
|
|
state.lookahead = 2;
|
|
let tmp22 = fill_window;
|
|
let tmp23 = fill_window(state);
|
|
} while (state.lookahead >= 3);
|
|
}
|
|
state.strstart = state.strstart + state.lookahead;
|
|
({ strstart: state.block_start, lookahead: state.insert } = state);
|
|
state.lookahead = 0;
|
|
state.prev_length = 2;
|
|
state.match_length = 2;
|
|
state.match_available = 0;
|
|
strm.next_in = next_in;
|
|
strm.input = input;
|
|
strm.avail_in = avail_in;
|
|
state.wrap = wrap;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return -2;
|
|
}
|
|
}
|
|
return -2;
|
|
};
|
|
arg5.deflateInfo = "pako deflate (from Nodeca project)";
|