| 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); |
| } |
| } |
| }; |
