449 lines
15 KiB
JavaScript
449 lines
15 KiB
JavaScript
var Buffer = require("buffer").Buffer;
|
|
|
|
function JSInflater(/*Buffer*/input) {
|
|
|
|
var WSIZE = 0x8000,
|
|
slide = new Buffer(0x10000),
|
|
windowPos = 0,
|
|
fixedTableList = null,
|
|
fixedTableDist,
|
|
fixedLookup,
|
|
bitBuf = 0,
|
|
bitLen = 0,
|
|
method = -1,
|
|
eof = false,
|
|
copyLen = 0,
|
|
copyDist = 0,
|
|
tblList, tblDist, bitList, bitdist,
|
|
|
|
inputPosition = 0,
|
|
|
|
MASK_BITS = [0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff],
|
|
LENS = [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],
|
|
LEXT = [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, 99, 99],
|
|
DISTS = [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],
|
|
DEXT = [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],
|
|
BITORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
|
|
|
function HuffTable(clen, cnum, cval, blist, elist, lookupm) {
|
|
|
|
this.status = 0;
|
|
this.root = null;
|
|
this.maxbit = 0;
|
|
|
|
var el, f, tail,
|
|
offsets = [],
|
|
countTbl = [],
|
|
sTbl = [],
|
|
values = [],
|
|
tentry = {extra: 0, bitcnt: 0, lbase: 0, next: null};
|
|
|
|
tail = this.root = null;
|
|
for(var i = 0; i < 0x11; i++) { countTbl[i] = 0; sTbl[i] = 0; offsets[i] = 0; }
|
|
for(i = 0; i < 0x120; i++) values[i] = 0;
|
|
|
|
el = cnum > 256 ? clen[256] : 16;
|
|
|
|
var pidx = -1;
|
|
while (++pidx < cnum) countTbl[clen[pidx]]++;
|
|
|
|
if(countTbl[0] == cnum) return;
|
|
|
|
for(var j = 1; j <= 16; j++) if(countTbl[j] != 0) break;
|
|
var bitLen = j;
|
|
for(i = 16; i != 0; i--) if(countTbl[i] != 0) break;
|
|
var maxLen = i;
|
|
|
|
lookupm < j && (lookupm = j);
|
|
|
|
var dCodes = 1 << j;
|
|
for(; j < i; j++, dCodes <<= 1)
|
|
if((dCodes -= countTbl[j]) < 0) {
|
|
this.status = 2;
|
|
this.maxbit = lookupm;
|
|
return;
|
|
}
|
|
|
|
if((dCodes -= countTbl[i]) < 0) {
|
|
this.status = 2;
|
|
this.maxbit = lookupm;
|
|
return;
|
|
}
|
|
|
|
countTbl[i] += dCodes;
|
|
offsets[1] = j = 0;
|
|
pidx = 1;
|
|
var xp = 2;
|
|
while(--i > 0) offsets[xp++] = (j += countTbl[pidx++]);
|
|
pidx = 0;
|
|
i = 0;
|
|
do {
|
|
(j = clen[pidx++]) && (values[offsets[j]++] = i);
|
|
} while(++i < cnum);
|
|
cnum = offsets[maxLen];
|
|
offsets[0] = i = 0;
|
|
pidx = 0;
|
|
|
|
var level = -1,
|
|
w = sTbl[0] = 0,
|
|
cnode = null,
|
|
tblCnt = 0,
|
|
tblStack = [];
|
|
|
|
for(; bitLen <= maxLen; bitLen++) {
|
|
var kccnt = countTbl[bitLen];
|
|
while(kccnt-- > 0) {
|
|
while(bitLen > w + sTbl[1 + level]) {
|
|
w += sTbl[1 + level];
|
|
level++;
|
|
tblCnt = (tblCnt = maxLen - w) > lookupm ? lookupm : tblCnt;
|
|
if((f = 1 << (j = bitLen - w)) > kccnt + 1) {
|
|
f -= kccnt + 1;
|
|
xp = bitLen;
|
|
while(++j < tblCnt) {
|
|
if((f <<= 1) <= countTbl[++xp]) break;
|
|
f -= countTbl[xp];
|
|
}
|
|
}
|
|
if(w + j > el && w < el) j = el - w;
|
|
tblCnt = 1 << j;
|
|
sTbl[1 + level] = j;
|
|
cnode = [];
|
|
while (cnode.length < tblCnt) cnode.push({extra: 0, bitcnt: 0, lbase: 0, next: null});
|
|
if (tail == null) {
|
|
tail = this.root = {next:null, list:null};
|
|
} else {
|
|
tail = tail.next = {next:null, list:null}
|
|
}
|
|
tail.next = null;
|
|
tail.list = cnode;
|
|
|
|
tblStack[level] = cnode;
|
|
|
|
if(level > 0) {
|
|
offsets[level] = i;
|
|
tentry.bitcnt = sTbl[level];
|
|
tentry.extra = 16 + j;
|
|
tentry.next = cnode;
|
|
j = (i & ((1 << w) - 1)) >> (w - sTbl[level]);
|
|
|
|
tblStack[level-1][j].extra = tentry.extra;
|
|
tblStack[level-1][j].bitcnt = tentry.bitcnt;
|
|
tblStack[level-1][j].lbase = tentry.lbase;
|
|
tblStack[level-1][j].next = tentry.next;
|
|
}
|
|
}
|
|
tentry.bitcnt = bitLen - w;
|
|
if(pidx >= cnum)
|
|
tentry.extra = 99;
|
|
else if(values[pidx] < cval) {
|
|
tentry.extra = (values[pidx] < 256 ? 16 : 15);
|
|
tentry.lbase = values[pidx++];
|
|
} else {
|
|
tentry.extra = elist[values[pidx] - cval];
|
|
tentry.lbase = blist[values[pidx++] - cval];
|
|
}
|
|
|
|
f = 1 << (bitLen - w);
|
|
for(j = i >> w; j < tblCnt; j += f) {
|
|
cnode[j].extra = tentry.extra;
|
|
cnode[j].bitcnt = tentry.bitcnt;
|
|
cnode[j].lbase = tentry.lbase;
|
|
cnode[j].next = tentry.next;
|
|
}
|
|
for(j = 1 << (bitLen - 1); (i & j) != 0; j >>= 1)
|
|
i ^= j;
|
|
i ^= j;
|
|
while((i & ((1 << w) - 1)) != offsets[level]) {
|
|
w -= sTbl[level];
|
|
level--;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.maxbit = sTbl[1];
|
|
this.status = ((dCodes != 0 && maxLen != 1) ? 1 : 0);
|
|
}
|
|
|
|
function addBits(n) {
|
|
while(bitLen < n) {
|
|
bitBuf |= input[inputPosition++] << bitLen;
|
|
bitLen += 8;
|
|
}
|
|
return bitBuf;
|
|
}
|
|
|
|
function cutBits(n) {
|
|
bitLen -= n;
|
|
return bitBuf >>= n;
|
|
}
|
|
|
|
function maskBits(n) {
|
|
while(bitLen < n) {
|
|
bitBuf |= input[inputPosition++] << bitLen;
|
|
bitLen += 8;
|
|
}
|
|
var res = bitBuf & MASK_BITS[n];
|
|
bitBuf >>= n;
|
|
bitLen -= n;
|
|
return res;
|
|
}
|
|
|
|
function codes(buff, off, size) {
|
|
var e, t;
|
|
if(size == 0) return 0;
|
|
|
|
var n = 0;
|
|
for(;;) {
|
|
t = tblList.list[addBits(bitList) & MASK_BITS[bitList]];
|
|
e = t.extra;
|
|
while(e > 16) {
|
|
if(e == 99) return -1;
|
|
cutBits(t.bitcnt);
|
|
e -= 16;
|
|
t = t.next[addBits(e) & MASK_BITS[e]];
|
|
e = t.extra;
|
|
}
|
|
cutBits(t.bitcnt);
|
|
if(e == 16) {
|
|
windowPos &= WSIZE - 1;
|
|
buff[off + n++] = slide[windowPos++] = t.lbase;
|
|
if(n == size) return size;
|
|
continue;
|
|
}
|
|
if(e == 15) break;
|
|
|
|
copyLen = t.lbase + maskBits(e);
|
|
t = tblDist.list[addBits(bitdist) & MASK_BITS[bitdist]];
|
|
e = t.extra;
|
|
|
|
while(e > 16) {
|
|
if(e == 99) return -1;
|
|
cutBits(t.bitcnt);
|
|
e -= 16;
|
|
t = t.next[addBits(e) & MASK_BITS[e]];
|
|
e = t.extra
|
|
}
|
|
cutBits(t.bitcnt);
|
|
copyDist = windowPos - t.lbase - maskBits(e);
|
|
|
|
while(copyLen > 0 && n < size) {
|
|
copyLen--;
|
|
copyDist &= WSIZE - 1;
|
|
windowPos &= WSIZE - 1;
|
|
buff[off + n++] = slide[windowPos++] = slide[copyDist++];
|
|
}
|
|
|
|
if(n == size) return size;
|
|
}
|
|
|
|
method = -1; // done
|
|
return n;
|
|
}
|
|
|
|
function stored(buff, off, size) {
|
|
cutBits(bitLen & 7);
|
|
var n = maskBits(0x10);
|
|
if(n != ((~maskBits(0x10)) & 0xffff)) return -1;
|
|
copyLen = n;
|
|
|
|
n = 0;
|
|
while(copyLen > 0 && n < size) {
|
|
copyLen--;
|
|
windowPos &= WSIZE - 1;
|
|
buff[off + n++] = slide[windowPos++] = maskBits(8);
|
|
}
|
|
|
|
if(copyLen == 0) method = -1;
|
|
return n;
|
|
}
|
|
|
|
function fixed(buff, off, size) {
|
|
var fixed_bd = 0;
|
|
if(fixedTableList == null) {
|
|
var lengths = [];
|
|
|
|
for(var symbol = 0; symbol < 144; symbol++) lengths[symbol] = 8;
|
|
for(; symbol < 256; symbol++) lengths[symbol] = 9;
|
|
for(; symbol < 280; symbol++) lengths[symbol] = 7;
|
|
for(; symbol < 288; symbol++) lengths[symbol] = 8;
|
|
|
|
fixedLookup = 7;
|
|
|
|
var htbl = new HuffTable(lengths, 288, 257, LENS, LEXT, fixedLookup);
|
|
|
|
if(htbl.status != 0) return -1;
|
|
|
|
fixedTableList = htbl.root;
|
|
fixedLookup = htbl.maxbit;
|
|
|
|
for(symbol = 0; symbol < 30; symbol++) lengths[symbol] = 5;
|
|
fixed_bd = 5;
|
|
|
|
htbl = new HuffTable(lengths, 30, 0, DISTS, DEXT, fixed_bd);
|
|
if(htbl.status > 1) {
|
|
fixedTableList = null;
|
|
return -1;
|
|
}
|
|
fixedTableDist = htbl.root;
|
|
fixed_bd = htbl.maxbit;
|
|
}
|
|
|
|
tblList = fixedTableList;
|
|
tblDist = fixedTableDist;
|
|
bitList = fixedLookup;
|
|
bitdist = fixed_bd;
|
|
return codes(buff, off, size);
|
|
}
|
|
|
|
function dynamic(buff, off, size) {
|
|
var ll = new Array(0x023C);
|
|
|
|
for (var m = 0; m < 0x023C; m++) ll[m] = 0;
|
|
|
|
var llencnt = 257 + maskBits(5),
|
|
dcodescnt = 1 + maskBits(5),
|
|
bitlencnt = 4 + maskBits(4);
|
|
|
|
if(llencnt > 286 || dcodescnt > 30) return -1;
|
|
|
|
for(var j = 0; j < bitlencnt; j++) ll[BITORDER[j]] = maskBits(3);
|
|
for(; j < 19; j++) ll[BITORDER[j]] = 0;
|
|
|
|
// build decoding table for trees--single level, 7 bit lookup
|
|
bitList = 7;
|
|
var hufTable = new HuffTable(ll, 19, 19, null, null, bitList);
|
|
if(hufTable.status != 0)
|
|
return -1; // incomplete code set
|
|
|
|
tblList = hufTable.root;
|
|
bitList = hufTable.maxbit;
|
|
var lencnt = llencnt + dcodescnt,
|
|
i = 0,
|
|
lastLen = 0;
|
|
while(i < lencnt) {
|
|
var hufLcode = tblList.list[addBits(bitList) & MASK_BITS[bitList]];
|
|
j = hufLcode.bitcnt;
|
|
cutBits(j);
|
|
j = hufLcode.lbase;
|
|
if(j < 16)
|
|
ll[i++] = lastLen = j;
|
|
else if(j == 16) {
|
|
j = 3 + maskBits(2);
|
|
if(i + j > lencnt) return -1;
|
|
while(j-- > 0) ll[i++] = lastLen;
|
|
} else if(j == 17) {
|
|
j = 3 + maskBits(3);
|
|
if(i + j > lencnt) return -1;
|
|
while(j-- > 0) ll[i++] = 0;
|
|
lastLen = 0;
|
|
} else {
|
|
j = 11 + maskBits(7);
|
|
if(i + j > lencnt) return -1;
|
|
while(j-- > 0) ll[i++] = 0;
|
|
lastLen = 0;
|
|
}
|
|
}
|
|
bitList = 9;
|
|
hufTable = new HuffTable(ll, llencnt, 257, LENS, LEXT, bitList);
|
|
bitList == 0 && (hufTable.status = 1);
|
|
|
|
if (hufTable.status != 0) return -1;
|
|
|
|
tblList = hufTable.root;
|
|
bitList = hufTable.maxbit;
|
|
|
|
for(i = 0; i < dcodescnt; i++) ll[i] = ll[i + llencnt];
|
|
bitdist = 6;
|
|
hufTable = new HuffTable(ll, dcodescnt, 0, DISTS, DEXT, bitdist);
|
|
tblDist = hufTable.root;
|
|
bitdist = hufTable.maxbit;
|
|
|
|
if((bitdist == 0 && llencnt > 257) || hufTable.status != 0) return -1;
|
|
|
|
return codes(buff, off, size);
|
|
}
|
|
|
|
return {
|
|
inflate : function(/*Buffer*/outputBuffer) {
|
|
tblList = null;
|
|
|
|
var size = outputBuffer.length,
|
|
offset = 0, i;
|
|
|
|
while(offset < size) {
|
|
if(eof && method == -1) return;
|
|
if(copyLen > 0) {
|
|
if(method != 0) {
|
|
while(copyLen > 0 && offset < size) {
|
|
copyLen--;
|
|
copyDist &= WSIZE - 1;
|
|
windowPos &= WSIZE - 1;
|
|
outputBuffer[offset++] = (slide[windowPos++] = slide[copyDist++]);
|
|
}
|
|
} else {
|
|
while(copyLen > 0 && offset < size) {
|
|
copyLen--;
|
|
windowPos &= WSIZE - 1;
|
|
outputBuffer[offset++] = (slide[windowPos++] = maskBits(8));
|
|
}
|
|
copyLen == 0 && (method = -1); // done
|
|
}
|
|
if (offset == size) return;
|
|
}
|
|
|
|
if(method == -1) {
|
|
if(eof) break;
|
|
eof = maskBits(1) != 0;
|
|
method = maskBits(2);
|
|
tblList = null;
|
|
copyLen = 0;
|
|
}
|
|
switch(method) {
|
|
case 0: i = stored(outputBuffer, offset, size - offset); break;
|
|
case 1: i = tblList != null ? codes(outputBuffer, offset, size - offset) : fixed(outputBuffer, offset, size - offset); break;
|
|
case 2: i = tblList != null ? codes(outputBuffer, offset, size - offset) : dynamic(outputBuffer, offset, size - offset); break;
|
|
default: i = -1; break;
|
|
}
|
|
|
|
if(i == -1) return;
|
|
offset += i;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
module.exports = function(/*Buffer*/inbuf) {
|
|
var zlib = require("zlib");
|
|
return {
|
|
inflateAsync : function(/*Function*/callback) {
|
|
var tmp = zlib.createInflateRaw(),
|
|
parts = [], total = 0;
|
|
tmp.on('data', function(data) {
|
|
parts.push(data);
|
|
total += data.length;
|
|
});
|
|
tmp.on('end', function() {
|
|
var buf = new Buffer(total), written = 0;
|
|
buf.fill(0);
|
|
|
|
for (var i = 0; i < parts.length; i++) {
|
|
var part = parts[i];
|
|
part.copy(buf, written);
|
|
written += part.length;
|
|
}
|
|
callback && callback(buf);
|
|
});
|
|
tmp.end(inbuf)
|
|
},
|
|
|
|
inflate : function(/*Buffer*/outputBuffer) {
|
|
var x = {
|
|
x: new JSInflater(inbuf)
|
|
};
|
|
x.x.inflate(outputBuffer);
|
|
delete(x.x);
|
|
}
|
|
}
|
|
};
|