@novnc/novnc 1.3.0 → 1.4.0-beta

package/lib/vendor/pako/lib/zlib/trees.js

@@ -1,7 +1,6 @@
 "use strict";
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -10,37 +9,34 @@ 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(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 /* Public constants ==========================================================*/
-
 /* ===========================================================================*/
+
 //var Z_FILTERED          = 1;
 //var Z_HUFFMAN_ONLY      = 2;
 //var Z_RLE               = 3;
-var Z_FIXED = 4; //var Z_DEFAULT_STRATEGY  = 0;
+var Z_FIXED = 4;
+//var Z_DEFAULT_STRATEGY  = 0;
 
 /* Possible values of the data_type field (though see inflate()) */
-
 var Z_BINARY = 0;
-var Z_TEXT = 1; //var Z_ASCII             = 1; // = Z_TEXT
-
+var Z_TEXT = 1;
+//var Z_ASCII             = 1; // = Z_TEXT
 var Z_UNKNOWN = 2;
+
 /*============================================================================*/
 
 function zero(buf) {
   var len = buf.length;
-
   while (--len >= 0) {
     buf[len] = 0;
   }
-} // From zutil.h
+}
 
+// From zutil.h
 
 var STORED_BLOCK = 0;
 var STATIC_TREES = 1;
@@ -50,8 +46,8 @@ var DYN_TREES = 2;
 var MIN_MATCH = 3;
 var MAX_MATCH = 258;
 /* The minimum and maximum match lengths */
-// From deflate.h
 
+// From deflate.h
 /* ===========================================================================
  * Internal compression state.
  */
@@ -100,15 +96,11 @@ 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 */
+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 */
+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 */
+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 */
@@ -120,12 +112,12 @@ var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
 /* ===========================================================================
  * Local data. These are initialized only once.
  */
+
 // We pre-fill arrays with 0 to avoid uninitialized gaps
 
-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 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);
 zero(static_ltree);
 /* The static literal tree. Since the bit lengths are imposed, there is no
@@ -141,7 +133,6 @@ zero(static_dtree);
  */
 
 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
@@ -149,7 +140,6 @@ zero(_dist_code);
  */
 
 var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
-
 zero(_length_code);
 /* length code for each normalized match length (0 == MIN_MATCH) */
 
@@ -162,61 +152,43 @@ 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.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.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;
 }
-
 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;
 }
+
 /* ===========================================================================
  * 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;
@@ -228,37 +200,28 @@ function send_bits(s, value, length) {
     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)
  * IN assertion: 1 <= len <= 15
  */
-
-
 function bi_reverse(code, len) {
   var res = 0;
-
   do {
     res |= code & 1;
     code >>>= 1;
     res <<= 1;
   } while (--len > 0);
-
   return res >>> 1;
 }
+
 /* ===========================================================================
  * Flush the bit buffer, keeping at most 7 bits in it.
  */
-
-
 function bi_flush(s) {
   if (s.bi_valid === 16) {
     put_short(s, s.bi_buf);
@@ -270,6 +233,7 @@ function bi_flush(s) {
     s.bi_valid -= 8;
   }
 }
+
 /* ===========================================================================
  * Compute the optimal bit lengths for a tree and update the total bit length
  * for the current block.
@@ -280,9 +244,8 @@ function bi_flush(s) {
  *     The length opt_len is updated; static_len is also updated if stree is
  *     not null.
  */
-
-
-function gen_bitlen(s, desc) //    deflate_state *s;
+function gen_bitlen(s, desc)
+//    deflate_state *s;
 //    tree_desc *desc;    /* the tree descriptor */
 {
   var tree = desc.dyn_tree;
@@ -292,144 +255,91 @@ function gen_bitlen(s, desc) //    deflate_state *s;
   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 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;
   }
+
   /* 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 */
-
+    } /* 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;
-  } // Trace((stderr,"\nbit length overflow\n"));
+  }
 
+  // Trace((stderr,"\nbit length overflow\n"));
   /* This happens for example on obj2 and pic of the Calgary corpus */
 
   /* 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 */
-
-    s.bl_count[bits + 1] += 2;
-    /* move one overflow item as its brother */
-
+    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,
      * but this does not affect bl_count[max_length]
      */
