{"ast":null,"code":"'use strict'; // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nvar utils = require('../utils/common');\n\nvar trees = require('./trees');\n\nvar adler32 = require('./adler32');\n\nvar crc32 = require('./crc32');\n\nvar msg = require('./messages');\n/* Public constants ==========================================================*/\n\n/* ===========================================================================*/\n\n/* Allowed flush values; see deflate() and inflate() below for details */\n\n\nvar Z_NO_FLUSH = 0;\nvar Z_PARTIAL_FLUSH = 1; //var Z_SYNC_FLUSH    = 2;\n\nvar Z_FULL_FLUSH = 3;\nvar Z_FINISH = 4;\nvar Z_BLOCK = 5; //var Z_TREES         = 6;\n\n/* Return codes for the compression/decompression functions. Negative values\n * are errors, positive values are used for special but normal events.\n */\n\nvar Z_OK = 0;\nvar Z_STREAM_END = 1; //var Z_NEED_DICT     = 2;\n//var Z_ERRNO         = -1;\n\nvar Z_STREAM_ERROR = -2;\nvar Z_DATA_ERROR = -3; //var Z_MEM_ERROR     = -4;\n\nvar Z_BUF_ERROR = -5; //var Z_VERSION_ERROR = -6;\n\n/* compression levels */\n//var Z_NO_COMPRESSION      = 0;\n//var Z_BEST_SPEED          = 1;\n//var Z_BEST_COMPRESSION    = 9;\n\nvar Z_DEFAULT_COMPRESSION = -1;\nvar Z_FILTERED = 1;\nvar Z_HUFFMAN_ONLY = 2;\nvar Z_RLE = 3;\nvar Z_FIXED = 4;\nvar Z_DEFAULT_STRATEGY = 0;\n/* Possible values of the data_type field (though see inflate()) */\n//var Z_BINARY              = 0;\n//var Z_TEXT                = 1;\n//var Z_ASCII               = 1; // = Z_TEXT\n\nvar Z_UNKNOWN = 2;\n/* The deflate compression method */\n\nvar Z_DEFLATED = 8;\n/*============================================================================*/\n\nvar MAX_MEM_LEVEL = 9;\n/* Maximum value for memLevel in deflateInit2 */\n\nvar MAX_WBITS = 15;\n/* 32K LZ77 window */\n\nvar DEF_MEM_LEVEL = 8;\nvar LENGTH_CODES = 29;\n/* number of length codes, not counting the special END_BLOCK code */\n\nvar LITERALS = 256;\n/* number of literal bytes 0..255 */\n\nvar L_CODES = LITERALS + 1 + LENGTH_CODES;\n/* number of Literal or Length codes, including the END_BLOCK code */\n\nvar D_CODES = 30;\n/* number of distance codes */\n\nvar BL_CODES = 19;\n/* number of codes used to transfer the bit lengths */\n\nvar HEAP_SIZE = 2 * L_CODES + 1;\n/* maximum heap size */\n\nvar MAX_BITS = 15;\n/* All codes must not exceed MAX_BITS bits */\n\nvar MIN_MATCH = 3;\nvar MAX_MATCH = 258;\nvar MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;\nvar PRESET_DICT = 0x20;\nvar INIT_STATE = 42;\nvar EXTRA_STATE = 69;\nvar NAME_STATE = 73;\nvar COMMENT_STATE = 91;\nvar HCRC_STATE = 103;\nvar BUSY_STATE = 113;\nvar FINISH_STATE = 666;\nvar BS_NEED_MORE = 1;\n/* block not completed, need more input or more output */\n\nvar BS_BLOCK_DONE = 2;\n/* block flush performed */\n\nvar BS_FINISH_STARTED = 3;\n/* finish started, need only more output at next deflate */\n\nvar BS_FINISH_DONE = 4;\n/* finish done, accept no more input or output */\n\nvar OS_CODE = 0x03; // Unix :) . Don't detect, use this default.\n\nfunction err(strm, errorCode) {\n  strm.msg = msg[errorCode];\n  return errorCode;\n}\n\nfunction rank(f) {\n  return (f << 1) - (f > 4 ? 9 : 0);\n}\n\nfunction zero(buf) {\n  var len = buf.length;\n\n  while (--len >= 0) {\n    buf[len] = 0;\n  }\n}\n/* =========================================================================\n * Flush as much pending output as possible. All deflate() output goes\n * through this function so some applications may wish to modify it\n * to avoid allocating a large strm->output buffer and copying into it.\n * (See also read_buf()).\n */\n\n\nfunction flush_pending(strm) {\n  var s = strm.state; //_tr_flush_bits(s);\n\n  var len = s.pending;\n\n  if (len > strm.avail_out) {\n    len = strm.avail_out;\n  }\n\n  if (len === 0) {\n    return;\n  }\n\n  utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);\n  strm.next_out += len;\n  s.pending_out += len;\n  strm.total_out += len;\n  strm.avail_out -= len;\n  s.pending -= len;\n\n  if (s.pending === 0) {\n    s.pending_out = 0;\n  }\n}\n\nfunction flush_block_only(s, last) {\n  trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);\n\n  s.block_start = s.strstart;\n  flush_pending(s.strm);\n}\n\nfunction put_byte(s, b) {\n  s.pending_buf[s.pending++] = b;\n}\n/* =========================================================================\n * Put a short in the pending buffer. The 16-bit value is put in MSB order.\n * IN assertion: the stream state is correct and there is enough room in\n * pending_buf.\n */\n\n\nfunction putShortMSB(s, b) {\n  //  put_byte(s, (Byte)(b >> 8));\n  //  put_byte(s, (Byte)(b & 0xff));\n  s.pending_buf[s.pending++] = b >>> 8 & 0xff;\n  s.pending_buf[s.pending++] = b & 0xff;\n}\n/* ===========================================================================\n * Read a new buffer from the current input stream, update the adler32\n * and total number of bytes read.  All deflate() input goes through\n * this function so some applications may wish to modify it to avoid\n * allocating a large strm->input buffer and copying from it.\n * (See also flush_pending()).\n */\n\n\nfunction read_buf(strm, buf, start, size) {\n  var len = strm.avail_in;\n\n  if (len > size) {\n    len = size;\n  }\n\n  if (len === 0) {\n    return 0;\n  }\n\n  strm.avail_in -= len; // zmemcpy(buf, strm->next_in, len);\n\n  utils.arraySet(buf, strm.input, strm.next_in, len, start);\n\n  if (strm.state.wrap === 1) {\n    strm.adler = adler32(strm.adler, buf, len, start);\n  } else if (strm.state.wrap === 2) {\n    strm.adler = crc32(strm.adler, buf, len, start);\n  }\n\n  strm.next_in += len;\n  strm.total_in += len;\n  return len;\n}\n/* ===========================================================================\n * Set match_start to the longest match starting at the given string and\n * return its length. Matches shorter or equal to prev_length are discarded,\n * in which case the result is equal to prev_length and match_start is\n * garbage.\n * IN assertions: cur_match is the head of the hash chain for the current\n *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1\n * OUT assertion: the match length is not greater than s->lookahead.\n */\n\n\nfunction longest_match(s, cur_match) {\n  var chain_length = s.max_chain_length;\n  /* max hash chain length */\n\n  var scan = s.strstart;\n  /* current string */\n\n  var match;\n  /* matched string */\n\n  var len;\n  /* length of current match */\n\n  var best_len = s.prev_length;\n  /* best match length so far */\n\n  var nice_match = s.nice_match;\n  /* stop if match long enough */\n\n  var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0\n  /*NIL*/\n  ;\n  var _win = s.window; // shortcut\n\n  var wmask = s.w_mask;\n  var prev = s.prev;\n  /* Stop when cur_match becomes <= limit. To simplify the code,\n   * we prevent matches with the string of window index 0.\n   */\n\n  var strend = s.strstart + MAX_MATCH;\n  var scan_end1 = _win[scan + best_len - 1];\n  var scan_end = _win[scan + best_len];\n  /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.\n   * It is easy to get rid of this optimization if necessary.\n   */\n  // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, \"Code too clever\");\n\n  /* Do not waste too much time if we already have a good match: */\n\n  if (s.prev_length >= s.good_match) {\n    chain_length >>= 2;\n  }\n  /* Do not look for matches beyond the end of the input. This is necessary\n   * to make deflate deterministic.\n   */\n\n\n  if (nice_match > s.lookahead) {\n    nice_match = s.lookahead;\n  } // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, \"need lookahead\");\n\n\n  do {\n    // Assert(cur_match < s->strstart, \"no future\");\n    match = cur_match;\n    /* Skip to next match if the match length cannot increase\n     * or if the match length is less than 2.  Note that the checks below\n     * for insufficient lookahead only occur occasionally for performance\n     * reasons.  Therefore uninitialized memory will be accessed, and\n     * conditional jumps will be made that depend on those values.\n     * However the length of the match is limited to the lookahead, so\n     * the output of deflate is not affected by the uninitialized values.\n     */\n\n    if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) {\n      continue;\n    }\n    /* The check at best_len-1 can be removed because it will be made\n     * again later. (This heuristic is not always a win.)\n     * It is not necessary to compare scan[2] and match[2] since they\n     * are always equal when the other bytes match, given that\n     * the hash keys are equal and that HASH_BITS >= 8.\n     */\n\n\n    scan += 2;\n    match++; // Assert(*scan == *match, \"match[2]?\");\n\n    /* We check for insufficient lookahead only every 8th comparison;\n     * the 256th check will be made at strstart+258.\n     */\n\n    do {\n      /*jshint noempty:false*/\n    } 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\");\n\n\n    len = MAX_MATCH - (strend - scan);\n    scan = strend - MAX_MATCH;\n\n    if (len > best_len) {\n      s.match_start = cur_match;\n      best_len = len;\n\n      if (len >= nice_match) {\n        break;\n      }\n\n      scan_end1 = _win[scan + best_len - 1];\n      scan_end = _win[scan + best_len];\n    }\n  } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);\n\n  if (best_len <= s.lookahead) {\n    return best_len;\n  }\n\n  return s.lookahead;\n}\n/* ===========================================================================\n * Fill the window when the lookahead becomes insufficient.\n * Updates strstart and lookahead.\n *\n * IN assertion: lookahead < MIN_LOOKAHEAD\n * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD\n *    At least one byte has been read, or avail_in == 0; reads are\n *    performed for at least two bytes (required for the zip translate_eol\n *    option -- not supported here).\n */\n\n\nfunction fill_window(s) {\n  var _w_size = s.w_size;\n  var p, n, m, more, str; //Assert(s->lookahead < MIN_LOOKAHEAD, \"already enough lookahead\");\n\n  do {\n    more = s.window_size - s.lookahead - s.strstart; // JS ints have 32 bit, block below not needed\n\n    /* Deal with !@#$% 64K limit: */\n    //if (sizeof(int) <= 2) {\n    //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {\n    //        more = wsize;\n    //\n    //  } else if (more == (unsigned)(-1)) {\n    //        /* Very unlikely, but possible on 16 bit machine if\n    //         * strstart == 0 && lookahead == 1 (input done a byte at time)\n    //         */\n    //        more--;\n    //    }\n    //}\n\n    /* If the window is almost full and there is insufficient lookahead,\n     * move the upper half to the lower one to make room in the upper half.\n     */\n\n    if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n      utils.arraySet(s.window, s.window, _w_size, _w_size, 0);\n      s.match_start -= _w_size;\n      s.strstart -= _w_size;\n      /* we now have strstart >= MAX_DIST */\n\n      s.block_start -= _w_size;\n      /* Slide the hash table (could be avoided with 32 bit values\n       at the expense of memory usage). We slide even when level == 0\n       to keep the hash table consistent if we switch back to level > 0\n       later. (Using level 0 permanently is not an optimal usage of\n       zlib, so we don't care about this pathological case.)\n       */\n\n      n = s.hash_size;\n      p = n;\n\n      do {\n        m = s.head[--p];\n        s.head[p] = m >= _w_size ? m - _w_size : 0;\n      } while (--n);\n\n      n = _w_size;\n      p = n;\n\n      do {\n        m = s.prev[--p];\n        s.prev[p] = m >= _w_size ? m - _w_size : 0;\n        /* If n is not on any hash chain, prev[n] is garbage but\n         * its value will never be used.\n         */\n      } while (--n);\n\n      more += _w_size;\n    }\n\n    if (s.strm.avail_in === 0) {\n      break;\n    }\n    /* If there was no sliding:\n     *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&\n     *    more == window_size - lookahead - strstart\n     * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)\n     * => more >= window_size - 2*WSIZE + 2\n     * In the BIG_MEM or MMAP case (not yet supported),\n     *   window_size == input_size + MIN_LOOKAHEAD  &&\n     *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.\n     * Otherwise, window_size == 2*WSIZE so more >= 2.\n     * If there was sliding, more >= WSIZE. So in all cases, more >= 2.\n     */\n    //Assert(more >= 2, \"more < 2\");\n\n\n    n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);\n    s.lookahead += n;\n    /* Initialize the hash value now that we have some input: */\n\n    if (s.lookahead + s.insert >= MIN_MATCH) {\n      str = s.strstart - s.insert;\n      s.ins_h = s.window[str];\n      /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */\n\n      s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask; //#if MIN_MATCH != 3\n      //        Call update_hash() MIN_MATCH-3 more times\n      //#endif\n\n      while (s.insert) {\n        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n        s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;\n        s.prev[str & s.w_mask] = s.head[s.ins_h];\n        s.head[s.ins_h] = str;\n        str++;\n        s.insert--;\n\n        if (s.lookahead + s.insert < MIN_MATCH) {\n          break;\n        }\n      }\n    }\n    /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,\n     * but this is not important since only literal bytes will be emitted.\n     */\n\n  } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);\n  /* If the WIN_INIT bytes after the end of the current data have never been\n   * written, then zero those bytes in order to avoid memory check reports of\n   * the use of uninitialized (or uninitialised as Julian writes) bytes by\n   * the longest match routines.  Update the high water mark for the next\n   * time through here.  WIN_INIT is set to MAX_MATCH since the longest match\n   * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.\n   */\n  //  if (s.high_water < s.window_size) {\n  //    var curr = s.strstart + s.lookahead;\n  //    var init = 0;\n  //\n  //    if (s.high_water < curr) {\n  //      /* Previous high water mark below current data -- zero WIN_INIT\n  //       * bytes or up to end of window, whichever is less.\n  //       */\n  //      init = s.window_size - curr;\n  //      if (init > WIN_INIT)\n  //        init = WIN_INIT;\n  //      zmemzero(s->window + curr, (unsigned)init);\n  //      s->high_water = curr + init;\n  //    }\n  //    else if (s->high_water < (ulg)curr + WIN_INIT) {\n  //      /* High water mark at or above current data, but below current data\n  //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up\n  //       * to end of window, whichever is less.\n  //       */\n  //      init = (ulg)curr + WIN_INIT - s->high_water;\n  //      if (init > s->window_size - s->high_water)\n  //        init = s->window_size - s->high_water;\n  //      zmemzero(s->window + s->high_water, (unsigned)init);\n  //      s->high_water += init;\n  //    }\n  //  }\n  //\n  //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,\n  //    \"not enough room for search\");\n\n}\n/* ===========================================================================\n * Copy without compression as much as possible from the input stream, return\n * the current block state.\n * This function does not insert new strings in the dictionary since\n * uncompressible data is probably not useful. This function is used\n * only for the level=0 compression option.\n * NOTE: this function should be optimized to avoid extra copying from\n * window to pending_buf.\n */\n\n\nfunction deflate_stored(s, flush) {\n  /* Stored blocks are limited to 0xffff bytes, pending_buf is limited\n   * to pending_buf_size, and each stored block has a 5 byte header:\n   */\n  var max_block_size = 0xffff;\n\n  if (max_block_size > s.pending_buf_size - 5) {\n    max_block_size = s.pending_buf_size - 5;\n  }\n  /* Copy as much as possible from input to output: */\n\n\n  for (;;) {\n    /* Fill the window as much as possible: */\n    if (s.lookahead <= 1) {\n      //Assert(s->strstart < s->w_size+MAX_DIST(s) ||\n      //  s->block_start >= (long)s->w_size, \"slide too late\");\n      //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||\n      //        s.block_start >= s.w_size)) {\n      //        throw  new Error(\"slide too late\");\n      //      }\n      fill_window(s);\n\n      if (s.lookahead === 0 && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n\n      if (s.lookahead === 0) {\n        break;\n      }\n      /* flush the current block */\n\n    } //Assert(s->block_start >= 0L, \"block gone\");\n    //    if (s.block_start < 0) throw new Error(\"block gone\");\n\n\n    s.strstart += s.lookahead;\n    s.lookahead = 0;\n    /* Emit a stored block if pending_buf will be full: */\n\n    var max_start = s.block_start + max_block_size;\n\n    if (s.strstart === 0 || s.strstart >= max_start) {\n      /* strstart == 0 is possible when wraparound on 16-bit machine */\n      s.lookahead = s.strstart - max_start;\n      s.strstart = max_start;\n      /*** FLUSH_BLOCK(s, 0); ***/\n\n      flush_block_only(s, false);\n\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n\n    }\n    /* Flush if we may have to slide, otherwise block_start may become\n     * negative and the data will be gone:\n     */\n\n\n    if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n\n    }\n  }\n\n  s.insert = 0;\n\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n\n\n    return BS_FINISH_DONE;\n  }\n\n  if (s.strstart > s.block_start) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n\n  }\n\n  return BS_NEED_MORE;\n}\n/* ===========================================================================\n * Compress as much as possible from the input stream, return the current\n * block state.\n * This function does not perform lazy evaluation of matches and inserts\n * new strings in the dictionary only for unmatched strings or for short\n * matches. It is used only for the fast compression options.\n */\n\n\nfunction deflate_fast(s, flush) {\n  var hash_head;\n  /* head of the hash chain */\n\n  var bflush;\n  /* set if current block must be flushed */\n\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the next match, plus MIN_MATCH bytes to insert the\n     * string following the next match.\n     */\n    if (s.lookahead < MIN_LOOKAHEAD) {\n      fill_window(s);\n\n      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n\n      if (s.lookahead === 0) {\n        break;\n        /* flush the current block */\n      }\n    }\n    /* Insert the string window[strstart .. strstart+2] in the\n     * dictionary, and set hash_head to the head of the hash chain:\n     */\n\n\n    hash_head = 0\n    /*NIL*/\n    ;\n\n    if (s.lookahead >= MIN_MATCH) {\n      /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n      s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n      s.head[s.ins_h] = s.strstart;\n      /***/\n    }\n    /* Find the longest match, discarding those <= prev_length.\n     * At this point we have always match_length < MIN_MATCH\n     */\n\n\n    if (hash_head !== 0\n    /*NIL*/\n    && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {\n      /* To simplify the code, we prevent matches with the string\n       * of window index 0 (in particular we have to avoid a match\n       * of the string with itself at the start of the input file).\n       */\n      s.match_length = longest_match(s, hash_head);\n      /* longest_match() sets match_start */\n    }\n\n    if (s.match_length >= MIN_MATCH) {\n      // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only\n\n      /*** _tr_tally_dist(s, s.strstart - s.match_start,\n                     s.match_length - MIN_MATCH, bflush); ***/\n      bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);\n      s.lookahead -= s.match_length;\n      /* Insert new strings in the hash table only if the match length\n       * is not too large. This saves time but degrades compression.\n       */\n\n      if (s.match_length <= s.max_lazy_match\n      /*max_insert_length*/\n      && s.lookahead >= MIN_MATCH) {\n        s.match_length--;\n        /* string at strstart already in table */\n\n        do {\n          s.strstart++;\n          /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n\n          s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n          s.head[s.ins_h] = s.strstart;\n          /***/\n\n          /* strstart never exceeds WSIZE-MAX_MATCH, so there are\n           * always MIN_MATCH bytes ahead.\n           */\n        } while (--s.match_length !== 0);\n\n        s.strstart++;\n      } else {\n        s.strstart += s.match_length;\n        s.match_length = 0;\n        s.ins_h = s.window[s.strstart];\n        /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */\n\n        s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask; //#if MIN_MATCH != 3\n        //                Call UPDATE_HASH() MIN_MATCH-3 more times\n        //#endif\n\n        /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not\n         * matter since it will be recomputed at next deflate call.\n         */\n      }\n    } else {\n      /* No match, output a literal byte */\n      //Tracevv((stderr,\"%c\", s.window[s.strstart]));\n\n      /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n      s.lookahead--;\n      s.strstart++;\n    }\n\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n\n    }\n  }\n\n  s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;\n\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n\n\n    return BS_FINISH_DONE;\n  }\n\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n\n  }\n\n  return BS_BLOCK_DONE;\n}\n/* ===========================================================================\n * Same as above, but achieves better compression. We use a lazy\n * evaluation for matches: a match is finally adopted only if there is\n * no better match at the next window position.\n */\n\n\nfunction deflate_slow(s, flush) {\n  var hash_head;\n  /* head of hash chain */\n\n  var bflush;\n  /* set if current block must be flushed */\n\n  var max_insert;\n  /* Process the input block. */\n\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the next match, plus MIN_MATCH bytes to insert the\n     * string following the next match.\n     */\n    if (s.lookahead < MIN_LOOKAHEAD) {\n      fill_window(s);\n\n      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n\n      if (s.lookahead === 0) {\n        break;\n      }\n      /* flush the current block */\n\n    }\n    /* Insert the string window[strstart .. strstart+2] in the\n     * dictionary, and set hash_head to the head of the hash chain:\n     */\n\n\n    hash_head = 0\n    /*NIL*/\n    ;\n\n    if (s.lookahead >= MIN_MATCH) {\n      /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n      s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n      s.head[s.ins_h] = s.strstart;\n      /***/\n    }\n    /* Find the longest match, discarding those <= prev_length.\n     */\n\n\n    s.prev_length = s.match_length;\n    s.prev_match = s.match_start;\n    s.match_length = MIN_MATCH - 1;\n\n    if (hash_head !== 0\n    /*NIL*/\n    && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD\n    /*MAX_DIST(s)*/\n    ) {\n      /* To simplify the code, we prevent matches with the string\n       * of window index 0 (in particular we have to avoid a match\n       * of the string with itself at the start of the input file).\n       */\n      s.match_length = longest_match(s, hash_head);\n      /* longest_match() sets match_start */\n\n      if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096\n      /*TOO_FAR*/\n      )) {\n        /* If prev_match is also MIN_MATCH, match_start is garbage\n         * but we will ignore the current match anyway.\n         */\n        s.match_length = MIN_MATCH - 1;\n      }\n    }\n    /* If there was a match at the previous step and the current\n     * match is not better, output the previous match:\n     */\n\n\n    if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {\n      max_insert = s.strstart + s.lookahead - MIN_MATCH;\n      /* Do not insert strings in hash table beyond this. */\n      //check_match(s, s.strstart-1, s.prev_match, s.prev_length);\n\n      /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n                     s.prev_length - MIN_MATCH, bflush);***/\n\n      bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);\n      /* Insert in hash table all strings up to the end of the match.\n       * strstart-1 and strstart are already inserted. If there is not\n       * enough lookahead, the last two strings are not inserted in\n       * the hash table.\n       */\n\n      s.lookahead -= s.prev_length - 1;\n      s.prev_length -= 2;\n\n      do {\n        if (++s.strstart <= max_insert) {\n          /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n          s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n          s.head[s.ins_h] = s.strstart;\n          /***/\n        }\n      } while (--s.prev_length !== 0);\n\n      s.match_available = 0;\n      s.match_length = MIN_MATCH - 1;\n      s.strstart++;\n\n      if (bflush) {\n        /*** FLUSH_BLOCK(s, 0); ***/\n        flush_block_only(s, false);\n\n        if (s.strm.avail_out === 0) {\n          return BS_NEED_MORE;\n        }\n        /***/\n\n      }\n    } else if (s.match_available) {\n      /* If there was no match at the previous position, output a\n       * single literal. If there was a match but the current match\n       * is longer, truncate the previous match to a single literal.\n       */\n      //Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n\n      /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);\n\n      if (bflush) {\n        /*** FLUSH_BLOCK_ONLY(s, 0) ***/\n        flush_block_only(s, false);\n        /***/\n      }\n\n      s.strstart++;\n      s.lookahead--;\n\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n    } else {\n      /* There is no previous match to compare with, wait for\n       * the next step to decide.\n       */\n      s.match_available = 1;\n      s.strstart++;\n      s.lookahead--;\n    }\n  } //Assert (flush != Z_NO_FLUSH, \"no flush?\");\n\n\n  if (s.match_available) {\n    //Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n\n    /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/\n    bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);\n    s.match_available = 0;\n  }\n\n  s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;\n\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n\n\n    return BS_FINISH_DONE;\n  }\n\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n\n  }\n\n  return BS_BLOCK_DONE;\n}\n/* ===========================================================================\n * For Z_RLE, simply look for runs of bytes, generate matches only of distance\n * one.  Do not maintain a hash table.  (It will be regenerated if this run of\n * deflate switches away from Z_RLE.)\n */\n\n\nfunction deflate_rle(s, flush) {\n  var bflush;\n  /* set if current block must be flushed */\n\n  var prev;\n  /* byte at distance one to match */\n\n  var scan, strend;\n  /* scan goes up to strend for length of run */\n\n  var _win = s.window;\n\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the longest run, plus one for the unrolled loop.\n     */\n    if (s.lookahead <= MAX_MATCH) {\n      fill_window(s);\n\n      if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n\n      if (s.lookahead === 0) {\n        break;\n      }\n      /* flush the current block */\n\n    }\n    /* See how many times the previous byte repeats */\n\n\n    s.match_length = 0;\n\n    if (s.lookahead >= MIN_MATCH && s.strstart > 0) {\n      scan = s.strstart - 1;\n      prev = _win[scan];\n\n      if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n        strend = s.strstart + MAX_MATCH;\n\n        do {\n          /*jshint noempty:false*/\n        } 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);\n\n        s.match_length = MAX_MATCH - (strend - scan);\n\n        if (s.match_length > s.lookahead) {\n          s.match_length = s.lookahead;\n        }\n      } //Assert(scan <= s->window+(uInt)(s->window_size-1), \"wild scan\");\n\n    }\n    /* Emit match if have run of MIN_MATCH or longer, else emit literal */\n\n\n    if (s.match_length >= MIN_MATCH) {\n      //check_match(s, s.strstart, s.strstart - 1, s.match_length);\n\n      /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/\n      bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);\n      s.lookahead -= s.match_length;\n      s.strstart += s.match_length;\n      s.match_length = 0;\n    } else {\n      /* No match, output a literal byte */\n      //Tracevv((stderr,\"%c\", s->window[s->strstart]));\n\n      /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n      s.lookahead--;\n      s.strstart++;\n    }\n\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n\n    }\n  }\n\n  s.insert = 0;\n\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n\n\n    return BS_FINISH_DONE;\n  }\n\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n\n  }\n\n  return BS_BLOCK_DONE;\n}\n/* ===========================================================================\n * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.\n * (It will be regenerated if this run of deflate switches away from Huffman.)\n */\n\n\nfunction deflate_huff(s, flush) {\n  var bflush;\n  /* set if current block must be flushed */\n\n  for (;;) {\n    /* Make sure that we have a literal to write. */\n    if (s.lookahead === 0) {\n      fill_window(s);\n\n      if (s.lookahead === 0) {\n        if (flush === Z_NO_FLUSH) {\n          return BS_NEED_MORE;\n        }\n\n        break;\n        /* flush the current block */\n      }\n    }\n    /* Output a literal byte */\n\n\n    s.match_length = 0; //Tracevv((stderr,\"%c\", s->window[s->strstart]));\n\n    /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n\n    bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n    s.lookahead--;\n    s.strstart++;\n\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n\n    }\n  }\n\n  s.insert = 0;\n\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n\n\n    return BS_FINISH_DONE;\n  }\n\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n\n  }\n\n  return BS_BLOCK_DONE;\n}\n/* Values for max_lazy_match, good_match and max_chain_length, depending on\n * the desired pack level (0..9). The values given below have been tuned to\n * exclude worst case performance for pathological files. Better values may be\n * found for specific files.\n */\n\n\nfunction Config(good_length, max_lazy, nice_length, max_chain, func) {\n  this.good_length = good_length;\n  this.max_lazy = max_lazy;\n  this.nice_length = nice_length;\n  this.max_chain = max_chain;\n  this.func = func;\n}\n\nvar configuration_table;\nconfiguration_table = [\n/*      good lazy nice chain */\nnew Config(0, 0, 0, 0, deflate_stored),\n/* 0 store only */\nnew Config(4, 4, 8, 4, deflate_fast),\n/* 1 max speed, no lazy matches */\nnew Config(4, 5, 16, 8, deflate_fast),\n/* 2 */\nnew Config(4, 6, 32, 32, deflate_fast),\n/* 3 */\nnew Config(4, 4, 16, 16, deflate_slow),\n/* 4 lazy matches */\nnew Config(8, 16, 32, 32, deflate_slow),\n/* 5 */\nnew Config(8, 16, 128, 128, deflate_slow),\n/* 6 */\nnew Config(8, 32, 128, 256, deflate_slow),\n/* 7 */\nnew Config(32, 128, 258, 1024, deflate_slow),\n/* 8 */\nnew Config(32, 258, 258, 4096, deflate_slow)\n/* 9 max compression */\n];\n/* ===========================================================================\n * Initialize the \"longest match\" routines for a new zlib stream\n */\n\nfunction lm_init(s) {\n  s.window_size = 2 * s.w_size;\n  /*** CLEAR_HASH(s); ***/\n\n  zero(s.head); // Fill with NIL (= 0);\n\n  /* Set the default configuration parameters:\n   */\n\n  s.max_lazy_match = configuration_table[s.level].max_lazy;\n  s.good_match = configuration_table[s.level].good_length;\n  s.nice_match = configuration_table[s.level].nice_length;\n  s.max_chain_length = configuration_table[s.level].max_chain;\n  s.strstart = 0;\n  s.block_start = 0;\n  s.lookahead = 0;\n  s.insert = 0;\n  s.match_length = s.prev_length = MIN_MATCH - 1;\n  s.match_available = 0;\n  s.ins_h = 0;\n}\n\nfunction DeflateState() {\n  this.strm = null;\n  /* pointer back to this zlib stream */\n\n  this.status = 0;\n  /* as the name implies */\n\n  this.pending_buf = null;\n  /* output still pending */\n\n  this.pending_buf_size = 0;\n  /* size of pending_buf */\n\n  this.pending_out = 0;\n  /* next pending byte to output to the stream */\n\n  this.pending = 0;\n  /* nb of bytes in the pending buffer */\n\n  this.wrap = 0;\n  /* bit 0 true for zlib, bit 1 true for gzip */\n\n  this.gzhead = null;\n  /* gzip header information to write */\n\n  this.gzindex = 0;\n  /* where in extra, name, or comment */\n\n  this.method = Z_DEFLATED;\n  /* can only be DEFLATED */\n\n  this.last_flush = -1;\n  /* value of flush param for previous deflate call */\n\n  this.w_size = 0;\n  /* LZ77 window size (32K by default) */\n\n  this.w_bits = 0;\n  /* log2(w_size)  (8..16) */\n\n  this.w_mask = 0;\n  /* w_size - 1 */\n\n  this.window = null;\n  /* Sliding window. Input bytes are read into the second half of the window,\n   * and move to the first half later to keep a dictionary of at least wSize\n   * bytes. With this organization, matches are limited to a distance of\n   * wSize-MAX_MATCH bytes, but this ensures that IO is always\n   * performed with a length multiple of the block size.\n   */\n\n  this.window_size = 0;\n  /* Actual size of window: 2*wSize, except when the user input buffer\n   * is directly used as sliding window.\n   */\n\n  this.prev = null;\n  /* Link to older string with same hash index. To limit the size of this\n   * array to 64K, this link is maintained only for the last 32K strings.\n   * An index in this array is thus a window index modulo 32K.\n   */\n\n  this.head = null;\n  /* Heads of the hash chains or NIL. */\n\n  this.ins_h = 0;\n  /* hash index of string to be inserted */\n\n  this.hash_size = 0;\n  /* number of elements in hash table */\n\n  this.hash_bits = 0;\n  /* log2(hash_size) */\n\n  this.hash_mask = 0;\n  /* hash_size-1 */\n\n  this.hash_shift = 0;\n  /* Number of bits by which ins_h must be shifted at each input\n   * step. It must be such that after MIN_MATCH steps, the oldest\n   * byte no longer takes part in the hash key, that is:\n   *   hash_shift * MIN_MATCH >= hash_bits\n   */\n\n  this.block_start = 0;\n  /* Window position at the beginning of the current output block. Gets\n   * negative when the window is moved backwards.\n   */\n\n  this.match_length = 0;\n  /* length of best match */\n\n  this.prev_match = 0;\n  /* previous match */\n\n  this.match_available = 0;\n  /* set if previous match exists */\n\n  this.strstart = 0;\n  /* start of string to insert */\n\n  this.match_start = 0;\n  /* start of matching string */\n\n  this.lookahead = 0;\n  /* number of valid bytes ahead in window */\n\n  this.prev_length = 0;\n  /* Length of the best match at previous step. Matches not greater than this\n   * are discarded. This is used in the lazy match evaluation.\n   */\n\n  this.max_chain_length = 0;\n  /* To speed up deflation, hash chains are never searched beyond this\n   * length.  A higher limit improves compression ratio but degrades the\n   * speed.\n   */\n\n  this.max_lazy_match = 0;\n  /* Attempt to find a better match only when the current match is strictly\n   * smaller than this value. This mechanism is used only for compression\n   * levels >= 4.\n   */\n  // That's alias to max_lazy_match, don't use directly\n  //this.max_insert_length = 0;\n\n  /* Insert new strings in the hash table only if the match length is not\n   * greater than this length. This saves time but degrades compression.\n   * max_insert_length is used only for compression levels <= 3.\n   */\n\n  this.level = 0;\n  /* compression level (1..9) */\n\n  this.strategy = 0;\n  /* favor or force Huffman coding*/\n\n  this.good_match = 0;\n  /* Use a faster search when the previous match is longer than this */\n\n  this.nice_match = 0;\n  /* Stop searching when current match exceeds this */\n\n  /* used by trees.c: */\n\n  /* Didn't use ct_data typedef below to suppress compiler warning */\n  // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */\n  // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */\n  // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */\n  // Use flat array of DOUBLE size, with interleaved fata,\n  // because JS does not support effective\n\n  this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2);\n  this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2);\n  this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2);\n  zero(this.dyn_ltree);\n  zero(this.dyn_dtree);\n  zero(this.bl_tree);\n  this.l_desc = null;\n  /* desc. for literal tree */\n\n  this.d_desc = null;\n  /* desc. for distance tree */\n\n  this.bl_desc = null;\n  /* desc. for bit length tree */\n  //ush bl_count[MAX_BITS+1];\n\n  this.bl_count = new utils.Buf16(MAX_BITS + 1);\n  /* number of codes at each bit length for an optimal tree */\n  //int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */\n\n  this.heap = new utils.Buf16(2 * L_CODES + 1);\n  /* heap used to build the Huffman trees */\n\n  zero(this.heap);\n  this.heap_len = 0;\n  /* number of elements in the heap */\n\n  this.heap_max = 0;\n  /* element of largest frequency */\n\n  /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n   * The same heap array is used to build all trees.\n   */\n\n  this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1];\n\n  zero(this.depth);\n  /* Depth of each subtree used as tie breaker for trees of equal frequency\n   */\n\n  this.l_buf = 0;\n  /* buffer index for literals or lengths */\n\n  this.lit_bufsize = 0;\n  /* Size of match buffer for literals/lengths.  There are 4 reasons for\n   * limiting lit_bufsize to 64K:\n   *   - frequencies can be kept in 16 bit counters\n   *   - if compression is not successful for the first block, all input\n   *     data is still in the window so we can still emit a stored block even\n   *     when input comes from standard input.  (This can also be done for\n   *     all blocks if lit_bufsize is not greater than 32K.)\n   *   - if compression is not successful for a file smaller than 64K, we can\n   *     even emit a stored file instead of a stored block (saving 5 bytes).\n   *     This is applicable only for zip (not gzip or zlib).\n   *   - creating new Huffman trees less frequently may not provide fast\n   *     adaptation to changes in the input data statistics. (Take for\n   *     example a binary file with poorly compressible code followed by\n   *     a highly compressible string table.) Smaller buffer sizes give\n   *     fast adaptation but have of course the overhead of transmitting\n   *     trees more frequently.\n   *   - I can't count above 4\n   */\n\n  this.last_lit = 0;\n  /* running index in l_buf */\n\n  this.d_buf = 0;\n  /* Buffer index for distances. To simplify the code, d_buf and l_buf have\n   * the same number of elements. To use different lengths, an extra flag\n   * array would be necessary.\n   */\n\n  this.opt_len = 0;\n  /* bit length of current block with optimal trees */\n\n  this.static_len = 0;\n  /* bit length of current block with static trees */\n\n  this.matches = 0;\n  /* number of string matches in current block */\n\n  this.insert = 0;\n  /* bytes at end of window left to insert */\n\n  this.bi_buf = 0;\n  /* Output buffer. bits are inserted starting at the bottom (least\n   * significant bits).\n   */\n\n  this.bi_valid = 0;\n  /* Number of valid bits in bi_buf.  All bits above the last valid bit\n   * are always zero.\n   */\n  // Used for window memory init. We safely ignore it for JS. That makes\n  // sense only for pointers and memory check tools.\n  //this.high_water = 0;\n\n  /* High water mark offset in window for initialized bytes -- bytes above\n   * this are set to zero in order to avoid memory check warnings when\n   * longest match routines access bytes past the input.  This is then\n   * updated to the new high water mark.\n   */\n}\n\nfunction deflateResetKeep(strm) {\n  var s;\n\n  if (!strm || !strm.state) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n  strm.total_in = strm.total_out = 0;\n  strm.data_type = Z_UNKNOWN;\n  s = strm.state;\n  s.pending = 0;\n  s.pending_out = 0;\n\n  if (s.wrap < 0) {\n    s.wrap = -s.wrap;\n    /* was made negative by deflate(..., Z_FINISH); */\n  }\n\n  s.status = s.wrap ? INIT_STATE : BUSY_STATE;\n  strm.adler = s.wrap === 2 ? 0 // crc32(0, Z_NULL, 0)\n  : 1; // adler32(0, Z_NULL, 0)\n\n  s.last_flush = Z_NO_FLUSH;\n\n  trees._tr_init(s);\n\n  return Z_OK;\n}\n\nfunction deflateReset(strm) {\n  var ret = deflateResetKeep(strm);\n\n  if (ret === Z_OK) {\n    lm_init(strm.state);\n  }\n\n  return ret;\n}\n\nfunction deflateSetHeader(strm, head) {\n  if (!strm || !strm.state) {\n    return Z_STREAM_ERROR;\n  }\n\n  if (strm.state.wrap !== 2) {\n    return Z_STREAM_ERROR;\n  }\n\n  strm.state.gzhead = head;\n  return Z_OK;\n}\n\nfunction deflateInit2(strm, level, method, windowBits, memLevel, strategy) {\n  if (!strm) {\n    // === Z_NULL\n    return Z_STREAM_ERROR;\n  }\n\n  var wrap = 1;\n\n  if (level === Z_DEFAULT_COMPRESSION) {\n    level = 6;\n  }\n\n  if (windowBits < 0) {\n    /* suppress zlib wrapper */\n    wrap = 0;\n    windowBits = -windowBits;\n  } else if (windowBits > 15) {\n    wrap = 2;\n    /* write gzip wrapper instead */\n\n    windowBits -= 16;\n  }\n\n  if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n  if (windowBits === 8) {\n    windowBits = 9;\n  }\n  /* until 256-byte window bug fixed */\n\n\n  var s = new DeflateState();\n  strm.state = s;\n  s.strm = strm;\n  s.wrap = wrap;\n  s.gzhead = null;\n  s.w_bits = windowBits;\n  s.w_size = 1 << s.w_bits;\n  s.w_mask = s.w_size - 1;\n  s.hash_bits = memLevel + 7;\n  s.hash_size = 1 << s.hash_bits;\n  s.hash_mask = s.hash_size - 1;\n  s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);\n  s.window = new utils.Buf8(s.w_size * 2);\n  s.head = new utils.Buf16(s.hash_size);\n  s.prev = new utils.Buf16(s.w_size); // Don't need mem init magic for JS.\n  //s.high_water = 0;  /* nothing written to s->window yet */\n\n  s.lit_bufsize = 1 << memLevel + 6;\n  /* 16K elements by default */\n\n  s.pending_buf_size = s.lit_bufsize * 4; //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);\n  //s->pending_buf = (uchf *) overlay;\n\n  s.pending_buf = new utils.Buf8(s.pending_buf_size); // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)\n  //s->d_buf = overlay + s->lit_bufsize/sizeof(ush);\n\n  s.d_buf = 1 * s.lit_bufsize; //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;\n\n  s.l_buf = (1 + 2) * s.lit_bufsize;\n  s.level = level;\n  s.strategy = strategy;\n  s.method = method;\n  return deflateReset(strm);\n}\n\nfunction deflateInit(strm, level) {\n  return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);\n}\n\nfunction deflate(strm, flush) {\n  var old_flush, s;\n  var beg, val; // for gzip header write only\n\n  if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) {\n    return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;\n  }\n\n  s = strm.state;\n\n  if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush !== Z_FINISH) {\n    return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR);\n  }\n\n  s.strm = strm;\n  /* just in case */\n\n  old_flush = s.last_flush;\n  s.last_flush = flush;\n  /* Write the header */\n\n  if (s.status === INIT_STATE) {\n    if (s.wrap === 2) {\n      // GZIP header\n      strm.adler = 0; //crc32(0L, Z_NULL, 0);\n\n      put_byte(s, 31);\n      put_byte(s, 139);\n      put_byte(s, 8);\n\n      if (!s.gzhead) {\n        // s->gzhead == Z_NULL\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n        put_byte(s, OS_CODE);\n        s.status = BUSY_STATE;\n      } else {\n        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));\n        put_byte(s, s.gzhead.time & 0xff);\n        put_byte(s, s.gzhead.time >> 8 & 0xff);\n        put_byte(s, s.gzhead.time >> 16 & 0xff);\n        put_byte(s, s.gzhead.time >> 24 & 0xff);\n        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n        put_byte(s, s.gzhead.os & 0xff);\n\n        if (s.gzhead.extra && s.gzhead.extra.length) {\n          put_byte(s, s.gzhead.extra.length & 0xff);\n          put_byte(s, s.gzhead.extra.length >> 8 & 0xff);\n        }\n\n        if (s.gzhead.hcrc) {\n          strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);\n        }\n\n        s.gzindex = 0;\n        s.status = EXTRA_STATE;\n      }\n    } else // DEFLATE header\n      {\n        var header = Z_DEFLATED + (s.w_bits - 8 << 4) << 8;\n        var level_flags = -1;\n\n        if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {\n          level_flags = 0;\n        } else if (s.level < 6) {\n          level_flags = 1;\n        } else if (s.level === 6) {\n          level_flags = 2;\n        } else {\n          level_flags = 3;\n        }\n\n        header |= level_flags << 6;\n\n        if (s.strstart !== 0) {\n          header |= PRESET_DICT;\n        }\n\n        header += 31 - header % 31;\n        s.status = BUSY_STATE;\n        putShortMSB(s, header);\n        /* Save the adler32 of the preset dictionary: */\n\n        if (s.strstart !== 0) {\n          putShortMSB(s, strm.adler >>> 16);\n          putShortMSB(s, strm.adler & 0xffff);\n        }\n\n        strm.adler = 1; // adler32(0L, Z_NULL, 0);\n      }\n  } //#ifdef GZIP\n\n\n  if (s.status === EXTRA_STATE) {\n    if (s.gzhead.extra\n    /* != Z_NULL*/\n    ) {\n      beg = s.pending;\n      /* start of bytes to update crc */\n\n      while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n\n          flush_pending(strm);\n          beg = s.pending;\n\n          if (s.pending === s.pending_buf_size) {\n            break;\n          }\n        }\n\n        put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);\n        s.gzindex++;\n      }\n\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n\n      if (s.gzindex === s.gzhead.extra.length) {\n        s.gzindex = 0;\n        s.status = NAME_STATE;\n      }\n    } else {\n      s.status = NAME_STATE;\n    }\n  }\n\n  if (s.status === NAME_STATE) {\n    if (s.gzhead.name\n    /* != Z_NULL*/\n    ) {\n      beg = s.pending;\n      /* start of bytes to update crc */\n      //int val;\n\n      do {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n\n          flush_pending(strm);\n          beg = s.pending;\n\n          if (s.pending === s.pending_buf_size) {\n            val = 1;\n            break;\n          }\n        } // JS specific: little magic to add zero terminator to end of string\n\n\n        if (s.gzindex < s.gzhead.name.length) {\n          val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;\n        } else {\n          val = 0;\n        }\n\n        put_byte(s, val);\n      } while (val !== 0);\n\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n\n      if (val === 0) {\n        s.gzindex = 0;\n        s.status = COMMENT_STATE;\n      }\n    } else {\n      s.status = COMMENT_STATE;\n    }\n  }\n\n  if (s.status === COMMENT_STATE) {\n    if (s.gzhead.comment\n    /* != Z_NULL*/\n    ) {\n      beg = s.pending;\n      /* start of bytes to update crc */\n      //int val;\n\n      do {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n\n          flush_pending(strm);\n          beg = s.pending;\n\n          if (s.pending === s.pending_buf_size) {\n            val = 1;\n            break;\n          }\n        } // JS specific: little magic to add zero terminator to end of string\n\n\n        if (s.gzindex < s.gzhead.comment.length) {\n          val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;\n        } else {\n          val = 0;\n        }\n\n        put_byte(s, val);\n      } while (val !== 0);\n\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n\n      if (val === 0) {\n        s.status = HCRC_STATE;\n      }\n    } else {\n      s.status = HCRC_STATE;\n    }\n  }\n\n  if (s.status === HCRC_STATE) {\n    if (s.gzhead.hcrc) {\n      if (s.pending + 2 > s.pending_buf_size) {\n        flush_pending(strm);\n      }\n\n      if (s.pending + 2 <= s.pending_buf_size) {\n        put_byte(s, strm.adler & 0xff);\n        put_byte(s, strm.adler >> 8 & 0xff);\n        strm.adler = 0; //crc32(0L, Z_NULL, 0);\n\n        s.status = BUSY_STATE;\n      }\n    } else {\n      s.status = BUSY_STATE;\n    }\n  } //#endif\n\n  /* Flush as much pending output as possible */\n\n\n  if (s.pending !== 0) {\n    flush_pending(strm);\n\n    if (strm.avail_out === 0) {\n      /* Since avail_out is 0, deflate will be called again with\n       * more output space, but possibly with both pending and\n       * avail_in equal to zero. There won't be anything to do,\n       * but this is not an error situation so make sure we\n       * return OK instead of BUF_ERROR at next call of deflate:\n       */\n      s.last_flush = -1;\n      return Z_OK;\n    }\n    /* Make sure there is something to do and avoid duplicate consecutive\n     * flushes. For repeated and useless calls with Z_FINISH, we keep\n     * returning Z_STREAM_END instead of Z_BUF_ERROR.\n     */\n\n  } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) {\n    return err(strm, Z_BUF_ERROR);\n  }\n  /* User must not provide more input after the first FINISH: */\n\n\n  if (s.status === FINISH_STATE && strm.avail_in !== 0) {\n    return err(strm, Z_BUF_ERROR);\n  }\n  /* Start a new block or continue the current one.\n   */\n\n\n  if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH && s.status !== FINISH_STATE) {\n    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);\n\n    if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {\n      s.status = FINISH_STATE;\n    }\n\n    if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n      if (strm.avail_out === 0) {\n        s.last_flush = -1;\n        /* avoid BUF_ERROR next call, see above */\n      }\n\n      return Z_OK;\n      /* If flush != Z_NO_FLUSH && avail_out == 0, the next call\n       * of deflate should use the same flush parameter to make sure\n       * that the flush is complete. So we don't have to output an\n       * empty block here, this will be done at next call. This also\n       * ensures that for a very small output buffer, we emit at most\n       * one empty block.\n       */\n    }\n\n    if (bstate === BS_BLOCK_DONE) {\n      if (flush === Z_PARTIAL_FLUSH) {\n        trees._tr_align(s);\n      } else if (flush !== Z_BLOCK) {\n        /* FULL_FLUSH or SYNC_FLUSH */\n        trees._tr_stored_block(s, 0, 0, false);\n        /* For a full flush, this empty block will be recognized\n         * as a special marker by inflate_sync().\n         */\n\n\n        if (flush === Z_FULL_FLUSH) {\n          /*** CLEAR_HASH(s); ***/\n\n          /* forget history */\n          zero(s.head); // Fill with NIL (= 0);\n\n          if (s.lookahead === 0) {\n            s.strstart = 0;\n            s.block_start = 0;\n            s.insert = 0;\n          }\n        }\n      }\n\n      flush_pending(strm);\n\n      if (strm.avail_out === 0) {\n        s.last_flush = -1;\n        /* avoid BUF_ERROR at next call, see above */\n\n        return Z_OK;\n      }\n    }\n  } //Assert(strm->avail_out > 0, \"bug2\");\n  //if (strm.avail_out <= 0) { throw new Error(\"bug2\");}\n\n\n  if (flush !== Z_FINISH) {\n    return Z_OK;\n  }\n\n  if (s.wrap <= 0) {\n    return Z_STREAM_END;\n  }\n  /* Write the trailer */\n\n\n  if (s.wrap === 2) {\n    put_byte(s, strm.adler & 0xff);\n    put_byte(s, strm.adler >> 8 & 0xff);\n    put_byte(s, strm.adler >> 16 & 0xff);\n    put_byte(s, strm.adler >> 24 & 0xff);\n    put_byte(s, strm.total_in & 0xff);\n    put_byte(s, strm.total_in >> 8 & 0xff);\n    put_byte(s, strm.total_in >> 16 & 0xff);\n    put_byte(s, strm.total_in >> 24 & 0xff);\n  } else {\n    putShortMSB(s, strm.adler >>> 16);\n    putShortMSB(s, strm.adler & 0xffff);\n  }\n\n  flush_pending(strm);\n  /* If avail_out is zero, the application will call deflate again\n   * to flush the rest.\n   */\n\n  if (s.wrap > 0) {\n    s.wrap = -s.wrap;\n  }\n  /* write the trailer only once! */\n\n\n  return s.pending !== 0 ? Z_OK : Z_STREAM_END;\n}\n\nfunction deflateEnd(strm) {\n  var status;\n\n  if (!strm\n  /*== Z_NULL*/\n  || !strm.state\n  /*== Z_NULL*/\n  ) {\n    return Z_STREAM_ERROR;\n  }\n\n  status = strm.state.status;\n\n  if (status !== INIT_STATE && status !== EXTRA_STATE && status !== NAME_STATE && status !== COMMENT_STATE && status !== HCRC_STATE && status !== BUSY_STATE && status !== FINISH_STATE) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n  strm.state = null;\n  return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;\n}\n/* =========================================================================\n * Initializes the compression dictionary from the given byte\n * sequence without producing any compressed output.\n */\n\n\nfunction deflateSetDictionary(strm, dictionary) {\n  var dictLength = dictionary.length;\n  var s;\n  var str, n;\n  var wrap;\n  var avail;\n  var next;\n  var input;\n  var tmpDict;\n\n  if (!strm\n  /*== Z_NULL*/\n  || !strm.state\n  /*== Z_NULL*/\n  ) {\n    return Z_STREAM_ERROR;\n  }\n\n  s = strm.state;\n  wrap = s.wrap;\n\n  if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) {\n    return Z_STREAM_ERROR;\n  }\n  /* when using zlib wrappers, compute Adler-32 for provided dictionary */\n\n\n  if (wrap === 1) {\n    /* adler32(strm->adler, dictionary, dictLength); */\n    strm.adler = adler32(strm.adler, dictionary, dictLength, 0);\n  }\n\n  s.wrap = 0;\n  /* avoid computing Adler-32 in read_buf */\n\n  /* if dictionary would fill window, just replace the history */\n\n  if (dictLength >= s.w_size) {\n    if (wrap === 0) {\n      /* already empty otherwise */\n\n      /*** CLEAR_HASH(s); ***/\n      zero(s.head); // Fill with NIL (= 0);\n\n      s.strstart = 0;\n      s.block_start = 0;\n      s.insert = 0;\n    }\n    /* use the tail */\n    // dictionary = dictionary.slice(dictLength - s.w_size);\n\n\n    tmpDict = new utils.Buf8(s.w_size);\n    utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);\n    dictionary = tmpDict;\n    dictLength = s.w_size;\n  }\n  /* insert dictionary into window and hash */\n\n\n  avail = strm.avail_in;\n  next = strm.next_in;\n  input = strm.input;\n  strm.avail_in = dictLength;\n  strm.next_in = 0;\n  strm.input = dictionary;\n  fill_window(s);\n\n  while (s.lookahead >= MIN_MATCH) {\n    str = s.strstart;\n    n = s.lookahead - (MIN_MATCH - 1);\n\n    do {\n      /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n      s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;\n      s.prev[str & s.w_mask] = s.head[s.ins_h];\n      s.head[s.ins_h] = str;\n      str++;\n    } while (--n);\n\n    s.strstart = str;\n    s.lookahead = MIN_MATCH - 1;\n    fill_window(s);\n  }\n\n  s.strstart += s.lookahead;\n  s.block_start = s.strstart;\n  s.insert = s.lookahead;\n  s.lookahead = 0;\n  s.match_length = s.prev_length = MIN_MATCH - 1;\n  s.match_available = 0;\n  strm.next_in = next;\n  strm.input = input;\n  strm.avail_in = avail;\n  s.wrap = wrap;\n  return Z_OK;\n}\n\nexports.deflateInit = deflateInit;\nexports.deflateInit2 = deflateInit2;\nexports.deflateReset = deflateReset;\nexports.deflateResetKeep = deflateResetKeep;\nexports.deflateSetHeader = deflateSetHeader;\nexports.deflate = deflate;\nexports.deflateEnd = deflateEnd;\nexports.deflateSetDictionary = deflateSetDictionary;\nexports.deflateInfo = 'pako deflate (from Nodeca project)';\n/* Not implemented\nexports.deflateBound = deflateBound;\nexports.deflateCopy = deflateCopy;\nexports.deflateParams = deflateParams;\nexports.deflatePending = deflatePending;\nexports.deflatePrime = deflatePrime;\nexports.deflateTune = deflateTune;\n*/","map":{"version":3,"sources":["/Users/tylerkoenig/Code/personal/react-scss2/node_modules/pako/lib/zlib/deflate.js"],"names":["utils","require","trees","adler32","crc32","msg","Z_NO_FLUSH","Z_PARTIAL_FLUSH","Z_FULL_FLUSH","Z_FINISH","Z_BLOCK","Z_OK","Z_STREAM_END","Z_STREAM_ERROR","Z_DATA_ERROR","Z_BUF_ERROR","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_FIXED","Z_DEFAULT_STRATEGY","Z_UNKNOWN","Z_DEFLATED","MAX_MEM_LEVEL","MAX_WBITS","DEF_MEM_LEVEL","LENGTH_CODES","LITERALS","L_CODES","D_CODES","BL_CODES","HEAP_SIZE","MAX_BITS","MIN_MATCH","MAX_MATCH","MIN_LOOKAHEAD","PRESET_DICT","INIT_STATE","EXTRA_STATE","NAME_STATE","COMMENT_STATE","HCRC_STATE","BUSY_STATE","FINISH_STATE","BS_NEED_MORE","BS_BLOCK_DONE","BS_FINISH_STARTED","BS_FINISH_DONE","OS_CODE","err","strm","errorCode","rank","f","zero","buf","len","length","flush_pending","s","state","pending","avail_out","arraySet","output","pending_buf","pending_out","next_out","total_out","flush_block_only","last","_tr_flush_block","block_start","strstart","put_byte","b","putShortMSB","read_buf","start","size","avail_in","input","next_in","wrap","adler","total_in","longest_match","cur_match","chain_length","max_chain_length","scan","match","best_len","prev_length","nice_match","limit","w_size","_win","window","wmask","w_mask","prev","strend","scan_end1","scan_end","good_match","lookahead","match_start","fill_window","_w_size","p","n","m","more","str","window_size","hash_size","head","insert","ins_h","hash_shift","hash_mask","deflate_stored","flush","max_block_size","pending_buf_size","max_start","deflate_fast","hash_head","bflush","match_length","_tr_tally","max_lazy_match","last_lit","deflate_slow","max_insert","prev_match","strategy","match_available","deflate_rle","deflate_huff","Config","good_length","max_lazy","nice_length","max_chain","func","configuration_table","lm_init","level","DeflateState","status","gzhead","gzindex","method","last_flush","w_bits","hash_bits","dyn_ltree","Buf16","dyn_dtree","bl_tree","l_desc","d_desc","bl_desc","bl_count","heap","heap_len","heap_max","depth","l_buf","lit_bufsize","d_buf","opt_len","static_len","matches","bi_buf","bi_valid","deflateResetKeep","data_type","_tr_init","deflateReset","ret","deflateSetHeader","deflateInit2","windowBits","memLevel","Buf8","deflateInit","deflate","old_flush","beg","val","text","hcrc","extra","name","comment","time","os","header","level_flags","charCodeAt","bstate","_tr_align","_tr_stored_block","deflateEnd","deflateSetDictionary","dictionary","dictLength","avail","next","tmpDict","exports","deflateInfo"],"mappings":"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","sourcesContent":["'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nvar utils   = require('../utils/common');\nvar trees   = require('./trees');\nvar adler32 = require('./adler32');\nvar crc32   = require('./crc32');\nvar msg     = require('./messages');\n\n/* Public constants ==========================================================*/\n/* ===========================================================================*/\n\n\n/* Allowed flush values; see deflate() and inflate() below for details */\nvar Z_NO_FLUSH      = 0;\nvar Z_PARTIAL_FLUSH = 1;\n//var Z_SYNC_FLUSH    = 2;\nvar Z_FULL_FLUSH    = 3;\nvar Z_FINISH        = 4;\nvar Z_BLOCK         = 5;\n//var Z_TREES         = 6;\n\n\n/* Return codes for the compression/decompression functions. Negative values\n * are errors, positive values are used for special but normal events.\n */\nvar Z_OK            = 0;\nvar Z_STREAM_END    = 1;\n//var Z_NEED_DICT     = 2;\n//var Z_ERRNO         = -1;\nvar Z_STREAM_ERROR  = -2;\nvar Z_DATA_ERROR    = -3;\n//var Z_MEM_ERROR     = -4;\nvar Z_BUF_ERROR     = -5;\n//var Z_VERSION_ERROR = -6;\n\n\n/* compression levels */\n//var Z_NO_COMPRESSION      = 0;\n//var Z_BEST_SPEED          = 1;\n//var Z_BEST_COMPRESSION    = 9;\nvar Z_DEFAULT_COMPRESSION = -1;\n\n\nvar Z_FILTERED            = 1;\nvar Z_HUFFMAN_ONLY        = 2;\nvar Z_RLE                 = 3;\nvar Z_FIXED               = 4;\nvar Z_DEFAULT_STRATEGY    = 0;\n\n/* Possible values of the data_type field (though see inflate()) */\n//var Z_BINARY              = 0;\n//var Z_TEXT                = 1;\n//var Z_ASCII               = 1; // = Z_TEXT\nvar Z_UNKNOWN             = 2;\n\n\n/* The deflate compression method */\nvar Z_DEFLATED  = 8;\n\n/*============================================================================*/\n\n\nvar MAX_MEM_LEVEL = 9;\n/* Maximum value for memLevel in deflateInit2 */\nvar MAX_WBITS = 15;\n/* 32K LZ77 window */\nvar DEF_MEM_LEVEL = 8;\n\n\nvar LENGTH_CODES  = 29;\n/* number of length codes, not counting the special END_BLOCK code */\nvar LITERALS      = 256;\n/* number of literal bytes 0..255 */\nvar L_CODES       = LITERALS + 1 + LENGTH_CODES;\n/* number of Literal or Length codes, including the END_BLOCK code */\nvar D_CODES       = 30;\n/* number of distance codes */\nvar BL_CODES      = 19;\n/* number of codes used to transfer the bit lengths */\nvar HEAP_SIZE     = 2 * L_CODES + 1;\n/* maximum heap size */\nvar MAX_BITS  = 15;\n/* All codes must not exceed MAX_BITS bits */\n\nvar MIN_MATCH = 3;\nvar MAX_MATCH = 258;\nvar MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);\n\nvar PRESET_DICT = 0x20;\n\nvar INIT_STATE = 42;\nvar EXTRA_STATE = 69;\nvar NAME_STATE = 73;\nvar COMMENT_STATE = 91;\nvar HCRC_STATE = 103;\nvar BUSY_STATE = 113;\nvar FINISH_STATE = 666;\n\nvar BS_NEED_MORE      = 1; /* block not completed, need more input or more output */\nvar BS_BLOCK_DONE     = 2; /* block flush performed */\nvar BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */\nvar BS_FINISH_DONE    = 4; /* finish done, accept no more input or output */\n\nvar OS_CODE = 0x03; // Unix :) . Don't detect, use this default.\n\nfunction err(strm, errorCode) {\n  strm.msg = msg[errorCode];\n  return errorCode;\n}\n\nfunction rank(f) {\n  return ((f) << 1) - ((f) > 4 ? 9 : 0);\n}\n\nfunction zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }\n\n\n/* =========================================================================\n * Flush as much pending output as possible. All deflate() output goes\n * through this function so some applications may wish to modify it\n * to avoid allocating a large strm->output buffer and copying into it.\n * (See also read_buf()).\n */\nfunction flush_pending(strm) {\n  var s = strm.state;\n\n  //_tr_flush_bits(s);\n  var len = s.pending;\n  if (len > strm.avail_out) {\n    len = strm.avail_out;\n  }\n  if (len === 0) { return; }\n\n  utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);\n  strm.next_out += len;\n  s.pending_out += len;\n  strm.total_out += len;\n  strm.avail_out -= len;\n  s.pending -= len;\n  if (s.pending === 0) {\n    s.pending_out = 0;\n  }\n}\n\n\nfunction flush_block_only(s, last) {\n  trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);\n  s.block_start = s.strstart;\n  flush_pending(s.strm);\n}\n\n\nfunction put_byte(s, b) {\n  s.pending_buf[s.pending++] = b;\n}\n\n\n/* =========================================================================\n * Put a short in the pending buffer. The 16-bit value is put in MSB order.\n * IN assertion: the stream state is correct and there is enough room in\n * pending_buf.\n */\nfunction putShortMSB(s, b) {\n//  put_byte(s, (Byte)(b >> 8));\n//  put_byte(s, (Byte)(b & 0xff));\n  s.pending_buf[s.pending++] = (b >>> 8) & 0xff;\n  s.pending_buf[s.pending++] = b & 0xff;\n}\n\n\n/* ===========================================================================\n * Read a new buffer from the current input stream, update the adler32\n * and total number of bytes read.  All deflate() input goes through\n * this function so some applications may wish to modify it to avoid\n * allocating a large strm->input buffer and copying from it.\n * (See also flush_pending()).\n */\nfunction read_buf(strm, buf, start, size) {\n  var len = strm.avail_in;\n\n  if (len > size) { len = size; }\n  if (len === 0) { return 0; }\n\n  strm.avail_in -= len;\n\n  // zmemcpy(buf, strm->next_in, len);\n  utils.arraySet(buf, strm.input, strm.next_in, len, start);\n  if (strm.state.wrap === 1) {\n    strm.adler = adler32(strm.adler, buf, len, start);\n  }\n\n  else if (strm.state.wrap === 2) {\n    strm.adler = crc32(strm.adler, buf, len, start);\n  }\n\n  strm.next_in += len;\n  strm.total_in += len;\n\n  return len;\n}\n\n\n/* ===========================================================================\n * Set match_start to the longest match starting at the given string and\n * return its length. Matches shorter or equal to prev_length are discarded,\n * in which case the result is equal to prev_length and match_start is\n * garbage.\n * IN assertions: cur_match is the head of the hash chain for the current\n *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1\n * OUT assertion: the match length is not greater than s->lookahead.\n */\nfunction longest_match(s, cur_match) {\n  var chain_length = s.max_chain_length;      /* max hash chain length */\n  var scan = s.strstart; /* current string */\n  var match;                       /* matched string */\n  var len;                           /* length of current match */\n  var best_len = s.prev_length;              /* best match length so far */\n  var nice_match = s.nice_match;             /* stop if match long enough */\n  var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ?\n      s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/;\n\n  var _win = s.window; // shortcut\n\n  var wmask = s.w_mask;\n  var prev  = s.prev;\n\n  /* Stop when cur_match becomes <= limit. To simplify the code,\n   * we prevent matches with the string of window index 0.\n   */\n\n  var strend = s.strstart + MAX_MATCH;\n  var scan_end1  = _win[scan + best_len - 1];\n  var scan_end   = _win[scan + best_len];\n\n  /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.\n   * It is easy to get rid of this optimization if necessary.\n   */\n  // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, \"Code too clever\");\n\n  /* Do not waste too much time if we already have a good match: */\n  if (s.prev_length >= s.good_match) {\n    chain_length >>= 2;\n  }\n  /* Do not look for matches beyond the end of the input. This is necessary\n   * to make deflate deterministic.\n   */\n  if (nice_match > s.lookahead) { nice_match = s.lookahead; }\n\n  // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, \"need lookahead\");\n\n  do {\n    // Assert(cur_match < s->strstart, \"no future\");\n    match = cur_match;\n\n    /* Skip to next match if the match length cannot increase\n     * or if the match length is less than 2.  Note that the checks below\n     * for insufficient lookahead only occur occasionally for performance\n     * reasons.  Therefore uninitialized memory will be accessed, and\n     * conditional jumps will be made that depend on those values.\n     * However the length of the match is limited to the lookahead, so\n     * the output of deflate is not affected by the uninitialized values.\n     */\n\n    if (_win[match + best_len]     !== scan_end  ||\n        _win[match + best_len - 1] !== scan_end1 ||\n        _win[match]                !== _win[scan] ||\n        _win[++match]              !== _win[scan + 1]) {\n      continue;\n    }\n\n    /* The check at best_len-1 can be removed because it will be made\n     * again later. (This heuristic is not always a win.)\n     * It is not necessary to compare scan[2] and match[2] since they\n     * are always equal when the other bytes match, given that\n     * the hash keys are equal and that HASH_BITS >= 8.\n     */\n    scan += 2;\n    match++;\n    // Assert(*scan == *match, \"match[2]?\");\n\n    /* We check for insufficient lookahead only every 8th comparison;\n     * the 256th check will be made at strstart+258.\n     */\n    do {\n      /*jshint noempty:false*/\n    } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&\n             _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&\n             _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&\n             _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&\n             scan < strend);\n\n    // Assert(scan <= s->window+(unsigned)(s->window_size-1), \"wild scan\");\n\n    len = MAX_MATCH - (strend - scan);\n    scan = strend - MAX_MATCH;\n\n    if (len > best_len) {\n      s.match_start = cur_match;\n      best_len = len;\n      if (len >= nice_match) {\n        break;\n      }\n      scan_end1  = _win[scan + best_len - 1];\n      scan_end   = _win[scan + best_len];\n    }\n  } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);\n\n  if (best_len <= s.lookahead) {\n    return best_len;\n  }\n  return s.lookahead;\n}\n\n\n/* ===========================================================================\n * Fill the window when the lookahead becomes insufficient.\n * Updates strstart and lookahead.\n *\n * IN assertion: lookahead < MIN_LOOKAHEAD\n * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD\n *    At least one byte has been read, or avail_in == 0; reads are\n *    performed for at least two bytes (required for the zip translate_eol\n *    option -- not supported here).\n */\nfunction fill_window(s) {\n  var _w_size = s.w_size;\n  var p, n, m, more, str;\n\n  //Assert(s->lookahead < MIN_LOOKAHEAD, \"already enough lookahead\");\n\n  do {\n    more = s.window_size - s.lookahead - s.strstart;\n\n    // JS ints have 32 bit, block below not needed\n    /* Deal with !@#$% 64K limit: */\n    //if (sizeof(int) <= 2) {\n    //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {\n    //        more = wsize;\n    //\n    //  } else if (more == (unsigned)(-1)) {\n    //        /* Very unlikely, but possible on 16 bit machine if\n    //         * strstart == 0 && lookahead == 1 (input done a byte at time)\n    //         */\n    //        more--;\n    //    }\n    //}\n\n\n    /* If the window is almost full and there is insufficient lookahead,\n     * move the upper half to the lower one to make room in the upper half.\n     */\n    if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n\n      utils.arraySet(s.window, s.window, _w_size, _w_size, 0);\n      s.match_start -= _w_size;\n      s.strstart -= _w_size;\n      /* we now have strstart >= MAX_DIST */\n      s.block_start -= _w_size;\n\n      /* Slide the hash table (could be avoided with 32 bit values\n       at the expense of memory usage). We slide even when level == 0\n       to keep the hash table consistent if we switch back to level > 0\n       later. (Using level 0 permanently is not an optimal usage of\n       zlib, so we don't care about this pathological case.)\n       */\n\n      n = s.hash_size;\n      p = n;\n      do {\n        m = s.head[--p];\n        s.head[p] = (m >= _w_size ? m - _w_size : 0);\n      } while (--n);\n\n      n = _w_size;\n      p = n;\n      do {\n        m = s.prev[--p];\n        s.prev[p] = (m >= _w_size ? m - _w_size : 0);\n        /* If n is not on any hash chain, prev[n] is garbage but\n         * its value will never be used.\n         */\n      } while (--n);\n\n      more += _w_size;\n    }\n    if (s.strm.avail_in === 0) {\n      break;\n    }\n\n    /* If there was no sliding:\n     *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&\n     *    more == window_size - lookahead - strstart\n     * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)\n     * => more >= window_size - 2*WSIZE + 2\n     * In the BIG_MEM or MMAP case (not yet supported),\n     *   window_size == input_size + MIN_LOOKAHEAD  &&\n     *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.\n     * Otherwise, window_size == 2*WSIZE so more >= 2.\n     * If there was sliding, more >= WSIZE. So in all cases, more >= 2.\n     */\n    //Assert(more >= 2, \"more < 2\");\n    n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);\n    s.lookahead += n;\n\n    /* Initialize the hash value now that we have some input: */\n    if (s.lookahead + s.insert >= MIN_MATCH) {\n      str = s.strstart - s.insert;\n      s.ins_h = s.window[str];\n\n      /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */\n      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask;\n//#if MIN_MATCH != 3\n//        Call update_hash() MIN_MATCH-3 more times\n//#endif\n      while (s.insert) {\n        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n        s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;\n\n        s.prev[str & s.w_mask] = s.head[s.ins_h];\n        s.head[s.ins_h] = str;\n        str++;\n        s.insert--;\n        if (s.lookahead + s.insert < MIN_MATCH) {\n          break;\n        }\n      }\n    }\n    /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,\n     * but this is not important since only literal bytes will be emitted.\n     */\n\n  } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);\n\n  /* If the WIN_INIT bytes after the end of the current data have never been\n   * written, then zero those bytes in order to avoid memory check reports of\n   * the use of uninitialized (or uninitialised as Julian writes) bytes by\n   * the longest match routines.  Update the high water mark for the next\n   * time through here.  WIN_INIT is set to MAX_MATCH since the longest match\n   * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.\n   */\n//  if (s.high_water < s.window_size) {\n//    var curr = s.strstart + s.lookahead;\n//    var init = 0;\n//\n//    if (s.high_water < curr) {\n//      /* Previous high water mark below current data -- zero WIN_INIT\n//       * bytes or up to end of window, whichever is less.\n//       */\n//      init = s.window_size - curr;\n//      if (init > WIN_INIT)\n//        init = WIN_INIT;\n//      zmemzero(s->window + curr, (unsigned)init);\n//      s->high_water = curr + init;\n//    }\n//    else if (s->high_water < (ulg)curr + WIN_INIT) {\n//      /* High water mark at or above current data, but below current data\n//       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up\n//       * to end of window, whichever is less.\n//       */\n//      init = (ulg)curr + WIN_INIT - s->high_water;\n//      if (init > s->window_size - s->high_water)\n//        init = s->window_size - s->high_water;\n//      zmemzero(s->window + s->high_water, (unsigned)init);\n//      s->high_water += init;\n//    }\n//  }\n//\n//  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,\n//    \"not enough room for search\");\n}\n\n/* ===========================================================================\n * Copy without compression as much as possible from the input stream, return\n * the current block state.\n * This function does not insert new strings in the dictionary since\n * uncompressible data is probably not useful. This function is used\n * only for the level=0 compression option.\n * NOTE: this function should be optimized to avoid extra copying from\n * window to pending_buf.\n */\nfunction deflate_stored(s, flush) {\n  /* Stored blocks are limited to 0xffff bytes, pending_buf is limited\n   * to pending_buf_size, and each stored block has a 5 byte header:\n   */\n  var max_block_size = 0xffff;\n\n  if (max_block_size > s.pending_buf_size - 5) {\n    max_block_size = s.pending_buf_size - 5;\n  }\n\n  /* Copy as much as possible from input to output: */\n  for (;;) {\n    /* Fill the window as much as possible: */\n    if (s.lookahead <= 1) {\n\n      //Assert(s->strstart < s->w_size+MAX_DIST(s) ||\n      //  s->block_start >= (long)s->w_size, \"slide too late\");\n//      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||\n//        s.block_start >= s.w_size)) {\n//        throw  new Error(\"slide too late\");\n//      }\n\n      fill_window(s);\n      if (s.lookahead === 0 && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n\n      if (s.lookahead === 0) {\n        break;\n      }\n      /* flush the current block */\n    }\n    //Assert(s->block_start >= 0L, \"block gone\");\n//    if (s.block_start < 0) throw new Error(\"block gone\");\n\n    s.strstart += s.lookahead;\n    s.lookahead = 0;\n\n    /* Emit a stored block if pending_buf will be full: */\n    var max_start = s.block_start + max_block_size;\n\n    if (s.strstart === 0 || s.strstart >= max_start) {\n      /* strstart == 0 is possible when wraparound on 16-bit machine */\n      s.lookahead = s.strstart - max_start;\n      s.strstart = max_start;\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n\n\n    }\n    /* Flush if we may have to slide, otherwise block_start may become\n     * negative and the data will be gone:\n     */\n    if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n    }\n  }\n\n  s.insert = 0;\n\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n\n  if (s.strstart > s.block_start) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n\n  return BS_NEED_MORE;\n}\n\n/* ===========================================================================\n * Compress as much as possible from the input stream, return the current\n * block state.\n * This function does not perform lazy evaluation of matches and inserts\n * new strings in the dictionary only for unmatched strings or for short\n * matches. It is used only for the fast compression options.\n */\nfunction deflate_fast(s, flush) {\n  var hash_head;        /* head of the hash chain */\n  var bflush;           /* set if current block must be flushed */\n\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the next match, plus MIN_MATCH bytes to insert the\n     * string following the next match.\n     */\n    if (s.lookahead < MIN_LOOKAHEAD) {\n      fill_window(s);\n      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n      if (s.lookahead === 0) {\n        break; /* flush the current block */\n      }\n    }\n\n    /* Insert the string window[strstart .. strstart+2] in the\n     * dictionary, and set hash_head to the head of the hash chain:\n     */\n    hash_head = 0/*NIL*/;\n    if (s.lookahead >= MIN_MATCH) {\n      /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n      s.head[s.ins_h] = s.strstart;\n      /***/\n    }\n\n    /* Find the longest match, discarding those <= prev_length.\n     * At this point we have always match_length < MIN_MATCH\n     */\n    if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) {\n      /* To simplify the code, we prevent matches with the string\n       * of window index 0 (in particular we have to avoid a match\n       * of the string with itself at the start of the input file).\n       */\n      s.match_length = longest_match(s, hash_head);\n      /* longest_match() sets match_start */\n    }\n    if (s.match_length >= MIN_MATCH) {\n      // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only\n\n      /*** _tr_tally_dist(s, s.strstart - s.match_start,\n                     s.match_length - MIN_MATCH, bflush); ***/\n      bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);\n\n      s.lookahead -= s.match_length;\n\n      /* Insert new strings in the hash table only if the match length\n       * is not too large. This saves time but degrades compression.\n       */\n      if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) {\n        s.match_length--; /* string at strstart already in table */\n        do {\n          s.strstart++;\n          /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n          s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n          s.head[s.ins_h] = s.strstart;\n          /***/\n          /* strstart never exceeds WSIZE-MAX_MATCH, so there are\n           * always MIN_MATCH bytes ahead.\n           */\n        } while (--s.match_length !== 0);\n        s.strstart++;\n      } else\n      {\n        s.strstart += s.match_length;\n        s.match_length = 0;\n        s.ins_h = s.window[s.strstart];\n        /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */\n        s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask;\n\n//#if MIN_MATCH != 3\n//                Call UPDATE_HASH() MIN_MATCH-3 more times\n//#endif\n        /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not\n         * matter since it will be recomputed at next deflate call.\n         */\n      }\n    } else {\n      /* No match, output a literal byte */\n      //Tracevv((stderr,\"%c\", s.window[s.strstart]));\n      /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n\n      s.lookahead--;\n      s.strstart++;\n    }\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n    }\n  }\n  s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n  return BS_BLOCK_DONE;\n}\n\n/* ===========================================================================\n * Same as above, but achieves better compression. We use a lazy\n * evaluation for matches: a match is finally adopted only if there is\n * no better match at the next window position.\n */\nfunction deflate_slow(s, flush) {\n  var hash_head;          /* head of hash chain */\n  var bflush;              /* set if current block must be flushed */\n\n  var max_insert;\n\n  /* Process the input block. */\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the next match, plus MIN_MATCH bytes to insert the\n     * string following the next match.\n     */\n    if (s.lookahead < MIN_LOOKAHEAD) {\n      fill_window(s);\n      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n      if (s.lookahead === 0) { break; } /* flush the current block */\n    }\n\n    /* Insert the string window[strstart .. strstart+2] in the\n     * dictionary, and set hash_head to the head of the hash chain:\n     */\n    hash_head = 0/*NIL*/;\n    if (s.lookahead >= MIN_MATCH) {\n      /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n      s.head[s.ins_h] = s.strstart;\n      /***/\n    }\n\n    /* Find the longest match, discarding those <= prev_length.\n     */\n    s.prev_length = s.match_length;\n    s.prev_match = s.match_start;\n    s.match_length = MIN_MATCH - 1;\n\n    if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&\n        s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {\n      /* To simplify the code, we prevent matches with the string\n       * of window index 0 (in particular we have to avoid a match\n       * of the string with itself at the start of the input file).\n       */\n      s.match_length = longest_match(s, hash_head);\n      /* longest_match() sets match_start */\n\n      if (s.match_length <= 5 &&\n         (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {\n\n        /* If prev_match is also MIN_MATCH, match_start is garbage\n         * but we will ignore the current match anyway.\n         */\n        s.match_length = MIN_MATCH - 1;\n      }\n    }\n    /* If there was a match at the previous step and the current\n     * match is not better, output the previous match:\n     */\n    if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {\n      max_insert = s.strstart + s.lookahead - MIN_MATCH;\n      /* Do not insert strings in hash table beyond this. */\n\n      //check_match(s, s.strstart-1, s.prev_match, s.prev_length);\n\n      /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n                     s.prev_length - MIN_MATCH, bflush);***/\n      bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);\n      /* Insert in hash table all strings up to the end of the match.\n       * strstart-1 and strstart are already inserted. If there is not\n       * enough lookahead, the last two strings are not inserted in\n       * the hash table.\n       */\n      s.lookahead -= s.prev_length - 1;\n      s.prev_length -= 2;\n      do {\n        if (++s.strstart <= max_insert) {\n          /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n          s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n          s.head[s.ins_h] = s.strstart;\n          /***/\n        }\n      } while (--s.prev_length !== 0);\n      s.match_available = 0;\n      s.match_length = MIN_MATCH - 1;\n      s.strstart++;\n\n      if (bflush) {\n        /*** FLUSH_BLOCK(s, 0); ***/\n        flush_block_only(s, false);\n        if (s.strm.avail_out === 0) {\n          return BS_NEED_MORE;\n        }\n        /***/\n      }\n\n    } else if (s.match_available) {\n      /* If there was no match at the previous position, output a\n       * single literal. If there was a match but the current match\n       * is longer, truncate the previous match to a single literal.\n       */\n      //Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n      /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);\n\n      if (bflush) {\n        /*** FLUSH_BLOCK_ONLY(s, 0) ***/\n        flush_block_only(s, false);\n        /***/\n      }\n      s.strstart++;\n      s.lookahead--;\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n    } else {\n      /* There is no previous match to compare with, wait for\n       * the next step to decide.\n       */\n      s.match_available = 1;\n      s.strstart++;\n      s.lookahead--;\n    }\n  }\n  //Assert (flush != Z_NO_FLUSH, \"no flush?\");\n  if (s.match_available) {\n    //Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n    /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/\n    bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);\n\n    s.match_available = 0;\n  }\n  s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n\n  return BS_BLOCK_DONE;\n}\n\n\n/* ===========================================================================\n * For Z_RLE, simply look for runs of bytes, generate matches only of distance\n * one.  Do not maintain a hash table.  (It will be regenerated if this run of\n * deflate switches away from Z_RLE.)\n */\nfunction deflate_rle(s, flush) {\n  var bflush;            /* set if current block must be flushed */\n  var prev;              /* byte at distance one to match */\n  var scan, strend;      /* scan goes up to strend for length of run */\n\n  var _win = s.window;\n\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the longest run, plus one for the unrolled loop.\n     */\n    if (s.lookahead <= MAX_MATCH) {\n      fill_window(s);\n      if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n      if (s.lookahead === 0) { break; } /* flush the current block */\n    }\n\n    /* See how many times the previous byte repeats */\n    s.match_length = 0;\n    if (s.lookahead >= MIN_MATCH && s.strstart > 0) {\n      scan = s.strstart - 1;\n      prev = _win[scan];\n      if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n        strend = s.strstart + MAX_MATCH;\n        do {\n          /*jshint noempty:false*/\n        } while (prev === _win[++scan] && prev === _win[++scan] &&\n                 prev === _win[++scan] && prev === _win[++scan] &&\n                 prev === _win[++scan] && prev === _win[++scan] &&\n                 prev === _win[++scan] && prev === _win[++scan] &&\n                 scan < strend);\n        s.match_length = MAX_MATCH - (strend - scan);\n        if (s.match_length > s.lookahead) {\n          s.match_length = s.lookahead;\n        }\n      }\n      //Assert(scan <= s->window+(uInt)(s->window_size-1), \"wild scan\");\n    }\n\n    /* Emit match if have run of MIN_MATCH or longer, else emit literal */\n    if (s.match_length >= MIN_MATCH) {\n      //check_match(s, s.strstart, s.strstart - 1, s.match_length);\n\n      /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/\n      bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);\n\n      s.lookahead -= s.match_length;\n      s.strstart += s.match_length;\n      s.match_length = 0;\n    } else {\n      /* No match, output a literal byte */\n      //Tracevv((stderr,\"%c\", s->window[s->strstart]));\n      /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n\n      s.lookahead--;\n      s.strstart++;\n    }\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n    }\n  }\n  s.insert = 0;\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n  return BS_BLOCK_DONE;\n}\n\n/* ===========================================================================\n * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.\n * (It will be regenerated if this run of deflate switches away from Huffman.)\n */\nfunction deflate_huff(s, flush) {\n  var bflush;             /* set if current block must be flushed */\n\n  for (;;) {\n    /* Make sure that we have a literal to write. */\n    if (s.lookahead === 0) {\n      fill_window(s);\n      if (s.lookahead === 0) {\n        if (flush === Z_NO_FLUSH) {\n          return BS_NEED_MORE;\n        }\n        break;      /* flush the current block */\n      }\n    }\n\n    /* Output a literal byte */\n    s.match_length = 0;\n    //Tracevv((stderr,\"%c\", s->window[s->strstart]));\n    /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n    bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n    s.lookahead--;\n    s.strstart++;\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n    }\n  }\n  s.insert = 0;\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n  return BS_BLOCK_DONE;\n}\n\n/* Values for max_lazy_match, good_match and max_chain_length, depending on\n * the desired pack level (0..9). The values given below have been tuned to\n * exclude worst case performance for pathological files. Better values may be\n * found for specific files.\n */\nfunction Config(good_length, max_lazy, nice_length, max_chain, func) {\n  this.good_length = good_length;\n  this.max_lazy = max_lazy;\n  this.nice_length = nice_length;\n  this.max_chain = max_chain;\n  this.func = func;\n}\n\nvar configuration_table;\n\nconfiguration_table = [\n  /*      good lazy nice chain */\n  new Config(0, 0, 0, 0, deflate_stored),          /* 0 store only */\n  new Config(4, 4, 8, 4, deflate_fast),            /* 1 max speed, no lazy matches */\n  new Config(4, 5, 16, 8, deflate_fast),           /* 2 */\n  new Config(4, 6, 32, 32, deflate_fast),          /* 3 */\n\n  new Config(4, 4, 16, 16, deflate_slow),          /* 4 lazy matches */\n  new Config(8, 16, 32, 32, deflate_slow),         /* 5 */\n  new Config(8, 16, 128, 128, deflate_slow),       /* 6 */\n  new Config(8, 32, 128, 256, deflate_slow),       /* 7 */\n  new Config(32, 128, 258, 1024, deflate_slow),    /* 8 */\n  new Config(32, 258, 258, 4096, deflate_slow)     /* 9 max compression */\n];\n\n\n/* ===========================================================================\n * Initialize the \"longest match\" routines for a new zlib stream\n */\nfunction lm_init(s) {\n  s.window_size = 2 * s.w_size;\n\n  /*** CLEAR_HASH(s); ***/\n  zero(s.head); // Fill with NIL (= 0);\n\n  /* Set the default configuration parameters:\n   */\n  s.max_lazy_match = configuration_table[s.level].max_lazy;\n  s.good_match = configuration_table[s.level].good_length;\n  s.nice_match = configuration_table[s.level].nice_length;\n  s.max_chain_length = configuration_table[s.level].max_chain;\n\n  s.strstart = 0;\n  s.block_start = 0;\n  s.lookahead = 0;\n  s.insert = 0;\n  s.match_length = s.prev_length = MIN_MATCH - 1;\n  s.match_available = 0;\n  s.ins_h = 0;\n}\n\n\nfunction DeflateState() {\n  this.strm = null;            /* pointer back to this zlib stream */\n  this.status = 0;            /* as the name implies */\n  this.pending_buf = null;      /* output still pending */\n  this.pending_buf_size = 0;  /* size of pending_buf */\n  this.pending_out = 0;       /* next pending byte to output to the stream */\n  this.pending = 0;           /* nb of bytes in the pending buffer */\n  this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */\n  this.gzhead = null;         /* gzip header information to write */\n  this.gzindex = 0;           /* where in extra, name, or comment */\n  this.method = Z_DEFLATED; /* can only be DEFLATED */\n  this.last_flush = -1;   /* value of flush param for previous deflate call */\n\n  this.w_size = 0;  /* LZ77 window size (32K by default) */\n  this.w_bits = 0;  /* log2(w_size)  (8..16) */\n  this.w_mask = 0;  /* w_size - 1 */\n\n  this.window = null;\n  /* Sliding window. Input bytes are read into the second half of the window,\n   * and move to the first half later to keep a dictionary of at least wSize\n   * bytes. With this organization, matches are limited to a distance of\n   * wSize-MAX_MATCH bytes, but this ensures that IO is always\n   * performed with a length multiple of the block size.\n   */\n\n  this.window_size = 0;\n  /* Actual size of window: 2*wSize, except when the user input buffer\n   * is directly used as sliding window.\n   */\n\n  this.prev = null;\n  /* Link to older string with same hash index. To limit the size of this\n   * array to 64K, this link is maintained only for the last 32K strings.\n   * An index in this array is thus a window index modulo 32K.\n   */\n\n  this.head = null;   /* Heads of the hash chains or NIL. */\n\n  this.ins_h = 0;       /* hash index of string to be inserted */\n  this.hash_size = 0;   /* number of elements in hash table */\n  this.hash_bits = 0;   /* log2(hash_size) */\n  this.hash_mask = 0;   /* hash_size-1 */\n\n  this.hash_shift = 0;\n  /* Number of bits by which ins_h must be shifted at each input\n   * step. It must be such that after MIN_MATCH steps, the oldest\n   * byte no longer takes part in the hash key, that is:\n   *   hash_shift * MIN_MATCH >= hash_bits\n   */\n\n  this.block_start = 0;\n  /* Window position at the beginning of the current output block. Gets\n   * negative when the window is moved backwards.\n   */\n\n  this.match_length = 0;      /* length of best match */\n  this.prev_match = 0;        /* previous match */\n  this.match_available = 0;   /* set if previous match exists */\n  this.strstart = 0;          /* start of string to insert */\n  this.match_start = 0;       /* start of matching string */\n  this.lookahead = 0;         /* number of valid bytes ahead in window */\n\n  this.prev_length = 0;\n  /* Length of the best match at previous step. Matches not greater than this\n   * are discarded. This is used in the lazy match evaluation.\n   */\n\n  this.max_chain_length = 0;\n  /* To speed up deflation, hash chains are never searched beyond this\n   * length.  A higher limit improves compression ratio but degrades the\n   * speed.\n   */\n\n  this.max_lazy_match = 0;\n  /* Attempt to find a better match only when the current match is strictly\n   * smaller than this value. This mechanism is used only for compression\n   * levels >= 4.\n   */\n  // That's alias to max_lazy_match, don't use directly\n  //this.max_insert_length = 0;\n  /* Insert new strings in the hash table only if the match length is not\n   * greater than this length. This saves time but degrades compression.\n   * max_insert_length is used only for compression levels <= 3.\n   */\n\n  this.level = 0;     /* compression level (1..9) */\n  this.strategy = 0;  /* favor or force Huffman coding*/\n\n  this.good_match = 0;\n  /* Use a faster search when the previous match is longer than this */\n\n  this.nice_match = 0; /* Stop searching when current match exceeds this */\n\n              /* used by trees.c: */\n\n  /* Didn't use ct_data typedef below to suppress compiler warning */\n\n  // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */\n  // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */\n  // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */\n\n  // Use flat array of DOUBLE size, with interleaved fata,\n  // because JS does not support effective\n  this.dyn_ltree  = new utils.Buf16(HEAP_SIZE * 2);\n  this.dyn_dtree  = new utils.Buf16((2 * D_CODES + 1) * 2);\n  this.bl_tree    = new utils.Buf16((2 * BL_CODES + 1) * 2);\n  zero(this.dyn_ltree);\n  zero(this.dyn_dtree);\n  zero(this.bl_tree);\n\n  this.l_desc   = null;         /* desc. for literal tree */\n  this.d_desc   = null;         /* desc. for distance tree */\n  this.bl_desc  = null;         /* desc. for bit length tree */\n\n  //ush bl_count[MAX_BITS+1];\n  this.bl_count = new utils.Buf16(MAX_BITS + 1);\n  /* number of codes at each bit length for an optimal tree */\n\n  //int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */\n  this.heap = new utils.Buf16(2 * L_CODES + 1);  /* heap used to build the Huffman trees */\n  zero(this.heap);\n\n  this.heap_len = 0;               /* number of elements in the heap */\n  this.heap_max = 0;               /* element of largest frequency */\n  /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n   * The same heap array is used to build all trees.\n   */\n\n  this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1];\n  zero(this.depth);\n  /* Depth of each subtree used as tie breaker for trees of equal frequency\n   */\n\n  this.l_buf = 0;          /* buffer index for literals or lengths */\n\n  this.lit_bufsize = 0;\n  /* Size of match buffer for literals/lengths.  There are 4 reasons for\n   * limiting lit_bufsize to 64K:\n   *   - frequencies can be kept in 16 bit counters\n   *   - if compression is not successful for the first block, all input\n   *     data is still in the window so we can still emit a stored block even\n   *     when input comes from standard input.  (This can also be done for\n   *     all blocks if lit_bufsize is not greater than 32K.)\n   *   - if compression is not successful for a file smaller than 64K, we can\n   *     even emit a stored file instead of a stored block (saving 5 bytes).\n   *     This is applicable only for zip (not gzip or zlib).\n   *   - creating new Huffman trees less frequently may not provide fast\n   *     adaptation to changes in the input data statistics. (Take for\n   *     example a binary file with poorly compressible code followed by\n   *     a highly compressible string table.) Smaller buffer sizes give\n   *     fast adaptation but have of course the overhead of transmitting\n   *     trees more frequently.\n   *   - I can't count above 4\n   */\n\n  this.last_lit = 0;      /* running index in l_buf */\n\n  this.d_buf = 0;\n  /* Buffer index for distances. To simplify the code, d_buf and l_buf have\n   * the same number of elements. To use different lengths, an extra flag\n   * array would be necessary.\n   */\n\n  this.opt_len = 0;       /* bit length of current block with optimal trees */\n  this.static_len = 0;    /* bit length of current block with static trees */\n  this.matches = 0;       /* number of string matches in current block */\n  this.insert = 0;        /* bytes at end of window left to insert */\n\n\n  this.bi_buf = 0;\n  /* Output buffer. bits are inserted starting at the bottom (least\n   * significant bits).\n   */\n  this.bi_valid = 0;\n  /* Number of valid bits in bi_buf.  All bits above the last valid bit\n   * are always zero.\n   */\n\n  // Used for window memory init. We safely ignore it for JS. That makes\n  // sense only for pointers and memory check tools.\n  //this.high_water = 0;\n  /* High water mark offset in window for initialized bytes -- bytes above\n   * this are set to zero in order to avoid memory check warnings when\n   * longest match routines access bytes past the input.  This is then\n   * updated to the new high water mark.\n   */\n}\n\n\nfunction deflateResetKeep(strm) {\n  var s;\n\n  if (!strm || !strm.state) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n  strm.total_in = strm.total_out = 0;\n  strm.data_type = Z_UNKNOWN;\n\n  s = strm.state;\n  s.pending = 0;\n  s.pending_out = 0;\n\n  if (s.wrap < 0) {\n    s.wrap = -s.wrap;\n    /* was made negative by deflate(..., Z_FINISH); */\n  }\n  s.status = (s.wrap ? INIT_STATE : BUSY_STATE);\n  strm.adler = (s.wrap === 2) ?\n    0  // crc32(0, Z_NULL, 0)\n  :\n    1; // adler32(0, Z_NULL, 0)\n  s.last_flush = Z_NO_FLUSH;\n  trees._tr_init(s);\n  return Z_OK;\n}\n\n\nfunction deflateReset(strm) {\n  var ret = deflateResetKeep(strm);\n  if (ret === Z_OK) {\n    lm_init(strm.state);\n  }\n  return ret;\n}\n\n\nfunction deflateSetHeader(strm, head) {\n  if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n  if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }\n  strm.state.gzhead = head;\n  return Z_OK;\n}\n\n\nfunction deflateInit2(strm, level, method, windowBits, memLevel, strategy) {\n  if (!strm) { // === Z_NULL\n    return Z_STREAM_ERROR;\n  }\n  var wrap = 1;\n\n  if (level === Z_DEFAULT_COMPRESSION) {\n    level = 6;\n  }\n\n  if (windowBits < 0) { /* suppress zlib wrapper */\n    wrap = 0;\n    windowBits = -windowBits;\n  }\n\n  else if (windowBits > 15) {\n    wrap = 2;           /* write gzip wrapper instead */\n    windowBits -= 16;\n  }\n\n\n  if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED ||\n    windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||\n    strategy < 0 || strategy > Z_FIXED) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n\n  if (windowBits === 8) {\n    windowBits = 9;\n  }\n  /* until 256-byte window bug fixed */\n\n  var s = new DeflateState();\n\n  strm.state = s;\n  s.strm = strm;\n\n  s.wrap = wrap;\n  s.gzhead = null;\n  s.w_bits = windowBits;\n  s.w_size = 1 << s.w_bits;\n  s.w_mask = s.w_size - 1;\n\n  s.hash_bits = memLevel + 7;\n  s.hash_size = 1 << s.hash_bits;\n  s.hash_mask = s.hash_size - 1;\n  s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);\n\n  s.window = new utils.Buf8(s.w_size * 2);\n  s.head = new utils.Buf16(s.hash_size);\n  s.prev = new utils.Buf16(s.w_size);\n\n  // Don't need mem init magic for JS.\n  //s.high_water = 0;  /* nothing written to s->window yet */\n\n  s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */\n\n  s.pending_buf_size = s.lit_bufsize * 4;\n\n  //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);\n  //s->pending_buf = (uchf *) overlay;\n  s.pending_buf = new utils.Buf8(s.pending_buf_size);\n\n  // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)\n  //s->d_buf = overlay + s->lit_bufsize/sizeof(ush);\n  s.d_buf = 1 * s.lit_bufsize;\n\n  //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;\n  s.l_buf = (1 + 2) * s.lit_bufsize;\n\n  s.level = level;\n  s.strategy = strategy;\n  s.method = method;\n\n  return deflateReset(strm);\n}\n\nfunction deflateInit(strm, level) {\n  return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);\n}\n\n\nfunction deflate(strm, flush) {\n  var old_flush, s;\n  var beg, val; // for gzip header write only\n\n  if (!strm || !strm.state ||\n    flush > Z_BLOCK || flush < 0) {\n    return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;\n  }\n\n  s = strm.state;\n\n  if (!strm.output ||\n      (!strm.input && strm.avail_in !== 0) ||\n      (s.status === FINISH_STATE && flush !== Z_FINISH)) {\n    return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);\n  }\n\n  s.strm = strm; /* just in case */\n  old_flush = s.last_flush;\n  s.last_flush = flush;\n\n  /* Write the header */\n  if (s.status === INIT_STATE) {\n\n    if (s.wrap === 2) { // GZIP header\n      strm.adler = 0;  //crc32(0L, Z_NULL, 0);\n      put_byte(s, 31);\n      put_byte(s, 139);\n      put_byte(s, 8);\n      if (!s.gzhead) { // s->gzhead == Z_NULL\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, s.level === 9 ? 2 :\n                    (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?\n                     4 : 0));\n        put_byte(s, OS_CODE);\n        s.status = BUSY_STATE;\n      }\n      else {\n        put_byte(s, (s.gzhead.text ? 1 : 0) +\n                    (s.gzhead.hcrc ? 2 : 0) +\n                    (!s.gzhead.extra ? 0 : 4) +\n                    (!s.gzhead.name ? 0 : 8) +\n                    (!s.gzhead.comment ? 0 : 16)\n        );\n        put_byte(s, s.gzhead.time & 0xff);\n        put_byte(s, (s.gzhead.time >> 8) & 0xff);\n        put_byte(s, (s.gzhead.time >> 16) & 0xff);\n        put_byte(s, (s.gzhead.time >> 24) & 0xff);\n        put_byte(s, s.level === 9 ? 2 :\n                    (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?\n                     4 : 0));\n        put_byte(s, s.gzhead.os & 0xff);\n        if (s.gzhead.extra && s.gzhead.extra.length) {\n          put_byte(s, s.gzhead.extra.length & 0xff);\n          put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);\n        }\n        if (s.gzhead.hcrc) {\n          strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);\n        }\n        s.gzindex = 0;\n        s.status = EXTRA_STATE;\n      }\n    }\n    else // DEFLATE header\n    {\n      var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;\n      var level_flags = -1;\n\n      if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {\n        level_flags = 0;\n      } else if (s.level < 6) {\n        level_flags = 1;\n      } else if (s.level === 6) {\n        level_flags = 2;\n      } else {\n        level_flags = 3;\n      }\n      header |= (level_flags << 6);\n      if (s.strstart !== 0) { header |= PRESET_DICT; }\n      header += 31 - (header % 31);\n\n      s.status = BUSY_STATE;\n      putShortMSB(s, header);\n\n      /* Save the adler32 of the preset dictionary: */\n      if (s.strstart !== 0) {\n        putShortMSB(s, strm.adler >>> 16);\n        putShortMSB(s, strm.adler & 0xffff);\n      }\n      strm.adler = 1; // adler32(0L, Z_NULL, 0);\n    }\n  }\n\n//#ifdef GZIP\n  if (s.status === EXTRA_STATE) {\n    if (s.gzhead.extra/* != Z_NULL*/) {\n      beg = s.pending;  /* start of bytes to update crc */\n\n      while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n          flush_pending(strm);\n          beg = s.pending;\n          if (s.pending === s.pending_buf_size) {\n            break;\n          }\n        }\n        put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);\n        s.gzindex++;\n      }\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n      if (s.gzindex === s.gzhead.extra.length) {\n        s.gzindex = 0;\n        s.status = NAME_STATE;\n      }\n    }\n    else {\n      s.status = NAME_STATE;\n    }\n  }\n  if (s.status === NAME_STATE) {\n    if (s.gzhead.name/* != Z_NULL*/) {\n      beg = s.pending;  /* start of bytes to update crc */\n      //int val;\n\n      do {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n          flush_pending(strm);\n          beg = s.pending;\n          if (s.pending === s.pending_buf_size) {\n            val = 1;\n            break;\n          }\n        }\n        // JS specific: little magic to add zero terminator to end of string\n        if (s.gzindex < s.gzhead.name.length) {\n          val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;\n        } else {\n          val = 0;\n        }\n        put_byte(s, val);\n      } while (val !== 0);\n\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n      if (val === 0) {\n        s.gzindex = 0;\n        s.status = COMMENT_STATE;\n      }\n    }\n    else {\n      s.status = COMMENT_STATE;\n    }\n  }\n  if (s.status === COMMENT_STATE) {\n    if (s.gzhead.comment/* != Z_NULL*/) {\n      beg = s.pending;  /* start of bytes to update crc */\n      //int val;\n\n      do {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n          flush_pending(strm);\n          beg = s.pending;\n          if (s.pending === s.pending_buf_size) {\n            val = 1;\n            break;\n          }\n        }\n        // JS specific: little magic to add zero terminator to end of string\n        if (s.gzindex < s.gzhead.comment.length) {\n          val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;\n        } else {\n          val = 0;\n        }\n        put_byte(s, val);\n      } while (val !== 0);\n\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n      if (val === 0) {\n        s.status = HCRC_STATE;\n      }\n    }\n    else {\n      s.status = HCRC_STATE;\n    }\n  }\n  if (s.status === HCRC_STATE) {\n    if (s.gzhead.hcrc) {\n      if (s.pending + 2 > s.pending_buf_size) {\n        flush_pending(strm);\n      }\n      if (s.pending + 2 <= s.pending_buf_size) {\n        put_byte(s, strm.adler & 0xff);\n        put_byte(s, (strm.adler >> 8) & 0xff);\n        strm.adler = 0; //crc32(0L, Z_NULL, 0);\n        s.status = BUSY_STATE;\n      }\n    }\n    else {\n      s.status = BUSY_STATE;\n    }\n  }\n//#endif\n\n  /* Flush as much pending output as possible */\n  if (s.pending !== 0) {\n    flush_pending(strm);\n    if (strm.avail_out === 0) {\n      /* Since avail_out is 0, deflate will be called again with\n       * more output space, but possibly with both pending and\n       * avail_in equal to zero. There won't be anything to do,\n       * but this is not an error situation so make sure we\n       * return OK instead of BUF_ERROR at next call of deflate:\n       */\n      s.last_flush = -1;\n      return Z_OK;\n    }\n\n    /* Make sure there is something to do and avoid duplicate consecutive\n     * flushes. For repeated and useless calls with Z_FINISH, we keep\n     * returning Z_STREAM_END instead of Z_BUF_ERROR.\n     */\n  } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&\n    flush !== Z_FINISH) {\n    return err(strm, Z_BUF_ERROR);\n  }\n\n  /* User must not provide more input after the first FINISH: */\n  if (s.status === FINISH_STATE && strm.avail_in !== 0) {\n    return err(strm, Z_BUF_ERROR);\n  }\n\n  /* Start a new block or continue the current one.\n   */\n  if (strm.avail_in !== 0 || s.lookahead !== 0 ||\n    (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {\n    var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) :\n      (s.strategy === Z_RLE ? deflate_rle(s, flush) :\n        configuration_table[s.level].func(s, flush));\n\n    if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {\n      s.status = FINISH_STATE;\n    }\n    if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n      if (strm.avail_out === 0) {\n        s.last_flush = -1;\n        /* avoid BUF_ERROR next call, see above */\n      }\n      return Z_OK;\n      /* If flush != Z_NO_FLUSH && avail_out == 0, the next call\n       * of deflate should use the same flush parameter to make sure\n       * that the flush is complete. So we don't have to output an\n       * empty block here, this will be done at next call. This also\n       * ensures that for a very small output buffer, we emit at most\n       * one empty block.\n       */\n    }\n    if (bstate === BS_BLOCK_DONE) {\n      if (flush === Z_PARTIAL_FLUSH) {\n        trees._tr_align(s);\n      }\n      else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */\n\n        trees._tr_stored_block(s, 0, 0, false);\n        /* For a full flush, this empty block will be recognized\n         * as a special marker by inflate_sync().\n         */\n        if (flush === Z_FULL_FLUSH) {\n          /*** CLEAR_HASH(s); ***/             /* forget history */\n          zero(s.head); // Fill with NIL (= 0);\n\n          if (s.lookahead === 0) {\n            s.strstart = 0;\n            s.block_start = 0;\n            s.insert = 0;\n          }\n        }\n      }\n      flush_pending(strm);\n      if (strm.avail_out === 0) {\n        s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */\n        return Z_OK;\n      }\n    }\n  }\n  //Assert(strm->avail_out > 0, \"bug2\");\n  //if (strm.avail_out <= 0) { throw new Error(\"bug2\");}\n\n  if (flush !== Z_FINISH) { return Z_OK; }\n  if (s.wrap <= 0) { return Z_STREAM_END; }\n\n  /* Write the trailer */\n  if (s.wrap === 2) {\n    put_byte(s, strm.adler & 0xff);\n    put_byte(s, (strm.adler >> 8) & 0xff);\n    put_byte(s, (strm.adler >> 16) & 0xff);\n    put_byte(s, (strm.adler >> 24) & 0xff);\n    put_byte(s, strm.total_in & 0xff);\n    put_byte(s, (strm.total_in >> 8) & 0xff);\n    put_byte(s, (strm.total_in >> 16) & 0xff);\n    put_byte(s, (strm.total_in >> 24) & 0xff);\n  }\n  else\n  {\n    putShortMSB(s, strm.adler >>> 16);\n    putShortMSB(s, strm.adler & 0xffff);\n  }\n\n  flush_pending(strm);\n  /* If avail_out is zero, the application will call deflate again\n   * to flush the rest.\n   */\n  if (s.wrap > 0) { s.wrap = -s.wrap; }\n  /* write the trailer only once! */\n  return s.pending !== 0 ? Z_OK : Z_STREAM_END;\n}\n\nfunction deflateEnd(strm) {\n  var status;\n\n  if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {\n    return Z_STREAM_ERROR;\n  }\n\n  status = strm.state.status;\n  if (status !== INIT_STATE &&\n    status !== EXTRA_STATE &&\n    status !== NAME_STATE &&\n    status !== COMMENT_STATE &&\n    status !== HCRC_STATE &&\n    status !== BUSY_STATE &&\n    status !== FINISH_STATE\n  ) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n  strm.state = null;\n\n  return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;\n}\n\n\n/* =========================================================================\n * Initializes the compression dictionary from the given byte\n * sequence without producing any compressed output.\n */\nfunction deflateSetDictionary(strm, dictionary) {\n  var dictLength = dictionary.length;\n\n  var s;\n  var str, n;\n  var wrap;\n  var avail;\n  var next;\n  var input;\n  var tmpDict;\n\n  if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {\n    return Z_STREAM_ERROR;\n  }\n\n  s = strm.state;\n  wrap = s.wrap;\n\n  if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {\n    return Z_STREAM_ERROR;\n  }\n\n  /* when using zlib wrappers, compute Adler-32 for provided dictionary */\n  if (wrap === 1) {\n    /* adler32(strm->adler, dictionary, dictLength); */\n    strm.adler = adler32(strm.adler, dictionary, dictLength, 0);\n  }\n\n  s.wrap = 0;   /* avoid computing Adler-32 in read_buf */\n\n  /* if dictionary would fill window, just replace the history */\n  if (dictLength >= s.w_size) {\n    if (wrap === 0) {            /* already empty otherwise */\n      /*** CLEAR_HASH(s); ***/\n      zero(s.head); // Fill with NIL (= 0);\n      s.strstart = 0;\n      s.block_start = 0;\n      s.insert = 0;\n    }\n    /* use the tail */\n    // dictionary = dictionary.slice(dictLength - s.w_size);\n    tmpDict = new utils.Buf8(s.w_size);\n    utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);\n    dictionary = tmpDict;\n    dictLength = s.w_size;\n  }\n  /* insert dictionary into window and hash */\n  avail = strm.avail_in;\n  next = strm.next_in;\n  input = strm.input;\n  strm.avail_in = dictLength;\n  strm.next_in = 0;\n  strm.input = dictionary;\n  fill_window(s);\n  while (s.lookahead >= MIN_MATCH) {\n    str = s.strstart;\n    n = s.lookahead - (MIN_MATCH - 1);\n    do {\n      /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;\n\n      s.prev[str & s.w_mask] = s.head[s.ins_h];\n\n      s.head[s.ins_h] = str;\n      str++;\n    } while (--n);\n    s.strstart = str;\n    s.lookahead = MIN_MATCH - 1;\n    fill_window(s);\n  }\n  s.strstart += s.lookahead;\n  s.block_start = s.strstart;\n  s.insert = s.lookahead;\n  s.lookahead = 0;\n  s.match_length = s.prev_length = MIN_MATCH - 1;\n  s.match_available = 0;\n  strm.next_in = next;\n  strm.input = input;\n  strm.avail_in = avail;\n  s.wrap = wrap;\n  return Z_OK;\n}\n\n\nexports.deflateInit = deflateInit;\nexports.deflateInit2 = deflateInit2;\nexports.deflateReset = deflateReset;\nexports.deflateResetKeep = deflateResetKeep;\nexports.deflateSetHeader = deflateSetHeader;\nexports.deflate = deflate;\nexports.deflateEnd = deflateEnd;\nexports.deflateSetDictionary = deflateSetDictionary;\nexports.deflateInfo = 'pako deflate (from Nodeca project)';\n\n/* Not implemented\nexports.deflateBound = deflateBound;\nexports.deflateCopy = deflateCopy;\nexports.deflateParams = deflateParams;\nexports.deflatePending = deflatePending;\nexports.deflatePrime = deflatePrime;\nexports.deflateTune = deflateTune;\n*/\n"]},"metadata":{},"sourceType":"script"}