@novnc/novnc 1.6.0 → 1.7.0

package/{lib/vendor → vendor}/pako/lib/zlib/trees.js

@@ -1,50 +1,35 @@
-"use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports._tr_align = _tr_align;
-exports._tr_flush_block = _tr_flush_block;
-exports._tr_init = _tr_init;
-exports._tr_stored_block = _tr_stored_block;
-exports._tr_tally = _tr_tally;
-var utils = _interopRequireWildcard(require("../utils/common.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+import * as utils from "../utils/common.js";
+
 /* Public constants ==========================================================*/
 /* ===========================================================================*/
 
+
 //var Z_FILTERED          = 1;
 //var Z_HUFFMAN_ONLY      = 2;
 //var Z_RLE               = 3;
-var Z_FIXED = 4;
+var Z_FIXED               = 4;
 //var Z_DEFAULT_STRATEGY  = 0;
 
 /* Possible values of the data_type field (though see inflate()) */
-var Z_BINARY = 0;
-var Z_TEXT = 1;
+var Z_BINARY              = 0;
+var Z_TEXT                = 1;
 //var Z_ASCII             = 1; // = Z_TEXT
-var Z_UNKNOWN = 2;
+var Z_UNKNOWN             = 2;
 
 /*============================================================================*/
 
-function zero(buf) {
-  var len = buf.length;
-  while (--len >= 0) {
-    buf[len] = 0;
-  }
-}
+
+function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
 
 // From zutil.h
 
 var STORED_BLOCK = 0;
 var STATIC_TREES = 1;
-var DYN_TREES = 2;
+var DYN_TREES    = 2;
 /* The three kinds of block type */
 
-var MIN_MATCH = 3;
-var MAX_MATCH = 258;
+var MIN_MATCH    = 3;
+var MAX_MATCH    = 258;
 /* The minimum and maximum match lengths */
 
 // From deflate.h
@@ -52,30 +37,31 @@ var MAX_MATCH = 258;
  * Internal compression state.
  */
 
-var LENGTH_CODES = 29;
+var LENGTH_CODES  = 29;
 /* number of length codes, not counting the special END_BLOCK code */
 
-var LITERALS = 256;
+var LITERALS      = 256;
 /* number of literal bytes 0..255 */
 
-var L_CODES = LITERALS + 1 + LENGTH_CODES;
+var L_CODES       = LITERALS + 1 + LENGTH_CODES;
 /* number of Literal or Length codes, including the END_BLOCK code */
 
-var D_CODES = 30;
+var D_CODES       = 30;
 /* number of distance codes */
 
-var BL_CODES = 19;
+var BL_CODES      = 19;
 /* number of codes used to transfer the bit lengths */
 
-var HEAP_SIZE = 2 * L_CODES + 1;
+var HEAP_SIZE     = 2 * L_CODES + 1;
 /* maximum heap size */
 
-var MAX_BITS = 15;
+var MAX_BITS      = 15;
 /* All codes must not exceed MAX_BITS bits */
 
-var Buf_size = 16;
+var Buf_size      = 16;
 /* size of bit buffer in bi_buf */
 
+
 /* ===========================================================================
  * Constants
  */
@@ -83,26 +69,30 @@ var Buf_size = 16;
 var MAX_BL_BITS = 7;
 /* Bit length codes must not exceed MAX_BL_BITS bits */
 
-var END_BLOCK = 256;
+var END_BLOCK   = 256;
 /* end of block literal code */
 
-var REP_3_6 = 16;
+var REP_3_6     = 16;
 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
 
-var REPZ_3_10 = 17;
+var REPZ_3_10   = 17;
 /* repeat a zero length 3-10 times  (3 bits of repeat count) */
 
 var REPZ_11_138 = 18;
 /* repeat a zero length 11-138 times  (7 bits of repeat count) */
 
 /* eslint-disable comma-spacing,array-bracket-spacing */
-var extra_lbits = /* extra bits for each length code */
-[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
-var extra_dbits = /* extra bits for each distance code */
-[0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
-var extra_blbits = /* extra bits for each bit length code */
-[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7];
-var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+var extra_lbits =   /* extra bits for each length code */
+  [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0];
+
+var extra_dbits =   /* extra bits for each distance code */
+  [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13];
+
+var extra_blbits =  /* extra bits for each bit length code */
+  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];
+
+var bl_order =
+  [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
 /* eslint-enable comma-spacing,array-bracket-spacing */
 
 /* The lengths of the bit length codes are sent in order of decreasing
@@ -118,7 +108,7 @@ var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
 var DIST_CODE_LEN = 512; /* see definition of array dist_code below */
 
 // !!!! Use flat array insdead of structure, Freq = i*2, Len = i*2+1
-var static_ltree = new Array((L_CODES + 2) * 2);
+var static_ltree  = new Array((L_CODES + 2) * 2);
 zero(static_ltree);
 /* The static literal tree. Since the bit lengths are imposed, there is no
  * need for the L_CODES extra codes used during heap construction. However
@@ -126,83 +116,97 @@ zero(static_ltree);
  * below).
  */
 
-var static_dtree = new Array(D_CODES * 2);
+var static_dtree  = new Array(D_CODES * 2);
 zero(static_dtree);
 /* The static distance tree. (Actually a trivial tree since all codes use
  * 5 bits.)
  */
 
-var _dist_code = new Array(DIST_CODE_LEN);
+var _dist_code    = new Array(DIST_CODE_LEN);
 zero(_dist_code);
 /* Distance codes. The first 256 values correspond to the distances
  * 3 .. 258, the last 256 values correspond to the top 8 bits of
  * the 15 bit distances.
  */
 
-var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
+var _length_code  = new Array(MAX_MATCH - MIN_MATCH + 1);
 zero(_length_code);
 /* length code for each normalized match length (0 == MIN_MATCH) */
 
-var base_length = new Array(LENGTH_CODES);
+var base_length   = new Array(LENGTH_CODES);
 zero(base_length);
 /* First normalized length for each code (0 = MIN_MATCH) */
 
-var base_dist = new Array(D_CODES);
+var base_dist     = new Array(D_CODES);
 zero(base_dist);
 /* First normalized distance for each code (0 = distance of 1) */
 
+
 function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
-  this.static_tree = static_tree; /* static tree or NULL */
-  this.extra_bits = extra_bits; /* extra bits for each code or NULL */
-  this.extra_base = extra_base; /* base index for extra_bits */
-  this.elems = elems; /* max number of elements in the tree */
-  this.max_length = max_length; /* max bit length for the codes */
+
+  this.static_tree  = static_tree;  /* static tree or NULL */
+  this.extra_bits   = extra_bits;   /* extra bits for each code or NULL */
+  this.extra_base   = extra_base;   /* base index for extra_bits */
+  this.elems        = elems;        /* max number of elements in the tree */
+  this.max_length   = max_length;   /* max bit length for the codes */
 
   // show if `static_tree` has data or dummy - needed for monomorphic objects
-  this.has_stree = static_tree && static_tree.length;
+  this.has_stree    = static_tree && static_tree.length;
 }
+
+
 var static_l_desc;
 var static_d_desc;
 var static_bl_desc;
+
+
 function TreeDesc(dyn_tree, stat_desc) {
-  this.dyn_tree = dyn_tree; /* the dynamic tree */
-  this.max_code = 0; /* largest code with non zero frequency */
-  this.stat_desc = stat_desc; /* the corresponding static tree */
+  this.dyn_tree = dyn_tree;     /* the dynamic tree */
+  this.max_code = 0;            /* largest code with non zero frequency */
+  this.stat_desc = stat_desc;   /* the corresponding static tree */
 }
+
+
+
 function d_code(dist) {
   return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
 }
 
+
 /* ===========================================================================
  * Output a short LSB first on the stream.
  * IN assertion: there is enough room in pendingBuf.
  */
 function put_short(s, w) {
-  //    put_byte(s, (uch)((w) & 0xff));
-  //    put_byte(s, (uch)((ush)(w) >> 8));
-  s.pending_buf[s.pending++] = w & 0xff;
-  s.pending_buf[s.pending++] = w >>> 8 & 0xff;
+//    put_byte(s, (uch)((w) & 0xff));
+//    put_byte(s, (uch)((ush)(w) >> 8));
+  s.pending_buf[s.pending++] = (w) & 0xff;
+  s.pending_buf[s.pending++] = (w >>> 8) & 0xff;
 }
 
+
 /* ===========================================================================
  * Send a value on a given number of bits.
  * IN assertion: length <= 16 and value fits in length bits.
  */
 function send_bits(s, value, length) {
-  if (s.bi_valid > Buf_size - length) {
-    s.bi_buf |= value << s.bi_valid & 0xffff;
+  if (s.bi_valid > (Buf_size - length)) {
+    s.bi_buf |= (value << s.bi_valid) & 0xffff;
     put_short(s, s.bi_buf);
-    s.bi_buf = value >> Buf_size - s.bi_valid;
+    s.bi_buf = value >> (Buf_size - s.bi_valid);
     s.bi_valid += length - Buf_size;
   } else {
-    s.bi_buf |= value << s.bi_valid & 0xffff;
+    s.bi_buf |= (value << s.bi_valid) & 0xffff;
     s.bi_valid += length;
   }
 }
+
+
 function send_code(s, c, tree) {
-  send_bits(s, tree[c * 2] /*.Code*/, tree[c * 2 + 1] /*.Len*/);
+  send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/);
 }
 
+
 /* ===========================================================================
  * Reverse the first len bits of a code, using straightforward code (a faster
  * method would use a table)
@@ -218,6 +222,7 @@ function bi_reverse(code, len) {
   return res >>> 1;
 }
 
+
 /* ===========================================================================
  * Flush the bit buffer, keeping at most 7 bits in it.
  */
@@ -226,6 +231,7 @@ function bi_flush(s) {
     put_short(s, s.bi_buf);
     s.bi_buf = 0;
     s.bi_valid = 0;
+
   } else if (s.bi_valid >= 8) {
     s.pending_buf[s.pending++] = s.bi_buf & 0xff;
     s.bi_buf >>= 8;
@@ -233,6 +239,7 @@ function bi_flush(s) {
   }
 }
 
+
 /* ===========================================================================
  * Compute the optimal bit lengths for a tree and update the total bit length
  * for the current block.
@@ -247,19 +254,19 @@ function gen_bitlen(s, desc)
 //    deflate_state *s;
 //    tree_desc *desc;    /* the tree descriptor */
 {
-  var tree = desc.dyn_tree;
-  var max_code = desc.max_code;
-  var stree = desc.stat_desc.static_tree;
-  var has_stree = desc.stat_desc.has_stree;
-  var extra = desc.stat_desc.extra_bits;
-  var base = desc.stat_desc.extra_base;
-  var max_length = desc.stat_desc.max_length;
-  var h; /* heap index */
-  var n, m; /* iterate over the tree elements */
-  var bits; /* bit length */
-  var xbits; /* extra bits */
-  var f; /* frequency */
-  var overflow = 0; /* number of elements with bit length too large */
+  var tree            = desc.dyn_tree;
+  var max_code        = desc.max_code;
+  var stree           = desc.stat_desc.static_tree;
+  var has_stree       = desc.stat_desc.has_stree;
+  var extra           = desc.stat_desc.extra_bits;
+  var base            = desc.stat_desc.extra_base;
+  var max_length      = desc.stat_desc.max_length;
+  var h;              /* heap index */
+  var n, m;           /* iterate over the tree elements */
+  var bits;           /* bit length */
+  var xbits;          /* extra bits */
+  var f;              /* frequency */
+  var overflow = 0;   /* number of elements with bit length too large */
 
   for (bits = 0; bits <= MAX_BITS; bits++) {
     s.bl_count[bits] = 0;
@@ -268,36 +275,32 @@ function gen_bitlen(s, desc)
   /* In a first pass, compute the optimal bit lengths (which may
    * overflow in the case of the bit length tree).
    */
-  tree[s.heap[s.heap_max] * 2 + 1] /*.Len*/ = 0; /* root of the heap */
+  tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */
 
   for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
     n = s.heap[h];
-    bits = tree[tree[n * 2 + 1] /*.Dad*/ * 2 + 1] /*.Len*/ + 1;
+    bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
     if (bits > max_length) {
       bits = max_length;
       overflow++;
     }
-    tree[n * 2 + 1] /*.Len*/ = bits;
+    tree[n * 2 + 1]/*.Len*/ = bits;
     /* We overwrite tree[n].Dad which is no longer needed */
 
-    if (n > max_code) {
-      continue;
-    } /* not a leaf node */
+    if (n > max_code) { continue; } /* not a leaf node */
 
     s.bl_count[bits]++;
     xbits = 0;
     if (n >= base) {
       xbits = extra[n - base];
     }
-    f = tree[n * 2] /*.Freq*/;
+    f = tree[n * 2]/*.Freq*/;
     s.opt_len += f * (bits + xbits);
     if (has_stree) {
-      s.static_len += f * (stree[n * 2 + 1] /*.Len*/ + xbits);
+      s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits);
     }
   }
-  if (overflow === 0) {
-    return;
-  }
+  if (overflow === 0) { return; }
 
   // Trace((stderr,"\nbit length overflow\n"));
   /* This happens for example on obj2 and pic of the Calgary corpus */
@@ -305,10 +308,8 @@ function gen_bitlen(s, desc)
   /* Find the first bit length which could increase: */
   do {
     bits = max_length - 1;
-    while (s.bl_count[bits] === 0) {
-      bits--;
-    }
-    s.bl_count[bits]--; /* move one leaf down the tree */
+    while (s.bl_count[bits] === 0) { bits--; }
+    s.bl_count[bits]--;      /* move one leaf down the tree */
     s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
     s.bl_count[max_length]--;
     /* The brother of the overflow item also moves one step up,
@@ -326,19 +327,18 @@ function gen_bitlen(s, desc)
     n = s.bl_count[bits];
     while (n !== 0) {
       m = s.heap[--h];
-      if (m > max_code) {
-        continue;
-      }
-      if (tree[m * 2 + 1] /*.Len*/ !== bits) {
+      if (m > max_code) { continue; }
+      if (tree[m * 2 + 1]/*.Len*/ !== bits) {
         // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
-        s.opt_len += (bits - tree[m * 2 + 1] /*.Len*/) * tree[m * 2] /*.Freq*/;
-        tree[m * 2 + 1] /*.Len*/ = bits;
+        s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;
+        tree[m * 2 + 1]/*.Len*/ = bits;
       }
       n--;
     }
   }
 }
 
+
 /* ===========================================================================
  * Generate the codes for a given tree and bit counts (which need not be
  * optimal).
@@ -353,15 +353,15 @@ function gen_codes(tree, max_code, bl_count)
 //    ushf *bl_count;            /* number of codes at each bit length */
 {
   var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */
-  var code = 0; /* running code value */
-  var bits; /* bit index */
-  var n; /* code index */
+  var code = 0;              /* running code value */
+  var bits;                  /* bit index */
+  var n;                     /* code index */
 
   /* The distribution counts are first used to generate the code values
    * without bit reversal.
    */
   for (bits = 1; bits <= MAX_BITS; bits++) {
-    next_code[bits] = code = code + bl_count[bits - 1] << 1;
+    next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
   }
   /* Check that the bit counts in bl_count are consistent. The last code
    * must be all ones.
@@ -370,28 +370,27 @@ function gen_codes(tree, max_code, bl_count)
   //        "inconsistent bit counts");
   //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
 
-  for (n = 0; n <= max_code; n++) {
-    var len = tree[n * 2 + 1] /*.Len*/;
-    if (len === 0) {
-      continue;
-    }
+  for (n = 0;  n <= max_code; n++) {
+    var len = tree[n * 2 + 1]/*.Len*/;
+    if (len === 0) { continue; }
     /* Now reverse the bits */
-    tree[n * 2] /*.Code*/ = bi_reverse(next_code[len]++, len);
+    tree[n * 2]/*.Code*/ = bi_reverse(next_code[len]++, len);
 
     //Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
     //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
   }
 }
 
+
 /* ===========================================================================
  * Initialize the various 'constant' tables.
  */
 function tr_static_init() {
-  var n; /* iterates over tree elements */
-  var bits; /* bit counter */
-  var length; /* length value */
-  var code; /* code value */
-  var dist; /* distance index */
+  var n;        /* iterates over tree elements */
+  var bits;     /* bit counter */
+  var length;   /* length value */
+  var code;     /* code value */
+  var dist;     /* distance index */
   var bl_count = new Array(MAX_BITS + 1);
   /* number of codes at each bit length for an optimal tree */
 
@@ -399,19 +398,19 @@ function tr_static_init() {
   //if (static_init_done) return;
 
   /* For some embedded targets, global variables are not initialized: */
-  /*#ifdef NO_INIT_GLOBAL_POINTERS
-    static_l_desc.static_tree = static_ltree;
-    static_l_desc.extra_bits = extra_lbits;
-    static_d_desc.static_tree = static_dtree;
-    static_d_desc.extra_bits = extra_dbits;
-    static_bl_desc.extra_bits = extra_blbits;
-  #endif*/
+/*#ifdef NO_INIT_GLOBAL_POINTERS
+  static_l_desc.static_tree = static_ltree;
+  static_l_desc.extra_bits = extra_lbits;
+  static_d_desc.static_tree = static_dtree;
+  static_d_desc.extra_bits = extra_dbits;
+  static_bl_desc.extra_bits = extra_blbits;
+#endif*/
 
   /* Initialize the mapping length (0..255) -> length code (0..28) */
   length = 0;
   for (code = 0; code < LENGTH_CODES - 1; code++) {
     base_length[code] = length;
-    for (n = 0; n < 1 << extra_lbits[code]; n++) {
+    for (n = 0; n < (1 << extra_lbits[code]); n++) {
       _length_code[length++] = code;
     }
   }
@@ -426,7 +425,7 @@ function tr_static_init() {
   dist = 0;
   for (code = 0; code < 16; code++) {
     base_dist[code] = dist;
-    for (n = 0; n < 1 << extra_dbits[code]; n++) {
+    for (n = 0; n < (1 << extra_dbits[code]); n++) {
       _dist_code[dist++] = code;
     }
   }
@@ -434,7 +433,7 @@ function tr_static_init() {
   dist >>= 7; /* from now on, all distances are divided by 128 */
   for (; code < D_CODES; code++) {
     base_dist[code] = dist << 7;
-    for (n = 0; n < 1 << extra_dbits[code] - 7; n++) {
+    for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
       _dist_code[256 + dist++] = code;
     }
   }
@@ -444,24 +443,25 @@ function tr_static_init() {
   for (bits = 0; bits <= MAX_BITS; bits++) {
     bl_count[bits] = 0;
   }
+
   n = 0;
   while (n <= 143) {
-    static_ltree[n * 2 + 1] /*.Len*/ = 8;
+    static_ltree[n * 2 + 1]/*.Len*/ = 8;
     n++;
     bl_count[8]++;
   }
   while (n <= 255) {
-    static_ltree[n * 2 + 1] /*.Len*/ = 9;
+    static_ltree[n * 2 + 1]/*.Len*/ = 9;
     n++;
     bl_count[9]++;
   }
   while (n <= 279) {
-    static_ltree[n * 2 + 1] /*.Len*/ = 7;
+    static_ltree[n * 2 + 1]/*.Len*/ = 7;
     n++;
     bl_count[7]++;
   }
   while (n <= 287) {
-    static_ltree[n * 2 + 1] /*.Len*/ = 8;
+    static_ltree[n * 2 + 1]/*.Len*/ = 8;
     n++;
     bl_count[8]++;
   }
@@ -473,18 +473,19 @@ function tr_static_init() {
 
   /* The static distance tree is trivial: */
   for (n = 0; n < D_CODES; n++) {
-    static_dtree[n * 2 + 1] /*.Len*/ = 5;
-    static_dtree[n * 2] /*.Code*/ = bi_reverse(n, 5);
+    static_dtree[n * 2 + 1]/*.Len*/ = 5;
+    static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);
   }
 
   // Now data ready and we can init static trees
   static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
-  static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
-  static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
+  static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS);
+  static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0,         BL_CODES, MAX_BL_BITS);
 
   //static_init_done = true;
 }
 
+
 /* ===========================================================================
  * Initialize a new block.
  */
@@ -492,24 +493,21 @@ function init_block(s) {
   var n; /* iterates over tree elements */
 
   /* Initialize the trees. */
-  for (n = 0; n < L_CODES; n++) {
-    s.dyn_ltree[n * 2] /*.Freq*/ = 0;
-  }
-  for (n = 0; n < D_CODES; n++) {
-    s.dyn_dtree[n * 2] /*.Freq*/ = 0;
-  }
-  for (n = 0; n < BL_CODES; n++) {
-    s.bl_tree[n * 2] /*.Freq*/ = 0;
-  }
-  s.dyn_ltree[END_BLOCK * 2] /*.Freq*/ = 1;
+  for (n = 0; n < L_CODES;  n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }
+  for (n = 0; n < D_CODES;  n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }
+  for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }
+
+  s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;
   s.opt_len = s.static_len = 0;
   s.last_lit = s.matches = 0;
 }
 
+
 /* ===========================================================================
  * Flush the bit buffer and align the output on a byte boundary
  */
-function bi_windup(s) {
+function bi_windup(s)
+{
   if (s.bi_valid > 8) {
     put_short(s, s.bi_buf);
   } else if (s.bi_valid > 0) {
@@ -530,15 +528,15 @@ function copy_block(s, buf, len, header)
 //unsigned len;     /* its length */
 //int      header;  /* true if block header must be written */
 {
-  bi_windup(s); /* align on byte boundary */
+  bi_windup(s);        /* align on byte boundary */
 
   if (header) {
     put_short(s, len);
     put_short(s, ~len);
   }
-  //  while (len--) {
-  //    put_byte(s, *buf++);
-  //  }
+//  while (len--) {
+//    put_byte(s, *buf++);
+//  }
   utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
   s.pending += len;
 }
@@ -550,7 +548,8 @@ function copy_block(s, buf, len, header)
 function smaller(tree, n, m, depth) {
   var _n2 = n * 2;
   var _m2 = m * 2;
-  return tree[_n2] /*.Freq*/ < tree[_m2] /*.Freq*/ || tree[_n2] /*.Freq*/ === tree[_m2] /*.Freq*/ && depth[n] <= depth[m];
+  return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||
+         (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));
 }
 
 /* ===========================================================================
@@ -565,16 +564,15 @@ function pqdownheap(s, tree, k)
 //    int k;               /* node to move down */
 {
   var v = s.heap[k];
-  var j = k << 1; /* left son of k */
+  var j = k << 1;  /* left son of k */
   while (j <= s.heap_len) {
     /* Set j to the smallest of the two sons: */
-    if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
+    if (j < s.heap_len &&
+      smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
       j++;
     }
     /* Exit if v is smaller than both sons */
-    if (smaller(tree, v, s.heap[j], s.depth)) {
-      break;
-    }
+    if (smaller(tree, v, s.heap[j], s.depth)) { break; }
 
     /* Exchange v with the smallest son */
     s.heap[k] = s.heap[j];
@@ -586,6 +584,7 @@ function pqdownheap(s, tree, k)
   s.heap[k] = v;
 }
 
+
 // inlined manually
 // var SMALLEST = 1;
 
@@ -597,17 +596,18 @@ function compress_block(s, ltree, dtree)
 //    const ct_data *ltree; /* literal tree */
 //    const ct_data *dtree; /* distance tree */
 {
-  var dist; /* distance of matched string */
-  var lc; /* match length or unmatched char (if dist == 0) */
-  var lx = 0; /* running index in l_buf */
-  var code; /* the code to send */
-  var extra; /* number of extra bits to send */
+  var dist;           /* distance of matched string */
+  var lc;             /* match length or unmatched char (if dist == 0) */
+  var lx = 0;         /* running index in l_buf */
+  var code;           /* the code to send */
+  var extra;          /* number of extra bits to send */
 
   if (s.last_lit !== 0) {
     do {
-      dist = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1];
+      dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);
       lc = s.pending_buf[s.l_buf + lx];
       lx++;
+
       if (dist === 0) {
         send_code(s, lc, ltree); /* send a literal byte */
         //Tracecv(isgraph(lc), (stderr," '%c' ", lc));
@@ -618,28 +618,31 @@ function compress_block(s, ltree, dtree)
         extra = extra_lbits[code];
         if (extra !== 0) {
           lc -= base_length[code];
-          send_bits(s, lc, extra); /* send the extra length bits */
+          send_bits(s, lc, extra);       /* send the extra length bits */
         }
         dist--; /* dist is now the match distance - 1 */
         code = d_code(dist);
         //Assert (code < D_CODES, "bad d_code");
 
-        send_code(s, code, dtree); /* send the distance code */
+        send_code(s, code, dtree);       /* send the distance code */
         extra = extra_dbits[code];
         if (extra !== 0) {
           dist -= base_dist[code];
-          send_bits(s, dist, extra); /* send the extra distance bits */
+          send_bits(s, dist, extra);   /* send the extra distance bits */
         }
       } /* literal or match pair ? */
 
       /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
       //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
       //       "pendingBuf overflow");
+
     } while (lx < s.last_lit);
   }
+
   send_code(s, END_BLOCK, ltree);
 }
 
+
 /* ===========================================================================
  * Construct one Huffman tree and assigns the code bit strings and lengths.
  * Update the total bit length for the current block.
@@ -652,13 +655,13 @@ function build_tree(s, desc)
 //    deflate_state *s;
 //    tree_desc *desc; /* the tree descriptor */
 {
-  var tree = desc.dyn_tree;
-  var stree = desc.stat_desc.static_tree;
+  var tree     = desc.dyn_tree;
+  var stree    = desc.stat_desc.static_tree;
   var has_stree = desc.stat_desc.has_stree;
-  var elems = desc.stat_desc.elems;
-  var n, m; /* iterate over heap elements */
+  var elems    = desc.stat_desc.elems;
+  var n, m;          /* iterate over heap elements */
   var max_code = -1; /* largest code with non zero frequency */
-  var node; /* new node being created */
+  var node;          /* new node being created */
 
   /* Construct the initial heap, with least frequent element in
    * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
@@ -666,12 +669,14 @@ function build_tree(s, desc)
    */
   s.heap_len = 0;
   s.heap_max = HEAP_SIZE;
+
   for (n = 0; n < elems; n++) {
-    if (tree[n * 2] /*.Freq*/ !== 0) {
+    if (tree[n * 2]/*.Freq*/ !== 0) {
       s.heap[++s.heap_len] = max_code = n;
       s.depth[n] = 0;
+
     } else {
-      tree[n * 2 + 1] /*.Len*/ = 0;
+      tree[n * 2 + 1]/*.Len*/ = 0;
     }
   }
 
@@ -681,12 +686,13 @@ function build_tree(s, desc)
    * two codes of non zero frequency.
    */
   while (s.heap_len < 2) {
-    node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
-    tree[node * 2] /*.Freq*/ = 1;
+    node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
+    tree[node * 2]/*.Freq*/ = 1;
     s.depth[node] = 0;
     s.opt_len--;
+
     if (has_stree) {
-      s.static_len -= stree[node * 2 + 1] /*.Len*/;
+      s.static_len -= stree[node * 2 + 1]/*.Len*/;
     }
     /* node is 0 or 1 so it does not have extra bits */
   }
@@ -695,37 +701,37 @@ function build_tree(s, desc)
   /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
    * establish sub-heaps of increasing lengths:
    */
-  for (n = s.heap_len >> 1 /*int /2*/; n >= 1; n--) {
-    pqdownheap(s, tree, n);
-  }
+  for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); }
 
   /* Construct the Huffman tree by repeatedly combining the least two
    * frequent nodes.
    */
-  node = elems; /* next internal node of the tree */
+  node = elems;              /* next internal node of the tree */
   do {
     //pqremove(s, tree, n);  /* n = node of least frequency */
     /*** pqremove ***/
-    n = s.heap[1 /*SMALLEST*/];
-    s.heap[1 /*SMALLEST*/] = s.heap[s.heap_len--];
-    pqdownheap(s, tree, 1 /*SMALLEST*/);
+    n = s.heap[1/*SMALLEST*/];
+    s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--];
+    pqdownheap(s, tree, 1/*SMALLEST*/);
     /***/
 
-    m = s.heap[1 /*SMALLEST*/]; /* m = node of next least frequency */
+    m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */
 
     s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */
     s.heap[--s.heap_max] = m;
 
     /* Create a new node father of n and m */
-    tree[node * 2] /*.Freq*/ = tree[n * 2] /*.Freq*/ + tree[m * 2] /*.Freq*/;
+    tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;
     s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
-    tree[n * 2 + 1] /*.Dad*/ = tree[m * 2 + 1] /*.Dad*/ = node;
+    tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node;
 
     /* and insert the new node in the heap */
-    s.heap[1 /*SMALLEST*/] = node++;
-    pqdownheap(s, tree, 1 /*SMALLEST*/);
+    s.heap[1/*SMALLEST*/] = node++;
+    pqdownheap(s, tree, 1/*SMALLEST*/);
+
   } while (s.heap_len >= 2);
-  s.heap[--s.heap_max] = s.heap[1 /*SMALLEST*/];
+
+  s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/];
 
   /* At this point, the fields freq and dad are set. We can now
    * generate the bit lengths.
@@ -736,6 +742,7 @@ function build_tree(s, desc)
   gen_codes(tree, max_code, s.bl_count);
 }
 
+
 /* ===========================================================================
  * Scan a literal or distance tree to determine the frequencies of the codes
  * in the bit length tree.
@@ -745,47 +752,55 @@ function scan_tree(s, tree, max_code)
 //    ct_data *tree;   /* the tree to be scanned */
 //    int max_code;    /* and its largest code of non zero frequency */
 {
-  var n; /* iterates over all tree elements */
-  var prevlen = -1; /* last emitted length */
-  var curlen; /* length of current code */
+  var n;                     /* iterates over all tree elements */
+  var prevlen = -1;          /* last emitted length */
+  var curlen;                /* length of current code */
 
-  var nextlen = tree[0 * 2 + 1] /*.Len*/; /* length of next code */
+  var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
 
-  var count = 0; /* repeat count of the current code */
-  var max_count = 7; /* max repeat count */
-  var min_count = 4; /* min repeat count */
+  var count = 0;             /* repeat count of the current code */
+  var max_count = 7;         /* max repeat count */
+  var min_count = 4;         /* min repeat count */
 
   if (nextlen === 0) {
     max_count = 138;
     min_count = 3;
   }
-  tree[(max_code + 1) * 2 + 1] /*.Len*/ = 0xffff; /* guard */
+  tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */
 
   for (n = 0; n <= max_code; n++) {
     curlen = nextlen;
-    nextlen = tree[(n + 1) * 2 + 1] /*.Len*/;
+    nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
+
     if (++count < max_count && curlen === nextlen) {
       continue;
+
     } else if (count < min_count) {
-      s.bl_tree[curlen * 2] /*.Freq*/ += count;
+      s.bl_tree[curlen * 2]/*.Freq*/ += count;
+
     } else if (curlen !== 0) {
-      if (curlen !== prevlen) {
-        s.bl_tree[curlen * 2] /*.Freq*/++;
-      }
-      s.bl_tree[REP_3_6 * 2] /*.Freq*/++;
+
+      if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }
+      s.bl_tree[REP_3_6 * 2]/*.Freq*/++;
+
     } else if (count <= 10) {
-      s.bl_tree[REPZ_3_10 * 2] /*.Freq*/++;
+      s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++;
+
     } else {
-      s.bl_tree[REPZ_11_138 * 2] /*.Freq*/++;
+      s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++;
     }
+
     count = 0;
     prevlen = curlen;
+
     if (nextlen === 0) {
       max_count = 138;
       min_count = 3;
+
     } else if (curlen === nextlen) {
       max_count = 6;
       min_count = 3;
+
     } else {
       max_count = 7;
       min_count = 4;
@@ -793,6 +808,7 @@ function scan_tree(s, tree, max_code)
   }
 }
 
+
 /* ===========================================================================
  * Send a literal or distance tree in compressed form, using the codes in
  * bl_tree.
@@ -802,30 +818,32 @@ function send_tree(s, tree, max_code)
 //    ct_data *tree; /* the tree to be scanned */
 //    int max_code;       /* and its largest code of non zero frequency */
 {
-  var n; /* iterates over all tree elements */
-  var prevlen = -1; /* last emitted length */
-  var curlen; /* length of current code */
+  var n;                     /* iterates over all tree elements */
+  var prevlen = -1;          /* last emitted length */
+  var curlen;                /* length of current code */
 
-  var nextlen = tree[0 * 2 + 1] /*.Len*/; /* length of next code */
+  var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
 
-  var count = 0; /* repeat count of the current code */
-  var max_count = 7; /* max repeat count */
-  var min_count = 4; /* min repeat count */
+  var count = 0;             /* repeat count of the current code */
+  var max_count = 7;         /* max repeat count */
+  var min_count = 4;         /* min repeat count */
 
-  /* tree[max_code+1].Len = -1; */ /* guard already set */
+  /* tree[max_code+1].Len = -1; */  /* guard already set */
   if (nextlen === 0) {
     max_count = 138;
     min_count = 3;
   }
+
   for (n = 0; n <= max_code; n++) {
     curlen = nextlen;
-    nextlen = tree[(n + 1) * 2 + 1] /*.Len*/;
+    nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
+
     if (++count < max_count && curlen === nextlen) {
       continue;
+
     } else if (count < min_count) {
-      do {
-        send_code(s, curlen, s.bl_tree);
-      } while (--count !== 0);
+      do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);
+
     } else if (curlen !== 0) {
       if (curlen !== prevlen) {
         send_code(s, curlen, s.bl_tree);
@@ -834,21 +852,26 @@ function send_tree(s, tree, max_code)
       //Assert(count >= 3 && count <= 6, " 3_6?");
       send_code(s, REP_3_6, s.bl_tree);
       send_bits(s, count - 3, 2);
+
     } else if (count <= 10) {
       send_code(s, REPZ_3_10, s.bl_tree);
       send_bits(s, count - 3, 3);
+
     } else {
       send_code(s, REPZ_11_138, s.bl_tree);
       send_bits(s, count - 11, 7);
     }
+
     count = 0;
     prevlen = curlen;
     if (nextlen === 0) {
       max_count = 138;
       min_count = 3;
+
     } else if (curlen === nextlen) {
       max_count = 6;
       min_count = 3;
+
     } else {
       max_count = 7;
       min_count = 4;
@@ -856,12 +879,13 @@ function send_tree(s, tree, max_code)
   }
 }
 
+
 /* ===========================================================================
  * Construct the Huffman tree for the bit lengths and return the index in
  * bl_order of the last bit length code to send.
  */
 function build_bl_tree(s) {
-  var max_blindex; /* index of last bit length code of non zero freq */
+  var max_blindex;  /* index of last bit length code of non zero freq */
 
   /* Determine the bit length frequencies for literal and distance trees */
   scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
@@ -878,7 +902,7 @@ function build_bl_tree(s) {
    * 3 but the actual value used is 4.)
    */
   for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
-    if (s.bl_tree[bl_order[max_blindex] * 2 + 1] /*.Len*/ !== 0) {
+    if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {
       break;
     }
   }
@@ -890,6 +914,7 @@ function build_bl_tree(s) {
   return max_blindex;
 }
 
+
 /* ===========================================================================
  * Send the header for a block using dynamic Huffman trees: the counts, the
  * lengths of the bit length codes, the literal tree and the distance tree.
@@ -899,18 +924,18 @@ function send_all_trees(s, lcodes, dcodes, blcodes)
 //    deflate_state *s;
 //    int lcodes, dcodes, blcodes; /* number of codes for each tree */
 {
-  var rank; /* index in bl_order */
+  var rank;                    /* index in bl_order */
 
   //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
   //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
   //        "too many codes");
   //Tracev((stderr, "\nbl counts: "));
   send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */
-  send_bits(s, dcodes - 1, 5);
-  send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */
+  send_bits(s, dcodes - 1,   5);
+  send_bits(s, blcodes - 4,  4); /* not -3 as stated in appnote.txt */
   for (rank = 0; rank < blcodes; rank++) {
     //Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
-    send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1] /*.Len*/, 3);
+    send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3);
   }
   //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
 
@@ -921,6 +946,7 @@ function send_all_trees(s, lcodes, dcodes, blcodes)
   //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
 }
 
+
 /* ===========================================================================
  * Check if the data type is TEXT or BINARY, using the following algorithm:
  * - TEXT if the two conditions below are satisfied:
@@ -944,17 +970,18 @@ function detect_data_type(s) {
 
   /* Check for non-textual ("black-listed") bytes. */
   for (n = 0; n <= 31; n++, black_mask >>>= 1) {
-    if (black_mask & 1 && s.dyn_ltree[n * 2] /*.Freq*/ !== 0) {
+    if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {
       return Z_BINARY;
     }
   }
 
   /* Check for textual ("white-listed") bytes. */
-  if (s.dyn_ltree[9 * 2] /*.Freq*/ !== 0 || s.dyn_ltree[10 * 2] /*.Freq*/ !== 0 || s.dyn_ltree[13 * 2] /*.Freq*/ !== 0) {
+  if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||
+      s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {
     return Z_TEXT;
   }
   for (n = 32; n < LITERALS; n++) {
-    if (s.dyn_ltree[n * 2] /*.Freq*/ !== 0) {
+    if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {
       return Z_TEXT;
     }
   }
@@ -964,19 +991,25 @@ function detect_data_type(s) {
    */
   return Z_BINARY;
 }
+
+
 var static_init_done = false;
 
 /* ===========================================================================
  * Initialize the tree data structures for a new zlib stream.
  */
-function _tr_init(s) {
+function _tr_init(s)
+{
+
   if (!static_init_done) {
     tr_static_init();
     static_init_done = true;
   }
-  s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
-  s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
+
+  s.l_desc  = new TreeDesc(s.dyn_ltree, static_l_desc);
+  s.d_desc  = new TreeDesc(s.dyn_dtree, static_d_desc);
   s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
+
   s.bi_buf = 0;
   s.bi_valid = 0;
 
@@ -984,6 +1017,7 @@ function _tr_init(s) {
   init_block(s);
 }
 
+
 /* ===========================================================================
  * Send a stored block
  */
@@ -993,10 +1027,11 @@ function _tr_stored_block(s, buf, stored_len, last)
 //ulg stored_len;   /* length of input block */
 //int last;         /* one if this is the last block for a file */
 {
-  send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); /* send block type */
+  send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);    /* send block type */
   copy_block(s, buf, stored_len, true); /* with header */
 }
 
+
 /* ===========================================================================
  * Send one empty static block to give enough lookahead for inflate.
  * This takes 10 bits, of which 7 may remain in the bit buffer.
@@ -1007,6 +1042,7 @@ function _tr_align(s) {
   bi_flush(s);
 }
 
+
 /* ===========================================================================
  * Determine the best encoding for the current block: dynamic trees, static
  * trees or store, and output the encoded block to the zip file.
@@ -1017,11 +1053,12 @@ function _tr_flush_block(s, buf, stored_len, last)
 //ulg stored_len;   /* length of input block */
 //int last;         /* one if this is the last block for a file */
 {
-  var opt_lenb, static_lenb; /* opt_len and static_len in bytes */
-  var max_blindex = 0; /* index of last bit length code of non zero freq */
+  var opt_lenb, static_lenb;  /* opt_len and static_len in bytes */
+  var max_blindex = 0;        /* index of last bit length code of non zero freq */
 
   /* Build the Huffman trees unless a stored block is forced */
   if (s.level > 0) {
+
     /* Check if the file is binary or text */
     if (s.strm.data_type === Z_UNKNOWN) {
       s.strm.data_type = detect_data_type(s);
@@ -1045,21 +1082,21 @@ function _tr_flush_block(s, buf, stored_len, last)
     max_blindex = build_bl_tree(s);
 
     /* Determine the best encoding. Compute the block lengths in bytes. */
-    opt_lenb = s.opt_len + 3 + 7 >>> 3;
-    static_lenb = s.static_len + 3 + 7 >>> 3;
+    opt_lenb = (s.opt_len + 3 + 7) >>> 3;
+    static_lenb = (s.static_len + 3 + 7) >>> 3;
 
     // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
     //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
     //        s->last_lit));
 
-    if (static_lenb <= opt_lenb) {
-      opt_lenb = static_lenb;
-    }
+    if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }
+
   } else {
     // Assert(buf != (char*)0, "lost buf");
     opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
   }
-  if (stored_len + 4 <= opt_lenb && buf !== -1) {
+
+  if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {
     /* 4: two words for the lengths */
 
     /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
@@ -1069,9 +1106,12 @@ function _tr_flush_block(s, buf, stored_len, last)
      * transform a block into a stored block.
      */
     _tr_stored_block(s, buf, stored_len, last);
+
   } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
+
     send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
     compress_block(s, static_ltree, static_dtree);
+
   } else {
     send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
     send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
@@ -1082,6 +1122,7 @@ function _tr_flush_block(s, buf, stored_len, last)
    * and uLong implemented on 32 bits.
    */
   init_block(s);
+
   if (last) {
     bi_windup(s);
   }
@@ -1100,51 +1141,55 @@ function _tr_tally(s, dist, lc)
 {
   //var out_length, in_length, dcode;
 
-  s.pending_buf[s.d_buf + s.last_lit * 2] = dist >>> 8 & 0xff;
+  s.pending_buf[s.d_buf + s.last_lit * 2]     = (dist >>> 8) & 0xff;
   s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;
+
   s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
   s.last_lit++;
+
   if (dist === 0) {
     /* lc is the unmatched char */
-    s.dyn_ltree[lc * 2] /*.Freq*/++;
+    s.dyn_ltree[lc * 2]/*.Freq*/++;
   } else {
     s.matches++;
     /* Here, lc is the match length - MIN_MATCH */
-    dist--; /* dist = match distance - 1 */
+    dist--;             /* dist = match distance - 1 */
     //Assert((ush)dist < (ush)MAX_DIST(s) &&
     //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
     //       (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
 
-    s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2] /*.Freq*/++;
-    s.dyn_dtree[d_code(dist) * 2] /*.Freq*/++;
+    s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;
+    s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
   }
 
-  // (!) This block is disabled in zlib defailts,
-  // don't enable it for binary compatibility
-
-  //#ifdef TRUNCATE_BLOCK
-  //  /* Try to guess if it is profitable to stop the current block here */
-  //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {
-  //    /* Compute an upper bound for the compressed length */
-  //    out_length = s.last_lit*8;
-  //    in_length = s.strstart - s.block_start;
-  //
-  //    for (dcode = 0; dcode < D_CODES; dcode++) {
-  //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);
-  //    }
-  //    out_length >>>= 3;
-  //    //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
-  //    //       s->last_lit, in_length, out_length,
-  //    //       100L - out_length*100L/in_length));
-  //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {
-  //      return true;
-  //    }
-  //  }
-  //#endif
-
-  return s.last_lit === s.lit_bufsize - 1;
+// (!) This block is disabled in zlib defailts,
+// don't enable it for binary compatibility
+
+//#ifdef TRUNCATE_BLOCK
+//  /* Try to guess if it is profitable to stop the current block here */
+//  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {
+//    /* Compute an upper bound for the compressed length */
+//    out_length = s.last_lit*8;
+//    in_length = s.strstart - s.block_start;
+//
+//    for (dcode = 0; dcode < D_CODES; dcode++) {
+//      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);
+//    }
+//    out_length >>>= 3;
+//    //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
+//    //       s->last_lit, in_length, out_length,
+//    //       100L - out_length*100L/in_length));
+//    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {
+//      return true;
+//    }
+//  }
+//#endif
+
+  return (s.last_lit === s.lit_bufsize - 1);
   /* We avoid equality with lit_bufsize because of wraparound at 64K
    * on 16 bit machines and because stored blocks are restricted to
    * 64K-1 bytes.
    */
-}
+}
+
+export { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align };