0x5eal/rbxts-pako
1
0
Fork 0
mirror of https://github.com/0x5eal/rbxts-pako.git synced 2025-04-03 02:10:57 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update comments in tree.js for Babel compatibility

Browse source 
- Closes #261, #263, #262
This commit is contained in:
Vitaly Puzrin 2022-11-07 01:34:34 +02:00
parent 174a1d12b6
commit 23c773e31c
1 changed files with 22 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
lib/zlib/trees.js
View file

@ -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;