base64zip.js

              return obj;
            };
            
            
            // reduce buffer size, avoiding mem copy
            exports.shrinkBuf = function (buf, size) {
              if (buf.length === size) { return buf; }
              if (buf.subarray) { return buf.subarray(0, size); }
              buf.length = size;
              return buf;
            };
            
            
            var fnTyped = {
              arraySet: function (dest, src, src_offs, len, dest_offs) {
                if (src.subarray && dest.subarray) {
                  dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
                  return;
                }
                // Fallback to ordinary array
                for (var i = 0; i < len; i++) {
                  dest[dest_offs + i] = src[src_offs + i];
                }
              },
              // Join array of chunks to single array.
              flattenChunks: function (chunks) {
                var i, l, len, pos, chunk, result;
            
                // calculate data length
                len = 0;
                for (i = 0, l = chunks.length; i < l; i++) {
                  len += chunks[i].length;
                }
            
                // join chunks
                result = new Uint8Array(len);
                pos = 0;
                for (i = 0, l = chunks.length; i < l; i++) {
                  chunk = chunks[i];
                  result.set(chunk, pos);
                  pos += chunk.length;
                }
            
                return result;
              }
            };
            
            var fnUntyped = {
              arraySet: function (dest, src, src_offs, len, dest_offs) {
                for (var i = 0; i < len; i++) {
                  dest[dest_offs + i] = src[src_offs + i];
                }
              },
              // Join array of chunks to single array.
              flattenChunks: function (chunks) {
                return [].concat.apply([], chunks);
              }
            };
            
            
            // Enable/Disable typed arrays use, for testing
            //
            exports.setTyped = function (on) {
              if (on) {
                exports.Buf8  = Uint8Array;
                exports.Buf16 = Uint16Array;
                exports.Buf32 = Int32Array;
                exports.assign(exports, fnTyped);
              } else {
                exports.Buf8  = Array;
                exports.Buf16 = Array;
                exports.Buf32 = Array;
                exports.assign(exports, fnUntyped);
              }
            };
            
            exports.setTyped(TYPED_OK);
            
            },{}],4:[function(require,module,exports){
            // String encode/decode helpers
            'use strict';
            
            
            var utils = require('./common');
            
            
            // Quick check if we can use fast array to bin string conversion
            //
            // - apply(Array) can fail on Android 2.2
            // - apply(Uint8Array) can fail on iOS 5.1 Safari
            //
            var STR_APPLY_OK = true;
            var STR_APPLY_UIA_OK = true;
            
            try { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; }
            try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }
            
            
            // Table with utf8 lengths (calculated by first byte of sequence)
            // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
            // because max possible codepoint is 0x10ffff
            var _utf8len = new utils.Buf8(256);
            for (var q = 0; q < 256; q++) {
              _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
            }
            _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
            
            
            // convert string to array (typed, when possible)
            exports.string2buf = function (str) {
              var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
            
              // count binary size
              for (m_pos = 0; m_pos < str_len; m_pos++) {
                c = str.charCodeAt(m_pos);
                if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
                  c2 = str.charCodeAt(m_pos + 1);
                  if ((c2 & 0xfc00) === 0xdc00) {
                    c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
                    m_pos++;
                  }
                }
                buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
              }
            
              // allocate buffer
              buf = new utils.Buf8(buf_len);
            
              // convert
              for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
                c = str.charCodeAt(m_pos);
                if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
                  c2 = str.charCodeAt(m_pos + 1);
                  if ((c2 & 0xfc00) === 0xdc00) {
                    c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
                    m_pos++;
                  }
                }
                if (c < 0x80) {
                  /* one byte */
                  buf[i++] = c;
                } else if (c < 0x800) {
                  /* two bytes */
                  buf[i++] = 0xC0 | (c >>> 6);
                  buf[i++] = 0x80 | (c & 0x3f);
                } else if (c < 0x10000) {
                  /* three bytes */
                  buf[i++] = 0xE0 | (c >>> 12);
                  buf[i++] = 0x80 | (c >>> 6 & 0x3f);
                  buf[i++] = 0x80 | (c & 0x3f);
                } else {
                  /* four bytes */
                  buf[i++] = 0xf0 | (c >>> 18);
                  buf[i++] = 0x80 | (c >>> 12 & 0x3f);
                  buf[i++] = 0x80 | (c >>> 6 & 0x3f);
                  buf[i++] = 0x80 | (c & 0x3f);
                }
              }
            
              return buf;
            };
            
            // Helper (used in 2 places)
            function buf2binstring(buf, len) {
              // On Chrome, the arguments in a function call that are allowed is `65534`.
              // If the length of the buffer is smaller than that, we can use this optimization,
              // otherwise we will take a slower path.
              if (len < 65534) {
                if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {
                  return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
                }
              }
            
              var result = '';
              for (var i = 0; i < len; i++) {
                result += String.fromCharCode(buf[i]);
              }
              return result;
            }
            
            
            // Convert byte array to binary string
            exports.buf2binstring = function (buf) {
              return buf2binstring(buf, buf.length);
            };
            
            
            // Convert binary string (typed, when possible)
            exports.binstring2buf = function (str) {
              var buf = new utils.Buf8(str.length);
              for (var i = 0, len = buf.length; i < len; i++) {
                buf[i] = str.charCodeAt(i);
              }
              return buf;
            };
            
            
            // convert array to string
            exports.buf2string = function (buf, max) {
              var i, out, c, c_len;
              var len = max || buf.length;
            
              // Reserve max possible length (2 words per char)
              // NB: by unknown reasons, Array is significantly faster for
              //     String.fromCharCode.apply than Uint16Array.
              var utf16buf = new Array(len * 2);
            
              for (out = 0, i = 0; i < len;) {
                c = buf[i++];
                // quick process ascii
                if (c < 0x80) { utf16buf[out++] = c; continue; }
            
                c_len = _utf8len[c];
                // skip 5 & 6 byte codes
                if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }
            
                // apply mask on first byte
                c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
                // join the rest
                while (c_len > 1 && i < len) {
                  c = (c << 6) | (buf[i++] & 0x3f);
                  c_len--;
                }
            
                // terminated by end of string?
                if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
            
                if (c < 0x10000) {
                  utf16buf[out++] = c;
                } else {
                  c -= 0x10000;
                  utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
                  utf16buf[out++] = 0xdc00 | (c & 0x3ff);
                }
              }
            
              return buf2binstring(utf16buf, out);
            };
            
            
            // Calculate max possible position in utf8 buffer,
            // that will not break sequence. If that's not possible
            // - (very small limits) return max size as is.
            //
            // buf[] - utf8 bytes array
            // max   - length limit (mandatory);
            exports.utf8border = function (buf, max) {
              var pos;
            
              max = max || buf.length;
              if (max > buf.length) { max = buf.length; }
            
              // go back from last position, until start of sequence found
              pos = max - 1;
              while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
            
              // Very small and broken sequence,
              // return max, because we should return something anyway.
              if (pos < 0) { return max; }
            
              // If we came to start of buffer - that means buffer is too small,
              // return max too.
              if (pos === 0) { return max; }
            
              return (pos + _utf8len[buf[pos]] > max) ? pos : max;
            };
            
            },{"./common":3}],5:[function(require,module,exports){
            'use strict';
            
            // Note: adler32 takes 12% for level 0 and 2% for level 6.
            // It isn't worth it to make additional optimizations as in original.
            // Small size is preferable.
            
            // (C) 1995-2013 Jean-loup Gailly and Mark Adler
            // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
            //
            // This software is provided 'as-is', without any express or implied
            // warranty. In no event will the authors be held liable for any damages
            // arising from the use of this software.
            //
            // Permission is granted to anyone to use this software for any purpose,
            // including commercial applications, and to alter it and redistribute it
            // freely, subject to the following restrictions:
            //
            // 1. The origin of this software must not be misrepresented; you must not
            //   claim that you wrote the original software. If you use this software
            //   in a product, an acknowledgment in the product documentation would be
            //   appreciated but is not required.
            // 2. Altered source versions must be plainly marked as such, and must not be
            //   misrepresented as being the original software.
            // 3. This notice may not be removed or altered from any source distribution.
            
            function adler32(adler, buf, len, pos) {
              var s1 = (adler & 0xffff) |0,
                  s2 = ((adler >>> 16) & 0xffff) |0,
                  n = 0;
            
              while (len !== 0) {
                // Set limit ~ twice less than 5552, to keep
                // s2 in 31-bits, because we force signed ints.
                // in other case %= will fail.
                n = len > 2000 ? 2000 : len;
                len -= n;
            
                do {
                  s1 = (s1 + buf[pos++]) |0;
                  s2 = (s2 + s1) |0;
                } while (--n);
            
                s1 %= 65521;
                s2 %= 65521;
              }
            
              return (s1 | (s2 << 16)) |0;
            }
            
            
            module.exports = adler32;
            
            },{}],6:[function(require,module,exports){
            'use strict';
            
            // (C) 1995-2013 Jean-loup Gailly and Mark Adler
            // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
            //
            // This software is provided 'as-is', without any express or implied
            // warranty. In no event will the authors be held liable for any damages
            // arising from the use of this software.
            //
            // Permission is granted to anyone to use this software for any purpose,
            // including commercial applications, and to alter it and redistribute it
            // freely, subject to the following restrictions:
            //
            // 1. The origin of this software must not be misrepresented; you must not
            //   claim that you wrote the original software. If you use this software
            //   in a product, an acknowledgment in the product documentation would be
            //   appreciated but is not required.
            // 2. Altered source versions must be plainly marked as such, and must not be
            //   misrepresented as being the original software.
            // 3. This notice may not be removed or altered from any source distribution.
            
            module.exports = {
            
              /* Allowed flush values; see deflate() and inflate() below for details */
              Z_NO_FLUSH:         0,
              Z_PARTIAL_FLUSH:    1,
              Z_SYNC_FLUSH:       2,
              Z_FULL_FLUSH:       3,
              Z_FINISH:           4,
              Z_BLOCK:            5,
              Z_TREES:            6,
            
              /* Return codes for the compression/decompression functions. Negative values
              * are errors, positive values are used for special but normal events.
              */
              Z_OK:               0,
              Z_STREAM_END:       1,
              Z_NEED_DICT:        2,
              Z_ERRNO:           -1,
              Z_STREAM_ERROR:    -2,
              Z_DATA_ERROR:      -3,
              //Z_MEM_ERROR:     -4,
              Z_BUF_ERROR:       -5,
              //Z_VERSION_ERROR: -6,
            
              /* compression levels */
              Z_NO_COMPRESSION:         0,
              Z_BEST_SPEED:             1,
              Z_BEST_COMPRESSION:       9,
              Z_DEFAULT_COMPRESSION:   -1,
            
            
              Z_FILTERED:               1,
              Z_HUFFMAN_ONLY:           2,
              Z_RLE:                    3,
              Z_FIXED:                  4,
              Z_DEFAULT_STRATEGY:       0,
            
              /* Possible values of the data_type field (though see inflate()) */
              Z_BINARY:                 0,
              Z_TEXT:                   1,
              //Z_ASCII:                1, // = Z_TEXT (deprecated)
              Z_UNKNOWN:                2,
            
              /* The deflate compression method */
              Z_DEFLATED:               8
              //Z_NULL:                 null // Use -1 or null inline, depending on var type
            };
            
            },{}],7:[function(require,module,exports){
            'use strict';
            
            // Note: we can't get significant speed boost here.
            // So write code to minimize size - no pregenerated tables
            // and array tools dependencies.
            
            // (C) 1995-2013 Jean-loup Gailly and Mark Adler
            // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
            //
            // This software is provided 'as-is', without any express or implied
            // warranty. In no event will the authors be held liable for any damages
            // arising from the use of this software.
            //
            // Permission is granted to anyone to use this software for any purpose,
            // including commercial applications, and to alter it and redistribute it
            // freely, subject to the following restrictions:
            //
            // 1. The origin of this software must not be misrepresented; you must not
            //   claim that you wrote the original software. If you use this software
            //   in a product, an acknowledgment in the product documentation would be
            //   appreciated but is not required.
            // 2. Altered source versions must be plainly marked as such, and must not be
            //   misrepresented as being the original software.
            // 3. This notice may not be removed or altered from any source distribution.
            
            // Use ordinary array, since untyped makes no boost here
            function makeTable() {
              var c, table = [];
            
              for (var n = 0; n < 256; n++) {
                c = n;
                for (var k = 0; k < 8; k++) {
                  c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
                }
                table[n] = c;
              }
            
              return table;
            }
            
            // Create table on load. Just 255 signed longs. Not a problem.
            var crcTable = makeTable();
            
            
            function crc32(crc, buf, len, pos) {
              var t = crcTable,
                  end = pos + len;
            
              crc ^= -1;
            
              for (var i = pos; i < end; i++) {
                crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
              }
            
              return (crc ^ (-1)); // >>> 0;
            }
            
            
            module.exports = crc32;
            
            },{}],8:[function(require,module,exports){
            'use strict';
            
            // (C) 1995-2013 Jean-loup Gailly and Mark Adler
            // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
            //
            // This software is provided 'as-is', without any express or implied
            // warranty. In no event will the authors be held liable for any damages
            // arising from the use of this software.
            //
            // Permission is granted to anyone to use this software for any purpose,
            // including commercial applications, and to alter it and redistribute it
            // freely, subject to the following restrictions:
            //
            // 1. The origin of this software must not be misrepresented; you must not
            //   claim that you wrote the original software. If you use this software
            //   in a product, an acknowledgment in the product documentation would be
            //   appreciated but is not required.
            // 2. Altered source versions must be plainly marked as such, and must not be
            //   misrepresented as being the original software.
            // 3. This notice may not be removed or altered from any source distribution.
            
            var utils   = require('../utils/common');
            var trees   = require('./trees');
            var adler32 = require('./adler32');
            var crc32   = require('./crc32');
            var msg     = require('./messages');
            
            /* Public constants ==========================================================*/
            /* ===========================================================================*/
            
            
            /* Allowed flush values; see deflate() and inflate() below for details */
            var Z_NO_FLUSH      = 0;
            var Z_PARTIAL_FLUSH = 1;
            //var Z_SYNC_FLUSH    = 2;
            var Z_FULL_FLUSH    = 3;
            var Z_FINISH        = 4;
            var Z_BLOCK         = 5;
            //var Z_TREES         = 6;
            
            
            /* Return codes for the compression/decompression functions. Negative values
             * are errors, positive values are used for special but normal events.
             */
            var Z_OK            = 0;
            var Z_STREAM_END    = 1;
            //var Z_NEED_DICT     = 2;
            //var Z_ERRNO         = -1;
            var Z_STREAM_ERROR  = -2;
            var Z_DATA_ERROR    = -3;
            //var Z_MEM_ERROR     = -4;
            var Z_BUF_ERROR     = -5;
            //var Z_VERSION_ERROR = -6;
            
            
            /* compression levels */
            //var Z_NO_COMPRESSION      = 0;
            //var Z_BEST_SPEED          = 1;
            //var Z_BEST_COMPRESSION    = 9;
            var Z_DEFAULT_COMPRESSION = -1;
            
            
            var Z_FILTERED            = 1;
            var Z_HUFFMAN_ONLY        = 2;
            var Z_RLE                 = 3;
            var Z_FIXED               = 4;
            var Z_DEFAULT_STRATEGY    = 0;
            
            /* Possible values of the data_type field (though see inflate()) */
            //var Z_BINARY              = 0;
            //var Z_TEXT                = 1;
            //var Z_ASCII               = 1; // = Z_TEXT
            var Z_UNKNOWN             = 2;
            
            
            /* The deflate compression method */
            var Z_DEFLATED  = 8;
            
            /*============================================================================*/
            
            
            var MAX_MEM_LEVEL = 9;
            /* Maximum value for memLevel in deflateInit2 */
            var MAX_WBITS = 15;
            /* 32K LZ77 window */
            var DEF_MEM_LEVEL = 8;
            
            
            var LENGTH_CODES  = 29;
            /* number of length codes, not counting the special END_BLOCK code */
            var LITERALS      = 256;
            /* number of literal bytes 0..255 */
            var L_CODES       = LITERALS + 1 + LENGTH_CODES;
            /* number of Literal or Length codes, including the END_BLOCK code */
            var D_CODES       = 30;
            /* number of distance codes */
            var BL_CODES      = 19;
            /* number of codes used to transfer the bit lengths */
            var HEAP_SIZE     = 2 * L_CODES + 1;
            /* maximum heap size */
            var MAX_BITS  = 15;
            /* All codes must not exceed MAX_BITS bits */
            
            var MIN_MATCH = 3;
            var MAX_MATCH = 258;
            var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
            
            var PRESET_DICT = 0x20;
            
            var INIT_STATE = 42;
            var EXTRA_STATE = 69;
            var NAME_STATE = 73;
            var COMMENT_STATE = 91;
            var HCRC_STATE = 103;
            var BUSY_STATE = 113;
            var FINISH_STATE = 666;
            
            var BS_NEED_MORE      = 1; /* block not completed, need more input or more output */
            var BS_BLOCK_DONE     = 2; /* block flush performed */
            var BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */
            var BS_FINISH_DONE    = 4; /* finish done, accept no more input or output */
            
            var OS_CODE = 0x03; // Unix :) . Don't detect, use this default.
            
            function err(strm, errorCode) {
              strm.msg = msg[errorCode];
              return errorCode;
            }
            
            function rank(f) {
              return ((f) << 1) - ((f) > 4 ? 9 : 0);
            }
            
            function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
            
            
            /* =========================================================================
             * 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->output buffer and copying into it.
             * (See also read_buf()).
             */
            function flush_pending(strm) {
              var s = strm.state;
            
              //_tr_flush_bits(s);
              var len = s.pending;
              if (len > strm.avail_out) {
                len = strm.avail_out;
              }
              if (len === 0) { return; }
            
              utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
              strm.next_out += len;
              s.pending_out += len;
              strm.total_out += len;
              strm.avail_out -= len;
              s.pending -= len;
              if (s.pending === 0) {
                s.pending_out = 0;
              }
            }
            
            
            function flush_block_only(s, last) {
              trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
              s.block_start = s.strstart;
              flush_pending(s.strm);
            }
            
            
            function put_byte(s, b) {
              s.pending_buf[s.pending++] = b;
            }
            
            
            /* =========================================================================
             * Put a short in the pending buffer. The 16-bit value is put in MSB order.
             * IN assertion: the stream state is correct and there is enough room in
             * pending_buf.
             */
            function putShortMSB(s, b) {
            //  put_byte(s, (Byte)(b >> 8));
            //  put_byte(s, (Byte)(b & 0xff));
              s.pending_buf[s.pending++] = (b >>> 8) & 0xff;
              s.pending_buf[s.pending++] = b & 0xff;
            }
            
            
            /* ===========================================================================
             * Read a new buffer from the current input stream, update the adler32
             * and 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->input buffer and copying from it.
             * (See also flush_pending()).
             */
            function read_buf(strm, buf, start, size) {
              var len = strm.avail_in;
            
              if (len > size) { len = size; }
              if (len === 0) { return 0; }
            
              strm.avail_in -= len;
            
              // zmemcpy(buf, strm->next_in, len);
              utils.arraySet(buf, strm.input, strm.next_in, len, start);
              if (strm.state.wrap === 1) {
                strm.adler = adler32(strm.adler, buf, len, start);
              }
            
              else if (strm.state.wrap === 2) {
                strm.adler = crc32(strm.adler, buf, len, start);
              }
            
              strm.next_in += len;
              strm.total_in += len;
            
              return len;
            }
            
            
            /* ===========================================================================
             * Set match_start to the longest match starting at the given string and
             * return its length. Matches shorter or equal to prev_length are discarded,
             * in which case the result is equal to prev_length and match_start is
             * garbage.
             * IN assertions: cur_match is the head of the hash chain for the current
             *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
             * OUT assertion: the match length is not greater than s->lookahead.
             */
            function longest_match(s, cur_match) {
              var chain_length = s.max_chain_length;      /* max hash chain length */
              var scan = s.strstart; /* current string */
              var match;                       /* matched string */
              var len;                           /* length of current match */
              var best_len = s.prev_length;              /* best match length so far */
              var nice_match = s.nice_match;             /* stop if match long enough */
              var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ?
                  s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/;
            
              var _win = s.window; // shortcut
            
              var wmask = s.w_mask;
              var prev  = s.prev;
            
              /* Stop when cur_match becomes <= limit. To simplify the code,
               * we prevent matches with the string of window index 0.
               */
            
              var strend = s.strstart + MAX_MATCH;
              var scan_end1  = _win[scan + best_len - 1];
              var scan_end   = _win[scan + best_len];
            
              /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
               * It is easy to get rid of this optimization if necessary.
               */
              // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
            
              /* Do not waste too much time if we already have a good match: */
              if (s.prev_length >= s.good_match) {
                chain_length >>= 2;
              }
              /* Do not look for matches beyond the end of the input. This is necessary
               * to make deflate deterministic.
               */
              if (nice_match > s.lookahead) { nice_match = s.lookahead; }
            
              // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
            
              do {
                // Assert(cur_match < s->strstart, "no future");
                match = cur_match;
            
                /* Skip to next match if the match length cannot increase
                 * or if the match length is less than 2.  Note that the checks below
                 * for insufficient lookahead only occur occasionally for performance
                 * reasons.  Therefore uninitialized memory will be accessed, and
                 * conditional jumps will be made that depend on those values.
                 * However the length of the match is limited to the lookahead, so
                 * the output of deflate is not affected by the uninitialized values.
                 */
            
                if (_win[match + best_len]     !== scan_end  ||
                    _win[match + best_len - 1] !== scan_end1 ||
                    _win[match]                !== _win[scan] ||
                    _win[++match]              !== _win[scan + 1]) {
                  continue;
                }
            
                /* The check at best_len-1 can be removed because it will be made
                 * again later. (This heuristic is not always a win.)
                 * It is not necessary to compare scan[2] and match[2] since they
                 * are always equal when the other bytes match, given that
                 * the hash keys are equal and that HASH_BITS >= 8.
                 */
                scan += 2;
                match++;
                // Assert(*scan == *match, "match[2]?");
            
                /* We check for insufficient lookahead only every 8th comparison;
                 * the 256th check will be made at strstart+258.
                 */
                do {
                  /*jshint noempty:false*/
                } 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);
            
                // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
            
                len = MAX_MATCH - (strend - scan);
                scan = strend - MAX_MATCH;
            
                if (len > best_len) {
                  s.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]) > limit && --chain_length !== 0);
            
              if (best_len <= s.lookahead) {
                return best_len;
              }
              return s.lookahead;
            }
            
            
            /* ===========================================================================
             * Fill the window when the lookahead becomes insufficient.
             * Updates strstart and lookahead.
             *
             * IN assertion: lookahead < MIN_LOOKAHEAD
             * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
             *    At least one byte has been read, or avail_in == 0; reads are
             *    performed for at least two bytes (required for the zip translate_eol
             *    option -- not supported here).
             */
            function fill_window(s) {
              var _w_size = s.w_size;
              var p, n, m, more, str;
            
              //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
            
              do {
                more = s.window_size - s.lookahead - s.strstart;
            
                // JS ints have 32 bit, block below not needed
                /* Deal with !@#$% 64K limit: */
                //if (sizeof(int) <= 2) {
                //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
                //        more = wsize;
                //
                //  } else if (more == (unsigned)(-1)) {
                //        /* Very unlikely, but possible on 16 bit machine if
                //         * strstart == 0 && lookahead == 1 (input done a byte at time)
                //         */
                //        more--;
                //    }
                //}
            
            
                /* If the window is almost full and there is insufficient lookahead,
                 * move the upper half to the lower one to make room in the upper half.
                 */
                if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
            
                  utils.arraySet(s.window, s.window, _w_size, _w_size, 0);
                  s.match_start -= _w_size;
                  s.strstart -= _w_size;
                  /* we now have strstart >= MAX_DIST */
                  s.block_start -= _w_size;
            
                  /* Slide the hash table (could be avoided with 32 bit values
                   at the expense of memory usage). We slide even when level == 0
                   to keep the hash table consistent if we switch back to level > 0
                   later. (Using level 0 permanently is not an optimal usage of
                   zlib, so we don't care about this pathological case.)
                   */
            
                  n = s.hash_size;
                  p = n;
                  do {
                    m = s.head[--p];
                    s.head[p] = (m >= _w_size ? m - _w_size : 0);
                  } while (--n);
            
                  n = _w_size;
                  p = n;
                  do {
                    m = s.prev[--p];
                    s.prev[p] = (m >= _w_size ? m - _w_size : 0);
                    /* If n is not on any hash chain, prev[n] is garbage but
                     * its value will never be used.
                     */
                  } while (--n);
            
                  more += _w_size;
                }
                if (s.strm.avail_in === 0) {
                  break;
                }
            
                /* If there was no sliding:
                 *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
                 *    more == window_size - lookahead - strstart
                 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
                 * => more >= window_size - 2*WSIZE + 2
                 * In the BIG_MEM or MMAP case (not yet supported),
                 *   window_size == input_size + MIN_LOOKAHEAD  &&
                 *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
                 * Otherwise, window_size == 2*WSIZE so more >= 2.
                 * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
                 */
                //Assert(more >= 2, "more < 2");
                n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
                s.lookahead += n;
            
                /* Initialize the hash value now that we have some input: */
                if (s.lookahead + s.insert >= MIN_MATCH) {
                  str = s.strstart - s.insert;
                  s.ins_h = s.window[str];
            
                  /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */
                  s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask;
            //#if MIN_MATCH != 3
            //        Call update_hash() MIN_MATCH-3 more times
            //#endif
                  while (s.insert) {
                    /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
                    s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
            
                    s.prev[str & s.w_mask] = s.head[s.ins_h];
                    s.head[s.ins_h] = str;
                    str++;
                    s.insert--;
                    if (s.lookahead + s.insert < MIN_MATCH) {
                      break;
                    }
                  }
                }
                /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
                 * but this is not important since only literal bytes will be emitted.
                 */
            
              } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
            
              /* If the WIN_INIT bytes after the end of the current data have never been
               * written, then zero those bytes in order to avoid memory check reports of
               * the use of uninitialized (or uninitialised as Julian writes) bytes by
               * the longest match routines.  Update the high water mark for the next
               * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
               * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
               */
            //  if (s.high_water < s.window_size) {
            //    var curr = s.strstart + s.lookahead;
            //    var init = 0;
            //
            //    if (s.high_water < curr) {
            //      /* Previous high water mark below current data -- zero WIN_INIT
            //       * bytes or up to end of window, whichever is less.
            //       */
            //      init = s.window_size - curr;
            //      if (init > WIN_INIT)
            //        init = WIN_INIT;
            //      zmemzero(s->window + curr, (unsigned)init);
            //      s->high_water = curr + init;
            //    }
            //    else if (s->high_water < (ulg)curr + WIN_INIT) {
            //      /* High water mark at or above current data, but below current data
            //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
            //       * to end of window, whichever is less.
            //       */
            //      init = (ulg)curr + WIN_INIT - s->high_water;
            //      if (init > s->window_size - s->high_water)
            //        init = s->window_size - s->high_water;
            //      zmemzero(s->window + s->high_water, (unsigned)init);
            //      s->high_water += init;
            //    }
            //  }
            //
            //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
            //    "not enough room for search");
            }
            
            /* ===========================================================================
             * Copy without compression as much as possible from the input stream, return
             * the current block state.
             * This function does not insert new strings in the dictionary since
             * uncompressible data is probably not useful. This function is used
             * only for the level=0 compression option.
             * NOTE: this function should be optimized to avoid extra copying from
             * window to pending_buf.
             */
            function deflate_stored(s, flush) {
              /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
               * to pending_buf_size, and each stored block has a 5 byte header:
               */
              var max_block_size = 0xffff;
            
              if (max_block_size > s.pending_buf_size - 5) {
                max_block_size = s.pending_buf_size - 5;
              }
            
              /* Copy as much as possible from input to output: */
              for (;;) {
                /* Fill the window as much as possible: */
                if (s.lookahead <= 1) {
            
                  //Assert(s->strstart < s->w_size+MAX_DIST(s) ||
                  //  s->block_start >= (long)s->w_size, "slide too late");
            //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||
            //        s.block_start >= s.w_size)) {
            //        throw  new Error("slide too late");
            //      }
            
                  fill_window(s);
                  if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
                    return BS_NEED_MORE;
                  }
            
                  if (s.lookahead === 0) {
                    break;
                  }
                  /* flush the current block */
                }
                //Assert(s->block_start >= 0L, "block gone");
            //    if (s.block_start < 0) throw new Error("block gone");
            
                s.strstart += s.lookahead;
                s.lookahead = 0;
            
                /* Emit a stored block if pending_buf will be full: */
                var max_start = s.block_start + max_block_size;
            
                if (s.strstart === 0 || s.strstart >= max_start) {
                  /* strstart == 0 is possible when wraparound on 16-bit machine */
                  s.lookahead = s.strstart - max_start;
                  s.strstart = max_start;
                  /*** FLUSH_BLOCK(s, 0); ***/
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;