-
     overflow -= 2;
   } while (overflow > 0);
+
   /* Now recompute all bit lengths, scanning in increasing frequency.
    * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
    * lengths instead of fixing only the wrong ones. This idea is taken
    * from 'ar' written by Haruhiko Okumura.)
    */
-
-
   for (bits = max_length; bits !== 0; bits--) {
     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 (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).
@@ -438,28 +348,19 @@ function gen_bitlen(s, desc) //    deflate_state *s;
  * OUT assertion: the field code is set for all tree elements of non
  *     zero code length.
  */
-
-
-function gen_codes(tree, max_code, bl_count) //    ct_data *tree;             /* the tree to decorate */
+function gen_codes(tree, max_code, bl_count)
+//    ct_data *tree;             /* the tree to decorate */
 //    int max_code;              /* largest code with non zero frequency */
 //    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 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 */
 
   /* 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;
   }
@@ -470,52 +371,35 @@ function gen_codes(tree, max_code, bl_count) //    ct_data *tree;             /*
   //        "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*/
-    ;
-
+    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) ",
+    //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 */
+
   // do check in _tr_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;
@@ -525,85 +409,60 @@ function tr_static_init() {
   #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++) {
       _length_code[length++] = code;
     }
-  } //Assert (length == 256, "tr_static_init: length != 256");
-
+  }
+  //Assert (length == 256, "tr_static_init: length != 256");
   /* Note that the length 255 (match length 258) can be represented
    * in two different ways: code 284 + 5 bits or code 285, so we
    * overwrite length_code[255] to use the best encoding:
    */
-
-
   _length_code[length - 1] = code;
-  /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
 
+  /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
   dist = 0;
-
   for (code = 0; code < 16; code++) {
     base_dist[code] = dist;
-
     for (n = 0; n < 1 << extra_dbits[code]; n++) {
       _dist_code[dist++] = code;
     }
-  } //Assert (dist == 256, "tr_static_init: dist != 256");
-
-
-  dist >>= 7;
-  /* from now on, all distances are divided by 128 */
-
+  }
+  //Assert (dist == 256, "tr_static_init: dist != 256");
+  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++) {
       _dist_code[256 + dist++] = code;
     }
-  } //Assert (dist == 256, "tr_static_init: 256+dist != 512");
+  }
+  //Assert (dist == 256, "tr_static_init: 256+dist != 512");
 
   /* Construct the codes of the static literal tree */
-
-
   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]++;
   }
@@ -611,65 +470,46 @@ function tr_static_init() {
    * tree construction to get a canonical Huffman tree (longest code
    * all ones)
    */
-
-
   gen_codes(static_ltree, L_CODES + 1, bl_count);
-  /* The static distance tree is trivial: */
 
+  /* 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);
-  } // Now data ready and we can init static trees
-
+    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_init_done = true;
+  static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
+
+  //static_init_done = true;
 }
+
 /* ===========================================================================
  * Initialize a new block.
  */
-
-
 function init_block(s) {
-  var n;
-  /* iterates over tree elements */
+  var n; /* iterates over tree elements */
 
   /* Initialize the trees. */
-
   for (n = 0; n < L_CODES; n++) {
-    s.dyn_ltree[n * 2]
-    /*.Freq*/
-    = 0;
+    s.dyn_ltree[n * 2] /*.Freq*/ = 0;
   }
-
   for (n = 0; n < D_CODES; n++) {
-    s.dyn_dtree[n * 2]
-    /*.Freq*/
-    = 0;
+    s.dyn_dtree[n * 2] /*.Freq*/ = 0;
   }
-
   for (n = 0; n < BL_CODES; n++) {
-    s.bl_tree[n * 2]
-    /*.Freq*/
-    = 0;
+    s.bl_tree[n * 2] /*.Freq*/ = 0;
   }
-
-  s.dyn_ltree[END_BLOCK * 2]
-  /*.Freq*/
-  = 1;
+  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) {
   if (s.bi_valid > 8) {
     put_short(s, s.bi_buf);
@@ -677,172 +517,131 @@ function bi_windup(s) {
     //put_byte(s, (Byte)s->bi_buf);
     s.pending_buf[s.pending++] = s.bi_buf;
   }
-
   s.bi_buf = 0;
   s.bi_valid = 0;
 }
+
 /* ===========================================================================
  * Copy a stored block, storing first the length and its
  * one's complement if requested.
  */
-
-
-function copy_block(s, buf, len, header) //DeflateState *s;
+function copy_block(s, buf, len, header)
+//DeflateState *s;
 //charf    *buf;    /* the input data */
 //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--) {
+  }
+  //  while (len--) {
   //    put_byte(s, *buf++);
   //  }
-
-
   utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
   s.pending += len;
 }
