diff --git a/benchmark/implementations/deflate-dankogai/index.js b/benchmark/implementations/deflate-dankogai/index.js new file mode 100644 index 0000000..48edbdd --- /dev/null +++ b/benchmark/implementations/deflate-dankogai/index.js @@ -0,0 +1,7 @@ +'use strict' + +var deflate = require('./rawdeflate').RawDeflate.deflate; + +exports.run = function(data, level) { + return deflate(data.typed, 0); +} diff --git a/benchmark/implementations/deflate-dankogai/rawdeflate.js b/benchmark/implementations/deflate-dankogai/rawdeflate.js new file mode 100644 index 0000000..20a659d --- /dev/null +++ b/benchmark/implementations/deflate-dankogai/rawdeflate.js @@ -0,0 +1,1676 @@ +/* + * $Id: rawdeflate.js,v 0.5 2013/04/09 14:25:38 dankogai Exp dankogai $ + * + * GNU General Public License, version 2 (GPL-2.0) + * http://opensource.org/licenses/GPL-2.0 + * Original: + * http://www.onicos.com/staff/iz/amuse/javascript/expert/deflate.txt + */ + +(function(ctx){ + +/* Copyright (C) 1999 Masanao Izumo + * Version: 1.0.1 + * LastModified: Dec 25 1999 + */ + +/* Interface: + * data = zip_deflate(src); + */ + +/* constant parameters */ +var zip_WSIZE = 32768; // Sliding Window size +var zip_STORED_BLOCK = 0; +var zip_STATIC_TREES = 1; +var zip_DYN_TREES = 2; + +/* for deflate */ +var zip_DEFAULT_LEVEL = 6; +var zip_FULL_SEARCH = true; +var zip_INBUFSIZ = 32768; // Input buffer size +var zip_INBUF_EXTRA = 64; // Extra buffer +var zip_OUTBUFSIZ = 1024 * 8; +var zip_window_size = 2 * zip_WSIZE; +var zip_MIN_MATCH = 3; +var zip_MAX_MATCH = 258; +var zip_BITS = 16; +// for SMALL_MEM +var zip_LIT_BUFSIZE = 0x2000; +var zip_HASH_BITS = 13; +// for MEDIUM_MEM +// var zip_LIT_BUFSIZE = 0x4000; +// var zip_HASH_BITS = 14; +// for BIG_MEM +// var zip_LIT_BUFSIZE = 0x8000; +// var zip_HASH_BITS = 15; +if(zip_LIT_BUFSIZE > zip_INBUFSIZ) + alert("error: zip_INBUFSIZ is too small"); +if((zip_WSIZE<<1) > (1< zip_BITS-1) + alert("error: zip_HASH_BITS is too large"); +if(zip_HASH_BITS < 8 || zip_MAX_MATCH != 258) + alert("error: Code too clever"); +var zip_DIST_BUFSIZE = zip_LIT_BUFSIZE; +var zip_HASH_SIZE = 1 << zip_HASH_BITS; +var zip_HASH_MASK = zip_HASH_SIZE - 1; +var zip_WMASK = zip_WSIZE - 1; +var zip_NIL = 0; // Tail of hash chains +var zip_TOO_FAR = 4096; +var zip_MIN_LOOKAHEAD = zip_MAX_MATCH + zip_MIN_MATCH + 1; +var zip_MAX_DIST = zip_WSIZE - zip_MIN_LOOKAHEAD; +var zip_SMALLEST = 1; +var zip_MAX_BITS = 15; +var zip_MAX_BL_BITS = 7; +var zip_LENGTH_CODES = 29; +var zip_LITERALS =256; +var zip_END_BLOCK = 256; +var zip_L_CODES = zip_LITERALS + 1 + zip_LENGTH_CODES; +var zip_D_CODES = 30; +var zip_BL_CODES = 19; +var zip_REP_3_6 = 16; +var zip_REPZ_3_10 = 17; +var zip_REPZ_11_138 = 18; +var zip_HEAP_SIZE = 2 * zip_L_CODES + 1; +var zip_H_SHIFT = parseInt((zip_HASH_BITS + zip_MIN_MATCH - 1) / + zip_MIN_MATCH); + +/* variables */ +var zip_free_queue; +var zip_qhead, zip_qtail; +var zip_initflag; +var zip_outbuf = null; +var zip_outcnt, zip_outoff; +var zip_complete; +var zip_window; +var zip_d_buf; +var zip_l_buf; +var zip_prev; +var zip_bi_buf; +var zip_bi_valid; +var zip_block_start; +var zip_ins_h; +var zip_hash_head; +var zip_prev_match; +var zip_match_available; +var zip_match_length; +var zip_prev_length; +var zip_strstart; +var zip_match_start; +var zip_eofile; +var zip_lookahead; +var zip_max_chain_length; +var zip_max_lazy_match; +var zip_compr_level; +var zip_good_match; +var zip_nice_match; +var zip_dyn_ltree; +var zip_dyn_dtree; +var zip_static_ltree; +var zip_static_dtree; +var zip_bl_tree; +var zip_l_desc; +var zip_d_desc; +var zip_bl_desc; +var zip_bl_count; +var zip_heap; +var zip_heap_len; +var zip_heap_max; +var zip_depth; +var zip_length_code; +var zip_dist_code; +var zip_base_length; +var zip_base_dist; +var zip_flag_buf; +var zip_last_lit; +var zip_last_dist; +var zip_last_flags; +var zip_flags; +var zip_flag_bit; +var zip_opt_len; +var zip_static_len; +var zip_deflate_data; +var zip_deflate_pos; + +/* objects (deflate) */ + +var zip_DeflateCT = function() { + this.fc = 0; // frequency count or bit string + this.dl = 0; // father node in Huffman tree or length of bit string +} + +var zip_DeflateTreeDesc = function() { + this.dyn_tree = null; // the dynamic tree + this.static_tree = null; // corresponding static tree or NULL + this.extra_bits = null; // extra bits for each code or NULL + this.extra_base = 0; // base index for extra_bits + this.elems = 0; // max number of elements in the tree + this.max_length = 0; // max bit length for the codes + this.max_code = 0; // largest code with non zero frequency +} + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ +var zip_DeflateConfiguration = function(a, b, c, d) { + this.good_length = a; // reduce lazy search above this match length + this.max_lazy = b; // do not perform lazy search above this match length + this.nice_length = c; // quit search above this match length + this.max_chain = d; +} + +var zip_DeflateBuffer = function() { + this.next = null; + this.len = 0; + this.ptr = new Array(zip_OUTBUFSIZ); + this.off = 0; +} + +/* constant tables */ +var zip_extra_lbits = new Array( + 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 zip_extra_dbits = new Array( + 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 zip_extra_blbits = new Array( + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7); +var zip_bl_order = new Array( + 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15); +var zip_configuration_table = new Array( + new zip_DeflateConfiguration(0, 0, 0, 0), + new zip_DeflateConfiguration(4, 4, 8, 4), + new zip_DeflateConfiguration(4, 5, 16, 8), + new zip_DeflateConfiguration(4, 6, 32, 32), + new zip_DeflateConfiguration(4, 4, 16, 16), + new zip_DeflateConfiguration(8, 16, 32, 32), + new zip_DeflateConfiguration(8, 16, 128, 128), + new zip_DeflateConfiguration(8, 32, 128, 256), + new zip_DeflateConfiguration(32, 128, 258, 1024), + new zip_DeflateConfiguration(32, 258, 258, 4096)); + + +/* routines (deflate) */ + +var zip_deflate_start = function(level) { + var i; + + if(!level) + level = zip_DEFAULT_LEVEL; + else if(level < 1) + level = 1; + else if(level > 9) + level = 9; + + zip_compr_level = level; + zip_initflag = false; + zip_eofile = false; + if(zip_outbuf != null) + return; + + zip_free_queue = zip_qhead = zip_qtail = null; + zip_outbuf = new Array(zip_OUTBUFSIZ); + zip_window = new Array(zip_window_size); + zip_d_buf = new Array(zip_DIST_BUFSIZE); + zip_l_buf = new Array(zip_INBUFSIZ + zip_INBUF_EXTRA); + zip_prev = new Array(1 << zip_BITS); + zip_dyn_ltree = new Array(zip_HEAP_SIZE); + for(i = 0; i < zip_HEAP_SIZE; i++) + zip_dyn_ltree[i] = new zip_DeflateCT(); + zip_dyn_dtree = new Array(2*zip_D_CODES+1); + for(i = 0; i < 2*zip_D_CODES+1; i++) + zip_dyn_dtree[i] = new zip_DeflateCT(); + zip_static_ltree = new Array(zip_L_CODES+2); + for(i = 0; i < zip_L_CODES+2; i++) + zip_static_ltree[i] = new zip_DeflateCT(); + zip_static_dtree = new Array(zip_D_CODES); + for(i = 0; i < zip_D_CODES; i++) + zip_static_dtree[i] = new zip_DeflateCT(); + zip_bl_tree = new Array(2*zip_BL_CODES+1); + for(i = 0; i < 2*zip_BL_CODES+1; i++) + zip_bl_tree[i] = new zip_DeflateCT(); + zip_l_desc = new zip_DeflateTreeDesc(); + zip_d_desc = new zip_DeflateTreeDesc(); + zip_bl_desc = new zip_DeflateTreeDesc(); + zip_bl_count = new Array(zip_MAX_BITS+1); + zip_heap = new Array(2*zip_L_CODES+1); + zip_depth = new Array(2*zip_L_CODES+1); + zip_length_code = new Array(zip_MAX_MATCH-zip_MIN_MATCH+1); + zip_dist_code = new Array(512); + zip_base_length = new Array(zip_LENGTH_CODES); + zip_base_dist = new Array(zip_D_CODES); + zip_flag_buf = new Array(parseInt(zip_LIT_BUFSIZE / 8)); +} + +var zip_deflate_end = function() { + zip_free_queue = zip_qhead = zip_qtail = null; + zip_outbuf = null; + zip_window = null; + zip_d_buf = null; + zip_l_buf = null; + zip_prev = null; + zip_dyn_ltree = null; + zip_dyn_dtree = null; + zip_static_ltree = null; + zip_static_dtree = null; + zip_bl_tree = null; + zip_l_desc = null; + zip_d_desc = null; + zip_bl_desc = null; + zip_bl_count = null; + zip_heap = null; + zip_depth = null; + zip_length_code = null; + zip_dist_code = null; + zip_base_length = null; + zip_base_dist = null; + zip_flag_buf = null; +} + +var zip_reuse_queue = function(p) { + p.next = zip_free_queue; + zip_free_queue = p; +} + +var zip_new_queue = function() { + var p; + + if(zip_free_queue != null) + { + p = zip_free_queue; + zip_free_queue = zip_free_queue.next; + } + else + p = new zip_DeflateBuffer(); + p.next = null; + p.len = p.off = 0; + + return p; +} + +var zip_head1 = function(i) { + return zip_prev[zip_WSIZE + i]; +} + +var zip_head2 = function(i, val) { + return zip_prev[zip_WSIZE + i] = val; +} + +/* put_byte is used for the compressed output, put_ubyte for the + * uncompressed output. However unlzw() uses window for its + * suffix table instead of its output buffer, so it does not use put_ubyte + * (to be cleaned up). + */ +var zip_put_byte = function(c) { + zip_outbuf[zip_outoff + zip_outcnt++] = c; + if(zip_outoff + zip_outcnt == zip_OUTBUFSIZ) + zip_qoutbuf(); +} + +/* Output a 16 bit value, lsb first */ +var zip_put_short = function(w) { + w &= 0xffff; + if(zip_outoff + zip_outcnt < zip_OUTBUFSIZ - 2) { + zip_outbuf[zip_outoff + zip_outcnt++] = (w & 0xff); + zip_outbuf[zip_outoff + zip_outcnt++] = (w >>> 8); + } else { + zip_put_byte(w & 0xff); + zip_put_byte(w >>> 8); + } +} + +/* ========================================================================== + * Insert string s in the dictionary and set match_head to the previous head + * of the hash chain (the most recent string with same hash key). Return + * the previous length of the hash chain. + * IN assertion: all calls to to INSERT_STRING are made with consecutive + * input characters and the first MIN_MATCH bytes of s are valid + * (except for the last MIN_MATCH-1 bytes of the input file). + */ +var zip_INSERT_STRING = function() { + zip_ins_h = ((zip_ins_h << zip_H_SHIFT) + ^ (zip_window[zip_strstart + zip_MIN_MATCH - 1] & 0xff)) + & zip_HASH_MASK; + zip_hash_head = zip_head1(zip_ins_h); + zip_prev[zip_strstart & zip_WMASK] = zip_hash_head; + zip_head2(zip_ins_h, zip_strstart); +} + +/* Send a code of the given tree. c and tree must not have side effects */ +var zip_SEND_CODE = function(c, tree) { + zip_send_bits(tree[c].fc, tree[c].dl); +} + +/* Mapping from a distance to a distance code. dist is the distance - 1 and + * must not have side effects. dist_code[256] and dist_code[257] are never + * used. + */ +var zip_D_CODE = function(dist) { + return (dist < 256 ? zip_dist_code[dist] + : zip_dist_code[256 + (dist>>7)]) & 0xff; +} + +/* ========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +var zip_SMALLER = function(tree, n, m) { + return tree[n].fc < tree[m].fc || + (tree[n].fc == tree[m].fc && zip_depth[n] <= zip_depth[m]); +} + +/* ========================================================================== + * read string data + */ +var zip_read_buff = function(buff, offset, n) { + var i; + for(i = 0; i < n && zip_deflate_pos < zip_deflate_data.length; i++) + buff[offset + i] = + //zip_deflate_data.charCodeAt(zip_deflate_pos++) & 0xff; + zip_deflate_data[zip_deflate_pos++]; + return i; +} + +/* ========================================================================== + * Initialize the "longest match" routines for a new file + */ +var zip_lm_init = function() { + var j; + + /* Initialize the hash table. */ + for(j = 0; j < zip_HASH_SIZE; j++) +// zip_head2(j, zip_NIL); + zip_prev[zip_WSIZE + j] = 0; + /* prev will be initialized on the fly */ + + /* Set the default configuration parameters: + */ + zip_max_lazy_match = zip_configuration_table[zip_compr_level].max_lazy; + zip_good_match = zip_configuration_table[zip_compr_level].good_length; + if(!zip_FULL_SEARCH) + zip_nice_match = zip_configuration_table[zip_compr_level].nice_length; + zip_max_chain_length = zip_configuration_table[zip_compr_level].max_chain; + + zip_strstart = 0; + zip_block_start = 0; + + zip_lookahead = zip_read_buff(zip_window, 0, 2 * zip_WSIZE); + if(zip_lookahead <= 0) { + zip_eofile = true; + zip_lookahead = 0; + return; + } + zip_eofile = false; + /* Make sure that we always have enough lookahead. This is important + * if input comes from a device such as a tty. + */ + while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile) + zip_fill_window(); + + /* If lookahead < MIN_MATCH, ins_h is garbage, but this is + * not important since only literal bytes will be emitted. + */ + zip_ins_h = 0; + for(j = 0; j < zip_MIN_MATCH - 1; j++) { +// UPDATE_HASH(ins_h, window[j]); + zip_ins_h = ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[j] & 0xff)) & zip_HASH_MASK; + } +} + +/* ========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + */ +var zip_longest_match = function(cur_match) { + var chain_length = zip_max_chain_length; // max hash chain length + var scanp = zip_strstart; // current string + var matchp; // matched string + var len; // length of current match + var best_len = zip_prev_length; // best match length so far + + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + var limit = (zip_strstart > zip_MAX_DIST ? zip_strstart - zip_MAX_DIST : zip_NIL); + + var strendp = zip_strstart + zip_MAX_MATCH; + var scan_end1 = zip_window[scanp + best_len - 1]; + var scan_end = zip_window[scanp + best_len]; + + /* Do not waste too much time if we already have a good match: */ + if(zip_prev_length >= zip_good_match) + chain_length >>= 2; + +// Assert(encoder->strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead"); + + do { +// Assert(cur_match < encoder->strstart, "no future"); + matchp = cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2: + */ + if(zip_window[matchp + best_len] != scan_end || + zip_window[matchp + best_len - 1] != scan_end1 || + zip_window[matchp] != zip_window[scanp] || + zip_window[++matchp] != zip_window[scanp + 1]) { + continue; + } + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scanp += 2; + matchp++; + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while(zip_window[++scanp] == zip_window[++matchp] && + zip_window[++scanp] == zip_window[++matchp] && + zip_window[++scanp] == zip_window[++matchp] && + zip_window[++scanp] == zip_window[++matchp] && + zip_window[++scanp] == zip_window[++matchp] && + zip_window[++scanp] == zip_window[++matchp] && + zip_window[++scanp] == zip_window[++matchp] && + zip_window[++scanp] == zip_window[++matchp] && + scanp < strendp); + + len = zip_MAX_MATCH - (strendp - scanp); + scanp = strendp - zip_MAX_MATCH; + + if(len > best_len) { + zip_match_start = cur_match; + best_len = len; + if(zip_FULL_SEARCH) { + if(len >= zip_MAX_MATCH) break; + } else { + if(len >= zip_nice_match) break; + } + + scan_end1 = zip_window[scanp + best_len-1]; + scan_end = zip_window[scanp + best_len]; + } + } while((cur_match = zip_prev[cur_match & zip_WMASK]) > limit + && --chain_length != 0); + + return best_len; +} + +/* ========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead, and sets eofile if end of input file. + * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0 + * OUT assertions: at least one byte has been read, or eofile is set; + * file reads are performed for at least two bytes (required for the + * translate_eol option). + */ +var zip_fill_window = function() { + var n, m; + + // Amount of free space at the end of the window. + var more = zip_window_size - zip_lookahead - zip_strstart; + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if(more == -1) { + /* Very unlikely, but possible on 16 bit machine if strstart == 0 + * and lookahead == 1 (input done one byte at time) + */ + more--; + } else if(zip_strstart >= zip_WSIZE + zip_MAX_DIST) { + /* By the IN assertion, the window is not empty so we can't confuse + * more == 0 with more == 64K on a 16 bit machine. + */ +// Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM"); + +// System.arraycopy(window, WSIZE, window, 0, WSIZE); + for(n = 0; n < zip_WSIZE; n++) + zip_window[n] = zip_window[n + zip_WSIZE]; + + zip_match_start -= zip_WSIZE; + zip_strstart -= zip_WSIZE; /* we now have strstart >= MAX_DIST: */ + zip_block_start -= zip_WSIZE; + + for(n = 0; n < zip_HASH_SIZE; n++) { + m = zip_head1(n); + zip_head2(n, m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL); + } + for(n = 0; n < zip_WSIZE; n++) { + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + m = zip_prev[n]; + zip_prev[n] = (m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL); + } + more += zip_WSIZE; + } + // At this point, more >= 2 + if(!zip_eofile) { + n = zip_read_buff(zip_window, zip_strstart + zip_lookahead, more); + if(n <= 0) + zip_eofile = true; + else + zip_lookahead += n; + } +} + +/* ========================================================================== + * Processes a new input file and return its compressed length. This + * function does not perform lazy evaluationof matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +var zip_deflate_fast = function() { + while(zip_lookahead != 0 && zip_qhead == null) { + var flush; // set if current block must be flushed + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + zip_INSERT_STRING(); + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if(zip_hash_head != zip_NIL && + zip_strstart - zip_hash_head <= zip_MAX_DIST) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + zip_match_length = zip_longest_match(zip_hash_head); + /* longest_match() sets match_start */ + if(zip_match_length > zip_lookahead) + zip_match_length = zip_lookahead; + } + if(zip_match_length >= zip_MIN_MATCH) { +// check_match(strstart, match_start, match_length); + + flush = zip_ct_tally(zip_strstart - zip_match_start, + zip_match_length - zip_MIN_MATCH); + zip_lookahead -= zip_match_length; + + /* Insert new strings in the hash table only if the match length + * is not too large. This saves time but degrades compression. + */ + if(zip_match_length <= zip_max_lazy_match) { + zip_match_length--; // string at strstart already in hash table + do { + zip_strstart++; + zip_INSERT_STRING(); + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH + * these bytes are garbage, but it does not matter since + * the next lookahead bytes will be emitted as literals. + */ + } while(--zip_match_length != 0); + zip_strstart++; + } else { + zip_strstart += zip_match_length; + zip_match_length = 0; + zip_ins_h = zip_window[zip_strstart] & 0xff; +// UPDATE_HASH(ins_h, window[strstart + 1]); + zip_ins_h = ((zip_ins_h< zip_lookahead) + zip_match_length = zip_lookahead; + + /* Ignore a length 3 match if it is too distant: */ + if(zip_match_length == zip_MIN_MATCH && + zip_strstart - zip_match_start > zip_TOO_FAR) { + /* If prev_match is also MIN_MATCH, match_start is garbage + * but we will ignore the current match anyway. + */ + zip_match_length--; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if(zip_prev_length >= zip_MIN_MATCH && + zip_match_length <= zip_prev_length) { + var flush; // set if current block must be flushed + +// check_match(strstart - 1, prev_match, prev_length); + flush = zip_ct_tally(zip_strstart - 1 - zip_prev_match, + zip_prev_length - zip_MIN_MATCH); + + /* Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. + */ + zip_lookahead -= zip_prev_length - 1; + zip_prev_length -= 2; + do { + zip_strstart++; + zip_INSERT_STRING(); + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH + * these bytes are garbage, but it does not matter since the + * next lookahead bytes will always be emitted as literals. + */ + } while(--zip_prev_length != 0); + zip_match_available = 0; + zip_match_length = zip_MIN_MATCH - 1; + zip_strstart++; + if(flush) { + zip_flush_block(0); + zip_block_start = zip_strstart; + } + } else if(zip_match_available != 0) { + /* If there was no match at the previous position, output a + * single literal. If there was a match but the current match + * is longer, truncate the previous match to a single literal. + */ + if(zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff)) { + zip_flush_block(0); + zip_block_start = zip_strstart; + } + zip_strstart++; + zip_lookahead--; + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + zip_match_available = 1; + zip_strstart++; + zip_lookahead--; + } + + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile) + zip_fill_window(); + } +} + +var zip_init_deflate = function() { + if(zip_eofile) + return; + zip_bi_buf = 0; + zip_bi_valid = 0; + zip_ct_init(); + zip_lm_init(); + + zip_qhead = null; + zip_outcnt = 0; + zip_outoff = 0; + zip_match_available = 0; + + if(zip_compr_level <= 3) + { + zip_prev_length = zip_MIN_MATCH - 1; + zip_match_length = 0; + } + else + { + zip_match_length = zip_MIN_MATCH - 1; + zip_match_available = 0; + zip_match_available = 0; + } + + zip_complete = false; +} + +/* ========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +var zip_deflate_internal = function(buff, off, buff_size) { + var n; + + if(!zip_initflag) + { + zip_init_deflate(); + zip_initflag = true; + if(zip_lookahead == 0) { // empty + zip_complete = true; + return 0; + } + } + + if((n = zip_qcopy(buff, off, buff_size)) == buff_size) + return buff_size; + + if(zip_complete) + return n; + + if(zip_compr_level <= 3) // optimized for speed + zip_deflate_fast(); + else + zip_deflate_better(); + if(zip_lookahead == 0) { + if(zip_match_available != 0) + zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff); + zip_flush_block(1); + zip_complete = true; + } + return n + zip_qcopy(buff, n + off, buff_size - n); +} + +var zip_qcopy = function(buff, off, buff_size) { + var n, i, j; + + n = 0; + while(zip_qhead != null && n < buff_size) + { + i = buff_size - n; + if(i > zip_qhead.len) + i = zip_qhead.len; +// System.arraycopy(qhead.ptr, qhead.off, buff, off + n, i); + for(j = 0; j < i; j++) + buff[off + n + j] = zip_qhead.ptr[zip_qhead.off + j]; + + zip_qhead.off += i; + zip_qhead.len -= i; + n += i; + if(zip_qhead.len == 0) { + var p; + p = zip_qhead; + zip_qhead = zip_qhead.next; + zip_reuse_queue(p); + } + } + + if(n == buff_size) + return n; + + if(zip_outoff < zip_outcnt) { + i = buff_size - n; + if(i > zip_outcnt - zip_outoff) + i = zip_outcnt - zip_outoff; + // System.arraycopy(outbuf, outoff, buff, off + n, i); + for(j = 0; j < i; j++) + buff[off + n + j] = zip_outbuf[zip_outoff + j]; + zip_outoff += i; + n += i; + if(zip_outcnt == zip_outoff) + zip_outcnt = zip_outoff = 0; + } + return n; +} + +/* ========================================================================== + * Allocate the match buffer, initialize the various tables and save the + * location of the internal file attribute (ascii/binary) and method + * (DEFLATE/STORE). + */ +var zip_ct_init = function() { + var n; // iterates over tree elements + var bits; // bit counter + var length; // length value + var code; // code value + var dist; // distance index + + if(zip_static_dtree[0].dl != 0) return; // ct_init already called + + zip_l_desc.dyn_tree = zip_dyn_ltree; + zip_l_desc.static_tree = zip_static_ltree; + zip_l_desc.extra_bits = zip_extra_lbits; + zip_l_desc.extra_base = zip_LITERALS + 1; + zip_l_desc.elems = zip_L_CODES; + zip_l_desc.max_length = zip_MAX_BITS; + zip_l_desc.max_code = 0; + + zip_d_desc.dyn_tree = zip_dyn_dtree; + zip_d_desc.static_tree = zip_static_dtree; + zip_d_desc.extra_bits = zip_extra_dbits; + zip_d_desc.extra_base = 0; + zip_d_desc.elems = zip_D_CODES; + zip_d_desc.max_length = zip_MAX_BITS; + zip_d_desc.max_code = 0; + + zip_bl_desc.dyn_tree = zip_bl_tree; + zip_bl_desc.static_tree = null; + zip_bl_desc.extra_bits = zip_extra_blbits; + zip_bl_desc.extra_base = 0; + zip_bl_desc.elems = zip_BL_CODES; + zip_bl_desc.max_length = zip_MAX_BL_BITS; + zip_bl_desc.max_code = 0; + + // Initialize the mapping length (0..255) -> length code (0..28) + length = 0; + for(code = 0; code < zip_LENGTH_CODES-1; code++) { + zip_base_length[code] = length; + for(n = 0; n < (1< dist code (0..29) */ + dist = 0; + for(code = 0 ; code < 16; code++) { + zip_base_dist[code] = dist; + for(n = 0; n < (1<>= 7; // from now on, all distances are divided by 128 + for( ; code < zip_D_CODES; code++) { + zip_base_dist[code] = dist << 7; + for(n = 0; n < (1<<(zip_extra_dbits[code]-7)); n++) + zip_dist_code[256 + dist++] = code; + } + // Assert (dist == 256, "ct_init: 256+dist != 512"); + + // Construct the codes of the static literal tree + for(bits = 0; bits <= zip_MAX_BITS; bits++) + zip_bl_count[bits] = 0; + n = 0; + while(n <= 143) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; } + while(n <= 255) { zip_static_ltree[n++].dl = 9; zip_bl_count[9]++; } + while(n <= 279) { zip_static_ltree[n++].dl = 7; zip_bl_count[7]++; } + while(n <= 287) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; } + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + zip_gen_codes(zip_static_ltree, zip_L_CODES + 1); + + /* The static distance tree is trivial: */ + for(n = 0; n < zip_D_CODES; n++) { + zip_static_dtree[n].dl = 5; + zip_static_dtree[n].fc = zip_bi_reverse(n, 5); + } + + // Initialize the first block of the first file: + zip_init_block(); +} + +/* ========================================================================== + * Initialize a new block. + */ +var zip_init_block = function() { + var n; // iterates over tree elements + + // Initialize the trees. + for(n = 0; n < zip_L_CODES; n++) zip_dyn_ltree[n].fc = 0; + for(n = 0; n < zip_D_CODES; n++) zip_dyn_dtree[n].fc = 0; + for(n = 0; n < zip_BL_CODES; n++) zip_bl_tree[n].fc = 0; + + zip_dyn_ltree[zip_END_BLOCK].fc = 1; + zip_opt_len = zip_static_len = 0; + zip_last_lit = zip_last_dist = zip_last_flags = 0; + zip_flags = 0; + zip_flag_bit = 1; +} + +/* ========================================================================== + * 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). + */ +var zip_pqdownheap = function( + tree, // the tree to restore + k) { // node to move down + var v = zip_heap[k]; + var j = k << 1; // left son of k + + while(j <= zip_heap_len) { + // Set j to the smallest of the two sons: + if(j < zip_heap_len && + zip_SMALLER(tree, zip_heap[j + 1], zip_heap[j])) + j++; + + // Exit if v is smaller than both sons + if(zip_SMALLER(tree, v, zip_heap[j])) + break; + + // Exchange v with the smallest son + zip_heap[k] = zip_heap[j]; + k = j; + + // And continue down the tree, setting j to the left son of k + j <<= 1; + } + zip_heap[k] = v; +} + +/* ========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +var zip_gen_bitlen = function(desc) { // the tree descriptor + var tree = desc.dyn_tree; + var extra = desc.extra_bits; + var base = desc.extra_base; + var max_code = desc.max_code; + var max_length = desc.max_length; + var stree = desc.static_tree; + 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 <= zip_MAX_BITS; bits++) + zip_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[zip_heap[zip_heap_max]].dl = 0; // root of the heap + + for(h = zip_heap_max + 1; h < zip_HEAP_SIZE; h++) { + n = zip_heap[h]; + bits = tree[tree[n].dl].dl + 1; + if(bits > max_length) { + bits = max_length; + overflow++; + } + tree[n].dl = bits; + // We overwrite tree[n].dl which is no longer needed + + if(n > max_code) + continue; // not a leaf node + + zip_bl_count[bits]++; + xbits = 0; + if(n >= base) + xbits = extra[n - base]; + f = tree[n].fc; + zip_opt_len += f * (bits + xbits); + if(stree != null) + zip_static_len += f * (stree[n].dl + xbits); + } + if(overflow == 0) + return; + + // 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(zip_bl_count[bits] == 0) + bits--; + zip_bl_count[bits]--; // move one leaf down the tree + zip_bl_count[bits + 1] += 2; // move one overflow item as its brother + zip_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 = zip_bl_count[bits]; + while(n != 0) { + m = zip_heap[--h]; + if(m > max_code) + continue; + if(tree[m].dl != bits) { + zip_opt_len += (bits - tree[m].dl) * tree[m].fc; + tree[m].fc = bits; + } + n--; + } + } +} + + /* ========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +var zip_gen_codes = function(tree, // the tree to decorate + max_code) { // largest code with non zero frequency + var next_code = new Array(zip_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 <= zip_MAX_BITS; bits++) { + code = ((code + zip_bl_count[bits-1]) << 1); + next_code[bits] = code; + } + + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ +// Assert (code + encoder->bl_count[MAX_BITS]-1 == (1<> 1; n >= 1; n--) + zip_pqdownheap(tree, n); + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + do { + n = zip_heap[zip_SMALLEST]; + zip_heap[zip_SMALLEST] = zip_heap[zip_heap_len--]; + zip_pqdownheap(tree, zip_SMALLEST); + + m = zip_heap[zip_SMALLEST]; // m = node of next least frequency + + // keep the nodes sorted by frequency + zip_heap[--zip_heap_max] = n; + zip_heap[--zip_heap_max] = m; + + // Create a new node father of n and m + tree[node].fc = tree[n].fc + tree[m].fc; +// depth[node] = (char)(MAX(depth[n], depth[m]) + 1); + if(zip_depth[n] > zip_depth[m] + 1) + zip_depth[node] = zip_depth[n]; + else + zip_depth[node] = zip_depth[m] + 1; + tree[n].dl = tree[m].dl = node; + + // and insert the new node in the heap + zip_heap[zip_SMALLEST] = node++; + zip_pqdownheap(tree, zip_SMALLEST); + + } while(zip_heap_len >= 2); + + zip_heap[--zip_heap_max] = zip_heap[zip_SMALLEST]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + zip_gen_bitlen(desc); + + // The field len is now set, we can generate the bit codes + zip_gen_codes(tree, max_code); +} + +/* ========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. Updates opt_len to take into account the repeat + * counts. (The contribution of the bit length codes will be added later + * during the construction of bl_tree.) + */ +var zip_scan_tree = function(tree,// the tree to be scanned + 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].dl; // 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 + + if(nextlen == 0) { + max_count = 138; + min_count = 3; + } + tree[max_code + 1].dl = 0xffff; // guard + + for(n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[n + 1].dl; + if(++count < max_count && curlen == nextlen) + continue; + else if(count < min_count) + zip_bl_tree[curlen].fc += count; + else if(curlen != 0) { + if(curlen != prevlen) + zip_bl_tree[curlen].fc++; + zip_bl_tree[zip_REP_3_6].fc++; + } else if(count <= 10) + zip_bl_tree[zip_REPZ_3_10].fc++; + else + zip_bl_tree[zip_REPZ_11_138].fc++; + 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; + } + } +} + + /* ========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +var zip_send_tree = function(tree, // the tree to be scanned + 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].dl; // 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 + + /* tree[max_code+1].dl = -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].dl; + if(++count < max_count && curlen == nextlen) { + continue; + } else if(count < min_count) { + do { zip_SEND_CODE(curlen, zip_bl_tree); } while(--count != 0); + } else if(curlen != 0) { + if(curlen != prevlen) { + zip_SEND_CODE(curlen, zip_bl_tree); + count--; + } + // Assert(count >= 3 && count <= 6, " 3_6?"); + zip_SEND_CODE(zip_REP_3_6, zip_bl_tree); + zip_send_bits(count - 3, 2); + } else if(count <= 10) { + zip_SEND_CODE(zip_REPZ_3_10, zip_bl_tree); + zip_send_bits(count-3, 3); + } else { + zip_SEND_CODE(zip_REPZ_11_138, zip_bl_tree); + zip_send_bits(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; + } + } +} + +/* ========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +var zip_build_bl_tree = function() { + var max_blindex; // index of last bit length code of non zero freq + + // Determine the bit length frequencies for literal and distance trees + zip_scan_tree(zip_dyn_ltree, zip_l_desc.max_code); + zip_scan_tree(zip_dyn_dtree, zip_d_desc.max_code); + + // Build the bit length tree: + zip_build_tree(zip_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. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for(max_blindex = zip_BL_CODES-1; max_blindex >= 3; max_blindex--) { + if(zip_bl_tree[zip_bl_order[max_blindex]].dl != 0) break; + } + /* Update opt_len to include the bit length tree and counts */ + zip_opt_len += 3*(max_blindex+1) + 5+5+4; +// Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", +// encoder->opt_len, encoder->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. + */ +var zip_send_all_trees = function(lcodes, dcodes, blcodes) { // number of codes for each tree + 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: ")); + zip_send_bits(lcodes-257, 5); // not +255 as stated in appnote.txt + zip_send_bits(dcodes-1, 5); + zip_send_bits(blcodes-4, 4); // not -3 as stated in appnote.txt + for(rank = 0; rank < blcodes; rank++) { +// Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + zip_send_bits(zip_bl_tree[zip_bl_order[rank]].dl, 3); + } + + // send the literal tree + zip_send_tree(zip_dyn_ltree,lcodes-1); + + // send the distance tree + zip_send_tree(zip_dyn_dtree,dcodes-1); +} + +/* ========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +var zip_flush_block = function(eof) { // true if this is the last block for a file + var opt_lenb, static_lenb; // opt_len and static_len in bytes + var max_blindex; // index of last bit length code of non zero freq + var stored_len; // length of input block + + stored_len = zip_strstart - zip_block_start; + zip_flag_buf[zip_last_flags] = zip_flags; // Save the flags for the last 8 items + + // Construct the literal and distance trees + zip_build_tree(zip_l_desc); +// Tracev((stderr, "\nlit data: dyn %ld, stat %ld", +// encoder->opt_len, encoder->static_len)); + + zip_build_tree(zip_d_desc); +// Tracev((stderr, "\ndist data: dyn %ld, stat %ld", +// encoder->opt_len, encoder->static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* 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 = zip_build_bl_tree(); + + // Determine the best encoding. Compute first the block length in bytes + opt_lenb = (zip_opt_len +3+7)>>3; + static_lenb = (zip_static_len+3+7)>>3; + +// Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ", +// opt_lenb, encoder->opt_len, +// static_lenb, encoder->static_len, stored_len, +// encoder->last_lit, encoder->last_dist)); + + if(static_lenb <= opt_lenb) + opt_lenb = static_lenb; + if(stored_len + 4 <= opt_lenb // 4: two words for the lengths + && zip_block_start >= 0) { + var i; + + /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + * Otherwise we can't have processed more than WSIZE input bytes since + * the last block flush, because compression would have been + * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to + * transform a block into a stored block. + */ + zip_send_bits((zip_STORED_BLOCK<<1)+eof, 3); /* send block type */ + zip_bi_windup(); /* align on byte boundary */ + zip_put_short(stored_len); + zip_put_short(~stored_len); + + // copy block +/* + p = &window[block_start]; + for(i = 0; i < stored_len; i++) + put_byte(p[i]); +*/ + for(i = 0; i < stored_len; i++) + zip_put_byte(zip_window[zip_block_start + i]); + + } else if(static_lenb == opt_lenb) { + zip_send_bits((zip_STATIC_TREES<<1)+eof, 3); + zip_compress_block(zip_static_ltree, zip_static_dtree); + } else { + zip_send_bits((zip_DYN_TREES<<1)+eof, 3); + zip_send_all_trees(zip_l_desc.max_code+1, + zip_d_desc.max_code+1, + max_blindex+1); + zip_compress_block(zip_dyn_ltree, zip_dyn_dtree); + } + + zip_init_block(); + + if(eof != 0) + zip_bi_windup(); +} + +/* ========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +var zip_ct_tally = function( + dist, // distance of matched string + lc) { // match length-MIN_MATCH or unmatched char (if dist==0) + zip_l_buf[zip_last_lit++] = lc; + if(dist == 0) { + // lc is the unmatched char + zip_dyn_ltree[lc].fc++; + } else { + // Here, lc is the match length - MIN_MATCH + dist--; // dist = match distance - 1 +// Assert((ush)dist < (ush)MAX_DIST && +// (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && +// (ush)D_CODE(dist) < (ush)D_CODES, "ct_tally: bad match"); + + zip_dyn_ltree[zip_length_code[lc]+zip_LITERALS+1].fc++; + zip_dyn_dtree[zip_D_CODE(dist)].fc++; + + zip_d_buf[zip_last_dist++] = dist; + zip_flags |= zip_flag_bit; + } + zip_flag_bit <<= 1; + + // Output the flags if they fill a byte + if((zip_last_lit & 7) == 0) { + zip_flag_buf[zip_last_flags++] = zip_flags; + zip_flags = 0; + zip_flag_bit = 1; + } + // Try to guess if it is profitable to stop the current block here + if(zip_compr_level > 2 && (zip_last_lit & 0xfff) == 0) { + // Compute an upper bound for the compressed length + var out_length = zip_last_lit * 8; + var in_length = zip_strstart - zip_block_start; + var dcode; + + for(dcode = 0; dcode < zip_D_CODES; dcode++) { + out_length += zip_dyn_dtree[dcode].fc * (5 + zip_extra_dbits[dcode]); + } + out_length >>= 3; +// Trace((stderr,"\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ", +// encoder->last_lit, encoder->last_dist, in_length, out_length, +// 100L - out_length*100L/in_length)); + if(zip_last_dist < parseInt(zip_last_lit/2) && + out_length < parseInt(in_length/2)) + return true; + } + return (zip_last_lit == zip_LIT_BUFSIZE-1 || + zip_last_dist == zip_DIST_BUFSIZE); + /* 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. + */ +} + + /* ========================================================================== + * Send the block data compressed using the given Huffman trees + */ +var zip_compress_block = function( + ltree, // literal tree + 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 dx = 0; // running index in d_buf + var fx = 0; // running index in flag_buf + var flag = 0; // current flags + var code; // the code to send + var extra; // number of extra bits to send + + if(zip_last_lit != 0) do { + if((lx & 7) == 0) + flag = zip_flag_buf[fx++]; + lc = zip_l_buf[lx++] & 0xff; + if((flag & 1) == 0) { + zip_SEND_CODE(lc, ltree); /* send a literal byte */ +// Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + // Here, lc is the match length - MIN_MATCH + code = zip_length_code[lc]; + zip_SEND_CODE(code+zip_LITERALS+1, ltree); // send the length code + extra = zip_extra_lbits[code]; + if(extra != 0) { + lc -= zip_base_length[code]; + zip_send_bits(lc, extra); // send the extra length bits + } + dist = zip_d_buf[dx++]; + // Here, dist is the match distance - 1 + code = zip_D_CODE(dist); +// Assert (code < D_CODES, "bad d_code"); + + zip_SEND_CODE(code, dtree); // send the distance code + extra = zip_extra_dbits[code]; + if(extra != 0) { + dist -= zip_base_dist[code]; + zip_send_bits(dist, extra); // send the extra distance bits + } + } // literal or match pair ? + flag >>= 1; + } while(lx < zip_last_lit); + + zip_SEND_CODE(zip_END_BLOCK, ltree); +} + +/* ========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +var zip_Buf_size = 16; // bit size of bi_buf +var zip_send_bits = function( + value, // value to send + length) { // number of bits + /* If not enough room in bi_buf, use (valid) bits from bi_buf and + * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) + * unused bits in value. + */ + if(zip_bi_valid > zip_Buf_size - length) { + zip_bi_buf |= (value << zip_bi_valid); + zip_put_short(zip_bi_buf); + zip_bi_buf = (value >> (zip_Buf_size - zip_bi_valid)); + zip_bi_valid += length - zip_Buf_size; + } else { + zip_bi_buf |= value << zip_bi_valid; + zip_bi_valid += length; + } +} + +/* ========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +var zip_bi_reverse = function( + code, // the value to invert + len) { // its bit length + var res = 0; + do { + res |= code & 1; + code >>= 1; + res <<= 1; + } while(--len > 0); + return res >> 1; +} + +/* ========================================================================== + * Write out any remaining bits in an incomplete byte. + */ +var zip_bi_windup = function() { + if(zip_bi_valid > 8) { + zip_put_short(zip_bi_buf); + } else if(zip_bi_valid > 0) { + zip_put_byte(zip_bi_buf); + } + zip_bi_buf = 0; + zip_bi_valid = 0; +} + +var zip_qoutbuf = function() { + if(zip_outcnt != 0) { + var q, i; + q = zip_new_queue(); + if(zip_qhead == null) + zip_qhead = zip_qtail = q; + else + zip_qtail = zip_qtail.next = q; + q.len = zip_outcnt - zip_outoff; +// System.arraycopy(zip_outbuf, zip_outoff, q.ptr, 0, q.len); + for(i = 0; i < q.len; i++) + q.ptr[i] = zip_outbuf[zip_outoff + i]; + zip_outcnt = zip_outoff = 0; + } +} + +var zip_deflate = function(str, level) { + var i, j; + + zip_deflate_data = str; + zip_deflate_pos = 0; + if(typeof level == "undefined") + level = zip_DEFAULT_LEVEL; + zip_deflate_start(level); + + var buff = new Array(16384); + var aout = []; + while((i = zip_deflate_internal(buff, 0, buff.length)) > 0) { + var cbuf = new Array(i); + for(j = 0; j < i; j++){ + cbuf[j] = String.fromCharCode(buff[j]); + } + aout[aout.length] = cbuf.join(""); + } + zip_deflate_data = null; // G.C. + return aout.join(""); +} + +if (! ctx.RawDeflate) ctx.RawDeflate = {}; +ctx.RawDeflate.deflate = zip_deflate; + +})(this); diff --git a/benchmark/implementations/deflate-imaya/deflate.js b/benchmark/implementations/deflate-imaya/deflate.js deleted file mode 100644 index f017eba..0000000 --- a/benchmark/implementations/deflate-imaya/deflate.js +++ /dev/null @@ -1,1784 +0,0 @@ -/** - * @license - * zlib.js - * JavaScript Zlib Library - * https://github.com/imaya/zlib.js - * - * The MIT License - * - * Copyright (c) 2012 imaya - * - * `deflate` algorythm from Imaya's `zlib.js`. Manually sttipped to use as node's commonjs module. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - - -var Zlib = {}; -Zlib.Util = {}; - - -/** - * @enum {number} - */ -Zlib.CompressionMethod = { - STORE: 0, - DEFLATE: 8 -}; - -var USE_TYPEDARRAY = Uint16Array != undefined; - -/////////////////////////////////////////////////////////////// -// util.js - -/** - * Byte String ...... Byte Array .......... - * @param {!string} str byte string. - * @return {!Array.} byte array. - */ -Zlib.Util.stringToByteArray = function(str) { - /** @type {!Array.<(string|number)>} */ - var tmp = str.split(''); - /** @type {number} */ - var i; - /** @type {number} */ - var il; - - for (i = 0, il = tmp.length; i < il; i++) { - tmp[i] = (tmp[i].charCodeAt(0) & 0xff) >>> 0; - } - - return tmp; -}; - -/////////////////////////////////////////////////////////////// -// adler32.js - -/** - * Adler32 ハッシュ値の作成 - * @param {!(Array|Uint8Array|string)} array 算出に使用する byte array. - * @return {number} Adler32 ハッシュ値. - */ -Zlib.Adler32 = function(array) { - if (typeof(array) === 'string') { - array = Zlib.Util.stringToByteArray(array); - } - return Zlib.Adler32.update(1, array); -}; - -/** - * Adler32 ハッシュ値の更新 - * @param {number} adler 現在のハッシュ値. - * @param {!(Array|Uint8Array)} array 更新に使用する byte array. - * @return {number} Adler32 ハッシュ値. - */ -Zlib.Adler32.update = function(adler, array) { - /** @type {number} */ - var s1 = adler & 0xffff; - /** @type {number} */ - var s2 = (adler >>> 16) & 0xffff; - /** @type {number} array length */ - var len = array.length; - /** @type {number} loop length (don't overflow) */ - var tlen; - /** @type {number} array index */ - var i = 0; - - while (len > 0) { - tlen = len > Zlib.Adler32.OptimizationParameter ? - Zlib.Adler32.OptimizationParameter : len; - len -= tlen; - do { - s1 += array[i++]; - s2 += s1; - } while (--tlen); - - s1 %= 65521; - s2 %= 65521; - } - - return ((s2 << 16) | s1) >>> 0; -}; - -/** - * Adler32 最適化パラメータ - * 現状では 1024 程度が最適. - * @see http://jsperf.com/adler-32-simple-vs-optimized/3 - * @define {number} - */ -Zlib.Adler32.OptimizationParameter = 1024; - -/////////////////////////////////////////////////////////////// -// bitstream.js - -/** - * ビットストリーム - * @constructor - * @param {!(Array|Uint8Array)=} buffer output buffer. - * @param {number=} bufferPosition start buffer pointer. - */ -Zlib.BitStream = function(buffer, bufferPosition) { - /** @type {number} buffer index. */ - this.index = typeof bufferPosition === 'number' ? bufferPosition : 0; - /** @type {number} bit index. */ - this.bitindex = 0; - /** @type {!(Array|Uint8Array)} bit-stream output buffer. */ - this.buffer = buffer instanceof (USE_TYPEDARRAY ? Uint8Array : Array) ? - buffer : - new (USE_TYPEDARRAY ? Uint8Array : Array)(Zlib.BitStream.DefaultBlockSize); - - // 入力された index が足りなかったら拡張するが、倍にしてもダメなら不正とする - if (this.buffer.length * 2 <= this.index) { - throw new Error("invalid index"); - } else if (this.buffer.length <= this.index) { - this.expandBuffer(); - } -}; - -/** - * デフォルトブロックサイズ. - * @const - * @type {number} - */ -Zlib.BitStream.DefaultBlockSize = 0x8000; - -/** - * expand buffer. - * @return {!(Array|Uint8Array)} new buffer. - */ -Zlib.BitStream.prototype.expandBuffer = function() { - /** @type {!(Array|Uint8Array)} old buffer. */ - var oldbuf = this.buffer; - /** @type {number} loop counter. */ - var i; - /** @type {number} loop limiter. */ - var il = oldbuf.length; - /** @type {!(Array|Uint8Array)} new buffer. */ - var buffer = - new (USE_TYPEDARRAY ? Uint8Array : Array)(il << 1); - - // copy buffer - if (USE_TYPEDARRAY) { - buffer.set(oldbuf); - } else { - // XXX: loop unrolling - for (i = 0; i < il; ++i) { - buffer[i] = oldbuf[i]; - } - } - - return (this.buffer = buffer); -}; - - -/** - * 数値をビットで指定した数だけ書き込む. - * @param {number} number 書き込む数値. - * @param {number} n 書き込むビット数. - * @param {boolean=} reverse 逆順に書き込むならば true. - */ -Zlib.BitStream.prototype.writeBits = function(number, n, reverse) { - var buffer = this.buffer; - var index = this.index; - var bitindex = this.bitindex; - - /** @type {number} current octet. */ - var current = buffer[index]; - /** @type {number} loop counter. */ - var i; - - /** - * 32-bit 整数のビット順を逆にする - * @param {number} n 32-bit integer. - * @return {number} reversed 32-bit integer. - * @private - */ - function rev32_(n) { - return (Zlib.BitStream.ReverseTable[n & 0xFF] << 24) | - (Zlib.BitStream.ReverseTable[n >>> 8 & 0xFF] << 16) | - (Zlib.BitStream.ReverseTable[n >>> 16 & 0xFF] << 8) | - Zlib.BitStream.ReverseTable[n >>> 24 & 0xFF]; - } - - if (reverse && n > 1) { - number = n > 8 ? - rev32_(number) >> (32 - n) : - Zlib.BitStream.ReverseTable[number] >> (8 - n); - } - - // Byte 境界を超えないとき - if (n + bitindex < 8) { - current = (current << n) | number; - bitindex += n; - // Byte 境界を超えるとき - } else { - for (i = 0; i < n; ++i) { - current = (current << 1) | ((number >> n - i - 1) & 1); - - // next byte - if (++bitindex === 8) { - bitindex = 0; - buffer[index++] = Zlib.BitStream.ReverseTable[current]; - current = 0; - - // expand - if (index === buffer.length) { - buffer = this.expandBuffer(); - } - } - } - } - buffer[index] = current; - - this.buffer = buffer; - this.bitindex = bitindex; - this.index = index; -}; - - -/** - * ストリームの終端処理を行う - * @return {!(Array|Uint8Array)} 終端処理後のバッファを byte array で返す. - */ -Zlib.BitStream.prototype.finish = function() { - var buffer = this.buffer; - var index = this.index; - - /** @type {!(Array|Uint8Array)} output buffer. */ - var output; - - // bitindex が 0 の時は余分に index が進んでいる状態 - if (this.bitindex > 0) { - buffer[index] <<= 8 - this.bitindex; - buffer[index] = Zlib.BitStream.ReverseTable[buffer[index]]; - index++; - } - - // array truncation - if (USE_TYPEDARRAY) { - output = buffer.subarray(0, index); - } else { - buffer.length = index; - output = buffer; - } - - return output; -}; - -/** - * 0-255 のビット順を反転したテーブル - * @const - * @type {!(Uint8Array|Array.)} - */ -Zlib.BitStream.ReverseTable = (function(table) { - return table; -})((function() { - /** @type {!(Array|Uint8Array)} reverse table. */ - var table = new (USE_TYPEDARRAY ? Uint8Array : Array)(256); - /** @type {number} loop counter. */ - var i; - /** @type {number} loop limiter. */ - var il; - - // generate - for (i = 0; i < 256; ++i) { - table[i] = (function(n) { - var r = n; - var s = 7; - - for (n >>>= 1; n; n >>>= 1) { - r <<= 1; - r |= n & 1; - --s; - } - - return (r << s & 0xff) >>> 0; - })(i); - } - - return table; -})()); - -/////////////////////////////////////////////////////////////// -// heap.js - -/** - * カスタムハフマン符号で使用するヒープ実装 - * @param {number} length ヒープサイズ. - * @constructor - */ -Zlib.Heap = function(length) { - this.buffer = new (USE_TYPEDARRAY ? Uint16Array : Array)(length * 2); - this.length = 0; -}; - -/** - * 親ノードの index 取得 - * @param {number} index 子ノードの index. - * @return {number} 親ノードの index. - * - */ -Zlib.Heap.prototype.getParent = function(index) { - return ((index - 2) / 4 | 0) * 2; -}; - -/** - * 子ノードの index 取得 - * @param {number} index 親ノードの index. - * @return {number} 子ノードの index. - */ -Zlib.Heap.prototype.getChild = function(index) { - return 2 * index + 2; -}; - -/** - * Heap に値を追加する - * @param {number} index キー index. - * @param {number} value 値. - * @return {number} 現在のヒープ長. - */ -Zlib.Heap.prototype.push = function(index, value) { - var current, parent, - heap = this.buffer, - swap; - - current = this.length; - heap[this.length++] = value; - heap[this.length++] = index; - - // ルートノードにたどり着くまで入れ替えを試みる - while (current > 0) { - parent = this.getParent(current); - - // 親ノードと比較して親の方が小さければ入れ替える - if (heap[current] > heap[parent]) { - swap = heap[current]; - heap[current] = heap[parent]; - heap[parent] = swap; - - swap = heap[current + 1]; - heap[current + 1] = heap[parent + 1]; - heap[parent + 1] = swap; - - current = parent; - // 入れ替えが必要なくなったらそこで抜ける - } else { - break; - } - } - - return this.length; -}; - -/** - * Heapから一番大きい値を返す - * @return {{index: number, value: number, length: number}} {index: キーindex, -* value: 値, length: ヒープ長} の Object. - */ -Zlib.Heap.prototype.pop = function() { - var index, value, - heap = this.buffer, swap, - current, parent; - - value = heap[0]; - index = heap[1]; - - // 後ろから値を取る - this.length -= 2; - heap[0] = heap[this.length]; - heap[1] = heap[this.length + 1]; - - parent = 0; - // ルートノードから下がっていく - while (true) { - current = this.getChild(parent); - - // 範囲チェック - if (current >= this.length) { - break; - } - - // 隣のノードと比較して、隣の方が値が大きければ隣を現在ノードとして選択 - if (current + 2 < this.length && heap[current + 2] > heap[current]) { - current += 2; - } - - // 親ノードと比較して親の方が小さい場合は入れ替える - if (heap[current] > heap[parent]) { - swap = heap[parent]; - heap[parent] = heap[current]; - heap[current] = swap; - - swap = heap[parent + 1]; - heap[parent + 1] = heap[current + 1]; - heap[current + 1] = swap; - } else { - break; - } - - parent = current; - } - - return {index: index, value: value, length: this.length}; -}; - -/////////////////////////////////////////////////////////////// -// rawdeflate.js - -/** - * Raw Deflate 実装 - * - * @constructor - * @param {!(Array.|Uint8Array)} input 符号化する対象のバッファ. - * @param {Object=} opt_params option parameters. - * - * typed array が使用可能なとき、outputBuffer が Array は自動的に Uint8Array に - * 変換されます. - * 別のオブジェクトになるため出力バッファを参照している変数などは - * 更新する必要があります. - */ -Zlib.RawDeflate = function(input, opt_params) { - /** @type {Zlib.RawDeflate.CompressionType} */ - this.compressionType = Zlib.RawDeflate.CompressionType.DYNAMIC; - /** @type {number} */ - this.lazy = 0; - /** @type {!(Array.|Uint32Array)} */ - this.freqsLitLen; - /** @type {!(Array.|Uint32Array)} */ - this.freqsDist; - /** @type {!(Array.|Uint8Array)} */ - this.input = - (USE_TYPEDARRAY && input instanceof Array) ? new Uint8Array(input) : input; - /** @type {!(Array.|Uint8Array)} output output buffer. */ - this.output; - /** @type {number} pos output buffer position. */ - this.op = 0; - - // option parameters - if (opt_params) { - if (opt_params['lazy']) { - this.lazy = opt_params['lazy']; - } - if (typeof opt_params['compressionType'] === 'number') { - this.compressionType = opt_params['compressionType']; - } - if (opt_params['outputBuffer']) { - this.output = - (USE_TYPEDARRAY && opt_params['outputBuffer'] instanceof Array) ? - new Uint8Array(opt_params['outputBuffer']) : opt_params['outputBuffer']; - } - if (typeof opt_params['outputIndex'] === 'number') { - this.op = opt_params['outputIndex']; - } - } - - if (!this.output) { - this.output = new (USE_TYPEDARRAY ? Uint8Array : Array)(0x8000); - } -}; - -/** - * @enum {number} - */ -Zlib.RawDeflate.CompressionType = { - NONE: 0, - FIXED: 1, - DYNAMIC: 2, - RESERVED: 3 -}; - - -/** - * LZ77 の最小マッチ長 - * @const - * @type {number} - */ -Zlib.RawDeflate.Lz77MinLength = 3; - -/** - * LZ77 の最大マッチ長 - * @const - * @type {number} - */ -Zlib.RawDeflate.Lz77MaxLength = 258; - -/** - * LZ77 のウィンドウサイズ - * @const - * @type {number} - */ -Zlib.RawDeflate.WindowSize = 0x8000; - -/** - * 最長の符号長 - * @const - * @type {number} - */ -Zlib.RawDeflate.MaxCodeLength = 16; - -/** - * ハフマン符号の最大数値 - * @const - * @type {number} - */ -Zlib.RawDeflate.HUFMAX = 286; - -/** - * 固定ハフマン符号の符号化テーブル - * @const - * @type {Array.>} - */ -Zlib.RawDeflate.FixedHuffmanTable = (function() { - var table = [], i; - - for (i = 0; i < 288; i++) { - switch (true) { - case (i <= 143): table.push([i + 0x030, 8]); break; - case (i <= 255): table.push([i - 144 + 0x190, 9]); break; - case (i <= 279): table.push([i - 256 + 0x000, 7]); break; - case (i <= 287): table.push([i - 280 + 0x0C0, 8]); break; - default: - throw 'invalid literal: ' + i; - } - } - - return table; -})(); - -/** - * DEFLATE ブロックの作成 - * @return {!(Array.|Uint8Array)} 圧縮済み byte array. - */ -Zlib.RawDeflate.prototype.compress = function() { - /** @type {!(Array.|Uint8Array)} */ - var blockArray; - /** @type {number} */ - var position; - /** @type {number} */ - var length; - - var input = this.input; - - // compression - switch (this.compressionType) { - case Zlib.RawDeflate.CompressionType.NONE: - // each 65535-Byte (length header: 16-bit) - for (position = 0, length = input.length; position < length;) { - blockArray = USE_TYPEDARRAY ? - input.subarray(position, position + 0xffff) : - input.slice(position, position + 0xffff); - position += blockArray.length; - this.makeNocompressBlock(blockArray, (position === length)); - } - break; - case Zlib.RawDeflate.CompressionType.FIXED: - this.output = this.makeFixedHuffmanBlock(input, true); - this.op = this.output.length; - break; - case Zlib.RawDeflate.CompressionType.DYNAMIC: - this.output = this.makeDynamicHuffmanBlock(input, true); - this.op = this.output.length; - break; - default: - throw 'invalid compression type'; - } - - return this.output; -}; - -/** - * 非圧縮ブロックの作成 - * @param {!(Array.|Uint8Array)} blockArray ブロックデータ byte array. - * @param {!boolean} isFinalBlock 最後のブロックならばtrue. - * @return {!(Array.|Uint8Array)} 非圧縮ブロック byte array. - */ -Zlib.RawDeflate.prototype.makeNocompressBlock = -function(blockArray, isFinalBlock) { - /** @type {number} */ - var bfinal; - /** @type {Zlib.RawDeflate.CompressionType} */ - var btype; - /** @type {number} */ - var len; - /** @type {number} */ - var nlen; - /** @type {number} */ - var i; - /** @type {number} */ - var il; - - var output = this.output; - var op = this.op; - - // expand buffer - if (USE_TYPEDARRAY) { - output = new Uint8Array(this.output.buffer); - while (output.length <= op + blockArray.length + 5) { - output = new Uint8Array(output.length << 1); - } - output.set(this.output); - } - - // header - bfinal = isFinalBlock ? 1 : 0; - btype = Zlib.RawDeflate.CompressionType.NONE; - output[op++] = (bfinal) | (btype << 1); - - // length - len = blockArray.length; - nlen = (~len + 0x10000) & 0xffff; - output[op++] = len & 0xff; - output[op++] = (len >>> 8) & 0xff; - output[op++] = nlen & 0xff; - output[op++] = (nlen >>> 8) & 0xff; - - // copy buffer - if (USE_TYPEDARRAY) { - output.set(blockArray, op); - op += blockArray.length; - output = output.subarray(0, op); - } else { - for (i = 0, il = blockArray.length; i < il; ++i) { - output[op++] = blockArray[i]; - } - output.length = op; - } - - this.op = op; - this.output = output; - - return output; -}; - -/** - * 固定ハフマンブロックの作成 - * @param {!(Array.|Uint8Array)} blockArray ブロックデータ byte array. - * @param {!boolean} isFinalBlock 最後のブロックならばtrue. - * @return {!(Array.|Uint8Array)} 固定ハフマン符号化ブロック byte array. - */ -Zlib.RawDeflate.prototype.makeFixedHuffmanBlock = -function(blockArray, isFinalBlock) { - /** @type {Zlib.BitStream} */ - var stream = new Zlib.BitStream(USE_TYPEDARRAY ? - new Uint8Array(this.output.buffer) : this.output, this.op); - /** @type {number} */ - var bfinal; - /** @type {Zlib.RawDeflate.CompressionType} */ - var btype; - /** @type {!(Array.|Uint16Array)} */ - var data; - - // header - bfinal = isFinalBlock ? 1 : 0; - btype = Zlib.RawDeflate.CompressionType.FIXED; - - stream.writeBits(bfinal, 1, true); - stream.writeBits(btype, 2, true); - - data = this.lz77(blockArray); - this.fixedHuffman(data, stream); - - return stream.finish(); -}; - -/** - * 動的ハフマンブロックの作成 - * @param {!(Array.|Uint8Array)} blockArray ブロックデータ byte array. - * @param {!boolean} isFinalBlock 最後のブロックならばtrue. - * @return {!(Array.|Uint8Array)} 動的ハフマン符号ブロック byte array. - */ -Zlib.RawDeflate.prototype.makeDynamicHuffmanBlock = -function(blockArray, isFinalBlock) { - /** @type {Zlib.BitStream} */ - var stream = new Zlib.BitStream(USE_TYPEDARRAY ? - new Uint8Array(this.output.buffer) : this.output, this.op); - /** @type {number} */ - var bfinal; - /** @type {Zlib.RawDeflate.CompressionType} */ - var btype; - /** @type {!(Array.|Uint16Array)} */ - var data; - /** @type {number} */ - var hlit; - /** @type {number} */ - var hdist; - /** @type {number} */ - var hclen; - /** @const @type {Array.} */ - var hclenOrder = - [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; - /** @type {!(Array.|Uint8Array)} */ - var litLenLengths; - /** @type {!(Array.|Uint16Array)} */ - var litLenCodes; - /** @type {!(Array.|Uint8Array)} */ - var distLengths; - /** @type {!(Array.|Uint16Array)} */ - var distCodes; - /** @type {{ - * codes: !(Array.|Uint32Array), - * freqs: !(Array.|Uint32Array) - * }} */ - var treeSymbols; - /** @type {!(Array.|Uint8Array)} */ - var treeLengths; - /** @type {Array} */ - var transLengths = new Array(19); - /** @type {!(Array.|Uint16Array)} */ - var treeCodes; - /** @type {number} */ - var code; - /** @type {number} */ - var bitlen; - /** @type {number} */ - var i; - /** @type {number} */ - var il; - - // header - bfinal = isFinalBlock ? 1 : 0; - btype = Zlib.RawDeflate.CompressionType.DYNAMIC; - - stream.writeBits(bfinal, 1, true); - stream.writeBits(btype, 2, true); - - data = this.lz77(blockArray); - - // リテラル・長さ, 距離のハフマン符号と符号長の算出 - litLenLengths = this.getLengths_(this.freqsLitLen, 15); - litLenCodes = this.getCodesFromLengths_(litLenLengths); - distLengths = this.getLengths_(this.freqsDist, 7); - distCodes = this.getCodesFromLengths_(distLengths); - - // HLIT, HDIST の決定 - for (hlit = 286; hlit > 257 && litLenLengths[hlit - 1] === 0; hlit--) {} - for (hdist = 30; hdist > 1 && distLengths[hdist - 1] === 0; hdist--) {} - - // HCLEN - treeSymbols = - this.getTreeSymbols_(hlit, litLenLengths, hdist, distLengths); - treeLengths = this.getLengths_(treeSymbols.freqs, 7); - for (i = 0; i < 19; i++) { - transLengths[i] = treeLengths[hclenOrder[i]]; - } - for (hclen = 19; hclen > 4 && transLengths[hclen - 1] === 0; hclen--) {} - - treeCodes = this.getCodesFromLengths_(treeLengths); - - // 出力 - stream.writeBits(hlit - 257, 5, true); - stream.writeBits(hdist - 1, 5, true); - stream.writeBits(hclen - 4, 4, true); - for (i = 0; i < hclen; i++) { - stream.writeBits(transLengths[i], 3, true); - } - - // ツリーの出力 - for (i = 0, il = treeSymbols.codes.length; i < il; i++) { - code = treeSymbols.codes[i]; - - stream.writeBits(treeCodes[code], treeLengths[code], true); - - // extra bits - if (code >= 16) { - i++; - switch (code) { - case 16: bitlen = 2; break; - case 17: bitlen = 3; break; - case 18: bitlen = 7; break; - default: - throw 'invalid code: ' + code; - } - - stream.writeBits(treeSymbols.codes[i], bitlen, true); - } - } - - this.dynamicHuffman( - data, - [litLenCodes, litLenLengths], - [distCodes, distLengths], - stream - ); - - return stream.finish(); -}; - - -/** - * 動的ハフマン符号化(カスタムハフマンテーブル) - * @param {!(Array.|Uint16Array)} dataArray LZ77 符号化済み byte array. - * @param {!Zlib.BitStream} stream 書き込み用ビットストリーム. - * @return {!Zlib.BitStream} ハフマン符号化済みビットストリームオブジェクト. - */ -Zlib.RawDeflate.prototype.dynamicHuffman = -function(dataArray, litLen, dist, stream) { - /** @type {number} */ - var index; - /** @type {number} */ - var length; - /** @type {number} */ - var literal; - /** @type {number} */ - var code; - /** @type {number} */ - var litLenCodes; - /** @type {number} */ - var litLenLengths; - /** @type {number} */ - var distCodes; - /** @type {number} */ - var distLengths; - - litLenCodes = litLen[0]; - litLenLengths = litLen[1]; - distCodes = dist[0]; - distLengths = dist[1]; - - // 符号を BitStream に書き込んでいく - for (index = 0, length = dataArray.length; index < length; ++index) { - literal = dataArray[index]; - - // literal or length - stream.writeBits(litLenCodes[literal], litLenLengths[literal], true); - - // 長さ・距離符号 - if (literal > 256) { - // length extra - stream.writeBits(dataArray[++index], dataArray[++index], true); - // distance - code = dataArray[++index]; - stream.writeBits(distCodes[code], distLengths[code], true); - // distance extra - stream.writeBits(dataArray[++index], dataArray[++index], true); - // 終端 - } else if (literal === 256) { - break; - } - } - - return stream; -}; - -/** - * 固定ハフマン符号化 - * @param {!(Array.|Uint16Array)} dataArray LZ77 符号化済み byte array. - * @param {!Zlib.BitStream} stream 書き込み用ビットストリーム. - * @return {!Zlib.BitStream} ハフマン符号化済みビットストリームオブジェクト. - */ -Zlib.RawDeflate.prototype.fixedHuffman = function(dataArray, stream) { - /** @type {number} */ - var index; - /** @type {number} */ - var length; - /** @type {number} */ - var literal; - - // 符号を BitStream に書き込んでいく - for (index = 0, length = dataArray.length; index < length; index++) { - literal = dataArray[index]; - - // 符号の書き込み - Zlib.BitStream.prototype.writeBits.apply( - stream, - Zlib.RawDeflate.FixedHuffmanTable[literal] - ); - - // 長さ・距離符号 - if (literal > 0x100) { - // length extra - stream.writeBits(dataArray[++index], dataArray[++index], true); - // distance - stream.writeBits(dataArray[++index], 5); - // distance extra - stream.writeBits(dataArray[++index], dataArray[++index], true); - // 終端 - } else if (literal === 0x100) { - break; - } - } - - return stream; -}; - -/** - * マッチ情報 - * @param {!number} length マッチした長さ. - * @param {!number} backwardDistance マッチ位置との距離. - * @constructor - */ -Zlib.RawDeflate.Lz77Match = function(length, backwardDistance) { - /** @type {number} match length. */ - this.length = length; - /** @type {number} backward distance. */ - this.backwardDistance = backwardDistance; -}; - -/** - * 長さ符号テーブル. - * [コード, 拡張ビット, 拡張ビット長] の配列となっている. - * @const - * @type {!(Array.|Uint32Array)} - */ -Zlib.RawDeflate.Lz77Match.LengthCodeTable = (function(table) { - return USE_TYPEDARRAY ? new Uint32Array(table) : table; -})((function() { - /** @type {!Array} */ - var table = []; - /** @type {number} */ - var i; - /** @type {!Array.} */ - var c; - - for (i = 3; i <= 258; i++) { - c = code(i); - table[i] = (c[2] << 24) | (c[1] << 16) | c[0]; - } - - /** - * @param {number} length lz77 length. - * @return {!Array.} lz77 codes. - */ - function code(length) { - switch (true) { - case (length === 3): return [257, length - 3, 0]; break; - case (length === 4): return [258, length - 4, 0]; break; - case (length === 5): return [259, length - 5, 0]; break; - case (length === 6): return [260, length - 6, 0]; break; - case (length === 7): return [261, length - 7, 0]; break; - case (length === 8): return [262, length - 8, 0]; break; - case (length === 9): return [263, length - 9, 0]; break; - case (length === 10): return [264, length - 10, 0]; break; - case (length <= 12): return [265, length - 11, 1]; break; - case (length <= 14): return [266, length - 13, 1]; break; - case (length <= 16): return [267, length - 15, 1]; break; - case (length <= 18): return [268, length - 17, 1]; break; - case (length <= 22): return [269, length - 19, 2]; break; - case (length <= 26): return [270, length - 23, 2]; break; - case (length <= 30): return [271, length - 27, 2]; break; - case (length <= 34): return [272, length - 31, 2]; break; - case (length <= 42): return [273, length - 35, 3]; break; - case (length <= 50): return [274, length - 43, 3]; break; - case (length <= 58): return [275, length - 51, 3]; break; - case (length <= 66): return [276, length - 59, 3]; break; - case (length <= 82): return [277, length - 67, 4]; break; - case (length <= 98): return [278, length - 83, 4]; break; - case (length <= 114): return [279, length - 99, 4]; break; - case (length <= 130): return [280, length - 115, 4]; break; - case (length <= 162): return [281, length - 131, 5]; break; - case (length <= 194): return [282, length - 163, 5]; break; - case (length <= 226): return [283, length - 195, 5]; break; - case (length <= 257): return [284, length - 227, 5]; break; - case (length === 258): return [285, length - 258, 0]; break; - default: throw 'invalid length: ' + length; - } - }; - - return table; -})()); - -/** - * 距離符号テーブル - * @param {!number} dist 距離. - * @return {!Array.} コード、拡張ビット、拡張ビット長の配列. - * @private - */ -Zlib.RawDeflate.Lz77Match.prototype.getDistanceCode_ = function(dist) { - /** @type {!Array.} distance code table. */ - var r; - - switch (true) { - case (dist === 1): r = [0, dist - 1, 0]; break; - case (dist === 2): r = [1, dist - 2, 0]; break; - case (dist === 3): r = [2, dist - 3, 0]; break; - case (dist === 4): r = [3, dist - 4, 0]; break; - case (dist <= 6): r = [4, dist - 5, 1]; break; - case (dist <= 8): r = [5, dist - 7, 1]; break; - case (dist <= 12): r = [6, dist - 9, 2]; break; - case (dist <= 16): r = [7, dist - 13, 2]; break; - case (dist <= 24): r = [8, dist - 17, 3]; break; - case (dist <= 32): r = [9, dist - 25, 3]; break; - case (dist <= 48): r = [10, dist - 33, 4]; break; - case (dist <= 64): r = [11, dist - 49, 4]; break; - case (dist <= 96): r = [12, dist - 65, 5]; break; - case (dist <= 128): r = [13, dist - 97, 5]; break; - case (dist <= 192): r = [14, dist - 129, 6]; break; - case (dist <= 256): r = [15, dist - 193, 6]; break; - case (dist <= 384): r = [16, dist - 257, 7]; break; - case (dist <= 512): r = [17, dist - 385, 7]; break; - case (dist <= 768): r = [18, dist - 513, 8]; break; - case (dist <= 1024): r = [19, dist - 769, 8]; break; - case (dist <= 1536): r = [20, dist - 1025, 9]; break; - case (dist <= 2048): r = [21, dist - 1537, 9]; break; - case (dist <= 3072): r = [22, dist - 2049, 10]; break; - case (dist <= 4096): r = [23, dist - 3073, 10]; break; - case (dist <= 6144): r = [24, dist - 4097, 11]; break; - case (dist <= 8192): r = [25, dist - 6145, 11]; break; - case (dist <= 12288): r = [26, dist - 8193, 12]; break; - case (dist <= 16384): r = [27, dist - 12289, 12]; break; - case (dist <= 24576): r = [28, dist - 16385, 13]; break; - case (dist <= 32768): r = [29, dist - 24577, 13]; break; - default: throw 'invalid distance'; - } - - return r; -}; - -/** - * マッチ情報を LZ77 符号化配列で返す. - * なお、ここでは以下の内部仕様で符号化している - * [ CODE, EXTRA-BIT-LEN, EXTRA, CODE, EXTRA-BIT-LEN, EXTRA ] - * @return {!Array.} LZ77 符号化 byte array. - */ -Zlib.RawDeflate.Lz77Match.prototype.toLz77Array = function() { - /** @type {number} */ - var length = this.length; - /** @type {number} */ - var dist = this.backwardDistance; - /** @type {Array} */ - var codeArray = []; - /** @type {number} */ - var pos = 0; - /** @type {!Array.} */ - var code; - - // length - code = Zlib.RawDeflate.Lz77Match.LengthCodeTable[length]; - codeArray[pos++] = code & 0xffff; - codeArray[pos++] = (code >> 16) & 0xff; - codeArray[pos++] = code >> 24; - - // distance - code = this.getDistanceCode_(dist); - codeArray[pos++] = code[0]; - codeArray[pos++] = code[1]; - codeArray[pos++] = code[2]; - - return codeArray; -}; - -/** - * LZ77 実装 - * @param {!(Array.|Uint8Array)} dataArray LZ77 符号化するバイト配列. - * @return {!(Array.|Uint16Array)} LZ77 符号化した配列. - */ -Zlib.RawDeflate.prototype.lz77 = function(dataArray) { - /** @type {number} input position */ - var position; - /** @type {number} input length */ - var length; - /** @type {number} loop counter */ - var i; - /** @type {number} loop limiter */ - var il; - /** @type {number} chained-hash-table key */ - var matchKey; - /** @type {Object.>} chained-hash-table */ - var table = {}; - /** @const @type {number} */ - var windowSize = Zlib.RawDeflate.WindowSize; - /** @type {Array.} match list */ - var matchList; - /** @type {Zlib.RawDeflate.Lz77Match} longest match */ - var longestMatch; - /** @type {Zlib.RawDeflate.Lz77Match} previous longest match */ - var prevMatch; - /** @type {!(Array.|Uint16Array)} lz77 buffer */ - var lz77buf = USE_TYPEDARRAY ? - new Uint16Array(dataArray.length * 2) : new Array(); - /** @type {number} lz77 output buffer pointer */ - var pos = 0; - /** @type {number} lz77 skip length */ - var skipLength = 0; - /** @type {!(Array.|Uint32Array)} */ - var freqsLitLen = new (USE_TYPEDARRAY ? Uint32Array : Array)(286); - /** @type {!(Array.|Uint32Array)} */ - var freqsDist = new (USE_TYPEDARRAY ? Uint32Array : Array)(30); - /** @type {number} */ - var lazy = this.lazy; - /** @type {*} temporary variable */ - var tmp; - - // 初期化 - if (!USE_TYPEDARRAY) { - for (i = 0; i <= 285;) { freqsLitLen[i++] = 0; } - for (i = 0; i <= 29;) { freqsDist[i++] = 0; } - } - freqsLitLen[256] = 1; // EOB の最低出現回数は 1 - - /** - * マッチデータの書き込み - * @param {Zlib.RawDeflate.Lz77Match} match LZ77 Match data. - * @param {!number} offset スキップ開始位置(相対指定). - * @private - */ - function writeMatch(match, offset) { - /** @type {Array.} */ - var lz77Array = match.toLz77Array(); - /** @type {number} */ - var i; - /** @type {number} */ - var il; - - for (i = 0, il = lz77Array.length; i < il; ++i) { - lz77buf[pos++] = lz77Array[i]; - } - freqsLitLen[lz77Array[0]]++; - freqsDist[lz77Array[3]]++; - skipLength = match.length + offset - 1; - prevMatch = null; - } - - // LZ77 符号化 - for (position = 0, length = dataArray.length; position < length; ++position) { - // ハッシュキーの作成 - for (matchKey = 0, i = 0, il = Zlib.RawDeflate.Lz77MinLength; i < il; ++i) { - if (position + i === length) { - break; - } - matchKey = (matchKey << 8) | dataArray[position + i]; - } - - // テーブルが未定義だったら作成する - if (table[matchKey] === void 0) { table[matchKey] = []; } - matchList = table[matchKey]; - - // skip - if (skipLength-- > 0) { - matchList.push(position); - continue; - } - - // マッチテーブルの更新 (最大戻り距離を超えているものを削除する) - while (matchList.length > 0 && position - matchList[0] > windowSize) { - matchList.shift(); - } - - // データ末尾でマッチしようがない場合はそのまま流しこむ - if (position + Zlib.RawDeflate.Lz77MinLength >= length) { - if (prevMatch) { - writeMatch(prevMatch, -1); - } - - for (i = 0, il = length - position; i < il; ++i) { - tmp = dataArray[position + i]; - lz77buf[pos++] = tmp; - ++freqsLitLen[tmp]; - } - break; - } - - // マッチ候補から最長のものを探す - if (matchList.length > 0) { - longestMatch = this.searchLongestMatch_(dataArray, position, matchList); - - if (prevMatch) { - // 現在のマッチの方が前回のマッチよりも長い - if (prevMatch.length < longestMatch.length) { - // write previous literal - tmp = dataArray[position - 1]; - lz77buf[pos++] = tmp; - ++freqsLitLen[tmp]; - - // write current match - writeMatch(longestMatch, 0); - } else { - // write previous match - writeMatch(prevMatch, -1); - } - } else if (longestMatch.length < lazy) { - prevMatch = longestMatch; - } else { - writeMatch(longestMatch, 0); - } - // 前回マッチしていて今回マッチがなかったら前回のを採用 - } else if (prevMatch) { - writeMatch(prevMatch, -1); - } else { - tmp = dataArray[position]; - lz77buf[pos++] = tmp; - ++freqsLitLen[tmp]; - } - - matchList.push(position); // マッチテーブルに現在の位置を保存 - } - - // 終端処理 - lz77buf[pos++] = 256; - freqsLitLen[256]++; - this.freqsLitLen = freqsLitLen; - this.freqsDist = freqsDist; - - return /** @type {!(Uint16Array|Array.)} */ ( - USE_TYPEDARRAY ? lz77buf.subarray(0, pos) : lz77buf - ); -}; - -/** - * マッチした候補の中から最長一致を探す - * @param {!Object} data plain data byte array. - * @param {!number} position plain data byte array position. - * @param {!Array.} matchList 候補となる位置の配列. - * @return {!Zlib.RawDeflate.Lz77Match} 最長かつ最短距離のマッチオブジェクト. - * @private - */ -Zlib.RawDeflate.prototype.searchLongestMatch_ = -function(data, position, matchList) { - var match, - currentMatch, - matchMax = 0, matchLength, - i, j, l, dl = data.length; - - // 候補を後ろから 1 つずつ絞り込んでゆく - permatch: - for (i = 0, l = matchList.length; i < l; i++) { - match = matchList[l - i - 1]; - matchLength = Zlib.RawDeflate.Lz77MinLength; - - // 前回までの最長一致を末尾から一致検索する - if (matchMax > Zlib.RawDeflate.Lz77MinLength) { - for (j = matchMax; j > Zlib.RawDeflate.Lz77MinLength; j--) { - if (data[match + j - 1] !== data[position + j - 1]) { - continue permatch; - } - } - matchLength = matchMax; - } - - // 最長一致探索 - while (matchLength < Zlib.RawDeflate.Lz77MaxLength && - position + matchLength < dl && - data[match + matchLength] === data[position + matchLength]) { - ++matchLength; - } - - // マッチ長が同じ場合は後方を優先 - if (matchLength > matchMax) { - currentMatch = match; - matchMax = matchLength; - } - - // 最長が確定したら後の処理は省略 - if (matchLength === Zlib.RawDeflate.Lz77MaxLength) { - break; - } - } - - return new Zlib.RawDeflate.Lz77Match(matchMax, position - currentMatch); -}; - -/** - * Tree-Transmit Symbols の算出 - * reference: PuTTY Deflate implementation - * @param {number} hlit HLIT. - * @param {!(Array.|Uint8Array)} litlenLengths リテラルと長さ符号の符号長配列. - * @param {number} hdist HDIST. - * @param {!(Array.|Uint8Array)} distLengths 距離符号の符号長配列. - * @return {{ - * codes: !(Array.|Uint32Array), - * freqs: !(Array.|Uint32Array) - * }} Tree-Transmit Symbols. - */ -Zlib.RawDeflate.prototype.getTreeSymbols_ = -function(hlit, litlenLengths, hdist, distLengths) { - var src = new (USE_TYPEDARRAY ? Uint32Array : Array)(hlit + hdist), - i, j, runLength, l, length, - result = new (USE_TYPEDARRAY ? Uint32Array : Array)(286 + 30), - nResult, - rpt, - freqs = new (USE_TYPEDARRAY ? Uint8Array : Array)(19); - - j = 0; - for (i = 0; i < hlit; i++) { - src[j++] = litlenLengths[i]; - } - for (i = 0; i < hdist; i++) { - src[j++] = distLengths[i]; - } - - // 初期化 - if (!USE_TYPEDARRAY) { - for (i = 0, l = freqs.length; i < l; ++i) { - freqs[i] = 0; - } - } - - // 符号化 - nResult = 0; - for (i = 0, l = src.length; i < l; i += j) { - // Run Length Encoding - for (j = 1; i + j < l && src[i + j] === src[i]; ++j) {} - - runLength = j; - - if (src[i] === 0) { - // 0 の繰り返しが 3 回未満ならばそのまま - if (runLength < 3) { - while (runLength-- > 0) { - result[nResult++] = 0; - freqs[0]++; - } - } else { - while (runLength > 0) { - // 繰り返しは最大 138 までなので切り詰める - rpt = (runLength < 138 ? runLength : 138); - - if (rpt > runLength - 3 && rpt < runLength) { - rpt = runLength - 3; - } - - // 3-10 回 -> 17 - if (rpt <= 10) { - result[nResult++] = 17; - result[nResult++] = rpt - 3; - freqs[17]++; - // 11-138 回 -> 18 - } else { - result[nResult++] = 18; - result[nResult++] = rpt - 11; - freqs[18]++; - } - - runLength -= rpt; - } - } - } else { - result[nResult++] = src[i]; - freqs[src[i]]++; - runLength--; - - // 繰り返し回数が3回未満ならばランレングス符号は要らない - if (runLength < 3) { - while (runLength-- > 0) { - result[nResult++] = src[i]; - freqs[src[i]]++; - } - // 3 回以上ならばランレングス符号化 - } else { - while (runLength > 0) { - // runLengthを 3-6 で分割 - rpt = (runLength < 6 ? runLength : 6); - - if (rpt > runLength - 3 && rpt < runLength) { - rpt = runLength - 3; - } - - result[nResult++] = 16; - result[nResult++] = rpt - 3; - freqs[16]++; - - runLength -= rpt; - } - } - } - } - - return { - codes: - USE_TYPEDARRAY ? result.subarray(0, nResult) : result.slice(0, nResult), - freqs: freqs - }; -}; - -/** - * ハフマン符号の長さを取得する - * @param {!(Array.|Uint32Array)} freqs 出現カウント. - * @param {number} limit 符号長の制限. - * @return {!(Array.|Uint8Array)} 符号長配列. - * @private - */ -Zlib.RawDeflate.prototype.getLengths_ = function(freqs, limit) { - /** @type {number} */ - var nSymbols = freqs.length; - /** @type {Zlib.Heap} */ - var heap = new Zlib.Heap(2 * Zlib.RawDeflate.HUFMAX); - /** @type {!(Array.|Uint8Array)} */ - var length = new (USE_TYPEDARRAY ? Uint8Array : Array)(nSymbols); - /** @type {Array} */ - var nodes; - /** @type {!(Array.|Uint8Array)} */ - var values; - /** @type {!(Array.|Uint8Array)} */ - var codeLength; - /** @type {number} */ - var i; - /** @type {number} */ - var il; - /** @type {Array.} */ - var freqsZero = []; - - // 配列の初期化 - if (!USE_TYPEDARRAY) { - for (i = 0; i < nSymbols; i++) { - length[i] = 0; - } - } - - // ヒープの構築 - for (i = 0; i < nSymbols; ++i) { - if (freqs[i] > 0) { - heap.push(i, freqs[i]); - } - } - nodes = new Array(heap.length / 2); - values = new (USE_TYPEDARRAY ? Uint32Array : Array)(heap.length / 2); - - // 非 0 の要素が一つだけだった場合は、そのシンボルに符号長 1 を割り当てて終了 - if (nodes.length === 1) { - length[heap.pop().index] = 1; - return length; - } - - // Reverse Package Merge Algorithm による Canonical Huffman Code の符号長決定 - for (i = 0, il = heap.length / 2; i < il; ++i) { - nodes[i] = heap.pop(); - values[i] = nodes[i].value; - } - codeLength = this.reversePackageMerge_(values, values.length, limit); - - for (i = 0, il = nodes.length; i < il; ++i) { - length[nodes[i].index] = codeLength[i]; - } - - return length; -}; - -/** - * Reverse Package Merge Algorithm. - * @param {!(Array.|Uint32Array)} freqs sorted probability. - * @param {number} symbols number of symbols. - * @param {number} limit code length limit. - * @return {!(Array.|Uint8Array)} code lengths. - */ -Zlib.RawDeflate.prototype.reversePackageMerge_ = function(freqs, symbols, limit) { - /** @type {!(Array.|Uint16Array)} */ - var minimumCost = new (USE_TYPEDARRAY ? Uint16Array : Array)(limit); - /** @type {!(Array.|Uint8Array)} */ - var flag = new (USE_TYPEDARRAY ? Uint8Array : Array)(limit); - /** @type {!(Array.|Uint8Array)} */ - var codeLength = new (USE_TYPEDARRAY ? Uint8Array : Array)(symbols); - /** @type {Array} */ - var value = new Array(limit); - /** @type {Array} */ - var type = new Array(limit); - /** @type {Array.} */ - var currentPosition = new Array(limit); - /** @type {number} */ - var excess = (1 << limit) - symbols; - /** @type {number} */ - var half = (1 << (limit - 1)); - /** @type {number} */ - var i; - /** @type {number} */ - var j; - /** @type {number} */ - var t; - /** @type {number} */ - var weight; - /** @type {number} */ - var next; - - /** - * @param {number} j - */ - function takePackage(j) { - /** @type {number} */ - var x = type[j][currentPosition[j]]; - - if (x === symbols) { - takePackage(j+1); - takePackage(j+1); - } else { - --codeLength[x]; - } - - ++currentPosition[j]; - } - - minimumCost[limit-1] = symbols; - - for (j = 0; j < limit; ++j) { - if (excess < half) { - flag[j] = 0; - } else { - flag[j] = 1; - excess -= half; - } - excess <<= 1; - minimumCost[limit-2-j] = (minimumCost[limit-1-j] / 2 | 0) + symbols; - } - minimumCost[0] = flag[0]; - - value[0] = new Array(minimumCost[0]); - type[0] = new Array(minimumCost[0]); - for (j = 1; j < limit; ++j) { - if (minimumCost[j] > 2 * minimumCost[j-1] + flag[j]) { - minimumCost[j] = 2 * minimumCost[j-1] + flag[j]; - } - value[j] = new Array(minimumCost[j]); - type[j] = new Array(minimumCost[j]); - } - - for (i = 0; i < symbols; ++i) { - codeLength[i] = limit; - } - - for (t = 0; t < minimumCost[limit-1]; ++t) { - value[limit-1][t] = freqs[t]; - type[limit-1][t] = t; - } - - for (i = 0; i < limit; ++i) { - currentPosition[i] = 0; - } - if (flag[limit-1] === 1) { - --codeLength[0]; - ++currentPosition[limit-1]; - } - - for (j = limit-2; j >= 0; --j) { - i = 0; - weight = 0; - next = currentPosition[j+1]; - - for (t = 0; t < minimumCost[j]; t++) { - weight = value[j+1][next] + value[j+1][next+1]; - - if (weight > freqs[i]) { - value[j][t] = weight; - type[j][t] = symbols; - next += 2; - } else { - value[j][t] = freqs[i]; - type[j][t] = i; - ++i; - } - } - - currentPosition[j] = 0; - if (flag[j] === 1) { - takePackage(j); - } - } - - return codeLength; -}; - -/** - * 符号長配列からハフマン符号を取得する - * reference: PuTTY Deflate implementation - * @param {!(Array.|Uint8Array)} lengths 符号長配列. - * @return {!(Array.|Uint16Array)} ハフマン符号配列. - * @private - */ -Zlib.RawDeflate.prototype.getCodesFromLengths_ = function(lengths) { - var codes = new (USE_TYPEDARRAY ? Uint16Array : Array)(lengths.length), - count = [], - startCode = [], - code = 0, i, il, j, m; - - // Count the codes of each length. - for (i = 0, il = lengths.length; i < il; i++) { - count[lengths[i]] = (count[lengths[i]] | 0) + 1; - } - - // Determine the starting code for each length block. - for (i = 1, il = Zlib.RawDeflate.MaxCodeLength; i <= il; i++) { - startCode[i] = code; - code += count[i] | 0; - code <<= 1; - } - - // Determine the code for each symbol. Mirrored, of course. - for (i = 0, il = lengths.length; i < il; i++) { - code = startCode[lengths[i]]; - startCode[lengths[i]] += 1; - codes[i] = 0; - - for (j = 0, m = lengths[i]; j < m; j++) { - codes[i] = (codes[i] << 1) | (code & 1); - code >>>= 1; - } - } - - return codes; -}; - -/////////////////////////////////////////////////////////////// -// deflate.js - -/** - * Zlib Deflate - * @constructor - * @param {!(Array|Uint8Array)} input 符号化する対象の byte array. - * @param {Object=} opt_params option parameters. - */ -Zlib.Deflate = function(input, opt_params) { - /** @type {!(Array|Uint8Array)} */ - this.input = input; - /** @type {!(Array|Uint8Array)} */ - this.output = - new (USE_TYPEDARRAY ? Uint8Array : Array)(Zlib.Deflate.DefaultBufferSize); - /** @type {Zlib.Deflate.CompressionType} */ - this.compressionType = Zlib.Deflate.CompressionType.DYNAMIC; - /** @type {Zlib.RawDeflate} */ - this.rawDeflate; - /** @type {Object} */ - var rawDeflateOption = {}; - /** @type {string} */ - var prop; - - // option parameters - if (opt_params || !(opt_params = {})) { - if (typeof opt_params['compressionType'] === 'number') { - this.compressionType = opt_params['compressionType']; - } - } - - // copy options - for (prop in opt_params) { - rawDeflateOption[prop] = opt_params[prop]; - } - - // set raw-deflate output buffer - rawDeflateOption['outputBuffer'] = this.output; - - this.rawDeflate = new Zlib.RawDeflate(this.input, rawDeflateOption); -}; - -/** - * @const - * @type {number} デフォルトバッファサイズ. - */ -Zlib.Deflate.DefaultBufferSize = 0x8000; - -/** - * @enum {number} - */ -Zlib.Deflate.CompressionType = Zlib.RawDeflate.CompressionType; - -/** - * 直接圧縮に掛ける. - * @param {!(Array|Uint8Array)} input target buffer. - * @param {Object=} opt_params option parameters. - * @return {!(Array|Uint8Array)} compressed data byte array. - */ -Zlib.Deflate.compress = function(input, opt_params) { - return (new Zlib.Deflate(input, opt_params)).compress(); -}; - -/** - * Deflate Compression. - * @return {!(Array|Uint8Array)} compressed data byte array. - */ -Zlib.Deflate.prototype.compress = function() { - /** @type {Zlib.CompressionMethod} */ - var cm; - /** @type {number} */ - var cinfo; - /** @type {number} */ - var cmf; - /** @type {number} */ - var flg; - /** @type {number} */ - var fcheck; - /** @type {number} */ - var fdict; - /** @type {number} */ - var flevel; - /** @type {number} */ - var clevel; - /** @type {number} */ - var adler; - /** @type {boolean} */ - var error = false; - /** @type {!(Array|Uint8Array)} */ - var output; - /** @type {number} */ - var pos = 0; - - output = this.output; - - // Compression Method and Flags - cm = Zlib.CompressionMethod.DEFLATE; - switch (cm) { - case Zlib.CompressionMethod.DEFLATE: - cinfo = Math.LOG2E * Math.log(Zlib.RawDeflate.WindowSize) - 8; - break; - default: - throw new Error('invalid compression method'); - } - cmf = (cinfo << 4) | cm; - output[pos++] = cmf; - - // Flags - fdict = 0; - switch (cm) { - case Zlib.CompressionMethod.DEFLATE: - switch (this.compressionType) { - case Zlib.Deflate.CompressionType.NONE: flevel = 0; break; - case Zlib.Deflate.CompressionType.FIXED: flevel = 1; break; - case Zlib.Deflate.CompressionType.DYNAMIC: flevel = 2; break; - default: throw new Error('unsupported compression type'); - } - break; - default: - throw new Error('invalid compression method'); - } - flg = (flevel << 6) | (fdict << 5); - fcheck = 31 - (cmf * 256 + flg) % 31; - flg |= fcheck; - output[pos++] = flg; - - // Adler-32 checksum - adler = Zlib.Adler32(this.input); - - this.rawDeflate.op = pos; - output = this.rawDeflate.compress(); - pos = output.length; - - if (USE_TYPEDARRAY) { - // subarray 分を元にもどす - output = new Uint8Array(output.buffer); - // expand buffer - if (output.length <= pos + 4) { - this.output = new Uint8Array(output.length + 4); - this.output.set(output); - output = this.output; - } - output = output.subarray(0, pos + 4); - } - - // adler32 - output[pos++] = (adler >> 24) & 0xff; - output[pos++] = (adler >> 16) & 0xff; - output[pos++] = (adler >> 8) & 0xff; - output[pos++] = (adler ) & 0xff; - - return output; -}; - -//////////////////////////////////////////////////////////////////////////////// - -var Deflate = function(data) { - return new Zlib.Deflate(data).compress(); -}; - - -module.exports = Deflate; diff --git a/benchmark/implementations/deflate-imaya/index.js b/benchmark/implementations/deflate-imaya/index.js index 25fa143..37d00b1 100644 --- a/benchmark/implementations/deflate-imaya/index.js +++ b/benchmark/implementations/deflate-imaya/index.js @@ -1,8 +1,8 @@ 'use strict' -var deflate = require('./deflate'); +var deflateSync = require('./node-zlib').deflateSync; -exports.run = function(data) { +exports.run = function(data, level) { // Compression levels not supported. Use unknown defaults always - return deflate(data.typed); + return deflateSync(data.typed, { level: level }); } diff --git a/benchmark/implementations/deflate-imaya/node-zlib.js b/benchmark/implementations/deflate-imaya/node-zlib.js new file mode 100644 index 0000000..6ef9c9c --- /dev/null +++ b/benchmark/implementations/deflate-imaya/node-zlib.js @@ -0,0 +1,53 @@ +/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';function q(b){throw b;}var t=void 0,v=!0;var A="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView;function E(b,a){this.index="number"===typeof a?a:0;this.m=0;this.buffer=b instanceof(A?Uint8Array:Array)?b:new (A?Uint8Array:Array)(32768);2*this.buffer.length<=this.index&&q(Error("invalid index"));this.buffer.length<=this.index&&this.f()}E.prototype.f=function(){var b=this.buffer,a,c=b.length,d=new (A?Uint8Array:Array)(c<<1);if(A)d.set(b);else for(a=0;a>>8&255]<<16|G[b>>>16&255]<<8|G[b>>>24&255])>>32-a:G[b]>>8-a);if(8>a+f)g=g<>a-k-1&1,8===++f&&(f=0,d[e++]=G[g],g=0,e===d.length&&(d=this.f()));d[e]=g;this.buffer=d;this.m=f;this.index=e};E.prototype.finish=function(){var b=this.buffer,a=this.index,c;0J;++J){for(var N=J,Q=N,ba=7,N=N>>>1;N;N>>>=1)Q<<=1,Q|=N&1,--ba;aa[J]=(Q<>>0}var G=aa;function R(b,a,c){var d,e="number"===typeof a?a:a=0,f="number"===typeof c?c:b.length;d=-1;for(e=f&7;e--;++a)d=d>>>8^S[(d^b[a])&255];for(e=f>>3;e--;a+=8)d=d>>>8^S[(d^b[a])&255],d=d>>>8^S[(d^b[a+1])&255],d=d>>>8^S[(d^b[a+2])&255],d=d>>>8^S[(d^b[a+3])&255],d=d>>>8^S[(d^b[a+4])&255],d=d>>>8^S[(d^b[a+5])&255],d=d>>>8^S[(d^b[a+6])&255],d=d>>>8^S[(d^b[a+7])&255];return(d^4294967295)>>>0} +var ga=[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, +2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977, +2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, +2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, +3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],S=A?new Uint32Array(ga):ga;function ha(){};function ia(b){this.buffer=new (A?Uint16Array:Array)(2*b);this.length=0}ia.prototype.getParent=function(b){return 2*((b-2)/4|0)};ia.prototype.push=function(b,a){var c,d,e=this.buffer,f;c=this.length;e[this.length++]=a;for(e[this.length++]=b;0e[d])f=e[c],e[c]=e[d],e[d]=f,f=e[c+1],e[c+1]=e[d+1],e[d+1]=f,c=d;else break;return this.length}; +ia.prototype.pop=function(){var b,a,c=this.buffer,d,e,f;a=c[0];b=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(f=0;;){e=2*f+2;if(e>=this.length)break;e+2c[e]&&(e+=2);if(c[e]>c[f])d=c[f],c[f]=c[e],c[e]=d,d=c[f+1],c[f+1]=c[e+1],c[e+1]=d;else break;f=e}return{index:b,value:a,length:this.length}};function ja(b){var a=b.length,c=0,d=Number.POSITIVE_INFINITY,e,f,g,k,h,l,s,p,m,n;for(p=0;pc&&(c=b[p]),b[p]>=1;n=g<<16|p;for(m=l;mT;T++)switch(v){case 143>=T:pa.push([T+48,8]);break;case 255>=T:pa.push([T-144+400,9]);break;case 279>=T:pa.push([T-256+0,7]);break;case 287>=T:pa.push([T-280+192,8]);break;default:q("invalid literal: "+T)} +ma.prototype.h=function(){var b,a,c,d,e=this.input;switch(this.k){case 0:c=0;for(d=e.length;c>>8&255;m[n++]=l&255;m[n++]=l>>>8&255;if(A)m.set(f,n),n+=f.length,m=m.subarray(0,n);else{s=0;for(p=f.length;sz)for(;0< +z--;)H[F++]=0,L[0]++;else for(;0z?z:138,C>z-3&&C=C?(H[F++]=17,H[F++]=C-3,L[17]++):(H[F++]=18,H[F++]=C-11,L[18]++),z-=C;else if(H[F++]=I[w],L[I[w]]++,z--,3>z)for(;0z?z:6,C>z-3&&CB;B++)sa[B]=ka[qb[B]];for(W=19;4=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272, +a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:q("invalid length: "+a)}}var a=[],c,d;for(c=3;258>=c;c++)d=b(c),a[c]=d[2]<<24|d[1]<< +16|d[0];return a}(),xa=A?new Uint32Array(wa):wa; +function qa(b,a){function c(a,c){var b=a.O,d=[],f=0,e;e=xa[a.length];d[f++]=e&65535;d[f++]=e>>16&255;d[f++]=e>>24;var g;switch(v){case 1===b:g=[0,b-1,0];break;case 2===b:g=[1,b-2,0];break;case 3===b:g=[2,b-3,0];break;case 4===b:g=[3,b-4,0];break;case 6>=b:g=[4,b-5,1];break;case 8>=b:g=[5,b-7,1];break;case 12>=b:g=[6,b-9,2];break;case 16>=b:g=[7,b-13,2];break;case 24>=b:g=[8,b-17,3];break;case 32>=b:g=[9,b-25,3];break;case 48>=b:g=[10,b-33,4];break;case 64>=b:g=[11,b-49,4];break;case 96>=b:g=[12,b- +65,5];break;case 128>=b:g=[13,b-97,5];break;case 192>=b:g=[14,b-129,6];break;case 256>=b:g=[15,b-193,6];break;case 384>=b:g=[16,b-257,7];break;case 512>=b:g=[17,b-385,7];break;case 768>=b:g=[18,b-513,8];break;case 1024>=b:g=[19,b-769,8];break;case 1536>=b:g=[20,b-1025,9];break;case 2048>=b:g=[21,b-1537,9];break;case 3072>=b:g=[22,b-2049,10];break;case 4096>=b:g=[23,b-3073,10];break;case 6144>=b:g=[24,b-4097,11];break;case 8192>=b:g=[25,b-6145,11];break;case 12288>=b:g=[26,b-8193,12];break;case 16384>= +b:g=[27,b-12289,12];break;case 24576>=b:g=[28,b-16385,13];break;case 32768>=b:g=[29,b-24577,13];break;default:q("invalid distance")}e=g;d[f++]=e[0];d[f++]=e[1];d[f++]=e[2];var h,k;h=0;for(k=d.length;h=f;)u[f++]=0;for(f=0;29>=f;)x[f++]=0}u[256]=1;d=0;for(e=a.length;d=e){p&&c(p,-1);f=0;for(g=e-d;fg&&a+gf&&(e=d,f=g);if(258===g)break}return new ua(f,a-e)} +function ra(b,a){var c=b.length,d=new ia(572),e=new (A?Uint8Array:Array)(c),f,g,k,h,l;if(!A)for(h=0;h2*e[n-1]+f[n]&&(e[n]=2*e[n-1]+f[n]),k[n]=Array(e[n]),h[n]=Array(e[n]);for(m=0;mb[m]?(k[n][r]=u,h[n][r]=a,x+=2):(k[n][r]=b[m],h[n][r]=m,++m);l[n]=0;1===f[n]&&d(n)}return g} +function ta(b){var a=new (A?Uint16Array:Array)(b.length),c=[],d=[],e=0,f,g,k,h;f=0;for(g=b.length;f>>=1}return a};function Aa(b,a){this.input=b;this.b=this.c=0;this.g={};a&&(a.flags&&(this.g=a.flags),"string"===typeof a.filename&&(this.filename=a.filename),"string"===typeof a.comment&&(this.w=a.comment),a.deflateOptions&&(this.l=a.deflateOptions));this.l||(this.l={})} +Aa.prototype.h=function(){var b,a,c,d,e,f,g,k,h=new (A?Uint8Array:Array)(32768),l=0,s=this.input,p=this.c,m=this.filename,n=this.w;h[l++]=31;h[l++]=139;h[l++]=8;b=0;this.g.fname&&(b|=Ba);this.g.fcomment&&(b|=Ca);this.g.fhcrc&&(b|=Da);h[l++]=b;a=(Date.now?Date.now():+new Date)/1E3|0;h[l++]=a&255;h[l++]=a>>>8&255;h[l++]=a>>>16&255;h[l++]=a>>>24&255;h[l++]=0;h[l++]=Sa;if(this.g.fname!==t){g=0;for(k=m.length;g>>8&255),h[l++]=f&255;h[l++]=0}if(this.g.comment){g= +0;for(k=n.length;g>>8&255),h[l++]=f&255;h[l++]=0}this.g.fhcrc&&(c=R(h,0,l)&65535,h[l++]=c&255,h[l++]=c>>>8&255);this.l.outputBuffer=h;this.l.outputIndex=l;e=new ma(s,this.l);h=e.h();l=e.b;A&&(l+8>h.buffer.byteLength?(this.a=new Uint8Array(l+8),this.a.set(new Uint8Array(h.buffer)),h=this.a):h=new Uint8Array(h.buffer));d=R(s,t,t);h[l++]=d&255;h[l++]=d>>>8&255;h[l++]=d>>>16&255;h[l++]=d>>>24&255;k=s.length;h[l++]=k&255;h[l++]=k>>>8&255;h[l++]=k>>>16&255;h[l++]= +k>>>24&255;this.c=p;A&&l>>=1;switch(b){case 0:var a=this.input,c=this.c,d=this.a,e=this.b,f=a.length,g=t,k=t,h=d.length,l=t;this.e=this.j=0;c+1>=f&&q(Error("invalid uncompressed block header: LEN"));g=a[c++]|a[c++]<<8;c+1>=f&&q(Error("invalid uncompressed block header: NLEN"));k=a[c++]|a[c++]<<8;g===~k&&q(Error("invalid uncompressed block header: length verify"));c+g>a.length&&q(Error("input buffer is broken"));switch(this.q){case Ua:for(;e+g>d.length;){l= +h-e;g-=l;if(A)d.set(a.subarray(c,c+l),e),e+=l,c+=l;else for(;l--;)d[e++]=a[c++];this.b=e;d=this.f();e=this.b}break;case Ta:for(;e+g>d.length;)d=this.f({B:2});break;default:q(Error("invalid inflate mode"))}if(A)d.set(a.subarray(c,c+g),e),e+=g,c+=g;else for(;g--;)d[e++]=a[c++];this.c=c;this.b=e;this.a=d;break;case 1:this.r(Va,Wa);break;case 2:Xa(this);break;default:q(Error("unknown BTYPE: "+b))}}return this.z()}; +var Ya=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],Za=A?new Uint16Array(Ya):Ya,$a=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258],ab=A?new Uint16Array($a):$a,bb=[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,0,0],cb=A?new Uint8Array(bb):bb,db=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577],eb=A?new Uint16Array(db):db,fb=[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],gb=A?new Uint8Array(fb):fb,hb=new (A?Uint8Array:Array)(288),$,ib;$=0;for(ib=hb.length;$=$?8:255>=$?9:279>=$?7:8;var Va=ja(hb),jb=new (A?Uint8Array:Array)(30),kb,lb;kb=0;for(lb=jb.length;kb=g&&q(Error("input buffer is broken")),c|=e[f++]<>>a;b.e=d-a;b.c=f;return k} +function mb(b,a){for(var c=b.j,d=b.e,e=b.input,f=b.c,g=e.length,k=a[0],h=a[1],l,s;d=g);)c|=e[f++]<>>16;b.j=c>>s;b.e=d-s;b.c=f;return l&65535} +function Xa(b){function a(a,b,c){var d,e=this.I,f,g;for(g=0;gf)d>=e&&(this.b=d,c=this.f(),d=this.b),c[d++]=f;else{g=f-257;h=ab[g];0=e&&(this.b=d,c=this.f(),d=this.b);for(;h--;)c[d]=c[d++-k]}for(;8<=this.e;)this.e-=8,this.c--;this.b=d}; +Y.prototype.R=function(b,a){var c=this.a,d=this.b;this.A=b;for(var e=c.length,f,g,k,h;256!==(f=mb(this,b));)if(256>f)d>=e&&(c=this.f(),e=c.length),c[d++]=f;else{g=f-257;h=ab[g];0e&&(c=this.f(),e=c.length);for(;h--;)c[d]=c[d++-k]}for(;8<=this.e;)this.e-=8,this.c--;this.b=d}; +Y.prototype.f=function(){var b=new (A?Uint8Array:Array)(this.b-32768),a=this.b-32768,c,d,e=this.a;if(A)b.set(e.subarray(32768,b.length));else{c=0;for(d=b.length;cc;++c)e[c]=e[a+c];this.b=32768;return e}; +Y.prototype.T=function(b){var a,c=this.input.length/this.c+1|0,d,e,f,g=this.input,k=this.a;b&&("number"===typeof b.B&&(c=b.B),"number"===typeof b.N&&(c+=b.N));2>c?(d=(g.length-this.c)/this.A[2],f=258*(d/2)|0,e=fa&&(this.a.length=a),b=this.a);return this.buffer=b};function nb(b){this.input=b;this.c=0;this.G=[];this.S=!1} +nb.prototype.i=function(){for(var b=this.input.length;this.c>>0;R(e,t,t)!==s&&q(Error("invalid CRC-32 checksum: 0x"+R(e,t,t).toString(16)+" / 0x"+ +s.toString(16)));a.$=c=(p[m++]|p[m++]<<8|p[m++]<<16|p[m++]<<24)>>>0;(e.length&4294967295)!==c&&q(Error("invalid input size: "+(e.length&4294967295)+" / "+c));this.G.push(a);this.c=m}this.S=v;var n=this.G,r,u,x=0,O=0,y;r=0;for(u=n.length;r>>0;b=a}for(var e=1,f=0,g=b.length,k,h=0;0>>0};function pb(b,a){var c,d;this.input=b;this.c=0;if(a||!(a={}))a.index&&(this.c=a.index),a.verify&&(this.W=a.verify);c=b[this.c++];d=b[this.c++];switch(c&15){case rb:this.method=rb;break;default:q(Error("unsupported compression method"))}0!==((c<<8)+d)%31&&q(Error("invalid fcheck flag:"+((c<<8)+d)%31));d&32&&q(Error("fdict flag is not supported"));this.K=new Y(b,{index:this.c,bufferSize:a.bufferSize,bufferType:a.bufferType,resize:a.resize})} +pb.prototype.i=function(){var b=this.input,a,c;a=this.K.i();this.c=this.K.c;this.W&&(c=(b[this.c++]<<24|b[this.c++]<<16|b[this.c++]<<8|b[this.c++])>>>0,c!==ob(a)&&q(Error("invalid adler-32 checksum")));return a};var rb=8;function sb(b,a){this.input=b;this.a=new (A?Uint8Array:Array)(32768);this.k=tb.t;var c={},d;if((a||!(a={}))&&"number"===typeof a.compressionType)this.k=a.compressionType;for(d in a)c[d]=a[d];c.outputBuffer=this.a;this.J=new ma(this.input,c)}var tb=oa; +sb.prototype.h=function(){var b,a,c,d,e,f,g,k=0;g=this.a;b=rb;switch(b){case rb:a=Math.LOG2E*Math.log(32768)-8;break;default:q(Error("invalid compression method"))}c=a<<4|b;g[k++]=c;switch(b){case rb:switch(this.k){case tb.NONE:e=0;break;case tb.M:e=1;break;case tb.t:e=2;break;default:q(Error("unsupported compression type"))}break;default:q(Error("invalid compression method"))}d=e<<6|0;g[k++]=d|31-(256*c+d)%31;f=ob(this.input);this.J.b=k;g=this.J.h();k=g.length;A&&(g=new Uint8Array(g.buffer),g.length<= +k+4&&(this.a=new Uint8Array(g.length+4),this.a.set(g),g=this.a),g=g.subarray(0,k+4));g[k++]=f>>24&255;g[k++]=f>>16&255;g[k++]=f>>8&255;g[k++]=f&255;return g};exports.deflate=ub;exports.deflateSync=vb;exports.inflate=wb;exports.inflateSync=xb;exports.gzip=yb;exports.gzipSync=zb;exports.gunzip=Ab;exports.gunzipSync=Bb;function ub(b,a,c){process.nextTick(function(){var d,e;try{e=vb(b,c)}catch(f){d=f}a(d,e)})}function vb(b,a){var c;c=(new sb(b)).h();a||(a={});return a.H?c:Cb(c)}function wb(b,a,c){process.nextTick(function(){var d,e;try{e=xb(b,c)}catch(f){d=f}a(d,e)})} +function xb(b,a){var c;b.subarray=b.slice;c=(new pb(b)).i();a||(a={});return a.noBuffer?c:Cb(c)}function yb(b,a,c){process.nextTick(function(){var d,e;try{e=zb(b,c)}catch(f){d=f}a(d,e)})}function zb(b,a){var c;b.subarray=b.slice;c=(new Aa(b)).h();a||(a={});return a.H?c:Cb(c)}function Ab(b,a,c){process.nextTick(function(){var d,e;try{e=Bb(b,c)}catch(f){d=f}a(d,e)})}function Bb(b,a){var c;b.subarray=b.slice;c=(new nb(b)).i();a||(a={});return a.H?c:Cb(c)} +function Cb(b){var a=new Buffer(b.length),c,d;c=0;for(d=b.length;c + * Version: 1.0.0.1 + * LastModified: Dec 25 1999 + */ + +/* Interface: + * data = zip_inflate(src); + */ + +/* constant parameters */ +var zip_WSIZE = 32768; // Sliding Window size +var zip_STORED_BLOCK = 0; +var zip_STATIC_TREES = 1; +var zip_DYN_TREES = 2; + +/* for inflate */ +var zip_lbits = 9; // bits in base literal/length lookup table +var zip_dbits = 6; // bits in base distance lookup table +var zip_INBUFSIZ = 32768; // Input buffer size +var zip_INBUF_EXTRA = 64; // Extra buffer + +/* variables (inflate) */ +var zip_slide; +var zip_wp; // current position in slide +var zip_fixed_tl = null; // inflate static +var zip_fixed_td; // inflate static +var zip_fixed_bl, fixed_bd; // inflate static +var zip_bit_buf; // bit buffer +var zip_bit_len; // bits in bit buffer +var zip_method; +var zip_eof; +var zip_copy_leng; +var zip_copy_dist; +var zip_tl, zip_td; // literal/length and distance decoder tables +var zip_bl, zip_bd; // number of bits decoded by tl and td + +var zip_inflate_data; +var zip_inflate_pos; + + +/* constant tables (inflate) */ +var zip_MASK_BITS = new Array( + 0x0000, + 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, + 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff); +// Tables for deflate from PKZIP's appnote.txt. +var zip_cplens = new Array( // Copy lengths for literal codes 257..285 + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0); +/* note: see note #13 above about the 258 in this list. */ +var zip_cplext = new Array( // Extra bits for literal codes 257..285 + 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, 99, 99); // 99==invalid +var zip_cpdist = new Array( // Copy offsets for distance codes 0..29 + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577); +var zip_cpdext = new Array( // Extra bits for distance codes + 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 zip_border = new Array( // Order of the bit length code lengths + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15); +/* objects (inflate) */ + +var zip_HuftList = function() { + this.next = null; + this.list = null; +} + +var zip_HuftNode = function() { + this.e = 0; // number of extra bits or operation + this.b = 0; // number of bits in this code or subcode + + // union + this.n = 0; // literal, length base, or distance base + this.t = null; // (zip_HuftNode) pointer to next level of table +} + +var zip_HuftBuild = function(b, // code lengths in bits (all assumed <= BMAX) + n, // number of codes (assumed <= N_MAX) + s, // number of simple-valued codes (0..s-1) + d, // list of base values for non-simple codes + e, // list of extra bits for non-simple codes + mm // maximum lookup bits + ) { + this.BMAX = 16; // maximum bit length of any code + this.N_MAX = 288; // maximum number of codes in any set + this.status = 0; // 0: success, 1: incomplete table, 2: bad input + this.root = null; // (zip_HuftList) starting table + this.m = 0; // maximum lookup bits, returns actual + +/* Given a list of code lengths and a maximum table size, make a set of + tables to decode that set of codes. Return zero on success, one if + the given code set is incomplete (the tables are still built in this + case), two if the input is invalid (all zero length codes or an + oversubscribed set of lengths), and three if not enough memory. + The code with value 256 is special, and the tables are constructed + so that no bits beyond that code are fetched when that code is + decoded. */ + { + var a; // counter for codes of length k + var c = new Array(this.BMAX+1); // bit length count table + var el; // length of EOB code (value 256) + var f; // i repeats in table every f entries + var g; // maximum code length + var h; // table level + var i; // counter, current code + var j; // counter + var k; // number of bits in current code + var lx = new Array(this.BMAX+1); // stack of bits per table + var p; // pointer into c[], b[], or v[] + var pidx; // index of p + var q; // (zip_HuftNode) points to current table + var r = new zip_HuftNode(); // table entry for structure assignment + var u = new Array(this.BMAX); // zip_HuftNode[BMAX][] table stack + var v = new Array(this.N_MAX); // values in order of bit length + var w; + var x = new Array(this.BMAX+1);// bit offsets, then code stack + var xp; // pointer into x or c + var y; // number of dummy codes added + var z; // number of entries in current table + var o; + var tail; // (zip_HuftList) + + tail = this.root = null; + for(i = 0; i < c.length; i++) + c[i] = 0; + for(i = 0; i < lx.length; i++) + lx[i] = 0; + for(i = 0; i < u.length; i++) + u[i] = null; + for(i = 0; i < v.length; i++) + v[i] = 0; + for(i = 0; i < x.length; i++) + x[i] = 0; + + // Generate counts for each bit length + el = n > 256 ? b[256] : this.BMAX; // set length of EOB code, if any + p = b; pidx = 0; + i = n; + do { + c[p[pidx]]++; // assume all entries <= BMAX + pidx++; + } while(--i > 0); + if(c[0] == n) { // null input--all zero length codes + this.root = null; + this.m = 0; + this.status = 0; + return; + } + + // Find minimum and maximum length, bound *m by those + for(j = 1; j <= this.BMAX; j++) + if(c[j] != 0) + break; + k = j; // minimum code length + if(mm < j) + mm = j; + for(i = this.BMAX; i != 0; i--) + if(c[i] != 0) + break; + g = i; // maximum code length + if(mm > i) + mm = i; + + // Adjust last length count to fill out codes, if needed + for(y = 1 << j; j < i; j++, y <<= 1) + if((y -= c[j]) < 0) { + this.status = 2; // bad input: more codes than bits + this.m = mm; + return; + } + if((y -= c[i]) < 0) { + this.status = 2; + this.m = mm; + return; + } + c[i] += y; + + // Generate starting offsets into the value table for each length + x[1] = j = 0; + p = c; + pidx = 1; + xp = 2; + while(--i > 0) // note that i == g from above + x[xp++] = (j += p[pidx++]); + + // Make a table of values in order of bit lengths + p = b; pidx = 0; + i = 0; + do { + if((j = p[pidx++]) != 0) + v[x[j]++] = i; + } while(++i < n); + n = x[g]; // set n to length of v + + // Generate the Huffman codes and for each, make the table entries + x[0] = i = 0; // first Huffman code is zero + p = v; pidx = 0; // grab values in bit order + h = -1; // no tables yet--level -1 + w = lx[0] = 0; // no bits decoded yet + q = null; // ditto + z = 0; // ditto + + // go through the bit lengths (k already is bits in shortest code) + for(; k <= g; k++) { + a = c[k]; + while(a-- > 0) { + // here i is the Huffman code of length k bits for value p[pidx] + // make tables up to required level + while(k > w + lx[1 + h]) { + w += lx[1 + h]; // add bits already decoded + h++; + + // compute minimum size table less than or equal to *m bits + z = (z = g - w) > mm ? mm : z; // upper limit + if((f = 1 << (j = k - w)) > a + 1) { // try a k-w bit table + // too few codes for k-w bit table + f -= a + 1; // deduct codes from patterns left + xp = k; + while(++j < z) { // try smaller tables up to z bits + if((f <<= 1) <= c[++xp]) + break; // enough codes to use up j bits + f -= c[xp]; // else deduct codes from patterns + } + } + if(w + j > el && w < el) + j = el - w; // make EOB code end at table + z = 1 << j; // table entries for j-bit table + lx[1 + h] = j; // set table size in stack + + // allocate and link in new table + q = new Array(z); + for(o = 0; o < z; o++) { + q[o] = new zip_HuftNode(); + } + + if(tail == null) + tail = this.root = new zip_HuftList(); + else + tail = tail.next = new zip_HuftList(); + tail.next = null; + tail.list = q; + u[h] = q; // table starts after link + + /* connect to last table, if there is one */ + if(h > 0) { + x[h] = i; // save pattern for backing up + r.b = lx[h]; // bits to dump before this table + r.e = 16 + j; // bits in this table + r.t = q; // pointer to this table + j = (i & ((1 << w) - 1)) >> (w - lx[h]); + u[h-1][j].e = r.e; + u[h-1][j].b = r.b; + u[h-1][j].n = r.n; + u[h-1][j].t = r.t; + } + } + + // set up table entry in r + r.b = k - w; + if(pidx >= n) + r.e = 99; // out of values--invalid code + else if(p[pidx] < s) { + r.e = (p[pidx] < 256 ? 16 : 15); // 256 is end-of-block code + r.n = p[pidx++]; // simple code is just the value + } else { + r.e = e[p[pidx] - s]; // non-simple--look up in lists + r.n = d[p[pidx++] - s]; + } + + // fill code-like entries with r // + f = 1 << (k - w); + for(j = i >> w; j < z; j += f) { + q[j].e = r.e; + q[j].b = r.b; + q[j].n = r.n; + q[j].t = r.t; + } + + // backwards increment the k-bit code i + for(j = 1 << (k - 1); (i & j) != 0; j >>= 1) + i ^= j; + i ^= j; + + // backup over finished tables + while((i & ((1 << w) - 1)) != x[h]) { + w -= lx[h]; // don't need to update q + h--; + } + } + } + + /* return actual size of base table */ + this.m = lx[1]; + + /* Return true (1) if we were given an incomplete table */ + this.status = ((y != 0 && g != 1) ? 1 : 0); + } /* end of constructor */ +} + + +/* routines (inflate) */ + +var zip_GET_BYTE = function() { + if(zip_inflate_data.length == zip_inflate_pos) + return -1; + //return zip_inflate_data.charCodeAt(zip_inflate_pos++) & 0xff; + return zip_inflate_data[zip_inflate_pos++]; +} + +var zip_NEEDBITS = function(n) { + while(zip_bit_len < n) { + zip_bit_buf |= zip_GET_BYTE() << zip_bit_len; + zip_bit_len += 8; + } +} + +var zip_GETBITS = function(n) { + return zip_bit_buf & zip_MASK_BITS[n]; +} + +var zip_DUMPBITS = function(n) { + zip_bit_buf >>= n; + zip_bit_len -= n; +} + +var zip_inflate_codes = function(buff, off, size) { + /* inflate (decompress) the codes in a deflated (compressed) block. + Return an error code or zero if it all goes ok. */ + var e; // table entry flag/number of extra bits + var t; // (zip_HuftNode) pointer to table entry + var n; + + if(size == 0) + return 0; + + // inflate the coded data + n = 0; + for(;;) { // do until end of block + zip_NEEDBITS(zip_bl); + t = zip_tl.list[zip_GETBITS(zip_bl)]; + e = t.e; + while(e > 16) { + if(e == 99) + return -1; + zip_DUMPBITS(t.b); + e -= 16; + zip_NEEDBITS(e); + t = t.t[zip_GETBITS(e)]; + e = t.e; + } + zip_DUMPBITS(t.b); + + if(e == 16) { // then it's a literal + zip_wp &= zip_WSIZE - 1; + buff[off + n++] = zip_slide[zip_wp++] = t.n; + if(n == size) + return size; + continue; + } + + // exit if end of block + if(e == 15) + break; + + // it's an EOB or a length + + // get length of block to copy + zip_NEEDBITS(e); + zip_copy_leng = t.n + zip_GETBITS(e); + zip_DUMPBITS(e); + + // decode distance of block to copy + zip_NEEDBITS(zip_bd); + t = zip_td.list[zip_GETBITS(zip_bd)]; + e = t.e; + + while(e > 16) { + if(e == 99) + return -1; + zip_DUMPBITS(t.b); + e -= 16; + zip_NEEDBITS(e); + t = t.t[zip_GETBITS(e)]; + e = t.e; + } + zip_DUMPBITS(t.b); + zip_NEEDBITS(e); + zip_copy_dist = zip_wp - t.n - zip_GETBITS(e); + zip_DUMPBITS(e); + + // do the copy + while(zip_copy_leng > 0 && n < size) { + zip_copy_leng--; + zip_copy_dist &= zip_WSIZE - 1; + zip_wp &= zip_WSIZE - 1; + buff[off + n++] = zip_slide[zip_wp++] + = zip_slide[zip_copy_dist++]; + } + + if(n == size) + return size; + } + + zip_method = -1; // done + return n; +} + +var zip_inflate_stored = function(buff, off, size) { + /* "decompress" an inflated type 0 (stored) block. */ + var n; + + // go to byte boundary + n = zip_bit_len & 7; + zip_DUMPBITS(n); + + // get the length and its complement + zip_NEEDBITS(16); + n = zip_GETBITS(16); + zip_DUMPBITS(16); + zip_NEEDBITS(16); + if(n != ((~zip_bit_buf) & 0xffff)) + return -1; // error in compressed data + zip_DUMPBITS(16); + + // read and output the compressed data + zip_copy_leng = n; + + n = 0; + while(zip_copy_leng > 0 && n < size) { + zip_copy_leng--; + zip_wp &= zip_WSIZE - 1; + zip_NEEDBITS(8); + buff[off + n++] = zip_slide[zip_wp++] = + zip_GETBITS(8); + zip_DUMPBITS(8); + } + + if(zip_copy_leng == 0) + zip_method = -1; // done + return n; +} + +var zip_inflate_fixed = function(buff, off, size) { + /* decompress an inflated type 1 (fixed Huffman codes) block. We should + either replace this with a custom decoder, or at least precompute the + Huffman tables. */ + + // if first time, set up tables for fixed blocks + if(zip_fixed_tl == null) { + var i; // temporary variable + var l = new Array(288); // length list for huft_build + var h; // zip_HuftBuild + + // literal table + for(i = 0; i < 144; i++) + l[i] = 8; + for(; i < 256; i++) + l[i] = 9; + for(; i < 280; i++) + l[i] = 7; + for(; i < 288; i++) // make a complete, but wrong code set + l[i] = 8; + zip_fixed_bl = 7; + + h = new zip_HuftBuild(l, 288, 257, zip_cplens, zip_cplext, + zip_fixed_bl); + if(h.status != 0) { + alert("HufBuild error: "+h.status); + return -1; + } + zip_fixed_tl = h.root; + zip_fixed_bl = h.m; + + // distance table + for(i = 0; i < 30; i++) // make an incomplete code set + l[i] = 5; + zip_fixed_bd = 5; + + h = new zip_HuftBuild(l, 30, 0, zip_cpdist, zip_cpdext, zip_fixed_bd); + if(h.status > 1) { + zip_fixed_tl = null; + alert("HufBuild error: "+h.status); + return -1; + } + zip_fixed_td = h.root; + zip_fixed_bd = h.m; + } + + zip_tl = zip_fixed_tl; + zip_td = zip_fixed_td; + zip_bl = zip_fixed_bl; + zip_bd = zip_fixed_bd; + return zip_inflate_codes(buff, off, size); +} + +var zip_inflate_dynamic = function(buff, off, size) { + // decompress an inflated type 2 (dynamic Huffman codes) block. + var i; // temporary variables + var j; + var l; // last length + var n; // number of lengths to get + var t; // (zip_HuftNode) literal/length code table + var nb; // number of bit length codes + var nl; // number of literal/length codes + var nd; // number of distance codes + var ll = new Array(286+30); // literal/length and distance code lengths + var h; // (zip_HuftBuild) + + for(i = 0; i < ll.length; i++) + ll[i] = 0; + + // read in table lengths + zip_NEEDBITS(5); + nl = 257 + zip_GETBITS(5); // number of literal/length codes + zip_DUMPBITS(5); + zip_NEEDBITS(5); + nd = 1 + zip_GETBITS(5); // number of distance codes + zip_DUMPBITS(5); + zip_NEEDBITS(4); + nb = 4 + zip_GETBITS(4); // number of bit length codes + zip_DUMPBITS(4); + if(nl > 286 || nd > 30) + return -1; // bad lengths + + // read in bit-length-code lengths + for(j = 0; j < nb; j++) + { + zip_NEEDBITS(3); + ll[zip_border[j]] = zip_GETBITS(3); + zip_DUMPBITS(3); + } + for(; j < 19; j++) + ll[zip_border[j]] = 0; + + // build decoding table for trees--single level, 7 bit lookup + zip_bl = 7; + h = new zip_HuftBuild(ll, 19, 19, null, null, zip_bl); + if(h.status != 0) + return -1; // incomplete code set + + zip_tl = h.root; + zip_bl = h.m; + + // read in literal and distance code lengths + n = nl + nd; + i = l = 0; + while(i < n) { + zip_NEEDBITS(zip_bl); + t = zip_tl.list[zip_GETBITS(zip_bl)]; + j = t.b; + zip_DUMPBITS(j); + j = t.n; + if(j < 16) // length of code in bits (0..15) + ll[i++] = l = j; // save last length in l + else if(j == 16) { // repeat last length 3 to 6 times + zip_NEEDBITS(2); + j = 3 + zip_GETBITS(2); + zip_DUMPBITS(2); + if(i + j > n) + return -1; + while(j-- > 0) + ll[i++] = l; + } else if(j == 17) { // 3 to 10 zero length codes + zip_NEEDBITS(3); + j = 3 + zip_GETBITS(3); + zip_DUMPBITS(3); + if(i + j > n) + return -1; + while(j-- > 0) + ll[i++] = 0; + l = 0; + } else { // j == 18: 11 to 138 zero length codes + zip_NEEDBITS(7); + j = 11 + zip_GETBITS(7); + zip_DUMPBITS(7); + if(i + j > n) + return -1; + while(j-- > 0) + ll[i++] = 0; + l = 0; + } + } + + // build the decoding tables for literal/length and distance codes + zip_bl = zip_lbits; + h = new zip_HuftBuild(ll, nl, 257, zip_cplens, zip_cplext, zip_bl); + if(zip_bl == 0) // no literals or lengths + h.status = 1; + if(h.status != 0) { + if(h.status == 1) + ;// **incomplete literal tree** + return -1; // incomplete code set + } + zip_tl = h.root; + zip_bl = h.m; + + for(i = 0; i < nd; i++) + ll[i] = ll[i + nl]; + zip_bd = zip_dbits; + h = new zip_HuftBuild(ll, nd, 0, zip_cpdist, zip_cpdext, zip_bd); + zip_td = h.root; + zip_bd = h.m; + + if(zip_bd == 0 && nl > 257) { // lengths but no distances + // **incomplete distance tree** + return -1; + } + + if(h.status == 1) { + ;// **incomplete distance tree** + } + if(h.status != 0) + return -1; + + // decompress until an end-of-block code + return zip_inflate_codes(buff, off, size); +} + +var zip_inflate_start = function() { + var i; + + if(zip_slide == null) + zip_slide = new Array(2 * zip_WSIZE); + zip_wp = 0; + zip_bit_buf = 0; + zip_bit_len = 0; + zip_method = -1; + zip_eof = false; + zip_copy_leng = zip_copy_dist = 0; + zip_tl = null; +} + +var zip_inflate_internal = function(buff, off, size) { + // decompress an inflated entry + var n, i; + + n = 0; + while(n < size) { + if(zip_eof && zip_method == -1) + return n; + + if(zip_copy_leng > 0) { + if(zip_method != zip_STORED_BLOCK) { + // STATIC_TREES or DYN_TREES + while(zip_copy_leng > 0 && n < size) { + zip_copy_leng--; + zip_copy_dist &= zip_WSIZE - 1; + zip_wp &= zip_WSIZE - 1; + buff[off + n++] = zip_slide[zip_wp++] = + zip_slide[zip_copy_dist++]; + } + } else { + while(zip_copy_leng > 0 && n < size) { + zip_copy_leng--; + zip_wp &= zip_WSIZE - 1; + zip_NEEDBITS(8); + buff[off + n++] = zip_slide[zip_wp++] = zip_GETBITS(8); + zip_DUMPBITS(8); + } + if(zip_copy_leng == 0) + zip_method = -1; // done + } + if(n == size) + return n; + } + + if(zip_method == -1) { + if(zip_eof) + break; + + // read in last block bit + zip_NEEDBITS(1); + if(zip_GETBITS(1) != 0) + zip_eof = true; + zip_DUMPBITS(1); + + // read in block type + zip_NEEDBITS(2); + zip_method = zip_GETBITS(2); + zip_DUMPBITS(2); + zip_tl = null; + zip_copy_leng = 0; + } + + switch(zip_method) { + case 0: // zip_STORED_BLOCK + i = zip_inflate_stored(buff, off + n, size - n); + break; + + case 1: // zip_STATIC_TREES + if(zip_tl != null) + i = zip_inflate_codes(buff, off + n, size - n); + else + i = zip_inflate_fixed(buff, off + n, size - n); + break; + + case 2: // zip_DYN_TREES + if(zip_tl != null) + i = zip_inflate_codes(buff, off + n, size - n); + else + i = zip_inflate_dynamic(buff, off + n, size - n); + break; + + default: // error + i = -1; + break; + } + + if(i == -1) { + if(zip_eof) + return 0; + return -1; + } + n += i; + } + return n; +} + +var zip_inflate = function(str) { + var i, j; + + zip_inflate_start(); + zip_inflate_data = str; + zip_inflate_pos = 0; + + var buff = new Array(1024); + var aout = []; + while((i = zip_inflate_internal(buff, 0, buff.length)) > 0) { + var cbuf = new Array(i); + for(j = 0; j < i; j++){ + cbuf[j] = String.fromCharCode(buff[j]); + } + aout[aout.length] = cbuf.join(""); + } + zip_inflate_data = null; // G.C. + return aout.join(""); +} + +if (! ctx.RawDeflate) ctx.RawDeflate = {}; +ctx.RawDeflate.inflate = zip_inflate; + +})(this); diff --git a/benchmark/implementations/inflate-imaya/index.js b/benchmark/implementations/inflate-imaya/index.js new file mode 100644 index 0000000..4bb76bd --- /dev/null +++ b/benchmark/implementations/inflate-imaya/index.js @@ -0,0 +1,8 @@ +'use strict' + +var inflateSync = require('./node-zlib').inflateSync; + +exports.run = function(data, level) { + // Compression levels not supported. Use unknown defaults always + return inflateSync(data.deflateTyped); +} diff --git a/benchmark/implementations/inflate-imaya/node-zlib.js b/benchmark/implementations/inflate-imaya/node-zlib.js new file mode 100644 index 0000000..6ef9c9c --- /dev/null +++ b/benchmark/implementations/inflate-imaya/node-zlib.js @@ -0,0 +1,53 @@ +/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';function q(b){throw b;}var t=void 0,v=!0;var A="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView;function E(b,a){this.index="number"===typeof a?a:0;this.m=0;this.buffer=b instanceof(A?Uint8Array:Array)?b:new (A?Uint8Array:Array)(32768);2*this.buffer.length<=this.index&&q(Error("invalid index"));this.buffer.length<=this.index&&this.f()}E.prototype.f=function(){var b=this.buffer,a,c=b.length,d=new (A?Uint8Array:Array)(c<<1);if(A)d.set(b);else for(a=0;a>>8&255]<<16|G[b>>>16&255]<<8|G[b>>>24&255])>>32-a:G[b]>>8-a);if(8>a+f)g=g<>a-k-1&1,8===++f&&(f=0,d[e++]=G[g],g=0,e===d.length&&(d=this.f()));d[e]=g;this.buffer=d;this.m=f;this.index=e};E.prototype.finish=function(){var b=this.buffer,a=this.index,c;0J;++J){for(var N=J,Q=N,ba=7,N=N>>>1;N;N>>>=1)Q<<=1,Q|=N&1,--ba;aa[J]=(Q<>>0}var G=aa;function R(b,a,c){var d,e="number"===typeof a?a:a=0,f="number"===typeof c?c:b.length;d=-1;for(e=f&7;e--;++a)d=d>>>8^S[(d^b[a])&255];for(e=f>>3;e--;a+=8)d=d>>>8^S[(d^b[a])&255],d=d>>>8^S[(d^b[a+1])&255],d=d>>>8^S[(d^b[a+2])&255],d=d>>>8^S[(d^b[a+3])&255],d=d>>>8^S[(d^b[a+4])&255],d=d>>>8^S[(d^b[a+5])&255],d=d>>>8^S[(d^b[a+6])&255],d=d>>>8^S[(d^b[a+7])&255];return(d^4294967295)>>>0} +var ga=[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, +2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977, +2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, +2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, +3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],S=A?new Uint32Array(ga):ga;function ha(){};function ia(b){this.buffer=new (A?Uint16Array:Array)(2*b);this.length=0}ia.prototype.getParent=function(b){return 2*((b-2)/4|0)};ia.prototype.push=function(b,a){var c,d,e=this.buffer,f;c=this.length;e[this.length++]=a;for(e[this.length++]=b;0e[d])f=e[c],e[c]=e[d],e[d]=f,f=e[c+1],e[c+1]=e[d+1],e[d+1]=f,c=d;else break;return this.length}; +ia.prototype.pop=function(){var b,a,c=this.buffer,d,e,f;a=c[0];b=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(f=0;;){e=2*f+2;if(e>=this.length)break;e+2c[e]&&(e+=2);if(c[e]>c[f])d=c[f],c[f]=c[e],c[e]=d,d=c[f+1],c[f+1]=c[e+1],c[e+1]=d;else break;f=e}return{index:b,value:a,length:this.length}};function ja(b){var a=b.length,c=0,d=Number.POSITIVE_INFINITY,e,f,g,k,h,l,s,p,m,n;for(p=0;pc&&(c=b[p]),b[p]>=1;n=g<<16|p;for(m=l;mT;T++)switch(v){case 143>=T:pa.push([T+48,8]);break;case 255>=T:pa.push([T-144+400,9]);break;case 279>=T:pa.push([T-256+0,7]);break;case 287>=T:pa.push([T-280+192,8]);break;default:q("invalid literal: "+T)} +ma.prototype.h=function(){var b,a,c,d,e=this.input;switch(this.k){case 0:c=0;for(d=e.length;c>>8&255;m[n++]=l&255;m[n++]=l>>>8&255;if(A)m.set(f,n),n+=f.length,m=m.subarray(0,n);else{s=0;for(p=f.length;sz)for(;0< +z--;)H[F++]=0,L[0]++;else for(;0z?z:138,C>z-3&&C=C?(H[F++]=17,H[F++]=C-3,L[17]++):(H[F++]=18,H[F++]=C-11,L[18]++),z-=C;else if(H[F++]=I[w],L[I[w]]++,z--,3>z)for(;0z?z:6,C>z-3&&CB;B++)sa[B]=ka[qb[B]];for(W=19;4=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272, +a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:q("invalid length: "+a)}}var a=[],c,d;for(c=3;258>=c;c++)d=b(c),a[c]=d[2]<<24|d[1]<< +16|d[0];return a}(),xa=A?new Uint32Array(wa):wa; +function qa(b,a){function c(a,c){var b=a.O,d=[],f=0,e;e=xa[a.length];d[f++]=e&65535;d[f++]=e>>16&255;d[f++]=e>>24;var g;switch(v){case 1===b:g=[0,b-1,0];break;case 2===b:g=[1,b-2,0];break;case 3===b:g=[2,b-3,0];break;case 4===b:g=[3,b-4,0];break;case 6>=b:g=[4,b-5,1];break;case 8>=b:g=[5,b-7,1];break;case 12>=b:g=[6,b-9,2];break;case 16>=b:g=[7,b-13,2];break;case 24>=b:g=[8,b-17,3];break;case 32>=b:g=[9,b-25,3];break;case 48>=b:g=[10,b-33,4];break;case 64>=b:g=[11,b-49,4];break;case 96>=b:g=[12,b- +65,5];break;case 128>=b:g=[13,b-97,5];break;case 192>=b:g=[14,b-129,6];break;case 256>=b:g=[15,b-193,6];break;case 384>=b:g=[16,b-257,7];break;case 512>=b:g=[17,b-385,7];break;case 768>=b:g=[18,b-513,8];break;case 1024>=b:g=[19,b-769,8];break;case 1536>=b:g=[20,b-1025,9];break;case 2048>=b:g=[21,b-1537,9];break;case 3072>=b:g=[22,b-2049,10];break;case 4096>=b:g=[23,b-3073,10];break;case 6144>=b:g=[24,b-4097,11];break;case 8192>=b:g=[25,b-6145,11];break;case 12288>=b:g=[26,b-8193,12];break;case 16384>= +b:g=[27,b-12289,12];break;case 24576>=b:g=[28,b-16385,13];break;case 32768>=b:g=[29,b-24577,13];break;default:q("invalid distance")}e=g;d[f++]=e[0];d[f++]=e[1];d[f++]=e[2];var h,k;h=0;for(k=d.length;h=f;)u[f++]=0;for(f=0;29>=f;)x[f++]=0}u[256]=1;d=0;for(e=a.length;d=e){p&&c(p,-1);f=0;for(g=e-d;fg&&a+gf&&(e=d,f=g);if(258===g)break}return new ua(f,a-e)} +function ra(b,a){var c=b.length,d=new ia(572),e=new (A?Uint8Array:Array)(c),f,g,k,h,l;if(!A)for(h=0;h2*e[n-1]+f[n]&&(e[n]=2*e[n-1]+f[n]),k[n]=Array(e[n]),h[n]=Array(e[n]);for(m=0;mb[m]?(k[n][r]=u,h[n][r]=a,x+=2):(k[n][r]=b[m],h[n][r]=m,++m);l[n]=0;1===f[n]&&d(n)}return g} +function ta(b){var a=new (A?Uint16Array:Array)(b.length),c=[],d=[],e=0,f,g,k,h;f=0;for(g=b.length;f>>=1}return a};function Aa(b,a){this.input=b;this.b=this.c=0;this.g={};a&&(a.flags&&(this.g=a.flags),"string"===typeof a.filename&&(this.filename=a.filename),"string"===typeof a.comment&&(this.w=a.comment),a.deflateOptions&&(this.l=a.deflateOptions));this.l||(this.l={})} +Aa.prototype.h=function(){var b,a,c,d,e,f,g,k,h=new (A?Uint8Array:Array)(32768),l=0,s=this.input,p=this.c,m=this.filename,n=this.w;h[l++]=31;h[l++]=139;h[l++]=8;b=0;this.g.fname&&(b|=Ba);this.g.fcomment&&(b|=Ca);this.g.fhcrc&&(b|=Da);h[l++]=b;a=(Date.now?Date.now():+new Date)/1E3|0;h[l++]=a&255;h[l++]=a>>>8&255;h[l++]=a>>>16&255;h[l++]=a>>>24&255;h[l++]=0;h[l++]=Sa;if(this.g.fname!==t){g=0;for(k=m.length;g>>8&255),h[l++]=f&255;h[l++]=0}if(this.g.comment){g= +0;for(k=n.length;g>>8&255),h[l++]=f&255;h[l++]=0}this.g.fhcrc&&(c=R(h,0,l)&65535,h[l++]=c&255,h[l++]=c>>>8&255);this.l.outputBuffer=h;this.l.outputIndex=l;e=new ma(s,this.l);h=e.h();l=e.b;A&&(l+8>h.buffer.byteLength?(this.a=new Uint8Array(l+8),this.a.set(new Uint8Array(h.buffer)),h=this.a):h=new Uint8Array(h.buffer));d=R(s,t,t);h[l++]=d&255;h[l++]=d>>>8&255;h[l++]=d>>>16&255;h[l++]=d>>>24&255;k=s.length;h[l++]=k&255;h[l++]=k>>>8&255;h[l++]=k>>>16&255;h[l++]= +k>>>24&255;this.c=p;A&&l>>=1;switch(b){case 0:var a=this.input,c=this.c,d=this.a,e=this.b,f=a.length,g=t,k=t,h=d.length,l=t;this.e=this.j=0;c+1>=f&&q(Error("invalid uncompressed block header: LEN"));g=a[c++]|a[c++]<<8;c+1>=f&&q(Error("invalid uncompressed block header: NLEN"));k=a[c++]|a[c++]<<8;g===~k&&q(Error("invalid uncompressed block header: length verify"));c+g>a.length&&q(Error("input buffer is broken"));switch(this.q){case Ua:for(;e+g>d.length;){l= +h-e;g-=l;if(A)d.set(a.subarray(c,c+l),e),e+=l,c+=l;else for(;l--;)d[e++]=a[c++];this.b=e;d=this.f();e=this.b}break;case Ta:for(;e+g>d.length;)d=this.f({B:2});break;default:q(Error("invalid inflate mode"))}if(A)d.set(a.subarray(c,c+g),e),e+=g,c+=g;else for(;g--;)d[e++]=a[c++];this.c=c;this.b=e;this.a=d;break;case 1:this.r(Va,Wa);break;case 2:Xa(this);break;default:q(Error("unknown BTYPE: "+b))}}return this.z()}; +var Ya=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],Za=A?new Uint16Array(Ya):Ya,$a=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258],ab=A?new Uint16Array($a):$a,bb=[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,0,0],cb=A?new Uint8Array(bb):bb,db=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577],eb=A?new Uint16Array(db):db,fb=[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],gb=A?new Uint8Array(fb):fb,hb=new (A?Uint8Array:Array)(288),$,ib;$=0;for(ib=hb.length;$=$?8:255>=$?9:279>=$?7:8;var Va=ja(hb),jb=new (A?Uint8Array:Array)(30),kb,lb;kb=0;for(lb=jb.length;kb=g&&q(Error("input buffer is broken")),c|=e[f++]<>>a;b.e=d-a;b.c=f;return k} +function mb(b,a){for(var c=b.j,d=b.e,e=b.input,f=b.c,g=e.length,k=a[0],h=a[1],l,s;d=g);)c|=e[f++]<>>16;b.j=c>>s;b.e=d-s;b.c=f;return l&65535} +function Xa(b){function a(a,b,c){var d,e=this.I,f,g;for(g=0;gf)d>=e&&(this.b=d,c=this.f(),d=this.b),c[d++]=f;else{g=f-257;h=ab[g];0=e&&(this.b=d,c=this.f(),d=this.b);for(;h--;)c[d]=c[d++-k]}for(;8<=this.e;)this.e-=8,this.c--;this.b=d}; +Y.prototype.R=function(b,a){var c=this.a,d=this.b;this.A=b;for(var e=c.length,f,g,k,h;256!==(f=mb(this,b));)if(256>f)d>=e&&(c=this.f(),e=c.length),c[d++]=f;else{g=f-257;h=ab[g];0e&&(c=this.f(),e=c.length);for(;h--;)c[d]=c[d++-k]}for(;8<=this.e;)this.e-=8,this.c--;this.b=d}; +Y.prototype.f=function(){var b=new (A?Uint8Array:Array)(this.b-32768),a=this.b-32768,c,d,e=this.a;if(A)b.set(e.subarray(32768,b.length));else{c=0;for(d=b.length;cc;++c)e[c]=e[a+c];this.b=32768;return e}; +Y.prototype.T=function(b){var a,c=this.input.length/this.c+1|0,d,e,f,g=this.input,k=this.a;b&&("number"===typeof b.B&&(c=b.B),"number"===typeof b.N&&(c+=b.N));2>c?(d=(g.length-this.c)/this.A[2],f=258*(d/2)|0,e=fa&&(this.a.length=a),b=this.a);return this.buffer=b};function nb(b){this.input=b;this.c=0;this.G=[];this.S=!1} +nb.prototype.i=function(){for(var b=this.input.length;this.c>>0;R(e,t,t)!==s&&q(Error("invalid CRC-32 checksum: 0x"+R(e,t,t).toString(16)+" / 0x"+ +s.toString(16)));a.$=c=(p[m++]|p[m++]<<8|p[m++]<<16|p[m++]<<24)>>>0;(e.length&4294967295)!==c&&q(Error("invalid input size: "+(e.length&4294967295)+" / "+c));this.G.push(a);this.c=m}this.S=v;var n=this.G,r,u,x=0,O=0,y;r=0;for(u=n.length;r>>0;b=a}for(var e=1,f=0,g=b.length,k,h=0;0>>0};function pb(b,a){var c,d;this.input=b;this.c=0;if(a||!(a={}))a.index&&(this.c=a.index),a.verify&&(this.W=a.verify);c=b[this.c++];d=b[this.c++];switch(c&15){case rb:this.method=rb;break;default:q(Error("unsupported compression method"))}0!==((c<<8)+d)%31&&q(Error("invalid fcheck flag:"+((c<<8)+d)%31));d&32&&q(Error("fdict flag is not supported"));this.K=new Y(b,{index:this.c,bufferSize:a.bufferSize,bufferType:a.bufferType,resize:a.resize})} +pb.prototype.i=function(){var b=this.input,a,c;a=this.K.i();this.c=this.K.c;this.W&&(c=(b[this.c++]<<24|b[this.c++]<<16|b[this.c++]<<8|b[this.c++])>>>0,c!==ob(a)&&q(Error("invalid adler-32 checksum")));return a};var rb=8;function sb(b,a){this.input=b;this.a=new (A?Uint8Array:Array)(32768);this.k=tb.t;var c={},d;if((a||!(a={}))&&"number"===typeof a.compressionType)this.k=a.compressionType;for(d in a)c[d]=a[d];c.outputBuffer=this.a;this.J=new ma(this.input,c)}var tb=oa; +sb.prototype.h=function(){var b,a,c,d,e,f,g,k=0;g=this.a;b=rb;switch(b){case rb:a=Math.LOG2E*Math.log(32768)-8;break;default:q(Error("invalid compression method"))}c=a<<4|b;g[k++]=c;switch(b){case rb:switch(this.k){case tb.NONE:e=0;break;case tb.M:e=1;break;case tb.t:e=2;break;default:q(Error("unsupported compression type"))}break;default:q(Error("invalid compression method"))}d=e<<6|0;g[k++]=d|31-(256*c+d)%31;f=ob(this.input);this.J.b=k;g=this.J.h();k=g.length;A&&(g=new Uint8Array(g.buffer),g.length<= +k+4&&(this.a=new Uint8Array(g.length+4),this.a.set(g),g=this.a),g=g.subarray(0,k+4));g[k++]=f>>24&255;g[k++]=f>>16&255;g[k++]=f>>8&255;g[k++]=f&255;return g};exports.deflate=ub;exports.deflateSync=vb;exports.inflate=wb;exports.inflateSync=xb;exports.gzip=yb;exports.gzipSync=zb;exports.gunzip=Ab;exports.gunzipSync=Bb;function ub(b,a,c){process.nextTick(function(){var d,e;try{e=vb(b,c)}catch(f){d=f}a(d,e)})}function vb(b,a){var c;c=(new sb(b)).h();a||(a={});return a.H?c:Cb(c)}function wb(b,a,c){process.nextTick(function(){var d,e;try{e=xb(b,c)}catch(f){d=f}a(d,e)})} +function xb(b,a){var c;b.subarray=b.slice;c=(new pb(b)).i();a||(a={});return a.noBuffer?c:Cb(c)}function yb(b,a,c){process.nextTick(function(){var d,e;try{e=zb(b,c)}catch(f){d=f}a(d,e)})}function zb(b,a){var c;b.subarray=b.slice;c=(new Aa(b)).h();a||(a={});return a.H?c:Cb(c)}function Ab(b,a,c){process.nextTick(function(){var d,e;try{e=Bb(b,c)}catch(f){d=f}a(d,e)})}function Bb(b,a){var c;b.subarray=b.slice;c=(new nb(b)).i();a||(a={});return a.H?c:Cb(c)} +function Cb(b){var a=new Buffer(b.length),c,d;c=0;for(d=b.length;c