node_modules, clean up package.json

1 files changed, 0 insertions, 448 deletions

diff --git a/node_modules/adm-zip/methods/inflater.js b/node_modules/adm-zip/methods/inflater.js
deleted file mode 100644
index 59536c90e..000000000
--- a/node_modules/adm-zip/methods/inflater.js
+++ /dev/null
@@ -1,448 +0,0 @@
-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);

-        }

-    }

-};