+
 /* ===========================================================================
  * Compares to subtrees, using the tree depth as tie breaker when
  * the subtrees have equal frequency. This minimizes the worst case length.
  */
-
-
 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];
 }
+
 /* ===========================================================================
  * Restore the heap property by moving down the tree starting at node k,
  * exchanging a node with the smallest of its two sons if necessary, stopping
  * when the heap property is re-established (each father smaller than its
  * two sons).
  */
-
-
-function pqdownheap(s, tree, k) //    deflate_state *s;
+function pqdownheap(s, tree, k)
+//    deflate_state *s;
 //    ct_data *tree;  /* the tree to restore */
 //    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)) {
       j++;
     }
     /* Exit if v is smaller than both sons */
-
-
     if (smaller(tree, v, s.heap[j], s.depth)) {
       break;
     }
-    /* Exchange v with the smallest son */
-
 
+    /* Exchange v with the smallest son */
     s.heap[k] = s.heap[j];
     k = j;
-    /* And continue down the tree, setting j to the left son of k */
 
+    /* And continue down the tree, setting j to the left son of k */
     j <<= 1;
   }
-
   s.heap[k] = v;
-} // inlined manually
+}
+
+// inlined manually
 // var SMALLEST = 1;
 
 /* ===========================================================================
  * Send the block data compressed using the given Huffman trees
  */
-
-
-function compress_block(s, ltree, dtree) //    deflate_state *s;
+function compress_block(s, ltree, dtree)
+//    deflate_state *s;
 //    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];
       lc = s.pending_buf[s.l_buf + lx];
       lx++;
-
       if (dist === 0) {
-        send_code(s, lc, ltree);
-        /* send a literal byte */
+        send_code(s, lc, ltree); /* send a literal byte */
         //Tracecv(isgraph(lc), (stderr," '%c' ", lc));
       } else {
         /* Here, lc is the match length - MIN_MATCH */
         code = _length_code[lc];
-        send_code(s, code + LITERALS + 1, ltree);
-        /* send the length code */
-
+        send_code(s, code + LITERALS + 1, ltree); /* send the length code */
         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 */
+        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 */
         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 ? */
+      } /* 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.
@@ -851,207 +650,132 @@ function compress_block(s, ltree, dtree) //    deflate_state *s;
  *     and corresponding code. The length opt_len is updated; static_len is
  *     also updated if stree is not null. The field max_code is set.
  */
-
-
-function build_tree(s, desc) //    deflate_state *s;
+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 has_stree = desc.stat_desc.has_stree;
   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 n, m; /* iterate over heap elements */
+  var max_code = -1; /* largest code with non zero frequency */
+  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].
    * heap[0] is not used.
    */
-
   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;
     }
   }
+
   /* The pkzip format requires that at least one distance code exists,
    * and that at least one bit should be sent even if there is only one
    * possible code. So to avoid special checks later on we force at least
    * 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;
+    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 */
-
   }
 
   desc.max_code = max_code;
+
   /* 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--) {
+  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 */
-
-    s.heap[--s.heap_max] = n;
-    /* keep the nodes sorted by 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*/
-    ;
+    /* Create a new node father of n and m */
+    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;
-    /* and insert the new node in the heap */
+    tree[n * 2 + 1] /*.Dad*/ = tree[m * 2 + 1] /*.Dad*/ = node;
 
-    s.heap[1
-    /*SMALLEST*/
-    ] = node++;
-    pqdownheap(s, tree, 1
-    /*SMALLEST*/
-    );
+    /* and insert the new node in the heap */
+    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.
    */
