base64zip.js

                      beg = s.pending;
                      if (s.pending === s.pending_buf_size) {
                        val = 1;
                        break;
                      }
                    }
                    // JS specific: little magic to add zero terminator to end of string
                    if (s.gzindex < s.gzhead.name.length) {
                      val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;
                    } else {
                      val = 0;
                    }
                    put_byte(s, val);
                  } while (val !== 0);
            
                  if (s.gzhead.hcrc && s.pending > beg) {
                    strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
                  }
                  if (val === 0) {
                    s.gzindex = 0;
                    s.status = COMMENT_STATE;
                  }
                }
                else {
                  s.status = COMMENT_STATE;
                }
              }
              if (s.status === COMMENT_STATE) {
                if (s.gzhead.comment/* != Z_NULL*/) {
                  beg = s.pending;  /* start of bytes to update crc */
                  //int val;
            
                  do {
                    if (s.pending === s.pending_buf_size) {
                      if (s.gzhead.hcrc && s.pending > beg) {
                        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
                      }
                      flush_pending(strm);
                      beg = s.pending;
                      if (s.pending === s.pending_buf_size) {
                        val = 1;
                        break;
                      }
                    }
                    // JS specific: little magic to add zero terminator to end of string
                    if (s.gzindex < s.gzhead.comment.length) {
                      val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;
                    } else {
                      val = 0;
                    }
                    put_byte(s, val);
                  } while (val !== 0);
            
                  if (s.gzhead.hcrc && s.pending > beg) {
                    strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
                  }
                  if (val === 0) {
                    s.status = HCRC_STATE;
                  }
                }
                else {
                  s.status = HCRC_STATE;
                }
              }
              if (s.status === HCRC_STATE) {
                if (s.gzhead.hcrc) {
                  if (s.pending + 2 > s.pending_buf_size) {
                    flush_pending(strm);
                  }
                  if (s.pending + 2 <= s.pending_buf_size) {
                    put_byte(s, strm.adler & 0xff);
                    put_byte(s, (strm.adler >> 8) & 0xff);
                    strm.adler = 0; //crc32(0L, Z_NULL, 0);
                    s.status = BUSY_STATE;
                  }
                }
                else {
                  s.status = BUSY_STATE;
                }
              }
            //#endif
            
              /* Flush as much pending output as possible */
              if (s.pending !== 0) {
                flush_pending(strm);
                if (strm.avail_out === 0) {
                  /* Since avail_out is 0, deflate will be called again with
                   * more output space, but possibly with both pending and
                   * avail_in equal to zero. There won't be anything to do,
                   * but this is not an error situation so make sure we
                   * return OK instead of BUF_ERROR at next call of deflate:
                   */
                  s.last_flush = -1;
                  return Z_OK;
                }
            
                /* Make sure there is something to do and avoid duplicate consecutive
                 * flushes. For repeated and useless calls with Z_FINISH, we keep
                 * returning Z_STREAM_END instead of Z_BUF_ERROR.
                 */
              } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
                flush !== Z_FINISH) {
                return err(strm, Z_BUF_ERROR);
              }
            
              /* User must not provide more input after the first FINISH: */
              if (s.status === FINISH_STATE && strm.avail_in !== 0) {
                return err(strm, Z_BUF_ERROR);
              }
            
              /* Start a new block or continue the current one.
               */
              if (strm.avail_in !== 0 || s.lookahead !== 0 ||
                (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {
                var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) :
                  (s.strategy === Z_RLE ? deflate_rle(s, flush) :
                    configuration_table[s.level].func(s, flush));
            
                if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
                  s.status = FINISH_STATE;
                }
                if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
                  if (strm.avail_out === 0) {
                    s.last_flush = -1;
                    /* avoid BUF_ERROR next call, see above */
                  }
                  return Z_OK;
                  /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
                   * of deflate should use the same flush parameter to make sure
                   * that the flush is complete. So we don't have to output an
                   * empty block here, this will be done at next call. This also
                   * ensures that for a very small output buffer, we emit at most
                   * one empty block.
                   */
                }
                if (bstate === BS_BLOCK_DONE) {
                  if (flush === Z_PARTIAL_FLUSH) {
                    trees._tr_align(s);
                  }
                  else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
            
                    trees._tr_stored_block(s, 0, 0, false);
                    /* For a full flush, this empty block will be recognized
                     * as a special marker by inflate_sync().
                     */
                    if (flush === Z_FULL_FLUSH) {
                      /*** CLEAR_HASH(s); ***/             /* forget history */
                      zero(s.head); // Fill with NIL (= 0);
            
                      if (s.lookahead === 0) {
                        s.strstart = 0;
                        s.block_start = 0;
                        s.insert = 0;
                      }
                    }
                  }
                  flush_pending(strm);
                  if (strm.avail_out === 0) {
                    s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */
                    return Z_OK;
                  }
                }
              }
              //Assert(strm->avail_out > 0, "bug2");
              //if (strm.avail_out <= 0) { throw new Error("bug2");}
            
              if (flush !== Z_FINISH) { return Z_OK; }
              if (s.wrap <= 0) { return Z_STREAM_END; }
            
              /* Write the trailer */
              if (s.wrap === 2) {
                put_byte(s, strm.adler & 0xff);
                put_byte(s, (strm.adler >> 8) & 0xff);
                put_byte(s, (strm.adler >> 16) & 0xff);
                put_byte(s, (strm.adler >> 24) & 0xff);
                put_byte(s, strm.total_in & 0xff);
                put_byte(s, (strm.total_in >> 8) & 0xff);
                put_byte(s, (strm.total_in >> 16) & 0xff);
                put_byte(s, (strm.total_in >> 24) & 0xff);
              }
              else
              {
                putShortMSB(s, strm.adler >>> 16);
                putShortMSB(s, strm.adler & 0xffff);
              }
            
              flush_pending(strm);
              /* If avail_out is zero, the application will call deflate again
               * to flush the rest.
               */
              if (s.wrap > 0) { s.wrap = -s.wrap; }
              /* write the trailer only once! */
              return s.pending !== 0 ? Z_OK : Z_STREAM_END;
            }
            
            function deflateEnd(strm) {
              var status;
            
              if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
                return Z_STREAM_ERROR;
              }
            
              status = strm.state.status;
              if (status !== INIT_STATE &&
                status !== EXTRA_STATE &&
                status !== NAME_STATE &&
                status !== COMMENT_STATE &&
                status !== HCRC_STATE &&
                status !== BUSY_STATE &&
                status !== FINISH_STATE
              ) {
                return err(strm, Z_STREAM_ERROR);
              }
            
              strm.state = null;
            
              return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
            }
            
            
            /* =========================================================================
             * Initializes the compression dictionary from the given byte
             * sequence without producing any compressed output.
             */
            function deflateSetDictionary(strm, dictionary) {
              var dictLength = dictionary.length;
            
              var s;
              var str, n;
              var wrap;
              var avail;
              var next;
              var input;
              var tmpDict;
            
              if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
                return Z_STREAM_ERROR;
              }
            
              s = strm.state;
              wrap = s.wrap;
            
              if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {
                return Z_STREAM_ERROR;
              }
            
              /* when using zlib wrappers, compute Adler-32 for provided dictionary */
              if (wrap === 1) {
                /* adler32(strm->adler, dictionary, dictLength); */
                strm.adler = adler32(strm.adler, dictionary, dictLength, 0);
              }
            
              s.wrap = 0;   /* avoid computing Adler-32 in read_buf */
            
              /* if dictionary would fill window, just replace the history */
              if (dictLength >= s.w_size) {
                if (wrap === 0) {            /* already empty otherwise */
                  /*** CLEAR_HASH(s); ***/
                  zero(s.head); // Fill with NIL (= 0);
                  s.strstart = 0;
                  s.block_start = 0;
                  s.insert = 0;
                }
                /* use the tail */
                // dictionary = dictionary.slice(dictLength - s.w_size);
                tmpDict = new utils.Buf8(s.w_size);
                utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);
                dictionary = tmpDict;
                dictLength = s.w_size;
              }
              /* insert dictionary into window and hash */
              avail = strm.avail_in;
              next = strm.next_in;
              input = strm.input;
              strm.avail_in = dictLength;
              strm.next_in = 0;
              strm.input = dictionary;
              fill_window(s);
              while (s.lookahead >= MIN_MATCH) {
                str = s.strstart;
                n = s.lookahead - (MIN_MATCH - 1);
                do {
                  /* 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++;
                } while (--n);
                s.strstart = str;
                s.lookahead = MIN_MATCH - 1;
                fill_window(s);
              }
              s.strstart += s.lookahead;
              s.block_start = s.strstart;
              s.insert = s.lookahead;
              s.lookahead = 0;
              s.match_length = s.prev_length = MIN_MATCH - 1;
              s.match_available = 0;
              strm.next_in = next;
              strm.input = input;
              strm.avail_in = avail;
              s.wrap = wrap;
              return Z_OK;
            }
            
            
            exports.deflateInit = deflateInit;
            exports.deflateInit2 = deflateInit2;
            exports.deflateReset = deflateReset;
            exports.deflateResetKeep = deflateResetKeep;
            exports.deflateSetHeader = deflateSetHeader;
            exports.deflate = deflate;
            exports.deflateEnd = deflateEnd;
            exports.deflateSetDictionary = deflateSetDictionary;
            exports.deflateInfo = 'pako deflate (from Nodeca project)';
            
            /* Not implemented
            exports.deflateBound = deflateBound;
            exports.deflateCopy = deflateCopy;
            exports.deflateParams = deflateParams;
            exports.deflatePending = deflatePending;
            exports.deflatePrime = deflatePrime;
            exports.deflateTune = deflateTune;
            */
            
            },{"../utils/common":3,"./adler32":5,"./crc32":7,"./messages":13,"./trees":14}],9:[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.
            
            function GZheader() {
              /* true if compressed data believed to be text */
              this.text       = 0;
              /* modification time */
              this.time       = 0;
              /* extra flags (not used when writing a gzip file) */
              this.xflags     = 0;
              /* operating system */
              this.os         = 0;
              /* pointer to extra field or Z_NULL if none */
              this.extra      = null;
              /* extra field length (valid if extra != Z_NULL) */
              this.extra_len  = 0; // Actually, we don't need it in JS,
                                   // but leave for few code modifications
            
              //
              // Setup limits is not necessary because in js we should not preallocate memory
              // for inflate use constant limit in 65536 bytes
              //
            
              /* space at extra (only when reading header) */
              // this.extra_max  = 0;
              /* pointer to zero-terminated file name or Z_NULL */
              this.name       = '';
              /* space at name (only when reading header) */
              // this.name_max   = 0;
              /* pointer to zero-terminated comment or Z_NULL */
              this.comment    = '';
              /* space at comment (only when reading header) */
              // this.comm_max   = 0;
              /* true if there was or will be a header crc */
              this.hcrc       = 0;
              /* true when done reading gzip header (not used when writing a gzip file) */
              this.done       = false;
            }
            
            module.exports = GZheader;
            
            },{}],10:[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.
            
            // See state defs from inflate.js
            var BAD = 30;       /* got a data error -- remain here until reset */
            var TYPE = 12;      /* i: waiting for type bits, including last-flag bit */
            
            /*
               Decode literal, length, and distance codes and write out the resulting
               literal and match bytes until either not enough input or output is
               available, an end-of-block is encountered, or a data error is encountered.
               When large enough input and output buffers are supplied to inflate(), for
               example, a 16K input buffer and a 64K output buffer, more than 95% of the
               inflate execution time is spent in this routine.
            
               Entry assumptions:
            
                    state.mode === LEN
                    strm.avail_in >= 6
                    strm.avail_out >= 258
                    start >= strm.avail_out
                    state.bits < 8
            
               On return, state.mode is one of:
            
                    LEN -- ran out of enough output space or enough available input
                    TYPE -- reached end of block code, inflate() to interpret next block
                    BAD -- error in block data
            
               Notes:
            
                - The maximum input bits used by a length/distance pair is 15 bits for the
                  length code, 5 bits for the length extra, 15 bits for the distance code,
                  and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
                  Therefore if strm.avail_in >= 6, then there is enough input to avoid
                  checking for available input while decoding.
            
                - The maximum bytes that a single length/distance pair can output is 258
                  bytes, which is the maximum length that can be coded.  inflate_fast()
                  requires strm.avail_out >= 258 for each loop to avoid checking for
                  output space.
             */
            module.exports = function inflate_fast(strm, start) {
              var state;
              var _in;                    /* local strm.input */
              var last;                   /* have enough input while in < last */
              var _out;                   /* local strm.output */
              var beg;                    /* inflate()'s initial strm.output */
              var end;                    /* while out < end, enough space available */
            //#ifdef INFLATE_STRICT
              var dmax;                   /* maximum distance from zlib header */
            //#endif
              var wsize;                  /* window size or zero if not using window */
              var whave;                  /* valid bytes in the window */
              var wnext;                  /* window write index */
              // Use `s_window` instead `window`, avoid conflict with instrumentation tools
              var s_window;               /* allocated sliding window, if wsize != 0 */
              var hold;                   /* local strm.hold */
              var bits;                   /* local strm.bits */
              var lcode;                  /* local strm.lencode */
              var dcode;                  /* local strm.distcode */
              var lmask;                  /* mask for first level of length codes */
              var dmask;                  /* mask for first level of distance codes */
              var here;                   /* retrieved table entry */
              var op;                     /* code bits, operation, extra bits, or */
                                          /*  window position, window bytes to copy */
              var len;                    /* match length, unused bytes */
              var dist;                   /* match distance */
              var from;                   /* where to copy match from */
              var from_source;
            
            
              var input, output; // JS specific, because we have no pointers
            
              /* copy state to local variables */
              state = strm.state;
              //here = state.here;
              _in = strm.next_in;
              input = strm.input;
              last = _in + (strm.avail_in - 5);
              _out = strm.next_out;
              output = strm.output;
              beg = _out - (start - strm.avail_out);
              end = _out + (strm.avail_out - 257);
            //#ifdef INFLATE_STRICT
              dmax = state.dmax;
            //#endif
              wsize = state.wsize;
              whave = state.whave;
              wnext = state.wnext;
              s_window = state.window;
              hold = state.hold;
              bits = state.bits;
              lcode = state.lencode;
              dcode = state.distcode;
              lmask = (1 << state.lenbits) - 1;
              dmask = (1 << state.distbits) - 1;
            
            
              /* decode literals and length/distances until end-of-block or not enough
                 input data or output space */
            
              top:
              do {
                if (bits < 15) {
                  hold += input[_in++] << bits;
                  bits += 8;
                  hold += input[_in++] << bits;
                  bits += 8;
                }
            
                here = lcode[hold & lmask];
            
                dolen:
                for (;;) { // Goto emulation
                  op = here >>> 24/*here.bits*/;
                  hold >>>= op;
                  bits -= op;
                  op = (here >>> 16) & 0xff/*here.op*/;
                  if (op === 0) {                          /* literal */
                    //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
                    //        "inflate:         literal '%c'\n" :
                    //        "inflate:         literal 0x%02x\n", here.val));
                    output[_out++] = here & 0xffff/*here.val*/;
                  }
                  else if (op & 16) {                     /* length base */
                    len = here & 0xffff/*here.val*/;
                    op &= 15;                           /* number of extra bits */
                    if (op) {
                      if (bits < op) {
                        hold += input[_in++] << bits;
                        bits += 8;
                      }
                      len += hold & ((1 << op) - 1);
                      hold >>>= op;
                      bits -= op;
                    }
                    //Tracevv((stderr, "inflate:         length %u\n", len));
                    if (bits < 15) {
                      hold += input[_in++] << bits;
                      bits += 8;
                      hold += input[_in++] << bits;
                      bits += 8;
                    }
                    here = dcode[hold & dmask];
            
                    dodist:
                    for (;;) { // goto emulation
                      op = here >>> 24/*here.bits*/;
                      hold >>>= op;
                      bits -= op;
                      op = (here >>> 16) & 0xff/*here.op*/;
            
                      if (op & 16) {                      /* distance base */
                        dist = here & 0xffff/*here.val*/;
                        op &= 15;                       /* number of extra bits */
                        if (bits < op) {
                          hold += input[_in++] << bits;
                          bits += 8;
                          if (bits < op) {
                            hold += input[_in++] << bits;
                            bits += 8;
                          }
                        }
                        dist += hold & ((1 << op) - 1);
            //#ifdef INFLATE_STRICT
                        if (dist > dmax) {
                          strm.msg = 'invalid distance too far back';
                          state.mode = BAD;
                          break top;
                        }
            //#endif
                        hold >>>= op;
                        bits -= op;
                        //Tracevv((stderr, "inflate:         distance %u\n", dist));
                        op = _out - beg;                /* max distance in output */
                        if (dist > op) {                /* see if copy from window */
                          op = dist - op;               /* distance back in window */
                          if (op > whave) {
                            if (state.sane) {
                              strm.msg = 'invalid distance too far back';
                              state.mode = BAD;
                              break top;
                            }
            
            // (!) This block is disabled in zlib defaults,
            // don't enable it for binary compatibility
            //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
            //                if (len <= op - whave) {
            //                  do {
            //                    output[_out++] = 0;
            //                  } while (--len);
            //                  continue top;
            //                }
            //                len -= op - whave;
            //                do {
            //                  output[_out++] = 0;
            //                } while (--op > whave);
            //                if (op === 0) {
            //                  from = _out - dist;
            //                  do {
            //                    output[_out++] = output[from++];
            //                  } while (--len);
            //                  continue top;
            //                }
            //#endif
                          }
                          from = 0; // window index
                          from_source = s_window;
                          if (wnext === 0) {           /* very common case */
                            from += wsize - op;
                            if (op < len) {         /* some from window */
                              len -= op;
                              do {
                                output[_out++] = s_window[from++];
                              } while (--op);
                              from = _out - dist;  /* rest from output */
                              from_source = output;
                            }
                          }
                          else if (wnext < op) {      /* wrap around window */
                            from += wsize + wnext - op;
                            op -= wnext;
                            if (op < len) {         /* some from end of window */
                              len -= op;
                              do {
                                output[_out++] = s_window[from++];
                              } while (--op);
                              from = 0;
                              if (wnext < len) {  /* some from start of window */
                                op = wnext;
                                len -= op;
                                do {
                                  output[_out++] = s_window[from++];
                                } while (--op);
                                from = _out - dist;      /* rest from output */
                                from_source = output;
                              }
                            }
                          }
                          else {                      /* contiguous in window */
                            from += wnext - op;
                            if (op < len) {         /* some from window */
                              len -= op;
                              do {
                                output[_out++] = s_window[from++];
                              } while (--op);
                              from = _out - dist;  /* rest from output */
                              from_source = output;
                            }
                          }
                          while (len > 2) {
                            output[_out++] = from_source[from++];
                            output[_out++] = from_source[from++];
                            output[_out++] = from_source[from++];
                            len -= 3;
                          }
                          if (len) {
                            output[_out++] = from_source[from++];
                            if (len > 1) {
                              output[_out++] = from_source[from++];
                            }
                          }
                        }
                        else {
                          from = _out - dist;          /* copy direct from output */
                          do {                        /* minimum length is three */
                            output[_out++] = output[from++];
                            output[_out++] = output[from++];
                            output[_out++] = output[from++];
                            len -= 3;
                          } while (len > 2);
                          if (len) {
                            output[_out++] = output[from++];
                            if (len > 1) {
                              output[_out++] = output[from++];
                            }
                          }
                        }
                      }
                      else if ((op & 64) === 0) {          /* 2nd level distance code */
                        here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
                        continue dodist;
                      }
                      else {
                        strm.msg = 'invalid distance code';
                        state.mode = BAD;
                        break top;
                      }
            
                      break; // need to emulate goto via "continue"
                    }
                  }
                  else if ((op & 64) === 0) {              /* 2nd level length code */
                    here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
                    continue dolen;
                  }
                  else if (op & 32) {                     /* end-of-block */
                    //Tracevv((stderr, "inflate:         end of block\n"));
                    state.mode = TYPE;
                    break top;
                  }
                  else {
                    strm.msg = 'invalid literal/length code';
                    state.mode = BAD;
                    break top;
                  }
            
                  break; // need to emulate goto via "continue"
                }
              } while (_in < last && _out < end);
            
              /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
              len = bits >> 3;
              _in -= len;
              bits -= len << 3;
              hold &= (1 << bits) - 1;
            
              /* update state and return */
              strm.next_in = _in;
              strm.next_out = _out;
              strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
              strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
              state.hold = hold;
              state.bits = bits;
              return;
            };
            
            },{}],11:[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 adler32       = require('./adler32');
            var crc32         = require('./crc32');
            var inflate_fast  = require('./inffast');
            var inflate_table = require('./inftrees');
            
            var CODES = 0;
            var LENS = 1;
            var DISTS = 2;
            
            /* 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;
            
            /* The deflate compression method */
            var Z_DEFLATED  = 8;
            
            
            /* STATES ====================================================================*/
            /* ===========================================================================*/
            
            
            var    HEAD = 1;       /* i: waiting for magic header */
            var    FLAGS = 2;      /* i: waiting for method and flags (gzip) */
            var    TIME = 3;       /* i: waiting for modification time (gzip) */
            var    OS = 4;         /* i: waiting for extra flags and operating system (gzip) */
            var    EXLEN = 5;      /* i: waiting for extra length (gzip) */
            var    EXTRA = 6;      /* i: waiting for extra bytes (gzip) */
            var    NAME = 7;       /* i: waiting for end of file name (gzip) */
            var    COMMENT = 8;    /* i: waiting for end of comment (gzip) */
            var    HCRC = 9;       /* i: waiting for header crc (gzip) */
            var    DICTID = 10;    /* i: waiting for dictionary check value */
            var    DICT = 11;      /* waiting for inflateSetDictionary() call */
            var        TYPE = 12;      /* i: waiting for type bits, including last-flag bit */
            var        TYPEDO = 13;    /* i: same, but skip check to exit inflate on new block */
            var        STORED = 14;    /* i: waiting for stored size (length and complement) */
            var        COPY_ = 15;     /* i/o: same as COPY below, but only first time in */
            var        COPY = 16;      /* i/o: waiting for input or output to copy stored block */
            var        TABLE = 17;     /* i: waiting for dynamic block table lengths */
            var        LENLENS = 18;   /* i: waiting for code length code lengths */
            var        CODELENS = 19;  /* i: waiting for length/lit and distance code lengths */
            var            LEN_ = 20;      /* i: same as LEN below, but only first time in */
            var            LEN = 21;       /* i: waiting for length/lit/eob code */
            var            LENEXT = 22;    /* i: waiting for length extra bits */
            var            DIST = 23;      /* i: waiting for distance code */
            var            DISTEXT = 24;   /* i: waiting for distance extra bits */
            var            MATCH = 25;     /* o: waiting for output space to copy string */
            var            LIT = 26;       /* o: waiting for output space to write literal */
            var    CHECK = 27;     /* i: waiting for 32-bit check value */
            var    LENGTH = 28;    /* i: waiting for 32-bit length (gzip) */
            var    DONE = 29;      /* finished check, done -- remain here until reset */
            var    BAD = 30;       /* got a data error -- remain here until reset */
            var    MEM = 31;       /* got an inflate() memory error -- remain here until reset */
            var    SYNC = 32;      /* looking for synchronization bytes to restart inflate() */
            
            /* ===========================================================================*/
            
            
            
            var ENOUGH_LENS = 852;
            var ENOUGH_DISTS = 592;
            //var ENOUGH =  (ENOUGH_LENS+ENOUGH_DISTS);
            
            var MAX_WBITS = 15;
            /* 32K LZ77 window */
            var DEF_WBITS = MAX_WBITS;
            
            
            function zswap32(q) {
              return  (((q >>> 24) & 0xff) +
                      ((q >>> 8) & 0xff00) +
                      ((q & 0xff00) << 8) +
                      ((q & 0xff) << 24));
            }
            
            
            function InflateState() {
              this.mode = 0;             /* current inflate mode */
              this.last = false;          /* true if processing last block */
              this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
              this.havedict = false;      /* true if dictionary provided */
              this.flags = 0;             /* gzip header method and flags (0 if zlib) */
              this.dmax = 0;              /* zlib header max distance (INFLATE_STRICT) */
              this.check = 0;             /* protected copy of check value */
              this.total = 0;             /* protected copy of output count */
              // TODO: may be {}
              this.head = null;           /* where to save gzip header information */
            
              /* sliding window */
              this.wbits = 0;             /* log base 2 of requested window size */
              this.wsize = 0;             /* window size or zero if not using window */
              this.whave = 0;             /* valid bytes in the window */
              this.wnext = 0;             /* window write index */
              this.window = null;         /* allocated sliding window, if needed */
            
              /* bit accumulator */
              this.hold = 0;              /* input bit accumulator */
              this.bits = 0;              /* number of bits in "in" */
            
              /* for string and stored block copying */
              this.length = 0;            /* literal or length of data to copy */
              this.offset = 0;            /* distance back to copy string from */
            
              /* for table and code decoding */
              this.extra = 0;             /* extra bits needed */
            
              /* fixed and dynamic code tables */
              this.lencode = null;          /* starting table for length/literal codes */
              this.distcode = null;         /* starting table for distance codes */
              this.lenbits = 0;           /* index bits for lencode */
              this.distbits = 0;          /* index bits for distcode */
            
              /* dynamic table building */
              this.ncode = 0;             /* number of code length code lengths */
              this.nlen = 0;              /* number of length code lengths */
              this.ndist = 0;             /* number of distance code lengths */
              this.have = 0;              /* number of code lengths in lens[] */
              this.next = null;              /* next available space in codes[] */
            
              this.lens = new utils.Buf16(320); /* temporary storage for code lengths */
              this.work = new utils.Buf16(288); /* work area for code table building */
            
              /*
               because we don't have pointers in js, we use lencode and distcode directly
               as buffers so we don't need codes
              */
              //this.codes = new utils.Buf32(ENOUGH);       /* space for code tables */
              this.lendyn = null;              /* dynamic table for length/literal codes (JS specific) */
              this.distdyn = null;             /* dynamic table for distance codes (JS specific) */
              this.sane = 0;                   /* if false, allow invalid distance too far */
              this.back = 0;                   /* bits back of last unprocessed length/lit */
              this.was = 0;                    /* initial length of match */
            }
            
            function inflateResetKeep(strm) {
              var state;
            
              if (!strm || !strm.state) { return Z_STREAM_ERROR; }
              state = strm.state;
              strm.total_in = strm.total_out = state.total = 0;
              strm.msg = ''; /*Z_NULL*/
              if (state.wrap) {       /* to support ill-conceived Java test suite */
                strm.adler = state.wrap & 1;
              }
              state.mode = HEAD;
              state.last = 0;
              state.havedict = 0;
              state.dmax = 32768;
              state.head = null/*Z_NULL*/;
              state.hold = 0;
              state.bits = 0;
              //state.lencode = state.distcode = state.next = state.codes;
              state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
              state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
            
              state.sane = 1;
              state.back = -1;
              //Tracev((stderr, "inflate: reset\n"));
              return Z_OK;
            }
            
            function inflateReset(strm) {
              var state;
            
              if (!strm || !strm.state) { return Z_STREAM_ERROR; }
              state = strm.state;
              state.wsize = 0;
              state.whave = 0;
              state.wnext = 0;
              return inflateResetKeep(strm);
            
            }
            
            function inflateReset2(strm, windowBits) {
              var wrap;
              var state;
            
              /* get the state */
              if (!strm || !strm.state) { return Z_STREAM_ERROR; }
              state = strm.state;
            
              /* extract wrap request from windowBits parameter */
              if (windowBits < 0) {
                wrap = 0;
                windowBits = -windowBits;
              }
              else {
                wrap = (windowBits >> 4) + 1;
                if (windowBits < 48) {
                  windowBits &= 15;
                }
              }
            
              /* set number of window bits, free window if different */
              if (windowBits && (windowBits < 8 || windowBits > 15)) {
                return Z_STREAM_ERROR;
              }
              if (state.window !== null && state.wbits !== windowBits) {
                state.window = null;
              }
            
              /* update state and reset the rest of it */
              state.wrap = wrap;
              state.wbits = windowBits;
              return inflateReset(strm);
            }
            
            function inflateInit2(strm, windowBits) {
              var ret;
              var state;
            
              if (!strm) { return Z_STREAM_ERROR; }
              //strm.msg = Z_NULL;                 /* in case we return an error */
            
              state = new InflateState();
            
              //if (state === Z_NULL) return Z_MEM_ERROR;
              //Tracev((stderr, "inflate: allocated\n"));
              strm.state = state;
              state.window = null/*Z_NULL*/;
              ret = inflateReset2(strm, windowBits);