diff --git a/lib/zlib/trees.js b/lib/zlib/trees.js index 41c1ed8..300f1d8 100644 --- a/lib/zlib/trees.js +++ b/lib/zlib/trees.js @@ -276,10 +276,10 @@ const bi_flush = (s) => { * The length opt_len is updated; static_len is also updated if stree is * not null. */ -const gen_bitlen = (s, desc) => +const gen_bitlen = (s, desc) => { // deflate_state *s; // tree_desc *desc; /* the tree descriptor */ -{ + const tree = desc.dyn_tree; const max_code = desc.max_code; const stree = desc.stat_desc.static_tree; @@ -373,11 +373,11 @@ const gen_bitlen = (s, desc) => * OUT assertion: the field code is set for all tree elements of non * zero code length. */ -const gen_codes = (tree, max_code, bl_count) => +const 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 */ -{ + const next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */ let code = 0; /* running code value */ let bits; /* bit index */ @@ -565,11 +565,11 @@ const smaller = (tree, n, m, depth) => { * when the heap property is re-established (each father smaller than its * two sons). */ -const pqdownheap = (s, tree, k) => +const pqdownheap = (s, tree, k) => { // deflate_state *s; // ct_data *tree; /* the tree to restore */ // int k; /* node to move down */ -{ + const v = s.heap[k]; let j = k << 1; /* left son of k */ while (j <= s.heap_len) { @@ -598,11 +598,11 @@ const pqdownheap = (s, tree, k) => /* =========================================================================== * Send the block data compressed using the given Huffman trees */ -const compress_block = (s, ltree, dtree) => +const compress_block = (s, ltree, dtree) => { // deflate_state *s; // const ct_data *ltree; /* literal tree */ // const ct_data *dtree; /* distance tree */ -{ + let dist; /* distance of matched string */ let lc; /* match length or unmatched char (if dist == 0) */ let sx = 0; /* running index in sym_buf */ @@ -656,10 +656,10 @@ const compress_block = (s, ltree, dtree) => * 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. */ -const build_tree = (s, desc) => +const build_tree = (s, desc) => { // deflate_state *s; // tree_desc *desc; /* the tree descriptor */ -{ + const tree = desc.dyn_tree; const stree = desc.stat_desc.static_tree; const has_stree = desc.stat_desc.has_stree; @@ -752,11 +752,11 @@ const build_tree = (s, desc) => * Scan a literal or distance tree to determine the frequencies of the codes * in the bit length tree. */ -const scan_tree = (s, tree, max_code) => +const 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 */ -{ + let n; /* iterates over all tree elements */ let prevlen = -1; /* last emitted length */ let curlen; /* length of current code */ @@ -818,11 +818,11 @@ const scan_tree = (s, tree, max_code) => * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ -const send_tree = (s, tree, max_code) => +const 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 */ -{ + let n; /* iterates over all tree elements */ let prevlen = -1; /* last emitted length */ let curlen; /* length of current code */ @@ -926,10 +926,10 @@ const build_bl_tree = (s) => { * lengths of the bit length codes, the literal tree and the distance tree. * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ -const send_all_trees = (s, lcodes, dcodes, blcodes) => +const send_all_trees = (s, lcodes, dcodes, blcodes) => { // deflate_state *s; // int lcodes, dcodes, blcodes; /* number of codes for each tree */ -{ + let rank; /* index in bl_order */ //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); @@ -1027,12 +1027,12 @@ const _tr_init = (s) => /* =========================================================================== * Send a stored block */ -const _tr_stored_block = (s, buf, stored_len, last) => +const _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 */ bi_windup(s); /* align on byte boundary */ put_short(s, stored_len); @@ -1059,12 +1059,12 @@ const _tr_align = (s) => { * Determine the best encoding for the current block: dynamic trees, static * trees or store, and write out the encoded block. */ -const _tr_flush_block = (s, buf, stored_len, last) => +const _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 */ -{ + let opt_lenb, static_lenb; /* opt_len and static_len in bytes */ let max_blindex = 0; /* index of last bit length code of non zero freq */ @@ -1146,11 +1146,11 @@ const _tr_flush_block = (s, buf, stored_len, last) => * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. */ -const _tr_tally = (s, dist, lc) => +const _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) */ -{ + s.pending_buf[s.sym_buf + s.sym_next++] = dist; s.pending_buf[s.sym_buf + s.sym_next++] = dist >> 8; s.pending_buf[s.sym_buf + s.sym_next++] = lc;