base64zip.js

                  }
                  /***/
            
            
                }
                /* Flush if we may have to slide, otherwise block_start may become
                 * negative and the data will be gone:
                 */
                if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) {
                  /*** FLUSH_BLOCK(s, 0); ***/
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                  /***/
                }
              }
            
              s.insert = 0;
            
              if (flush === Z_FINISH) {
                /*** FLUSH_BLOCK(s, 1); ***/
                flush_block_only(s, true);
                if (s.strm.avail_out === 0) {
                  return BS_FINISH_STARTED;
                }
                /***/
                return BS_FINISH_DONE;
              }
            
              if (s.strstart > s.block_start) {
                /*** FLUSH_BLOCK(s, 0); ***/
                flush_block_only(s, false);
                if (s.strm.avail_out === 0) {
                  return BS_NEED_MORE;
                }
                /***/
              }
            
              return BS_NEED_MORE;
            }
            
            /* ===========================================================================
             * Compress as much as possible from the input stream, return the current
             * block state.
             * This function does not perform lazy evaluation of matches and inserts
             * new strings in the dictionary only for unmatched strings or for short
             * matches. It is used only for the fast compression options.
             */
            function deflate_fast(s, flush) {
              var hash_head;        /* head of the hash chain */
              var bflush;           /* set if current block must be flushed */
            
              for (;;) {
                /* Make sure that we always have enough lookahead, except
                 * at the end of the input file. We need MAX_MATCH bytes
                 * for the next match, plus MIN_MATCH bytes to insert the
                 * string following the next match.
                 */
                if (s.lookahead < MIN_LOOKAHEAD) {
                  fill_window(s);
                  if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
                    return BS_NEED_MORE;
                  }
                  if (s.lookahead === 0) {
                    break; /* flush the current block */
                  }
                }
            
                /* Insert the string window[strstart .. strstart+2] in the
                 * dictionary, and set hash_head to the head of the hash chain:
                 */
                hash_head = 0/*NIL*/;
                if (s.lookahead >= MIN_MATCH) {
                  /*** INSERT_STRING(s, s.strstart, hash_head); ***/
                  s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
                  hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
                  s.head[s.ins_h] = s.strstart;
                  /***/
                }
            
                /* Find the longest match, discarding those <= prev_length.
                 * At this point we have always match_length < MIN_MATCH
                 */
                if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) {
                  /* To simplify the code, we prevent matches with the string
                   * of window index 0 (in particular we have to avoid a match
                   * of the string with itself at the start of the input file).
                   */
                  s.match_length = longest_match(s, hash_head);
                  /* longest_match() sets match_start */
                }
                if (s.match_length >= MIN_MATCH) {
                  // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only
            
                  /*** _tr_tally_dist(s, s.strstart - s.match_start,
                                 s.match_length - MIN_MATCH, bflush); ***/
                  bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
            
                  s.lookahead -= s.match_length;
            
                  /* Insert new strings in the hash table only if the match length
                   * is not too large. This saves time but degrades compression.
                   */
                  if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) {
                    s.match_length--; /* string at strstart already in table */
                    do {
                      s.strstart++;
                      /*** INSERT_STRING(s, s.strstart, hash_head); ***/
                      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
                      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
                      s.head[s.ins_h] = s.strstart;
                      /***/
                      /* strstart never exceeds WSIZE-MAX_MATCH, so there are
                       * always MIN_MATCH bytes ahead.
                       */
                    } while (--s.match_length !== 0);
                    s.strstart++;
                  } else
                  {
                    s.strstart += s.match_length;
                    s.match_length = 0;
                    s.ins_h = s.window[s.strstart];
                    /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
                    s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask;
            
            //#if MIN_MATCH != 3
            //                Call UPDATE_HASH() MIN_MATCH-3 more times
            //#endif
                    /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
                     * matter since it will be recomputed at next deflate call.
                     */
                  }
                } else {
                  /* No match, output a literal byte */
                  //Tracevv((stderr,"%c", s.window[s.strstart]));
                  /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
                  bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
            
                  s.lookahead--;
                  s.strstart++;
                }
                if (bflush) {
                  /*** FLUSH_BLOCK(s, 0); ***/
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                  /***/
                }
              }
              s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);
              if (flush === Z_FINISH) {
                /*** FLUSH_BLOCK(s, 1); ***/
                flush_block_only(s, true);
                if (s.strm.avail_out === 0) {
                  return BS_FINISH_STARTED;
                }
                /***/
                return BS_FINISH_DONE;
              }
              if (s.last_lit) {
                /*** FLUSH_BLOCK(s, 0); ***/
                flush_block_only(s, false);
                if (s.strm.avail_out === 0) {
                  return BS_NEED_MORE;
                }
                /***/
              }
              return BS_BLOCK_DONE;
            }
            
            /* ===========================================================================
             * Same as above, but achieves better compression. We use a lazy
             * evaluation for matches: a match is finally adopted only if there is
             * no better match at the next window position.
             */
            function deflate_slow(s, flush) {
              var hash_head;          /* head of hash chain */
              var bflush;              /* set if current block must be flushed */
            
              var max_insert;
            
              /* Process the input block. */
              for (;;) {
                /* Make sure that we always have enough lookahead, except
                 * at the end of the input file. We need MAX_MATCH bytes
                 * for the next match, plus MIN_MATCH bytes to insert the
                 * string following the next match.
                 */
                if (s.lookahead < MIN_LOOKAHEAD) {
                  fill_window(s);
                  if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
                    return BS_NEED_MORE;
                  }
                  if (s.lookahead === 0) { break; } /* flush the current block */
                }
            
                /* Insert the string window[strstart .. strstart+2] in the
                 * dictionary, and set hash_head to the head of the hash chain:
                 */
                hash_head = 0/*NIL*/;
                if (s.lookahead >= MIN_MATCH) {
                  /*** INSERT_STRING(s, s.strstart, hash_head); ***/
                  s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
                  hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
                  s.head[s.ins_h] = s.strstart;
                  /***/
                }
            
                /* Find the longest match, discarding those <= prev_length.
                 */
                s.prev_length = s.match_length;
                s.prev_match = s.match_start;
                s.match_length = MIN_MATCH - 1;
            
                if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&
                    s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
                  /* To simplify the code, we prevent matches with the string
                   * of window index 0 (in particular we have to avoid a match
                   * of the string with itself at the start of the input file).
                   */
                  s.match_length = longest_match(s, hash_head);
                  /* longest_match() sets match_start */
            
                  if (s.match_length <= 5 &&
                     (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {
            
                    /* If prev_match is also MIN_MATCH, match_start is garbage
                     * but we will ignore the current match anyway.
                     */
                    s.match_length = MIN_MATCH - 1;
                  }
                }
                /* If there was a match at the previous step and the current
                 * match is not better, output the previous match:
                 */
                if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
                  max_insert = s.strstart + s.lookahead - MIN_MATCH;
                  /* Do not insert strings in hash table beyond this. */
            
                  //check_match(s, s.strstart-1, s.prev_match, s.prev_length);
            
                  /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
                                 s.prev_length - MIN_MATCH, bflush);***/
                  bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
                  /* Insert in hash table all strings up to the end of the match.
                   * strstart-1 and strstart are already inserted. If there is not
                   * enough lookahead, the last two strings are not inserted in
                   * the hash table.
                   */
                  s.lookahead -= s.prev_length - 1;
                  s.prev_length -= 2;
                  do {
                    if (++s.strstart <= max_insert) {
                      /*** INSERT_STRING(s, s.strstart, hash_head); ***/
                      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
                      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
                      s.head[s.ins_h] = s.strstart;
                      /***/
                    }
                  } while (--s.prev_length !== 0);
                  s.match_available = 0;
                  s.match_length = MIN_MATCH - 1;
                  s.strstart++;
            
                  if (bflush) {
                    /*** FLUSH_BLOCK(s, 0); ***/
                    flush_block_only(s, false);
                    if (s.strm.avail_out === 0) {
                      return BS_NEED_MORE;
                    }
                    /***/
                  }
            
                } else if (s.match_available) {
                  /* If there was no match at the previous position, output a
                   * single literal. If there was a match but the current match
                   * is longer, truncate the previous match to a single literal.
                   */
                  //Tracevv((stderr,"%c", s->window[s->strstart-1]));
                  /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
                  bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
            
                  if (bflush) {
                    /*** FLUSH_BLOCK_ONLY(s, 0) ***/
                    flush_block_only(s, false);
                    /***/
                  }
                  s.strstart++;
                  s.lookahead--;
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                } else {
                  /* There is no previous match to compare with, wait for
                   * the next step to decide.
                   */
                  s.match_available = 1;
                  s.strstart++;
                  s.lookahead--;
                }
              }
              //Assert (flush != Z_NO_FLUSH, "no flush?");
              if (s.match_available) {
                //Tracevv((stderr,"%c", s->window[s->strstart-1]));
                /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
                bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
            
                s.match_available = 0;
              }
              s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
              if (flush === Z_FINISH) {
                /*** FLUSH_BLOCK(s, 1); ***/
                flush_block_only(s, true);
                if (s.strm.avail_out === 0) {
                  return BS_FINISH_STARTED;
                }
                /***/
                return BS_FINISH_DONE;
              }
              if (s.last_lit) {
                /*** FLUSH_BLOCK(s, 0); ***/
                flush_block_only(s, false);
                if (s.strm.avail_out === 0) {
                  return BS_NEED_MORE;
                }
                /***/
              }
            
              return BS_BLOCK_DONE;
            }
            
            
            /* ===========================================================================
             * For Z_RLE, simply look for runs of bytes, generate matches only of distance
             * one.  Do not maintain a hash table.  (It will be regenerated if this run of
             * deflate switches away from Z_RLE.)
             */
            function deflate_rle(s, flush) {
              var bflush;            /* set if current block must be flushed */
              var prev;              /* byte at distance one to match */
              var scan, strend;      /* scan goes up to strend for length of run */
            
              var _win = s.window;
            
              for (;;) {
                /* Make sure that we always have enough lookahead, except
                 * at the end of the input file. We need MAX_MATCH bytes
                 * for the longest run, plus one for the unrolled loop.
                 */
                if (s.lookahead <= MAX_MATCH) {
                  fill_window(s);
                  if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {
                    return BS_NEED_MORE;
                  }
                  if (s.lookahead === 0) { break; } /* flush the current block */
                }
            
                /* See how many times the previous byte repeats */
                s.match_length = 0;
                if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
                  scan = s.strstart - 1;
                  prev = _win[scan];
                  if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
                    strend = s.strstart + MAX_MATCH;
                    do {
                      /*jshint noempty:false*/
                    } while (prev === _win[++scan] && prev === _win[++scan] &&
                             prev === _win[++scan] && prev === _win[++scan] &&
                             prev === _win[++scan] && prev === _win[++scan] &&
                             prev === _win[++scan] && prev === _win[++scan] &&
                             scan < strend);
                    s.match_length = MAX_MATCH - (strend - scan);
                    if (s.match_length > s.lookahead) {
                      s.match_length = s.lookahead;
                    }
                  }
                  //Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
                }
            
                /* Emit match if have run of MIN_MATCH or longer, else emit literal */
                if (s.match_length >= MIN_MATCH) {
                  //check_match(s, s.strstart, s.strstart - 1, s.match_length);
            
                  /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/
                  bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
            
                  s.lookahead -= s.match_length;
                  s.strstart += s.match_length;
                  s.match_length = 0;
                } else {
                  /* No match, output a literal byte */
                  //Tracevv((stderr,"%c", s->window[s->strstart]));
                  /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
                  bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
            
                  s.lookahead--;
                  s.strstart++;
                }
                if (bflush) {
                  /*** FLUSH_BLOCK(s, 0); ***/
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                  /***/
                }
              }
              s.insert = 0;
              if (flush === Z_FINISH) {
                /*** FLUSH_BLOCK(s, 1); ***/
                flush_block_only(s, true);
                if (s.strm.avail_out === 0) {
                  return BS_FINISH_STARTED;
                }
                /***/
                return BS_FINISH_DONE;
              }
              if (s.last_lit) {
                /*** FLUSH_BLOCK(s, 0); ***/
                flush_block_only(s, false);
                if (s.strm.avail_out === 0) {
                  return BS_NEED_MORE;
                }
                /***/
              }
              return BS_BLOCK_DONE;
            }
            
            /* ===========================================================================
             * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
             * (It will be regenerated if this run of deflate switches away from Huffman.)
             */
            function deflate_huff(s, flush) {
              var bflush;             /* set if current block must be flushed */
            
              for (;;) {
                /* Make sure that we have a literal to write. */
                if (s.lookahead === 0) {
                  fill_window(s);
                  if (s.lookahead === 0) {
                    if (flush === Z_NO_FLUSH) {
                      return BS_NEED_MORE;
                    }
                    break;      /* flush the current block */
                  }
                }
            
                /* Output a literal byte */
                s.match_length = 0;
                //Tracevv((stderr,"%c", s->window[s->strstart]));
                /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
                bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
                s.lookahead--;
                s.strstart++;
                if (bflush) {
                  /*** FLUSH_BLOCK(s, 0); ***/
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                  /***/
                }
              }
              s.insert = 0;
              if (flush === Z_FINISH) {
                /*** FLUSH_BLOCK(s, 1); ***/
                flush_block_only(s, true);
                if (s.strm.avail_out === 0) {
                  return BS_FINISH_STARTED;
                }
                /***/
                return BS_FINISH_DONE;
              }
              if (s.last_lit) {
                /*** FLUSH_BLOCK(s, 0); ***/
                flush_block_only(s, false);
                if (s.strm.avail_out === 0) {
                  return BS_NEED_MORE;
                }
                /***/
              }
              return BS_BLOCK_DONE;
            }
            
            /* Values for max_lazy_match, good_match and max_chain_length, depending on
             * the desired pack level (0..9). The values given below have been tuned to
             * exclude worst case performance for pathological files. Better values may be
             * found for specific files.
             */
            function Config(good_length, max_lazy, nice_length, max_chain, func) {
              this.good_length = good_length;
              this.max_lazy = max_lazy;
              this.nice_length = nice_length;
              this.max_chain = max_chain;
              this.func = func;
            }
            
            var configuration_table;
            
            configuration_table = [
              /*      good lazy nice chain */
              new Config(0, 0, 0, 0, deflate_stored),          /* 0 store only */
              new Config(4, 4, 8, 4, deflate_fast),            /* 1 max speed, no lazy matches */
              new Config(4, 5, 16, 8, deflate_fast),           /* 2 */
              new Config(4, 6, 32, 32, deflate_fast),          /* 3 */
            
              new Config(4, 4, 16, 16, deflate_slow),          /* 4 lazy matches */
              new Config(8, 16, 32, 32, deflate_slow),         /* 5 */
              new Config(8, 16, 128, 128, deflate_slow),       /* 6 */
              new Config(8, 32, 128, 256, deflate_slow),       /* 7 */
              new Config(32, 128, 258, 1024, deflate_slow),    /* 8 */
              new Config(32, 258, 258, 4096, deflate_slow)     /* 9 max compression */
            ];
            
            
            /* ===========================================================================
             * Initialize the "longest match" routines for a new zlib stream
             */
            function lm_init(s) {
              s.window_size = 2 * s.w_size;
            
              /*** CLEAR_HASH(s); ***/
              zero(s.head); // Fill with NIL (= 0);
            
              /* Set the default configuration parameters:
               */
              s.max_lazy_match = configuration_table[s.level].max_lazy;
              s.good_match = configuration_table[s.level].good_length;
              s.nice_match = configuration_table[s.level].nice_length;
              s.max_chain_length = configuration_table[s.level].max_chain;
            
              s.strstart = 0;
              s.block_start = 0;
              s.lookahead = 0;
              s.insert = 0;
              s.match_length = s.prev_length = MIN_MATCH - 1;
              s.match_available = 0;
              s.ins_h = 0;
            }
            
            
            function DeflateState() {
              this.strm = null;            /* pointer back to this zlib stream */
              this.status = 0;            /* as the name implies */
              this.pending_buf = null;      /* output still pending */
              this.pending_buf_size = 0;  /* size of pending_buf */
              this.pending_out = 0;       /* next pending byte to output to the stream */
              this.pending = 0;           /* nb of bytes in the pending buffer */
              this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
              this.gzhead = null;         /* gzip header information to write */
              this.gzindex = 0;           /* where in extra, name, or comment */
              this.method = Z_DEFLATED; /* can only be DEFLATED */
              this.last_flush = -1;   /* value of flush param for previous deflate call */
            
              this.w_size = 0;  /* LZ77 window size (32K by default) */
              this.w_bits = 0;  /* log2(w_size)  (8..16) */
              this.w_mask = 0;  /* w_size - 1 */
            
              this.window = null;
              /* Sliding window. Input bytes are read into the second half of the window,
               * and move to the first half later to keep a dictionary of at least wSize
               * bytes. With this organization, matches are limited to a distance of
               * wSize-MAX_MATCH bytes, but this ensures that IO is always
               * performed with a length multiple of the block size.
               */
            
              this.window_size = 0;
              /* Actual size of window: 2*wSize, except when the user input buffer
               * is directly used as sliding window.
               */
            
              this.prev = null;
              /* Link to older string with same hash index. To limit the size of this
               * array to 64K, this link is maintained only for the last 32K strings.
               * An index in this array is thus a window index modulo 32K.
               */
            
              this.head = null;   /* Heads of the hash chains or NIL. */
            
              this.ins_h = 0;       /* hash index of string to be inserted */
              this.hash_size = 0;   /* number of elements in hash table */
              this.hash_bits = 0;   /* log2(hash_size) */
              this.hash_mask = 0;   /* hash_size-1 */
            
              this.hash_shift = 0;
              /* Number of bits by which ins_h must be shifted at each input
               * step. It must be such that after MIN_MATCH steps, the oldest
               * byte no longer takes part in the hash key, that is:
               *   hash_shift * MIN_MATCH >= hash_bits
               */
            
              this.block_start = 0;
              /* Window position at the beginning of the current output block. Gets
               * negative when the window is moved backwards.
               */
            
              this.match_length = 0;      /* length of best match */
              this.prev_match = 0;        /* previous match */
              this.match_available = 0;   /* set if previous match exists */
              this.strstart = 0;          /* start of string to insert */
              this.match_start = 0;       /* start of matching string */
              this.lookahead = 0;         /* number of valid bytes ahead in window */
            
              this.prev_length = 0;
              /* Length of the best match at previous step. Matches not greater than this
               * are discarded. This is used in the lazy match evaluation.
               */
            
              this.max_chain_length = 0;
              /* To speed up deflation, hash chains are never searched beyond this
               * length.  A higher limit improves compression ratio but degrades the
               * speed.
               */
            
              this.max_lazy_match = 0;
              /* Attempt to find a better match only when the current match is strictly
               * smaller than this value. This mechanism is used only for compression
               * levels >= 4.
               */
              // That's alias to max_lazy_match, don't use directly
              //this.max_insert_length = 0;
              /* Insert new strings in the hash table only if the match length is not
               * greater than this length. This saves time but degrades compression.
               * max_insert_length is used only for compression levels <= 3.
               */
            
              this.level = 0;     /* compression level (1..9) */
              this.strategy = 0;  /* favor or force Huffman coding*/
            
              this.good_match = 0;
              /* Use a faster search when the previous match is longer than this */
            
              this.nice_match = 0; /* Stop searching when current match exceeds this */
            
                          /* used by trees.c: */
            
              /* Didn't use ct_data typedef below to suppress compiler warning */
            
              // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
              // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
              // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
            
              // Use flat array of DOUBLE size, with interleaved fata,
              // because JS does not support effective
              this.dyn_ltree  = new utils.Buf16(HEAP_SIZE * 2);
              this.dyn_dtree  = new utils.Buf16((2 * D_CODES + 1) * 2);
              this.bl_tree    = new utils.Buf16((2 * BL_CODES + 1) * 2);
              zero(this.dyn_ltree);
              zero(this.dyn_dtree);
              zero(this.bl_tree);
            
              this.l_desc   = null;         /* desc. for literal tree */
              this.d_desc   = null;         /* desc. for distance tree */
              this.bl_desc  = null;         /* desc. for bit length tree */
            
              //ush bl_count[MAX_BITS+1];
              this.bl_count = new utils.Buf16(MAX_BITS + 1);
              /* number of codes at each bit length for an optimal tree */
            
              //int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
              this.heap = new utils.Buf16(2 * L_CODES + 1);  /* heap used to build the Huffman trees */
              zero(this.heap);
            
              this.heap_len = 0;               /* number of elements in the heap */
              this.heap_max = 0;               /* element of largest frequency */
              /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
               * The same heap array is used to build all trees.
               */
            
              this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1];
              zero(this.depth);
              /* Depth of each subtree used as tie breaker for trees of equal frequency
               */
            
              this.l_buf = 0;          /* buffer index for literals or lengths */
            
              this.lit_bufsize = 0;
              /* Size of match buffer for literals/lengths.  There are 4 reasons for
               * limiting lit_bufsize to 64K:
               *   - frequencies can be kept in 16 bit counters
               *   - if compression is not successful for the first block, all input
               *     data is still in the window so we can still emit a stored block even
               *     when input comes from standard input.  (This can also be done for
               *     all blocks if lit_bufsize is not greater than 32K.)
               *   - if compression is not successful for a file smaller than 64K, we can
               *     even emit a stored file instead of a stored block (saving 5 bytes).
               *     This is applicable only for zip (not gzip or zlib).
               *   - creating new Huffman trees less frequently may not provide fast
               *     adaptation to changes in the input data statistics. (Take for
               *     example a binary file with poorly compressible code followed by
               *     a highly compressible string table.) Smaller buffer sizes give
               *     fast adaptation but have of course the overhead of transmitting
               *     trees more frequently.
               *   - I can't count above 4
               */
            
              this.last_lit = 0;      /* running index in l_buf */
            
              this.d_buf = 0;
              /* Buffer index for distances. To simplify the code, d_buf and l_buf have
               * the same number of elements. To use different lengths, an extra flag
               * array would be necessary.
               */
            
              this.opt_len = 0;       /* bit length of current block with optimal trees */
              this.static_len = 0;    /* bit length of current block with static trees */
              this.matches = 0;       /* number of string matches in current block */
              this.insert = 0;        /* bytes at end of window left to insert */
            
            
              this.bi_buf = 0;
              /* Output buffer. bits are inserted starting at the bottom (least
               * significant bits).
               */
              this.bi_valid = 0;
              /* Number of valid bits in bi_buf.  All bits above the last valid bit
               * are always zero.
               */
            
              // Used for window memory init. We safely ignore it for JS. That makes
              // sense only for pointers and memory check tools.
              //this.high_water = 0;
              /* High water mark offset in window for initialized bytes -- bytes above
               * this are set to zero in order to avoid memory check warnings when
               * longest match routines access bytes past the input.  This is then
               * updated to the new high water mark.
               */
            }
            
            
            function deflateResetKeep(strm) {
              var s;
            
              if (!strm || !strm.state) {
                return err(strm, Z_STREAM_ERROR);
              }
            
              strm.total_in = strm.total_out = 0;
              strm.data_type = Z_UNKNOWN;
            
              s = strm.state;
              s.pending = 0;
              s.pending_out = 0;
            
              if (s.wrap < 0) {
                s.wrap = -s.wrap;
                /* was made negative by deflate(..., Z_FINISH); */
              }
              s.status = (s.wrap ? INIT_STATE : BUSY_STATE);
              strm.adler = (s.wrap === 2) ?
                0  // crc32(0, Z_NULL, 0)
              :
                1; // adler32(0, Z_NULL, 0)
              s.last_flush = Z_NO_FLUSH;
              trees._tr_init(s);
              return Z_OK;
            }
            
            
            function deflateReset(strm) {
              var ret = deflateResetKeep(strm);
              if (ret === Z_OK) {
                lm_init(strm.state);
              }
              return ret;
            }
            
            
            function deflateSetHeader(strm, head) {
              if (!strm || !strm.state) { return Z_STREAM_ERROR; }
              if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }
              strm.state.gzhead = head;
              return Z_OK;
            }
            
            
            function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
              if (!strm) { // === Z_NULL
                return Z_STREAM_ERROR;
              }
              var wrap = 1;
            
              if (level === Z_DEFAULT_COMPRESSION) {
                level = 6;
              }
            
              if (windowBits < 0) { /* suppress zlib wrapper */
                wrap = 0;
                windowBits = -windowBits;
              }
            
              else if (windowBits > 15) {
                wrap = 2;           /* write gzip wrapper instead */
                windowBits -= 16;
              }
            
            
              if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED ||
                windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
                strategy < 0 || strategy > Z_FIXED) {
                return err(strm, Z_STREAM_ERROR);
              }
            
            
              if (windowBits === 8) {
                windowBits = 9;
              }
              /* until 256-byte window bug fixed */
            
              var s = new DeflateState();
            
              strm.state = s;
              s.strm = strm;
            
              s.wrap = wrap;
              s.gzhead = null;
              s.w_bits = windowBits;
              s.w_size = 1 << s.w_bits;
              s.w_mask = s.w_size - 1;
            
              s.hash_bits = memLevel + 7;
              s.hash_size = 1 << s.hash_bits;
              s.hash_mask = s.hash_size - 1;
              s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
            
              s.window = new utils.Buf8(s.w_size * 2);
              s.head = new utils.Buf16(s.hash_size);
              s.prev = new utils.Buf16(s.w_size);
            
              // Don't need mem init magic for JS.
              //s.high_water = 0;  /* nothing written to s->window yet */
            
              s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
            
              s.pending_buf_size = s.lit_bufsize * 4;
            
              //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
              //s->pending_buf = (uchf *) overlay;
              s.pending_buf = new utils.Buf8(s.pending_buf_size);
            
              // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)
              //s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
              s.d_buf = 1 * s.lit_bufsize;
            
              //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
              s.l_buf = (1 + 2) * s.lit_bufsize;
            
              s.level = level;
              s.strategy = strategy;
              s.method = method;
            
              return deflateReset(strm);
            }
            
            function deflateInit(strm, level) {
              return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
            }
            
            
            function deflate(strm, flush) {
              var old_flush, s;
              var beg, val; // for gzip header write only
            
              if (!strm || !strm.state ||
                flush > Z_BLOCK || flush < 0) {
                return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
              }
            
              s = strm.state;
            
              if (!strm.output ||
                  (!strm.input && strm.avail_in !== 0) ||
                  (s.status === FINISH_STATE && flush !== Z_FINISH)) {
                return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);
              }
            
              s.strm = strm; /* just in case */
              old_flush = s.last_flush;
              s.last_flush = flush;
            
              /* Write the header */
              if (s.status === INIT_STATE) {
            
                if (s.wrap === 2) { // GZIP header
                  strm.adler = 0;  //crc32(0L, Z_NULL, 0);
                  put_byte(s, 31);
                  put_byte(s, 139);
                  put_byte(s, 8);
                  if (!s.gzhead) { // s->gzhead == Z_NULL
                    put_byte(s, 0);
                    put_byte(s, 0);
                    put_byte(s, 0);
                    put_byte(s, 0);
                    put_byte(s, 0);
                    put_byte(s, s.level === 9 ? 2 :
                                (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
                                 4 : 0));
                    put_byte(s, OS_CODE);
                    s.status = BUSY_STATE;
                  }
                  else {
                    put_byte(s, (s.gzhead.text ? 1 : 0) +
                                (s.gzhead.hcrc ? 2 : 0) +
                                (!s.gzhead.extra ? 0 : 4) +
                                (!s.gzhead.name ? 0 : 8) +
                                (!s.gzhead.comment ? 0 : 16)
                    );
                    put_byte(s, s.gzhead.time & 0xff);
                    put_byte(s, (s.gzhead.time >> 8) & 0xff);
                    put_byte(s, (s.gzhead.time >> 16) & 0xff);
                    put_byte(s, (s.gzhead.time >> 24) & 0xff);
                    put_byte(s, s.level === 9 ? 2 :
                                (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
                                 4 : 0));
                    put_byte(s, s.gzhead.os & 0xff);
                    if (s.gzhead.extra && s.gzhead.extra.length) {
                      put_byte(s, s.gzhead.extra.length & 0xff);
                      put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);
                    }
                    if (s.gzhead.hcrc) {
                      strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);
                    }
                    s.gzindex = 0;
                    s.status = EXTRA_STATE;
                  }
                }
                else // DEFLATE header
                {
                  var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;
                  var level_flags = -1;
            
                  if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
                    level_flags = 0;
                  } else if (s.level < 6) {
                    level_flags = 1;
                  } else if (s.level === 6) {
                    level_flags = 2;
                  } else {
                    level_flags = 3;
                  }
                  header |= (level_flags << 6);
                  if (s.strstart !== 0) { header |= PRESET_DICT; }
                  header += 31 - (header % 31);
            
                  s.status = BUSY_STATE;
                  putShortMSB(s, header);
            
                  /* Save the adler32 of the preset dictionary: */
                  if (s.strstart !== 0) {
                    putShortMSB(s, strm.adler >>> 16);
                    putShortMSB(s, strm.adler & 0xffff);
                  }
                  strm.adler = 1; // adler32(0L, Z_NULL, 0);
                }
              }
            
            //#ifdef GZIP
              if (s.status === EXTRA_STATE) {
                if (s.gzhead.extra/* != Z_NULL*/) {
                  beg = s.pending;  /* start of bytes to update crc */
            
                  while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {
                    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) {
                        break;
                      }
                    }
                    put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);
                    s.gzindex++;
                  }
                  if (s.gzhead.hcrc && s.pending > beg) {
                    strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
                  }
                  if (s.gzindex === s.gzhead.extra.length) {
                    s.gzindex = 0;
                    s.status = NAME_STATE;
                  }
                }
                else {
                  s.status = NAME_STATE;
                }
              }
              if (s.status === NAME_STATE) {
                if (s.gzhead.name/* != 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);