-
   gen_bitlen(s, desc);
-  /* The field len is now set, we can generate the bit codes */
 
+  /* The field len is now set, we can generate the bit codes */
   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.
  */
-
-
-function scan_tree(s, tree, max_code) //    deflate_state *s;
+function scan_tree(s, tree, max_code)
+//    deflate_state *s;
 //    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 n; /* iterates over all tree elements */
+  var prevlen = -1; /* last emitted length */
+  var curlen; /* length of current code */
 
-  var prevlen = -1;
-  /* last emitted length */
+  var nextlen = tree[0 * 2 + 1] /*.Len*/; /* length of next code */
 
-  var curlen;
-  /* length of current 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*/++;
     } else if (count <= 10) {
       s.bl_tree[REPZ_3_10 * 2] /*.Freq*/++;
@@ -1061,7 +785,6 @@ function scan_tree(s, tree, max_code) //    deflate_state *s;
 
     count = 0;
     prevlen = curlen;
-
     if (nextlen === 0) {
       max_count = 138;
       min_count = 3;
@@ -1074,53 +797,34 @@ function scan_tree(s, tree, max_code) //    deflate_state *s;
     }
   }
 }
+
 /* ===========================================================================
  * Send a literal or distance tree in compressed form, using the codes in
  * bl_tree.
  */
-
-
-function send_tree(s, tree, max_code) //    deflate_state *s;
+function send_tree(s, tree, max_code)
+//    deflate_state *s;
 //    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 nextlen = tree[0 * 2 + 1]
-  /*.Len*/
-  ;
-  /* length of next code */
-
-  var count = 0;
-  /* repeat count of the current code */
+  var n; /* iterates over all tree elements */
+  var prevlen = -1; /* last emitted length */
+  var curlen; /* length of current code */
 
-  var max_count = 7;
-  /* max repeat count */
+  var nextlen = tree[0 * 2 + 1] /*.Len*/; /* length of next code */
 
-  var min_count = 4;
-  /* min repeat count */
-
-  /* tree[max_code+1].Len = -1; */
-
-  /* guard already set */
+  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 */
   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;
@@ -1132,9 +836,8 @@ function send_tree(s, tree, max_code) //    deflate_state *s;
       if (curlen !== prevlen) {
         send_code(s, curlen, s.bl_tree);
         count--;
-      } //Assert(count >= 3 && count <= 6, " 3_6?");
-
-
+      }
+      //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) {
@@ -1144,10 +847,8 @@ function send_tree(s, tree, max_code) //    deflate_state *s;
       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;
@@ -1160,22 +861,19 @@ function send_tree(s, tree, max_code) //    deflate_state *s;
     }
   }
 }
+
 /* ===========================================================================
  * 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);
   scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
-  /* Build the bit length tree: */
 
+  /* Build the bit length tree: */
   build_tree(s, s.bl_desc);
   /* opt_len now includes the length of the tree representations, except
    * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
@@ -1185,62 +883,50 @@ function build_bl_tree(s) {
    * requires that at least 4 bit length codes be sent. (appnote.txt says
    * 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;
     }
   }
   /* Update opt_len to include the bit length tree and counts */
-
-
-  s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+  s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+  //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
   //        s->opt_len, s->static_len));
 
   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.
  * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
  */
-
-
-function send_all_trees(s, lcodes, dcodes, blcodes) //    deflate_state *s;
+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, 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, 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);
-  } //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
-
+    send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1] /*.Len*/, 3);
+  }
+  //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
 
-  send_tree(s, s.dyn_ltree, lcodes - 1);
-  /* literal tree */
+  send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */
   //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
 
-  send_tree(s, s.dyn_dtree, dcodes - 1);
-  /* distance tree */
+  send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */
   //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:
@@ -1254,8 +940,6 @@ function send_all_trees(s, lcodes, dcodes, blcodes) //    deflate_state *s;
  *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
  * IN assertion: the fields Freq of dyn_ltree are set.
  */
-
-
 function detect_data_type(s) {
   /* black_mask is the bit mask of black-listed bytes
    * set bits 0..6, 14..25, and 28..31
@@ -1263,123 +947,100 @@ function detect_data_type(s) {
    */
   var black_mask = 0xf3ffc07f;
   var n;
-  /* Check for non-textual ("black-listed") bytes. */
 
+  /* 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) {
+  /* 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) {
     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;
     }
   }
+
   /* There are no "black-listed" or "white-listed" bytes:
    * this stream either is empty or has tolerated ("gray-listed") bytes only.
    */
-
-
   return Z_BINARY;
 }
-
 var static_init_done = false;
+
 /* ===========================================================================
  * Initialize the tree data structures for a new zlib stream.
  */
-
 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.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
   s.bi_buf = 0;
   s.bi_valid = 0;
-  /* Initialize the first block of the first file: */
 
+  /* Initialize the first block of the first file: */
   init_block(s);
 }
+
 /* ===========================================================================
  * Send a stored block
  */
-
-
-function _tr_stored_block(s, buf, stored_len, last) //DeflateState *s;
+function _tr_stored_block(s, buf, stored_len, last)
+//DeflateState *s;
 //charf *buf;       /* input block */
 //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 */
-
-  copy_block(s, buf, stored_len, true);
-  /* with header */
+  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.
  */
-
-
 function _tr_align(s) {
   send_bits(s, STATIC_TREES << 1, 3);
   send_code(s, END_BLOCK, static_ltree);
   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.
  */
-
-
-function _tr_flush_block(s, buf, stored_len, last) //DeflateState *s;
+function _tr_flush_block(s, buf, stored_len, last)
+//DeflateState *s;
 //charf *buf;       /* input block, or NULL if too old */
 //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);
     }
-    /* Construct the literal and distance trees */
-
 
-    build_tree(s, s.l_desc); // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
+    /* Construct the literal and distance trees */
+    build_tree(s, s.l_desc);
+    // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
     //        s->static_len));
 
-    build_tree(s, s.d_desc); // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
+    build_tree(s, s.d_desc);
+    // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
     //        s->static_len));
-
     /* At this point, opt_len and static_len are the total bit lengths of
      * the compressed block data, excluding the tree representations.
      */
@@ -1387,12 +1048,13 @@ function _tr_flush_block(s, buf, stored_len, last) //DeflateState *s;
     /* Build the bit length tree for the above two trees, and get the index
      * in bl_order of the last bit length code to send.
      */
-
     max_blindex = build_bl_tree(s);
-    /* Determine the best encoding. Compute the block lengths in bytes. */
 
+    /* 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; // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
+    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));
 
@@ -1401,8 +1063,7 @@ function _tr_flush_block(s, buf, stored_len, last) //DeflateState *s;
     }
   } else {
     // Assert(buf != (char*)0, "lost buf");
-    opt_lenb = static_lenb = stored_len + 5;
-    /* force a stored block */
+    opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
   }
 
   if (stored_len + 4 <= opt_lenb && buf !== -1) {
@@ -1422,54 +1083,52 @@ function _tr_flush_block(s, buf, stored_len, last) //DeflateState *s;
     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);
     compress_block(s, s.dyn_ltree, s.dyn_dtree);
-  } // Assert (s->compressed_len == s->bits_sent, "bad compressed size");
-
+  }
+  // Assert (s->compressed_len == s->bits_sent, "bad compressed size");
   /* The above check is made mod 2^32, for files larger than 512 MB
    * and uLong implemented on 32 bits.
    */
-
-
   init_block(s);
-
   if (last) {
     bi_windup(s);
-  } // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
+  }
+  // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
   //       s->compressed_len-7*last));
-
 }
+
 /* ===========================================================================
  * Save the match info and tally the frequency counts. Return true if
  * the current block must be flushed.
  */
-
-
-function _tr_tally(s, dist, lc) //    deflate_state *s;
+function _tr_tally(s, dist, lc)
+//    deflate_state *s;
 //    unsigned dist;  /* distance of matched string */
 //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
 {
   //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 + 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*/++;
   } 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*/++;
-  } // (!) This block is disabled in zlib defailts,
+  }
+
+  // (!) 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) {
@@ -1490,7 +1149,6 @@ function _tr_tally(s, dist, lc) //    deflate_state *s;
   //  }
   //#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