commit fa6e6f175dc4946e79dc429056ea6e1dd0b1b6dc Author: Eric Wood Date: Mon Oct 29 14:40:39 2012 -0500 Initial commit. Works like a charm. diff --git a/converter.js b/converter.js new file mode 100644 index 0000000..06231bf --- /dev/null +++ b/converter.js @@ -0,0 +1,135 @@ +excelParser = { + parseStringTable: function(data) { + var doc = $(data); + var stringTags = doc.find('si'); + var strings = $.map(stringTags, function(s,i) { + return $(s).find('t').text(); + }); + + return strings; + }, + + toLatex: function(table) { + var max = 0; + for(var i=0; i < table.length; i++) { + if(table[i] && table[i].length > max) { max = table[i].length; } + } + + var numCols = max; + var args = []; + for(var i=0; i < numCols; i++) { + args[i] = 'l'; + } + args = ' | ' + args.join(' | ') + ' | '; + var latex = "\\begin{tabular}{" + args + "}\n\\hline\n"; + for(var i=0; i < table.length; i++) { + var cols = table[i]; + // TODO: replace "&" with "\&" + if(cols === undefined) { cols = []; } + if(cols.length < numCols) { + for(var x=cols.length; x < max; x++) { + cols[x] = '\\ '; + } + } + + latex += "\t" + cols.join(' & '); + latex += " \\\\ \\hline\n"; + } + + latex += "\\end{tabular}\n"; + + $('#latex-output').val(latex); + }, + + processSheet: function(data, stringTable) { + // get jQuery object out of the data for accessing stuffs + var doc = $(data); + + var table = []; + + var rows = doc.find('sheetdata row'); + $.each(rows, function(i,row) { + var rowNum = parseInt($(row).attr('r')); + + // get columns + var cols = $(row).find('c'); + var colVals = $.map(cols, function(col,j) { + var col = $(col); + var val = col.find('v').text(); + if(col.attr('t') == 's') { + return stringTable[parseInt(val)]; + } else { + return val; + } + }); + table[rowNum-1] = colVals; + }); + + return table; + }, + + handleSheet: function(entries, stringTable) { + // filter out all files that aren't worksheets + var sheets = $.grep(entries, function(n,i) { + return /^xl\/worksheets\//.test(n.filename); + }); + + // for now, only process the first sheet + // TODO: give the user a choice of which sheet to process + var sheet = sheets[0]; + sheet.getData(new zip.TextWriter(), function(text) { + var table = excelParser.processSheet(text, stringTable); + excelParser.toLatex(table); + }); + }, + + handleFile: function(event) { + // prevent default browser behavior + event.stopPropagation(); + event.preventDefault(); + + // get file information + var files = event.dataTransfer.files; + if(!files.length) { + // no files were given somehow... + $('#latex-output').val('No files were given...try again?'); + return false; + } + + var blob = files[0]; + + // unzip and process files + zip.createReader(new zip.BlobReader(blob), function(reader) { + reader.getEntries(function(entries) { + if(!entries.length) { return false; } + + // get the string table + var stFile = $.grep(entries, function(n,i) { + return /^xl\/sharedStrings\.xml$/.test(n.filename); + })[0]; + + stFile.getData(new zip.TextWriter(), function(text) { + var stringTable = excelParser.parseStringTable(text); + excelParser.handleSheet(entries, stringTable); + }); + + }); + }); + }, + + init: function() { + // hack because of jQuery shenanigans + jQuery.event.props.push('dataTransfer'); + + $('body').bind('dragover', function(event) { + event.stopPropagation(); + event.preventDefault(); + }); + + $('body').bind('drop', excelParser.handleFile); + } +}; + +$(function() { + excelParser.init(); +}); diff --git a/deflate.js b/deflate.js new file mode 100644 index 0000000..4d22565 --- /dev/null +++ b/deflate.js @@ -0,0 +1,2127 @@ +/* + Copyright (c) 2012 Gildas Lormeau. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the distribution. + + 3. The names of the authors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, + INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, + INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This program is based on JZlib 1.0.2 ymnk, JCraft,Inc. + * JZlib is based on zlib-1.1.3, so all credit should go authors + * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) + * and contributors of zlib. + */ + +(function(obj) { + + // Global + + var MAX_BITS = 15; + var D_CODES = 30; + var BL_CODES = 19; + + var LENGTH_CODES = 29; + var LITERALS = 256; + var L_CODES = (LITERALS + 1 + LENGTH_CODES); + var HEAP_SIZE = (2 * L_CODES + 1); + + var END_BLOCK = 256; + + // Bit length codes must not exceed MAX_BL_BITS bits + var MAX_BL_BITS = 7; + + // repeat previous bit length 3-6 times (2 bits of repeat count) + var REP_3_6 = 16; + + // repeat a zero length 3-10 times (3 bits of repeat count) + var REPZ_3_10 = 17; + + // repeat a zero length 11-138 times (7 bits of repeat count) + var REPZ_11_138 = 18; + + // The lengths of the bit length codes are sent in order of decreasing + // probability, to avoid transmitting the lengths for unused bit + // length codes. + + var Buf_size = 8 * 2; + + // JZlib version : "1.0.2" + var Z_DEFAULT_COMPRESSION = -1; + + // compression strategy + var Z_FILTERED = 1; + var Z_HUFFMAN_ONLY = 2; + var Z_DEFAULT_STRATEGY = 0; + + var Z_NO_FLUSH = 0; + var Z_PARTIAL_FLUSH = 1; + var Z_FULL_FLUSH = 3; + var Z_FINISH = 4; + + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_NEED_DICT = 2; + var Z_STREAM_ERROR = -2; + var Z_DATA_ERROR = -3; + var Z_BUF_ERROR = -5; + + // Tree + + // see definition of array dist_code below + var DIST_CODE_LEN = 512; + + var _dist_code = [ 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, 18, 18, 19, 19, + 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, + 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 ]; + + function Tree() { + var that = this; + + // dyn_tree; // the dynamic tree + // max_code; // largest code with non zero frequency + // stat_desc; // the corresponding static tree + + // 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. + function gen_bitlen(s) { + var tree = that.dyn_tree; + var stree = that.stat_desc.static_tree; + var extra = that.stat_desc.extra_bits; + var base = that.stat_desc.extra_base; + var max_length = that.stat_desc.max_length; + var h; // heap index + var n, m; // iterate over the tree elements + var bits; // bit length + var xbits; // extra bits + var f; // frequency + var overflow = 0; // number of elements with bit length too large + + for (bits = 0; bits <= MAX_BITS; bits++) + s.bl_count[bits] = 0; + + // In a first pass, compute the optimal bit lengths (which may + // overflow in the case of the bit length tree). + tree[s.heap[s.heap_max] * 2 + 1] = 0; // root of the heap + + for (h = s.heap_max + 1; h < HEAP_SIZE; h++) { + n = s.heap[h]; + bits = tree[tree[n * 2 + 1] * 2 + 1] + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n * 2 + 1] = bits; + // We overwrite tree[n*2+1] which is no longer needed + + if (n > that.max_code) + continue; // not a leaf node + + s.bl_count[bits]++; + xbits = 0; + if (n >= base) + xbits = extra[n - base]; + f = tree[n * 2]; + s.opt_len += f * (bits + xbits); + if (stree) + s.static_len += f * (stree[n * 2 + 1] + 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 (s.bl_count[bits] === 0) + bits--; + s.bl_count[bits]--; // move one leaf down the tree + s.bl_count[bits + 1] += 2; // move one overflow item as its brother + s.bl_count[max_length]--; + // The brother of the overflow item also moves one step up, + // but this does not affect bl_count[max_length] + overflow -= 2; + } while (overflow > 0); + + for (bits = max_length; bits !== 0; bits--) { + n = s.bl_count[bits]; + while (n !== 0) { + m = s.heap[--h]; + if (m > that.max_code) + continue; + if (tree[m * 2 + 1] != bits) { + s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2]; + tree[m * 2 + 1] = bits; + } + n--; + } + } + } + + // Reverse the first len bits of a code, using straightforward code (a + // faster + // method would use a table) + // IN assertion: 1 <= len <= 15 + function bi_reverse(code, // 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; + } + + // 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. + function gen_codes(tree, // the tree to decorate + max_code, // largest code with non zero frequency + bl_count // number of codes at each bit length + ) { + var next_code = []; // next code value for each + // bit length + var code = 0; // running code value + var bits; // bit index + var n; // code index + var len; + + // The distribution counts are first used to generate the code values + // without bit reversal. + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = ((code + bl_count[bits - 1]) << 1); + } + + // Check that the bit counts in bl_count are consistent. The last code + // must be all ones. + // Assert (code + bl_count[MAX_BITS]-1 == (1<= 1; n--) + s.pqdownheap(tree, n); + + // Construct the Huffman tree by repeatedly combining the least two + // frequent nodes. + + node = elems; // next internal node of the tree + do { + // n = node of least frequency + n = s.heap[1]; + s.heap[1] = s.heap[s.heap_len--]; + s.pqdownheap(tree, 1); + m = s.heap[1]; // m = node of next least frequency + + s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency + s.heap[--s.heap_max] = m; + + // Create a new node father of n and m + tree[node * 2] = (tree[n * 2] + tree[m * 2]); + s.depth[node] = Math.max(s.depth[n], s.depth[m]) + 1; + tree[n * 2 + 1] = tree[m * 2 + 1] = node; + + // and insert the new node in the heap + s.heap[1] = node++; + s.pqdownheap(tree, 1); + } while (s.heap_len >= 2); + + s.heap[--s.heap_max] = s.heap[1]; + + // At this point, the fields freq and dad are set. We can now + // generate the bit lengths. + + gen_bitlen(s); + + // The field len is now set, we can generate the bit codes + gen_codes(tree, that.max_code, s.bl_count); + }; + + } + + Tree._length_code = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, + 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, + 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 ]; + + Tree.base_length = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0 ]; + + Tree.base_dist = [ 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, + 24576 ]; + + // 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. + Tree.d_code = function(dist) { + return ((dist) < 256 ? _dist_code[dist] : _dist_code[256 + ((dist) >>> 7)]); + }; + + // extra bits for each length code + Tree.extra_lbits = [ 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 ]; + + // extra bits for each distance code + Tree.extra_dbits = [ 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 ]; + + // extra bits for each bit length code + Tree.extra_blbits = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 ]; + + Tree.bl_order = [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]; + + // StaticTree + + function StaticTree(static_tree, extra_bits, extra_base, elems, max_length) { + var that = this; + that.static_tree = static_tree; + that.extra_bits = extra_bits; + that.extra_base = extra_base; + that.elems = elems; + that.max_length = max_length; + } + + StaticTree.static_ltree = [ 12, 8, 140, 8, 76, 8, 204, 8, 44, 8, 172, 8, 108, 8, 236, 8, 28, 8, 156, 8, 92, 8, 220, 8, 60, 8, 188, 8, 124, 8, 252, 8, 2, 8, + 130, 8, 66, 8, 194, 8, 34, 8, 162, 8, 98, 8, 226, 8, 18, 8, 146, 8, 82, 8, 210, 8, 50, 8, 178, 8, 114, 8, 242, 8, 10, 8, 138, 8, 74, 8, 202, 8, 42, + 8, 170, 8, 106, 8, 234, 8, 26, 8, 154, 8, 90, 8, 218, 8, 58, 8, 186, 8, 122, 8, 250, 8, 6, 8, 134, 8, 70, 8, 198, 8, 38, 8, 166, 8, 102, 8, 230, 8, + 22, 8, 150, 8, 86, 8, 214, 8, 54, 8, 182, 8, 118, 8, 246, 8, 14, 8, 142, 8, 78, 8, 206, 8, 46, 8, 174, 8, 110, 8, 238, 8, 30, 8, 158, 8, 94, 8, + 222, 8, 62, 8, 190, 8, 126, 8, 254, 8, 1, 8, 129, 8, 65, 8, 193, 8, 33, 8, 161, 8, 97, 8, 225, 8, 17, 8, 145, 8, 81, 8, 209, 8, 49, 8, 177, 8, 113, + 8, 241, 8, 9, 8, 137, 8, 73, 8, 201, 8, 41, 8, 169, 8, 105, 8, 233, 8, 25, 8, 153, 8, 89, 8, 217, 8, 57, 8, 185, 8, 121, 8, 249, 8, 5, 8, 133, 8, + 69, 8, 197, 8, 37, 8, 165, 8, 101, 8, 229, 8, 21, 8, 149, 8, 85, 8, 213, 8, 53, 8, 181, 8, 117, 8, 245, 8, 13, 8, 141, 8, 77, 8, 205, 8, 45, 8, + 173, 8, 109, 8, 237, 8, 29, 8, 157, 8, 93, 8, 221, 8, 61, 8, 189, 8, 125, 8, 253, 8, 19, 9, 275, 9, 147, 9, 403, 9, 83, 9, 339, 9, 211, 9, 467, 9, + 51, 9, 307, 9, 179, 9, 435, 9, 115, 9, 371, 9, 243, 9, 499, 9, 11, 9, 267, 9, 139, 9, 395, 9, 75, 9, 331, 9, 203, 9, 459, 9, 43, 9, 299, 9, 171, 9, + 427, 9, 107, 9, 363, 9, 235, 9, 491, 9, 27, 9, 283, 9, 155, 9, 411, 9, 91, 9, 347, 9, 219, 9, 475, 9, 59, 9, 315, 9, 187, 9, 443, 9, 123, 9, 379, + 9, 251, 9, 507, 9, 7, 9, 263, 9, 135, 9, 391, 9, 71, 9, 327, 9, 199, 9, 455, 9, 39, 9, 295, 9, 167, 9, 423, 9, 103, 9, 359, 9, 231, 9, 487, 9, 23, + 9, 279, 9, 151, 9, 407, 9, 87, 9, 343, 9, 215, 9, 471, 9, 55, 9, 311, 9, 183, 9, 439, 9, 119, 9, 375, 9, 247, 9, 503, 9, 15, 9, 271, 9, 143, 9, + 399, 9, 79, 9, 335, 9, 207, 9, 463, 9, 47, 9, 303, 9, 175, 9, 431, 9, 111, 9, 367, 9, 239, 9, 495, 9, 31, 9, 287, 9, 159, 9, 415, 9, 95, 9, 351, 9, + 223, 9, 479, 9, 63, 9, 319, 9, 191, 9, 447, 9, 127, 9, 383, 9, 255, 9, 511, 9, 0, 7, 64, 7, 32, 7, 96, 7, 16, 7, 80, 7, 48, 7, 112, 7, 8, 7, 72, 7, + 40, 7, 104, 7, 24, 7, 88, 7, 56, 7, 120, 7, 4, 7, 68, 7, 36, 7, 100, 7, 20, 7, 84, 7, 52, 7, 116, 7, 3, 8, 131, 8, 67, 8, 195, 8, 35, 8, 163, 8, + 99, 8, 227, 8 ]; + + StaticTree.static_dtree = [ 0, 5, 16, 5, 8, 5, 24, 5, 4, 5, 20, 5, 12, 5, 28, 5, 2, 5, 18, 5, 10, 5, 26, 5, 6, 5, 22, 5, 14, 5, 30, 5, 1, 5, 17, 5, 9, 5, + 25, 5, 5, 5, 21, 5, 13, 5, 29, 5, 3, 5, 19, 5, 11, 5, 27, 5, 7, 5, 23, 5 ]; + + StaticTree.static_l_desc = new StaticTree(StaticTree.static_ltree, Tree.extra_lbits, LITERALS + 1, L_CODES, MAX_BITS); + + StaticTree.static_d_desc = new StaticTree(StaticTree.static_dtree, Tree.extra_dbits, 0, D_CODES, MAX_BITS); + + StaticTree.static_bl_desc = new StaticTree(null, Tree.extra_blbits, 0, BL_CODES, MAX_BL_BITS); + + // Deflate + + var MAX_MEM_LEVEL = 9; + var DEF_MEM_LEVEL = 8; + + function Config(good_length, max_lazy, nice_length, max_chain, func) { + var that = this; + that.good_length = good_length; + that.max_lazy = max_lazy; + that.nice_length = nice_length; + that.max_chain = max_chain; + that.func = func; + } + + var STORED = 0; + var FAST = 1; + var SLOW = 2; + var config_table = [ new Config(0, 0, 0, 0, STORED), new Config(4, 4, 8, 4, FAST), new Config(4, 5, 16, 8, FAST), new Config(4, 6, 32, 32, FAST), + new Config(4, 4, 16, 16, SLOW), new Config(8, 16, 32, 32, SLOW), new Config(8, 16, 128, 128, SLOW), new Config(8, 32, 128, 256, SLOW), + new Config(32, 128, 258, 1024, SLOW), new Config(32, 258, 258, 4096, SLOW) ]; + + var z_errmsg = [ "need dictionary", // Z_NEED_DICT + // 2 + "stream end", // Z_STREAM_END 1 + "", // Z_OK 0 + "", // Z_ERRNO (-1) + "stream error", // Z_STREAM_ERROR (-2) + "data error", // Z_DATA_ERROR (-3) + "", // Z_MEM_ERROR (-4) + "buffer error", // Z_BUF_ERROR (-5) + "",// Z_VERSION_ERROR (-6) + "" ]; + + // block not completed, need more input or more output + var NeedMore = 0; + + // block flush performed + var BlockDone = 1; + + // finish started, need only more output at next deflate + var FinishStarted = 2; + + // finish done, accept no more input or output + var FinishDone = 3; + + // preset dictionary flag in zlib header + var PRESET_DICT = 0x20; + + var INIT_STATE = 42; + var BUSY_STATE = 113; + var FINISH_STATE = 666; + + // The deflate compression method + var Z_DEFLATED = 8; + + var STORED_BLOCK = 0; + var STATIC_TREES = 1; + var DYN_TREES = 2; + + // The three kinds of block type + var Z_BINARY = 0; + var Z_ASCII = 1; + var Z_UNKNOWN = 2; + + var MIN_MATCH = 3; + var MAX_MATCH = 258; + var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1); + + function smaller(tree, n, m, depth) { + var tn2 = tree[n * 2]; + var tm2 = tree[m * 2]; + return (tn2 < tm2 || (tn2 == tm2 && depth[n] <= depth[m])); + } + + function Deflate() { + + var that = this; + var strm; // pointer back to this zlib stream + var status; // as the name implies + // pending_buf; // output still pending + var pending_buf_size; // size of pending_buf + // pending_out; // next pending byte to output to the stream + // pending; // nb of bytes in the pending buffer + // data_type; // UNKNOWN, BINARY or ASCII + var method; // STORED (for zip only) or DEFLATED + var last_flush; // value of flush param for previous deflate call + + var w_size; // LZ77 window size (32K by default) + var w_bits; // log2(w_size) (8..16) + var w_mask; // w_size - 1 + + var window; + // Sliding window. Input bytes are read into the second half of the window, + // and move to the first half later to keep a dictionary of at least wSize + // bytes. With this organization, matches are limited to a distance of + // wSize-MAX_MATCH bytes, but this ensures that IO is always + // performed with a length multiple of the block size. Also, it limits + // the window size to 64K, which is quite useful on MSDOS. + // To do: use the user input buffer as sliding window. + + var window_size; + // Actual size of window: 2*wSize, except when the user input buffer + // is directly used as sliding window. + + var prev; + // Link to older string with same hash index. To limit the size of this + // array to 64K, this link is maintained only for the last 32K strings. + // An index in this array is thus a window index modulo 32K. + + var head; // Heads of the hash chains or NIL. + + var ins_h; // hash index of string to be inserted + var hash_size; // number of elements in hash table + var hash_bits; // log2(hash_size) + var hash_mask; // hash_size-1 + + // Number of bits by which ins_h must be shifted at each input + // step. It must be such that after MIN_MATCH steps, the oldest + // byte no longer takes part in the hash key, that is: + // hash_shift * MIN_MATCH >= hash_bits + var hash_shift; + + // Window position at the beginning of the current output block. Gets + // negative when the window is moved backwards. + + var block_start; + + var match_length; // length of best match + var prev_match; // previous match + var match_available; // set if previous match exists + var strstart; // start of string to insert + var match_start; // start of matching string + var lookahead; // number of valid bytes ahead in window + + // Length of the best match at previous step. Matches not greater than this + // are discarded. This is used in the lazy match evaluation. + var prev_length; + + // To speed up deflation, hash chains are never searched beyond this + // length. A higher limit improves compression ratio but degrades the speed. + var max_chain_length; + + // Attempt to find a better match only when the current match is strictly + // smaller than this value. This mechanism is used only for compression + // levels >= 4. + var max_lazy_match; + + // Insert new strings in the hash table only if the match length is not + // greater than this length. This saves time but degrades compression. + // max_insert_length is used only for compression levels <= 3. + + var level; // compression level (1..9) + var strategy; // favor or force Huffman coding + + // Use a faster search when the previous match is longer than this + var good_match; + + // Stop searching when current match exceeds this + var nice_match; + + var dyn_ltree; // literal and length tree + var dyn_dtree; // distance tree + var bl_tree; // Huffman tree for bit lengths + + var l_desc = new Tree(); // desc for literal tree + var d_desc = new Tree(); // desc for distance tree + var bl_desc = new Tree(); // desc for bit length tree + + // that.heap_len; // number of elements in the heap + // that.heap_max; // element of largest frequency + // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + // The same heap array is used to build all trees. + + // Depth of each subtree used as tie breaker for trees of equal frequency + that.depth = []; + + var l_buf; // index for literals or lengths */ + + // Size of match buffer for literals/lengths. There are 4 reasons for + // limiting lit_bufsize to 64K: + // - frequencies can be kept in 16 bit counters + // - if compression is not successful for the first block, all input + // data is still in the window so we can still emit a stored block even + // when input comes from standard input. (This can also be done for + // all blocks if lit_bufsize is not greater than 32K.) + // - if compression is not successful for a file smaller than 64K, we can + // even emit a stored file instead of a stored block (saving 5 bytes). + // This is applicable only for zip (not gzip or zlib). + // - creating new Huffman trees less frequently may not provide fast + // adaptation to changes in the input data statistics. (Take for + // example a binary file with poorly compressible code followed by + // a highly compressible string table.) Smaller buffer sizes give + // fast adaptation but have of course the overhead of transmitting + // trees more frequently. + // - I can't count above 4 + var lit_bufsize; + + var last_lit; // running index in l_buf + + // Buffer for distances. To simplify the code, d_buf and l_buf have + // the same number of elements. To use different lengths, an extra flag + // array would be necessary. + + var d_buf; // index of pendig_buf + + // that.opt_len; // bit length of current block with optimal trees + // that.static_len; // bit length of current block with static trees + var matches; // number of string matches in current block + var last_eob_len; // bit length of EOB code for last block + + // Output buffer. bits are inserted starting at the bottom (least + // significant bits). + var bi_buf; + + // Number of valid bits in bi_buf. All bits above the last valid bit + // are always zero. + var bi_valid; + + // number of codes at each bit length for an optimal tree + that.bl_count = []; + + // heap used to build the Huffman trees + that.heap = []; + + dyn_ltree = []; + dyn_dtree = []; + bl_tree = []; + + function lm_init() { + var i; + window_size = 2 * w_size; + + head[hash_size - 1] = 0; + for (i = 0; i < hash_size - 1; i++) { + head[i] = 0; + } + + // Set the default configuration parameters: + max_lazy_match = config_table[level].max_lazy; + good_match = config_table[level].good_length; + nice_match = config_table[level].nice_length; + max_chain_length = config_table[level].max_chain; + + strstart = 0; + block_start = 0; + lookahead = 0; + match_length = prev_length = MIN_MATCH - 1; + match_available = 0; + ins_h = 0; + } + + function init_block() { + var i; + // Initialize the trees. + for (i = 0; i < L_CODES; i++) + dyn_ltree[i * 2] = 0; + for (i = 0; i < D_CODES; i++) + dyn_dtree[i * 2] = 0; + for (i = 0; i < BL_CODES; i++) + bl_tree[i * 2] = 0; + + dyn_ltree[END_BLOCK * 2] = 1; + that.opt_len = that.static_len = 0; + last_lit = matches = 0; + } + + // Initialize the tree data structures for a new zlib stream. + function tr_init() { + + l_desc.dyn_tree = dyn_ltree; + l_desc.stat_desc = StaticTree.static_l_desc; + + d_desc.dyn_tree = dyn_dtree; + d_desc.stat_desc = StaticTree.static_d_desc; + + bl_desc.dyn_tree = bl_tree; + bl_desc.stat_desc = StaticTree.static_bl_desc; + + bi_buf = 0; + bi_valid = 0; + last_eob_len = 8; // enough lookahead for inflate + + // Initialize the first block of the first file: + init_block(); + } + + // 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). + that.pqdownheap = function(tree, // the tree to restore + k // node to move down + ) { + var heap = that.heap; + var v = heap[k]; + var j = k << 1; // left son of k + while (j <= that.heap_len) { + // Set j to the smallest of the two sons: + if (j < that.heap_len && smaller(tree, heap[j + 1], heap[j], that.depth)) { + j++; + } + // Exit if v is smaller than both sons + if (smaller(tree, v, heap[j], that.depth)) + break; + + // Exchange v with the smallest son + heap[k] = heap[j]; + k = j; + // And continue down the tree, setting j to the left son of k + j <<= 1; + } + heap[k] = v; + }; + + // Scan a literal or distance tree to determine the frequencies of the codes + // in the bit length tree. + function scan_tree(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 * 2 + 1]; // 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) * 2 + 1] = 0xffff; // guard + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + bl_tree[curlen * 2] += count; + } else if (curlen !== 0) { + if (curlen != prevlen) + bl_tree[curlen * 2]++; + bl_tree[REP_3_6 * 2]++; + } else if (count <= 10) { + bl_tree[REPZ_3_10 * 2]++; + } else { + bl_tree[REPZ_11_138 * 2]++; + } + 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. + function build_bl_tree() { + var max_blindex; // index of last bit length code of non zero freq + + // Determine the bit length frequencies for literal and distance trees + scan_tree(dyn_ltree, l_desc.max_code); + scan_tree(dyn_dtree, d_desc.max_code); + + // Build the bit length tree: + bl_desc.build_tree(that); + // 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 = BL_CODES - 1; max_blindex >= 3; max_blindex--) { + if (bl_tree[Tree.bl_order[max_blindex] * 2 + 1] !== 0) + break; + } + // Update opt_len to include the bit length tree and counts + that.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + + return max_blindex; + } + + // Output a byte on the stream. + // IN assertion: there is enough room in pending_buf. + function put_byte(p) { + that.pending_buf[that.pending++] = p; + } + + function put_short(w) { + put_byte(w & 0xff); + put_byte((w >>> 8) & 0xff); + } + + function putShortMSB(b) { + put_byte((b >> 8) & 0xff); + put_byte((b & 0xff) & 0xff); + } + + function send_bits(value, length) { + var val, len = length; + if (bi_valid > Buf_size - len) { + val = value; + // bi_buf |= (val << bi_valid); + bi_buf |= ((val << bi_valid) & 0xffff); + put_short(bi_buf); + bi_buf = val >>> (Buf_size - bi_valid); + bi_valid += len - Buf_size; + } else { + // bi_buf |= (value) << bi_valid; + bi_buf |= (((value) << bi_valid) & 0xffff); + bi_valid += len; + } + } + + function send_code(c, tree) { + var c2 = c * 2; + send_bits(tree[c2] & 0xffff, tree[c2 + 1] & 0xffff); + } + + // Send a literal or distance tree in compressed form, using the codes in + // bl_tree. + function send_tree(tree,// the tree to be sent + max_code // and its largest code of non zero frequency + ) { + var n; // iterates over all tree elements + var prevlen = -1; // last emitted length + var curlen; // length of current code + var nextlen = tree[0 * 2 + 1]; // 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; + } + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + do { + send_code(curlen, bl_tree); + } while (--count !== 0); + } else if (curlen !== 0) { + if (curlen != prevlen) { + send_code(curlen, bl_tree); + count--; + } + send_code(REP_3_6, bl_tree); + send_bits(count - 3, 2); + } else if (count <= 10) { + send_code(REPZ_3_10, bl_tree); + send_bits(count - 3, 3); + } else { + send_code(REPZ_11_138, bl_tree); + 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; + } + } + } + + // Send the header for a block using dynamic Huffman trees: the counts, the + // lengths of the bit length codes, the literal tree and the distance tree. + // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + function send_all_trees(lcodes, dcodes, blcodes) { + var rank; // index in bl_order + + send_bits(lcodes - 257, 5); // not +255 as stated in appnote.txt + send_bits(dcodes - 1, 5); + send_bits(blcodes - 4, 4); // not -3 as stated in appnote.txt + for (rank = 0; rank < blcodes; rank++) { + send_bits(bl_tree[Tree.bl_order[rank] * 2 + 1], 3); + } + send_tree(dyn_ltree, lcodes - 1); // literal tree + send_tree(dyn_dtree, dcodes - 1); // distance tree + } + + // Flush the bit buffer, keeping at most 7 bits in it. + function bi_flush() { + if (bi_valid == 16) { + put_short(bi_buf); + bi_buf = 0; + bi_valid = 0; + } else if (bi_valid >= 8) { + put_byte(bi_buf & 0xff); + bi_buf >>>= 8; + bi_valid -= 8; + } + } + + // Send one empty static block to give enough lookahead for inflate. + // This takes 10 bits, of which 7 may remain in the bit buffer. + // The current inflate code requires 9 bits of lookahead. If the + // last two codes for the previous block (real code plus EOB) were coded + // on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode + // the last real code. In this case we send two empty static blocks instead + // of one. (There are no problems if the previous block is stored or fixed.) + // To simplify the code, we assume the worst case of last real code encoded + // on one bit only. + function _tr_align() { + send_bits(STATIC_TREES << 1, 3); + send_code(END_BLOCK, StaticTree.static_ltree); + + bi_flush(); + + // Of the 10 bits for the empty block, we have already sent + // (10 - bi_valid) bits. The lookahead for the last real code (before + // the EOB of the previous block) was thus at least one plus the length + // of the EOB plus what we have just sent of the empty static block. + if (1 + last_eob_len + 10 - bi_valid < 9) { + send_bits(STATIC_TREES << 1, 3); + send_code(END_BLOCK, StaticTree.static_ltree); + bi_flush(); + } + last_eob_len = 7; + } + + // Save the match info and tally the frequency counts. Return true if + // the current block must be flushed. + function _tr_tally(dist, // distance of matched string + lc // match length-MIN_MATCH or unmatched char (if dist==0) + ) { + var out_length, in_length, dcode; + that.pending_buf[d_buf + last_lit * 2] = (dist >>> 8) & 0xff; + that.pending_buf[d_buf + last_lit * 2 + 1] = dist & 0xff; + + that.pending_buf[l_buf + last_lit] = lc & 0xff; + last_lit++; + + if (dist === 0) { + // lc is the unmatched char + dyn_ltree[lc * 2]++; + } else { + matches++; + // Here, lc is the match length - MIN_MATCH + dist--; // dist = match distance - 1 + dyn_ltree[(Tree._length_code[lc] + LITERALS + 1) * 2]++; + dyn_dtree[Tree.d_code(dist) * 2]++; + } + + if ((last_lit & 0x1fff) === 0 && level > 2) { + // Compute an upper bound for the compressed length + out_length = last_lit * 8; + in_length = strstart - block_start; + for (dcode = 0; dcode < D_CODES; dcode++) { + out_length += dyn_dtree[dcode * 2] * (5 + Tree.extra_dbits[dcode]); + } + out_length >>>= 3; + if ((matches < Math.floor(last_lit / 2)) && out_length < Math.floor(in_length / 2)) + return true; + } + + return (last_lit == lit_bufsize - 1); + // We avoid equality with lit_bufsize because of wraparound at 64K + // on 16 bit machines and because stored blocks are restricted to + // 64K-1 bytes. + } + + // Send the block data compressed using the given Huffman trees + function compress_block(ltree, dtree) { + var dist; // distance of matched string + var lc; // match length or unmatched char (if dist === 0) + var lx = 0; // running index in l_buf + var code; // the code to send + var extra; // number of extra bits to send + + if (last_lit !== 0) { + do { + dist = ((that.pending_buf[d_buf + lx * 2] << 8) & 0xff00) | (that.pending_buf[d_buf + lx * 2 + 1] & 0xff); + lc = (that.pending_buf[l_buf + lx]) & 0xff; + lx++; + + if (dist === 0) { + send_code(lc, ltree); // send a literal byte + } else { + // Here, lc is the match length - MIN_MATCH + code = Tree._length_code[lc]; + + send_code(code + LITERALS + 1, ltree); // send the length + // code + extra = Tree.extra_lbits[code]; + if (extra !== 0) { + lc -= Tree.base_length[code]; + send_bits(lc, extra); // send the extra length bits + } + dist--; // dist is now the match distance - 1 + code = Tree.d_code(dist); + + send_code(code, dtree); // send the distance code + extra = Tree.extra_dbits[code]; + if (extra !== 0) { + dist -= Tree.base_dist[code]; + send_bits(dist, extra); // send the extra distance bits + } + } // literal or match pair ? + + // Check that the overlay between pending_buf and d_buf+l_buf is + // ok: + } while (lx < last_lit); + } + + send_code(END_BLOCK, ltree); + last_eob_len = ltree[END_BLOCK * 2 + 1]; + } + + // Set the data type to ASCII or BINARY, using a crude approximation: + // binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise. + // IN assertion: the fields freq of dyn_ltree are set and the total of all + // frequencies does not exceed 64K (to fit in an int on 16 bit machines). + function set_data_type() { + var n = 0; + var ascii_freq = 0; + var bin_freq = 0; + while (n < 7) { + bin_freq += dyn_ltree[n * 2]; + n++; + } + while (n < 128) { + ascii_freq += dyn_ltree[n * 2]; + n++; + } + while (n < LITERALS) { + bin_freq += dyn_ltree[n * 2]; + n++; + } + that.data_type = (bin_freq > (ascii_freq >>> 2) ? Z_BINARY : Z_ASCII) & 0xff; + } + + // Flush the bit buffer and align the output on a byte boundary + function bi_windup() { + if (bi_valid > 8) { + put_short(bi_buf); + } else if (bi_valid > 0) { + put_byte(bi_buf & 0xff); + } + bi_buf = 0; + bi_valid = 0; + } + + // Copy a stored block, storing first the length and its + // one's complement if requested. + function copy_block(buf, // the input data + len, // its length + header // true if block header must be written + ) { + var index = 0; + bi_windup(); // align on byte boundary + last_eob_len = 8; // enough lookahead for inflate + + if (header) { + put_short(len); + put_short(~len); + } + + that.pending_buf.set(window.subarray(buf, buf + len), that.pending); + that.pending += len; + } + + // Send a stored block + function _tr_stored_block(buf, // input block + stored_len, // length of input block + eof // true if this is the last block for a file + ) { + send_bits((STORED_BLOCK << 1) + (eof ? 1 : 0), 3); // send block type + copy_block(buf, stored_len, true); // with header + } + + // Determine the best encoding for the current block: dynamic trees, static + // trees or store, and output the encoded block to the zip file. + function _tr_flush_block(buf, // input block, or NULL if too old + stored_len, // length of input block + 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 = 0; // index of last bit length code of non zero freq + + // Build the Huffman trees unless a stored block is forced + if (level > 0) { + // Check if the file is ascii or binary + if (that.data_type == Z_UNKNOWN) + set_data_type(); + + // Construct the literal and distance trees + l_desc.build_tree(that); + + d_desc.build_tree(that); + + // 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 = build_bl_tree(); + + // Determine the best encoding. Compute first the block length in + // bytes + opt_lenb = (that.opt_len + 3 + 7) >>> 3; + static_lenb = (that.static_len + 3 + 7) >>> 3; + + if (static_lenb <= opt_lenb) + opt_lenb = static_lenb; + } else { + opt_lenb = static_lenb = stored_len + 5; // force a stored block + } + + if ((stored_len + 4 <= opt_lenb) && buf != -1) { + // 4: two words for the lengths + // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + // 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. + _tr_stored_block(buf, stored_len, eof); + } else if (static_lenb == opt_lenb) { + send_bits((STATIC_TREES << 1) + (eof ? 1 : 0), 3); + compress_block(StaticTree.static_ltree, StaticTree.static_dtree); + } else { + send_bits((DYN_TREES << 1) + (eof ? 1 : 0), 3); + send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, max_blindex + 1); + compress_block(dyn_ltree, dyn_dtree); + } + + // The above check is made mod 2^32, for files larger than 512 MB + // and uLong implemented on 32 bits. + + init_block(); + + if (eof) { + bi_windup(); + } + } + + function flush_block_only(eof) { + _tr_flush_block(block_start >= 0 ? block_start : -1, strstart - block_start, eof); + block_start = strstart; + strm.flush_pending(); + } + + // Fill the window when the lookahead becomes insufficient. + // Updates strstart and lookahead. + // + // IN assertion: lookahead < MIN_LOOKAHEAD + // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + // At least one byte has been read, or avail_in === 0; reads are + // performed for at least two bytes (required for the zip translate_eol + // option -- not supported here). + function fill_window() { + var n, m; + var p; + var more; // Amount of free space at the end of the window. + + do { + more = (window_size - lookahead - strstart); + + // Deal with !@#$% 64K limit: + if (more === 0 && strstart === 0 && lookahead === 0) { + more = w_size; + } else if (more == -1) { + // Very unlikely, but possible on 16 bit machine if strstart == + // 0 + // and lookahead == 1 (input done one byte at time) + more--; + + // 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. + } else if (strstart >= w_size + w_size - MIN_LOOKAHEAD) { + window.set(window.subarray(w_size, w_size + w_size), 0); + + match_start -= w_size; + strstart -= w_size; // we now have strstart >= MAX_DIST + block_start -= w_size; + + // Slide the hash table (could be avoided with 32 bit values + // at the expense of memory usage). We slide even when level == + // 0 + // to keep the hash table consistent if we switch back to level + // > 0 + // later. (Using level 0 permanently is not an optimal usage of + // zlib, so we don't care about this pathological case.) + + n = hash_size; + p = n; + do { + m = (head[--p] & 0xffff); + head[p] = (m >= w_size ? m - w_size : 0); + } while (--n !== 0); + + n = w_size; + p = n; + do { + m = (prev[--p] & 0xffff); + prev[p] = (m >= w_size ? m - w_size : 0); + // If n is not on any hash chain, prev[n] is garbage but + // its value will never be used. + } while (--n !== 0); + more += w_size; + } + + if (strm.avail_in === 0) + return; + + // If there was no sliding: + // strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + // more == window_size - lookahead - strstart + // => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + // => more >= window_size - 2*WSIZE + 2 + // In the BIG_MEM or MMAP case (not yet supported), + // window_size == input_size + MIN_LOOKAHEAD && + // strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + // Otherwise, window_size == 2*WSIZE so more >= 2. + // If there was sliding, more >= WSIZE. So in all cases, more >= 2. + + n = strm.read_buf(window, strstart + lookahead, more); + lookahead += n; + + // Initialize the hash value now that we have some input: + if (lookahead >= MIN_MATCH) { + ins_h = window[strstart] & 0xff; + ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask; + } + // If the whole input has less than MIN_MATCH bytes, ins_h is + // garbage, + // but this is not important since only literal bytes will be + // emitted. + } while (lookahead < MIN_LOOKAHEAD && strm.avail_in !== 0); + } + + // Copy without compression as much as possible from the input stream, + // return + // the current block state. + // This function does not insert new strings in the dictionary since + // uncompressible data is probably not useful. This function is used + // only for the level=0 compression option. + // NOTE: this function should be optimized to avoid extra copying from + // window to pending_buf. + function deflate_stored(flush) { + // Stored blocks are limited to 0xffff bytes, pending_buf is limited + // to pending_buf_size, and each stored block has a 5 byte header: + + var max_block_size = 0xffff; + var max_start; + + if (max_block_size > pending_buf_size - 5) { + max_block_size = pending_buf_size - 5; + } + + // Copy as much as possible from input to output: + while (true) { + // Fill the window as much as possible: + if (lookahead <= 1) { + fill_window(); + if (lookahead === 0 && flush == Z_NO_FLUSH) + return NeedMore; + if (lookahead === 0) + break; // flush the current block + } + + strstart += lookahead; + lookahead = 0; + + // Emit a stored block if pending_buf will be full: + max_start = block_start + max_block_size; + if (strstart === 0 || strstart >= max_start) { + // strstart === 0 is possible when wraparound on 16-bit machine + lookahead = (strstart - max_start); + strstart = max_start; + + flush_block_only(false); + if (strm.avail_out === 0) + return NeedMore; + + } + + // Flush if we may have to slide, otherwise block_start may become + // negative and the data will be gone: + if (strstart - block_start >= w_size - MIN_LOOKAHEAD) { + flush_block_only(false); + if (strm.avail_out === 0) + return NeedMore; + } + } + + flush_block_only(flush == Z_FINISH); + if (strm.avail_out === 0) + return (flush == Z_FINISH) ? FinishStarted : NeedMore; + + return flush == Z_FINISH ? FinishDone : BlockDone; + } + + function longest_match(cur_match) { + var chain_length = max_chain_length; // max hash chain length + var scan = strstart; // current string + var match; // matched string + var len; // length of current match + var best_len = prev_length; // best match length so far + var limit = strstart > (w_size - MIN_LOOKAHEAD) ? strstart - (w_size - MIN_LOOKAHEAD) : 0; + var _nice_match = nice_match; + + // Stop when cur_match becomes <= limit. To simplify the code, + // we prevent matches with the string of window index 0. + + var wmask = w_mask; + + var strend = strstart + MAX_MATCH; + var scan_end1 = window[scan + best_len - 1]; + var scan_end = window[scan + best_len]; + + // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of + // 16. + // It is easy to get rid of this optimization if necessary. + + // Do not waste too much time if we already have a good match: + if (prev_length >= good_match) { + chain_length >>= 2; + } + + // Do not look for matches beyond the end of the input. This is + // necessary + // to make deflate deterministic. + if (_nice_match > lookahead) + _nice_match = lookahead; + + do { + match = cur_match; + + // Skip to next match if the match length cannot increase + // or if the match length is less than 2: + if (window[match + best_len] != scan_end || window[match + best_len - 1] != scan_end1 || window[match] != window[scan] + || window[++match] != window[scan + 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. + scan += 2; + match++; + + // We check for insufficient lookahead only every 8th comparison; + // the 256th check will be made at strstart+258. + do { + } while (window[++scan] == window[++match] && window[++scan] == window[++match] && window[++scan] == window[++match] + && window[++scan] == window[++match] && window[++scan] == window[++match] && window[++scan] == window[++match] + && window[++scan] == window[++match] && window[++scan] == window[++match] && scan < strend); + + len = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + + if (len > best_len) { + match_start = cur_match; + best_len = len; + if (len >= _nice_match) + break; + scan_end1 = window[scan + best_len - 1]; + scan_end = window[scan + best_len]; + } + + } while ((cur_match = (prev[cur_match & wmask] & 0xffff)) > limit && --chain_length !== 0); + + if (best_len <= lookahead) + return best_len; + return lookahead; + } + + // Compress as much as possible from the input stream, return the current + // block state. + // This function does not perform lazy evaluation of 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. + function deflate_fast(flush) { + // short hash_head = 0; // head of the hash chain + var hash_head = 0; // head of the hash chain + var bflush; // set if current block must be flushed + + while (true) { + // 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. + if (lookahead < MIN_LOOKAHEAD) { + fill_window(); + if (lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return NeedMore; + } + if (lookahead === 0) + break; // flush the current block + } + + // Insert the string window[strstart .. strstart+2] in the + // dictionary, and set hash_head to the head of the hash chain: + if (lookahead >= MIN_MATCH) { + ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask; + + // prev[strstart&w_mask]=hash_head=head[ins_h]; + hash_head = (head[ins_h] & 0xffff); + prev[strstart & w_mask] = head[ins_h]; + head[ins_h] = strstart; + } + + // Find the longest match, discarding those <= prev_length. + // At this point we have always match_length < MIN_MATCH + + if (hash_head !== 0 && ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD) { + // 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). + if (strategy != Z_HUFFMAN_ONLY) { + match_length = longest_match(hash_head); + } + // longest_match() sets match_start + } + if (match_length >= MIN_MATCH) { + // check_match(strstart, match_start, match_length); + + bflush = _tr_tally(strstart - match_start, match_length - MIN_MATCH); + + lookahead -= 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 (match_length <= max_lazy_match && lookahead >= MIN_MATCH) { + match_length--; // string at strstart already in hash table + do { + strstart++; + + ins_h = ((ins_h << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask; + // prev[strstart&w_mask]=hash_head=head[ins_h]; + hash_head = (head[ins_h] & 0xffff); + prev[strstart & w_mask] = head[ins_h]; + head[ins_h] = strstart; + + // strstart never exceeds WSIZE-MAX_MATCH, so there are + // always MIN_MATCH bytes ahead. + } while (--match_length !== 0); + strstart++; + } else { + strstart += match_length; + match_length = 0; + ins_h = window[strstart] & 0xff; + + ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask; + // If lookahead < MIN_MATCH, ins_h is garbage, but it does + // not + // matter since it will be recomputed at next deflate call. + } + } else { + // No match, output a literal byte + + bflush = _tr_tally(0, window[strstart] & 0xff); + lookahead--; + strstart++; + } + if (bflush) { + + flush_block_only(false); + if (strm.avail_out === 0) + return NeedMore; + } + } + + flush_block_only(flush == Z_FINISH); + if (strm.avail_out === 0) { + if (flush == Z_FINISH) + return FinishStarted; + else + return NeedMore; + } + return flush == Z_FINISH ? FinishDone : BlockDone; + } + + // 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. + function deflate_slow(flush) { + // short hash_head = 0; // head of hash chain + var hash_head = 0; // head of hash chain + var bflush; // set if current block must be flushed + var max_insert; + + // Process the input block. + while (true) { + // 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. + + if (lookahead < MIN_LOOKAHEAD) { + fill_window(); + if (lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return NeedMore; + } + if (lookahead === 0) + break; // flush the current block + } + + // Insert the string window[strstart .. strstart+2] in the + // dictionary, and set hash_head to the head of the hash chain: + + if (lookahead >= MIN_MATCH) { + ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask; + // prev[strstart&w_mask]=hash_head=head[ins_h]; + hash_head = (head[ins_h] & 0xffff); + prev[strstart & w_mask] = head[ins_h]; + head[ins_h] = strstart; + } + + // Find the longest match, discarding those <= prev_length. + prev_length = match_length; + prev_match = match_start; + match_length = MIN_MATCH - 1; + + if (hash_head !== 0 && prev_length < max_lazy_match && ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD) { + // 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). + + if (strategy != Z_HUFFMAN_ONLY) { + match_length = longest_match(hash_head); + } + // longest_match() sets match_start + + if (match_length <= 5 && (strategy == Z_FILTERED || (match_length == MIN_MATCH && strstart - match_start > 4096))) { + + // If prev_match is also MIN_MATCH, match_start is garbage + // but we will ignore the current match anyway. + match_length = MIN_MATCH - 1; + } + } + + // If there was a match at the previous step and the current + // match is not better, output the previous match: + if (prev_length >= MIN_MATCH && match_length <= prev_length) { + max_insert = strstart + lookahead - MIN_MATCH; + // Do not insert strings in hash table beyond this. + + // check_match(strstart-1, prev_match, prev_length); + + bflush = _tr_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH); + + // Insert in hash table all strings up to the end of the match. + // strstart-1 and strstart are already inserted. If there is not + // enough lookahead, the last two strings are not inserted in + // the hash table. + lookahead -= prev_length - 1; + prev_length -= 2; + do { + if (++strstart <= max_insert) { + ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask; + // prev[strstart&w_mask]=hash_head=head[ins_h]; + hash_head = (head[ins_h] & 0xffff); + prev[strstart & w_mask] = head[ins_h]; + head[ins_h] = strstart; + } + } while (--prev_length !== 0); + match_available = 0; + match_length = MIN_MATCH - 1; + strstart++; + + if (bflush) { + flush_block_only(false); + if (strm.avail_out === 0) + return NeedMore; + } + } else if (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. + + bflush = _tr_tally(0, window[strstart - 1] & 0xff); + + if (bflush) { + flush_block_only(false); + } + strstart++; + lookahead--; + if (strm.avail_out === 0) + return NeedMore; + } else { + // There is no previous match to compare with, wait for + // the next step to decide. + + match_available = 1; + strstart++; + lookahead--; + } + } + + if (match_available !== 0) { + bflush = _tr_tally(0, window[strstart - 1] & 0xff); + match_available = 0; + } + flush_block_only(flush == Z_FINISH); + + if (strm.avail_out === 0) { + if (flush == Z_FINISH) + return FinishStarted; + else + return NeedMore; + } + + return flush == Z_FINISH ? FinishDone : BlockDone; + } + + function deflateReset(strm) { + strm.total_in = strm.total_out = 0; + strm.msg = null; // + strm.data_type = Z_UNKNOWN; + + that.pending = 0; + that.pending_out = 0; + + status = BUSY_STATE; + + last_flush = Z_NO_FLUSH; + + tr_init(); + lm_init(); + return Z_OK; + } + + that.deflateInit = function(strm, _level, bits, _method, memLevel, _strategy) { + if (!_method) + _method = Z_DEFLATED; + if (!memLevel) + memLevel = DEF_MEM_LEVEL; + if (!_strategy) + _strategy = Z_DEFAULT_STRATEGY; + + // byte[] my_version=ZLIB_VERSION; + + // + // if (!version || version[0] != my_version[0] + // || stream_size != sizeof(z_stream)) { + // return Z_VERSION_ERROR; + // } + + strm.msg = null; + + if (_level == Z_DEFAULT_COMPRESSION) + _level = 6; + + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || _method != Z_DEFLATED || bits < 9 || bits > 15 || _level < 0 || _level > 9 || _strategy < 0 + || _strategy > Z_HUFFMAN_ONLY) { + return Z_STREAM_ERROR; + } + + strm.dstate = that; + + w_bits = bits; + w_size = 1 << w_bits; + w_mask = w_size - 1; + + hash_bits = memLevel + 7; + hash_size = 1 << hash_bits; + hash_mask = hash_size - 1; + hash_shift = Math.floor((hash_bits + MIN_MATCH - 1) / MIN_MATCH); + + window = new Uint8Array(w_size * 2); + prev = []; + head = []; + + lit_bufsize = 1 << (memLevel + 6); // 16K elements by default + + // We overlay pending_buf and d_buf+l_buf. This works since the average + // output size for (length,distance) codes is <= 24 bits. + that.pending_buf = new Uint8Array(lit_bufsize * 4); + pending_buf_size = lit_bufsize * 4; + + d_buf = Math.floor(lit_bufsize / 2); + l_buf = (1 + 2) * lit_bufsize; + + level = _level; + + strategy = _strategy; + method = _method & 0xff; + + return deflateReset(strm); + }; + + that.deflateEnd = function() { + if (status != INIT_STATE && status != BUSY_STATE && status != FINISH_STATE) { + return Z_STREAM_ERROR; + } + // Deallocate in reverse order of allocations: + that.pending_buf = null; + head = null; + prev = null; + window = null; + // free + that.dstate = null; + return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; + }; + + that.deflateParams = function(strm, _level, _strategy) { + var err = Z_OK; + + if (_level == Z_DEFAULT_COMPRESSION) { + _level = 6; + } + if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > Z_HUFFMAN_ONLY) { + return Z_STREAM_ERROR; + } + + if (config_table[level].func != config_table[_level].func && strm.total_in !== 0) { + // Flush the last buffer: + err = strm.deflate(Z_PARTIAL_FLUSH); + } + + if (level != _level) { + level = _level; + max_lazy_match = config_table[level].max_lazy; + good_match = config_table[level].good_length; + nice_match = config_table[level].nice_length; + max_chain_length = config_table[level].max_chain; + } + strategy = _strategy; + return err; + }; + + that.deflateSetDictionary = function(strm, dictionary, dictLength) { + var length = dictLength; + var n, index = 0; + + if (!dictionary || status != INIT_STATE) + return Z_STREAM_ERROR; + + if (length < MIN_MATCH) + return Z_OK; + if (length > w_size - MIN_LOOKAHEAD) { + length = w_size - MIN_LOOKAHEAD; + index = dictLength - length; // use the tail of the dictionary + } + window.set(dictionary.subarray(index, index + length), 0); + + strstart = length; + block_start = length; + + // Insert all strings in the hash table (except for the last two bytes). + // s->lookahead stays null, so s->ins_h will be recomputed at the next + // call of fill_window. + + ins_h = window[0] & 0xff; + ins_h = (((ins_h) << hash_shift) ^ (window[1] & 0xff)) & hash_mask; + + for (n = 0; n <= length - MIN_MATCH; n++) { + ins_h = (((ins_h) << hash_shift) ^ (window[(n) + (MIN_MATCH - 1)] & 0xff)) & hash_mask; + prev[n & w_mask] = head[ins_h]; + head[ins_h] = n; + } + return Z_OK; + }; + + that.deflate = function(_strm, flush) { + var i, header, level_flags, old_flush, bstate; + + if (flush > Z_FINISH || flush < 0) { + return Z_STREAM_ERROR; + } + + if (!_strm.next_out || (!_strm.next_in && _strm.avail_in !== 0) || (status == FINISH_STATE && flush != Z_FINISH)) { + _strm.msg = z_errmsg[Z_NEED_DICT - (Z_STREAM_ERROR)]; + return Z_STREAM_ERROR; + } + if (_strm.avail_out === 0) { + _strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)]; + return Z_BUF_ERROR; + } + + strm = _strm; // just in case + old_flush = last_flush; + last_flush = flush; + + // Write the zlib header + if (status == INIT_STATE) { + header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8; + level_flags = ((level - 1) & 0xff) >> 1; + + if (level_flags > 3) + level_flags = 3; + header |= (level_flags << 6); + if (strstart !== 0) + header |= PRESET_DICT; + header += 31 - (header % 31); + + status = BUSY_STATE; + putShortMSB(header); + } + + // Flush as much pending output as possible + if (that.pending !== 0) { + strm.flush_pending(); + if (strm.avail_out === 0) { + // console.log(" avail_out==0"); + // Since avail_out is 0, deflate will be called again with + // more output space, but possibly with both pending and + // avail_in equal to zero. There won't be anything to do, + // but this is not an error situation so make sure we + // return OK instead of BUF_ERROR at next call of deflate: + last_flush = -1; + return Z_OK; + } + + // Make sure there is something to do and avoid duplicate + // consecutive + // flushes. For repeated and useless calls with Z_FINISH, we keep + // returning Z_STREAM_END instead of Z_BUFF_ERROR. + } else if (strm.avail_in === 0 && flush <= old_flush && flush != Z_FINISH) { + strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)]; + return Z_BUF_ERROR; + } + + // User must not provide more input after the first FINISH: + if (status == FINISH_STATE && strm.avail_in !== 0) { + _strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)]; + return Z_BUF_ERROR; + } + + // Start a new block or continue the current one. + if (strm.avail_in !== 0 || lookahead !== 0 || (flush != Z_NO_FLUSH && status != FINISH_STATE)) { + bstate = -1; + switch (config_table[level].func) { + case STORED: + bstate = deflate_stored(flush); + break; + case FAST: + bstate = deflate_fast(flush); + break; + case SLOW: + bstate = deflate_slow(flush); + break; + default: + } + + if (bstate == FinishStarted || bstate == FinishDone) { + status = FINISH_STATE; + } + if (bstate == NeedMore || bstate == FinishStarted) { + if (strm.avail_out === 0) { + last_flush = -1; // avoid BUF_ERROR next call, see above + } + return Z_OK; + // If flush != Z_NO_FLUSH && avail_out === 0, the next call + // of deflate should use the same flush parameter to make sure + // that the flush is complete. So we don't have to output an + // empty block here, this will be done at next call. This also + // ensures that for a very small output buffer, we emit at most + // one empty block. + } + + if (bstate == BlockDone) { + if (flush == Z_PARTIAL_FLUSH) { + _tr_align(); + } else { // FULL_FLUSH or SYNC_FLUSH + _tr_stored_block(0, 0, false); + // For a full flush, this empty block will be recognized + // as a special marker by inflate_sync(). + if (flush == Z_FULL_FLUSH) { + // state.head[s.hash_size-1]=0; + for (i = 0; i < hash_size/*-1*/; i++) + // forget history + head[i] = 0; + } + } + strm.flush_pending(); + if (strm.avail_out === 0) { + last_flush = -1; // avoid BUF_ERROR at next call, see above + return Z_OK; + } + } + } + + if (flush != Z_FINISH) + return Z_OK; + return Z_STREAM_END; + }; + } + + // ZStream + + function ZStream() { + var that = this; + that.next_in_index = 0; + that.next_out_index = 0; + // that.next_in; // next input byte + that.avail_in = 0; // number of bytes available at next_in + that.total_in = 0; // total nb of input bytes read so far + // that.next_out; // next output byte should be put there + that.avail_out = 0; // remaining free space at next_out + that.total_out = 0; // total nb of bytes output so far + // that.msg; + // that.dstate; + // that.data_type; // best guess about the data type: ascii or binary + + } + + ZStream.prototype = { + deflateInit : function(level, bits) { + var that = this; + that.dstate = new Deflate(); + if (!bits) + bits = MAX_BITS; + return that.dstate.deflateInit(that, level, bits); + }, + + deflate : function(flush) { + var that = this; + if (!that.dstate) { + return Z_STREAM_ERROR; + } + return that.dstate.deflate(that, flush); + }, + + deflateEnd : function() { + var that = this; + if (!that.dstate) + return Z_STREAM_ERROR; + var ret = that.dstate.deflateEnd(); + that.dstate = null; + return ret; + }, + + deflateParams : function(level, strategy) { + var that = this; + if (!that.dstate) + return Z_STREAM_ERROR; + return that.dstate.deflateParams(that, level, strategy); + }, + + deflateSetDictionary : function(dictionary, dictLength) { + var that = this; + if (!that.dstate) + return Z_STREAM_ERROR; + return that.dstate.deflateSetDictionary(that, dictionary, dictLength); + }, + + // Read a new buffer from the current input stream, update the + // total number of bytes read. All deflate() input goes through + // this function so some applications may wish to modify it to avoid + // allocating a large strm->next_in buffer and copying from it. + // (See also flush_pending()). + read_buf : function(buf, start, size) { + var that = this; + var len = that.avail_in; + if (len > size) + len = size; + if (len === 0) + return 0; + that.avail_in -= len; + buf.set(that.next_in.subarray(that.next_in_index, that.next_in_index + len), start); + that.next_in_index += len; + that.total_in += len; + return len; + }, + + // Flush as much pending output as possible. All deflate() output goes + // through this function so some applications may wish to modify it + // to avoid allocating a large strm->next_out buffer and copying into it. + // (See also read_buf()). + flush_pending : function() { + var that = this; + var len = that.dstate.pending; + + if (len > that.avail_out) + len = that.avail_out; + if (len === 0) + return; + + // if (that.dstate.pending_buf.length <= that.dstate.pending_out || that.next_out.length <= that.next_out_index + // || that.dstate.pending_buf.length < (that.dstate.pending_out + len) || that.next_out.length < (that.next_out_index + + // len)) { + // console.log(that.dstate.pending_buf.length + ", " + that.dstate.pending_out + ", " + that.next_out.length + ", " + + // that.next_out_index + ", " + len); + // console.log("avail_out=" + that.avail_out); + // } + + that.next_out.set(that.dstate.pending_buf.subarray(that.dstate.pending_out, that.dstate.pending_out + len), that.next_out_index); + + that.next_out_index += len; + that.dstate.pending_out += len; + that.total_out += len; + that.avail_out -= len; + that.dstate.pending -= len; + if (that.dstate.pending === 0) { + that.dstate.pending_out = 0; + } + } + }; + + // Deflater + + function Deflater(level) { + var that = this; + var z = new ZStream(); + var bufsize = 512; + var flush = Z_NO_FLUSH; + var buf = new Uint8Array(bufsize); + + if (typeof level == "undefined") + level = Z_DEFAULT_COMPRESSION; + z.deflateInit(level); + z.next_out = buf; + + that.append = function(data, onprogress) { + var err, buffers = [], lastIndex = 0, bufferIndex = 0, bufferSize = 0, array; + if (!data.length) + return; + z.next_in_index = 0; + z.next_in = data; + z.avail_in = data.length; + do { + z.next_out_index = 0; + z.avail_out = bufsize; + err = z.deflate(flush); + if (err != Z_OK) + throw "deflating: " + z.msg; + if (z.next_out_index) + if (z.next_out_index == bufsize) + buffers.push(new Uint8Array(buf)); + else + buffers.push(new Uint8Array(buf.subarray(0, z.next_out_index))); + bufferSize += z.next_out_index; + if (onprogress && z.next_in_index > 0 && z.next_in_index != lastIndex) { + onprogress(z.next_in_index); + lastIndex = z.next_in_index; + } + } while (z.avail_in > 0 || z.avail_out === 0); + array = new Uint8Array(bufferSize); + buffers.forEach(function(chunk) { + array.set(chunk, bufferIndex); + bufferIndex += chunk.length; + }); + return array; + }; + that.flush = function() { + var err, ab, buffers = [], bufferIndex = 0, bufferSize = 0, array; + do { + z.next_out_index = 0; + z.avail_out = bufsize; + err = z.deflate(Z_FINISH); + if (err != Z_STREAM_END && err != Z_OK) + throw "deflating: " + z.msg; + if (bufsize - z.avail_out > 0) + buffers.push(new Uint8Array(buf.subarray(0, z.next_out_index))); + bufferSize += z.next_out_index; + } while (z.avail_in > 0 || z.avail_out === 0); + z.deflateEnd(); + array = new Uint8Array(bufferSize); + buffers.forEach(function(chunk) { + array.set(chunk, bufferIndex); + bufferIndex += chunk.length; + }); + return array; + }; + } + + var deflater; + + if (obj.zip) + obj.zip.Deflater = Deflater; + else { + deflater = new Deflater(); + obj.addEventListener("message", function(event) { + var message = event.data; + if (message.init) { + deflater = new Deflater(message.level); + obj.postMessage({ + oninit : true + }); + } + if (message.append) + obj.postMessage({ + onappend : true, + data : deflater.append(message.data, function(current) { + obj.postMessage({ + progress : true, + current : current + }); + }) + }); + if (message.flush) + obj.postMessage({ + onflush : true, + data : deflater.flush() + }); + }, false); + } + +})(this); diff --git a/index.html b/index.html new file mode 100644 index 0000000..2b7782f --- /dev/null +++ b/index.html @@ -0,0 +1,14 @@ + + + Excel to LaTeX converter + + +

Excel to LaTeX converter

+

Drag any .xlsx file onto the page to begin!

+

LaTeX output:

+ + + + + + diff --git a/inflate.js b/inflate.js new file mode 100644 index 0000000..67dfe18 --- /dev/null +++ b/inflate.js @@ -0,0 +1,2169 @@ +/* + Copyright (c) 2012 Gildas Lormeau. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the distribution. + + 3. The names of the authors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, + INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, + INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This program is based on JZlib 1.0.2 ymnk, JCraft,Inc. + * JZlib is based on zlib-1.1.3, so all credit should go authors + * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu) + * and contributors of zlib. + */ + +(function(obj) { + + // Global + var MAX_BITS = 15; + + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_NEED_DICT = 2; + var Z_STREAM_ERROR = -2; + var Z_DATA_ERROR = -3; + var Z_MEM_ERROR = -4; + var Z_BUF_ERROR = -5; + + var inflate_mask = [ 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff, 0x000003ff, + 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff ]; + + var MANY = 1440; + + var MAX_WBITS = 15; // 32K LZ77 window + var DEF_WBITS = MAX_WBITS; + + // JZlib version : "1.0.2" + var Z_NO_FLUSH = 0; + var Z_FINISH = 4; + + // InfTree + var fixed_bl = 9; + var fixed_bd = 5; + + var fixed_tl = [ 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 192, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 160, 0, 8, 0, + 0, 8, 128, 0, 8, 64, 0, 9, 224, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 144, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 208, 81, 7, 17, 0, 8, 104, 0, 8, 40, + 0, 9, 176, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 240, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 200, 81, 7, 13, + 0, 8, 100, 0, 8, 36, 0, 9, 168, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 232, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 152, 84, 7, 83, 0, 8, 124, 0, 8, 60, + 0, 9, 216, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 184, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 248, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, + 35, 0, 8, 114, 0, 8, 50, 0, 9, 196, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 164, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 228, 80, 7, 7, 0, 8, 90, 0, 8, + 26, 0, 9, 148, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 212, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 180, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 244, 80, + 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 204, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 172, 0, 8, 6, 0, 8, 134, 0, + 8, 70, 0, 9, 236, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 156, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 220, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 188, 0, + 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 252, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 194, 80, 7, 10, 0, 8, 97, + 0, 8, 33, 0, 9, 162, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 226, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 146, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 210, + 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 178, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 242, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, + 0, 8, 53, 0, 9, 202, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 170, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 234, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 154, + 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 218, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 186, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 250, 80, 7, 3, 0, 8, 83, + 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 198, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 166, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 230, + 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 150, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 214, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 182, 0, 8, 11, 0, 8, 139, + 0, 8, 75, 0, 9, 246, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 206, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 174, + 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 238, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 158, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 222, 82, 7, 27, 0, 8, 111, + 0, 8, 47, 0, 9, 190, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 254, 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, + 193, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 161, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 225, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 145, 83, 7, 59, 0, 8, + 120, 0, 8, 56, 0, 9, 209, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 177, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 241, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, + 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 201, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 169, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 233, 80, 7, 8, 0, 8, + 92, 0, 8, 28, 0, 9, 153, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 217, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 185, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, + 249, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 197, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 165, 0, 8, 2, 0, 8, + 130, 0, 8, 66, 0, 9, 229, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 149, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 213, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, + 181, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 245, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 205, 81, 7, 15, 0, 8, + 102, 0, 8, 38, 0, 9, 173, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 237, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 157, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, + 221, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 189, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 253, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, + 8, 113, 0, 8, 49, 0, 9, 195, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 163, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 227, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, + 147, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 211, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 179, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 243, 80, 7, 4, 0, 8, + 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 203, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 171, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, + 235, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 155, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 219, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 187, 0, 8, 13, 0, 8, + 141, 0, 8, 77, 0, 9, 251, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 199, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, + 167, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 231, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 151, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 215, 82, 7, 19, 0, 8, + 107, 0, 8, 43, 0, 9, 183, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 247, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, + 207, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 175, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 239, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 159, 84, 7, 99, 0, 8, + 127, 0, 8, 63, 0, 9, 223, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 191, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 255 ]; + var fixed_td = [ 80, 5, 1, 87, 5, 257, 83, 5, 17, 91, 5, 4097, 81, 5, 5, 89, 5, 1025, 85, 5, 65, 93, 5, 16385, 80, 5, 3, 88, 5, 513, 84, 5, 33, 92, 5, + 8193, 82, 5, 9, 90, 5, 2049, 86, 5, 129, 192, 5, 24577, 80, 5, 2, 87, 5, 385, 83, 5, 25, 91, 5, 6145, 81, 5, 7, 89, 5, 1537, 85, 5, 97, 93, 5, + 24577, 80, 5, 4, 88, 5, 769, 84, 5, 49, 92, 5, 12289, 82, 5, 13, 90, 5, 3073, 86, 5, 193, 192, 5, 24577 ]; + + // Tables for deflate from PKZIP's appnote.txt. + var cplens = [ // 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 ]; + + // see note #13 above about 258 + var cplext = [ // 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, 112, 112 // 112==invalid + ]; + + var cpdist = [ // 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 cpdext = [ // 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 ]; + + // If BMAX needs to be larger than 16, then h and x[] should be uLong. + var BMAX = 15; // maximum bit length of any code + + function InfTree() { + var that = this; + + var hn; // hufts used in space + var v; // work area for huft_build + var c; // bit length count table + var r; // table entry for structure assignment + var u; // table stack + var x; // bit offsets, then code stack + + function huft_build(b, // code lengths in bits (all assumed <= + // BMAX) + bindex, n, // number of codes (assumed <= 288) + 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 + t, // result: starting table + m, // maximum lookup bits, returns actual + hp,// space for trees + hn,// hufts used in space + v // working area: values in order of bit length + ) { + // Given a list of code lengths and a maximum table size, make a set of + // tables to decode that set of codes. Return Z_OK on success, + // Z_BUF_ERROR + // if the given code set is incomplete (the tables are still built in + // this + // case), Z_DATA_ERROR if the input is invalid (an over-subscribed set + // of + // lengths), or Z_MEM_ERROR if not enough memory. + + var a; // counter for codes of length k + 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 l; // bits per table (returned in m) + var mask; // (1 << w) - 1, to avoid cc -O bug on HP + var p; // pointer into c[], b[], or v[] + var q; // points to current table + var w; // bits before this table == (l * h) + var xp; // pointer into x + var y; // number of dummy codes added + var z; // number of entries in current table + + // Generate counts for each bit length + + p = 0; + i = n; + do { + c[b[bindex + p]]++; + p++; + i--; // assume all entries <= BMAX + } while (i !== 0); + + if (c[0] == n) { // null input--all zero length codes + t[0] = -1; + m[0] = 0; + return Z_OK; + } + + // Find minimum and maximum length, bound *m by those + l = m[0]; + for (j = 1; j <= BMAX; j++) + if (c[j] !== 0) + break; + k = j; // minimum code length + if (l < j) { + l = j; + } + for (i = BMAX; i !== 0; i--) { + if (c[i] !== 0) + break; + } + g = i; // maximum code length + if (l > i) { + l = i; + } + m[0] = l; + + // Adjust last length count to fill out codes, if needed + for (y = 1 << j; j < i; j++, y <<= 1) { + if ((y -= c[j]) < 0) { + return Z_DATA_ERROR; + } + } + if ((y -= c[i]) < 0) { + return Z_DATA_ERROR; + } + c[i] += y; + + // Generate starting offsets into the value table for each length + x[1] = j = 0; + p = 1; + xp = 2; + while (--i !== 0) { // note that i == g from above + x[xp] = (j += c[p]); + xp++; + p++; + } + + // Make a table of values in order of bit lengths + i = 0; + p = 0; + do { + if ((j = b[bindex + p]) !== 0) { + v[x[j]++] = i; + } + p++; + } 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 = 0; // grab values in bit order + h = -1; // no tables yet--level -1 + w = -l; // bits decoded == (l * h) + u[0] = 0; // just to keep compilers happy + q = 0; // 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 + // make tables up to required level + while (k > w + l) { + h++; + w += l; // previous table always l bits + // compute minimum size table less than or equal to l bits + z = g - w; + z = (z > l) ? l : z; // table size 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; + if (j < z) { + 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 + } + } + } + z = 1 << j; // table entries for j-bit table + + // allocate new table + if (hn[0] + z > MANY) { // (note: doesn't matter for fixed) + return Z_DATA_ERROR; // overflow of MANY + } + u[h] = q = /* hp+ */hn[0]; // DEBUG + hn[0] += z; + + // connect to last table, if there is one + if (h !== 0) { + x[h] = i; // save pattern for backing up + r[0] = /* (byte) */j; // bits in this table + r[1] = /* (byte) */l; // bits to dump before this table + j = i >>> (w - l); + r[2] = /* (int) */(q - u[h - 1] - j); // offset to this table + hp.set(r, (u[h - 1] + j) * 3); + // to + // last + // table + } else { + t[0] = q; // first table is returned result + } + } + + // set up table entry in r + r[1] = /* (byte) */(k - w); + if (p >= n) { + r[0] = 128 + 64; // out of values--invalid code + } else if (v[p] < s) { + r[0] = /* (byte) */(v[p] < 256 ? 0 : 32 + 64); // 256 is + // end-of-block + r[2] = v[p++]; // simple code is just the value + } else { + r[0] = /* (byte) */(e[v[p] - s] + 16 + 64); // non-simple--look + // up in lists + r[2] = d[v[p++] - s]; + } + + // fill code-like entries with r + f = 1 << (k - w); + for (j = i >>> w; j < z; j += f) { + hp.set(r, (q + j) * 3); + } + + // 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 + mask = (1 << w) - 1; // needed on HP, cc -O bug + while ((i & mask) != x[h]) { + h--; // don't need to update q + w -= l; + mask = (1 << w) - 1; + } + } + } + // Return Z_BUF_ERROR if we were given an incomplete table + return y !== 0 && g != 1 ? Z_BUF_ERROR : Z_OK; + } + + function initWorkArea(vsize) { + var i; + if (!hn) { + hn = []; // []; //new Array(1); + v = []; // new Array(vsize); + c = new Int32Array(BMAX + 1); // new Array(BMAX + 1); + r = []; // new Array(3); + u = new Int32Array(BMAX); // new Array(BMAX); + x = new Int32Array(BMAX + 1); // new Array(BMAX + 1); + } + if (v.length < vsize) { + v = []; // new Array(vsize); + } + for (i = 0; i < vsize; i++) { + v[i] = 0; + } + for (i = 0; i < BMAX + 1; i++) { + c[i] = 0; + } + for (i = 0; i < 3; i++) { + r[i] = 0; + } + // for(int i=0; i 257)) { + if (result == Z_DATA_ERROR) { + z.msg = "oversubscribed distance tree"; + } else if (result == Z_BUF_ERROR) { + z.msg = "incomplete distance tree"; + result = Z_DATA_ERROR; + } else if (result != Z_MEM_ERROR) { + z.msg = "empty distance tree with lengths"; + result = Z_DATA_ERROR; + } + return result; + } + + return Z_OK; + }; + + } + + InfTree.inflate_trees_fixed = function(bl, // literal desired/actual bit depth + bd, // distance desired/actual bit depth + tl,// literal/length tree result + td,// distance tree result + z // for memory allocation + ) { + bl[0] = fixed_bl; + bd[0] = fixed_bd; + tl[0] = fixed_tl; + td[0] = fixed_td; + return Z_OK; + }; + + // InfCodes + + // waiting for "i:"=input, + // "o:"=output, + // "x:"=nothing + var START = 0; // x: set up for LEN + var LEN = 1; // i: get length/literal/eob next + var LENEXT = 2; // i: getting length extra (have base) + var DIST = 3; // i: get distance next + var DISTEXT = 4;// i: getting distance extra + var COPY = 5; // o: copying bytes in window, waiting + // for space + var LIT = 6; // o: got literal, waiting for output + // space + var WASH = 7; // o: got eob, possibly still output + // waiting + var END = 8; // x: got eob and all data flushed + var BADCODE = 9;// x: got error + + function InfCodes() { + var that = this; + + var mode; // current inflate_codes mode + + // mode dependent information + var len = 0; + + var tree; // pointer into tree + var tree_index = 0; + var need = 0; // bits needed + + var lit = 0; + + // if EXT or COPY, where and how much + var get = 0; // bits to get for extra + var dist = 0; // distance back to copy from + + var lbits = 0; // ltree bits decoded per branch + var dbits = 0; // dtree bits decoder per branch + var ltree; // literal/length/eob tree + var ltree_index = 0; // literal/length/eob tree + var dtree; // distance tree + var dtree_index = 0; // distance tree + + // Called with number of bytes left to write in window at least 258 + // (the maximum string length) and number of input bytes available + // at least ten. The ten bytes are six bytes for the longest length/ + // distance pair plus four bytes for overloading the bit buffer. + + function inflate_fast(bl, bd, tl, tl_index, td, td_index, s, z) { + var t; // temporary pointer + var tp; // temporary pointer + var tp_index; // temporary pointer + var e; // extra bits or operation + var b; // bit buffer + var k; // bits in bit buffer + var p; // input data pointer + var n; // bytes available there + var q; // output window write pointer + var m; // bytes to end of window or read pointer + var ml; // mask for literal/length tree + var md; // mask for distance tree + var c; // bytes to copy + var d; // distance back to copy from + var r; // copy source pointer + + var tp_index_t_3; // (tp_index+t)*3 + + // load input, output, bit values + p = z.next_in_index; + n = z.avail_in; + b = s.bitb; + k = s.bitk; + q = s.write; + m = q < s.read ? s.read - q - 1 : s.end - q; + + // initialize masks + ml = inflate_mask[bl]; + md = inflate_mask[bd]; + + // do until not enough input or output space for fast loop + do { // assume called with m >= 258 && n >= 10 + // get literal/length code + while (k < (20)) { // max bits for literal/length code + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + t = b & ml; + tp = tl; + tp_index = tl_index; + tp_index_t_3 = (tp_index + t) * 3; + if ((e = tp[tp_index_t_3]) === 0) { + b >>= (tp[tp_index_t_3 + 1]); + k -= (tp[tp_index_t_3 + 1]); + + s.window[q++] = /* (byte) */tp[tp_index_t_3 + 2]; + m--; + continue; + } + do { + + b >>= (tp[tp_index_t_3 + 1]); + k -= (tp[tp_index_t_3 + 1]); + + if ((e & 16) !== 0) { + e &= 15; + c = tp[tp_index_t_3 + 2] + (/* (int) */b & inflate_mask[e]); + + b >>= e; + k -= e; + + // decode distance base of block to copy + while (k < (15)) { // max bits for distance code + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + t = b & md; + tp = td; + tp_index = td_index; + tp_index_t_3 = (tp_index + t) * 3; + e = tp[tp_index_t_3]; + + do { + + b >>= (tp[tp_index_t_3 + 1]); + k -= (tp[tp_index_t_3 + 1]); + + if ((e & 16) !== 0) { + // get extra bits to add to distance base + e &= 15; + while (k < (e)) { // get extra bits (up to 13) + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + d = tp[tp_index_t_3 + 2] + (b & inflate_mask[e]); + + b >>= (e); + k -= (e); + + // do the copy + m -= c; + if (q >= d) { // offset before dest + // just copy + r = q - d; + if (q - r > 0 && 2 > (q - r)) { + s.window[q++] = s.window[r++]; // minimum + // count is + // three, + s.window[q++] = s.window[r++]; // so unroll + // loop a + // little + c -= 2; + } else { + s.window.set(s.window.subarray(r, r + 2), q); + q += 2; + r += 2; + c -= 2; + } + } else { // else offset after destination + r = q - d; + do { + r += s.end; // force pointer in window + } while (r < 0); // covers invalid distances + e = s.end - r; + if (c > e) { // if source crosses, + c -= e; // wrapped copy + if (q - r > 0 && e > (q - r)) { + do { + s.window[q++] = s.window[r++]; + } while (--e !== 0); + } else { + s.window.set(s.window.subarray(r, r + e), q); + q += e; + r += e; + e = 0; + } + r = 0; // copy rest from start of window + } + + } + + // copy all or what's left + if (q - r > 0 && c > (q - r)) { + do { + s.window[q++] = s.window[r++]; + } while (--c !== 0); + } else { + s.window.set(s.window.subarray(r, r + c), q); + q += c; + r += c; + c = 0; + } + break; + } else if ((e & 64) === 0) { + t += tp[tp_index_t_3 + 2]; + t += (b & inflate_mask[e]); + tp_index_t_3 = (tp_index + t) * 3; + e = tp[tp_index_t_3]; + } else { + z.msg = "invalid distance code"; + + c = z.avail_in - n; + c = (k >> 3) < c ? k >> 3 : c; + n += c; + p -= c; + k -= c << 3; + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + + return Z_DATA_ERROR; + } + } while (true); + break; + } + + if ((e & 64) === 0) { + t += tp[tp_index_t_3 + 2]; + t += (b & inflate_mask[e]); + tp_index_t_3 = (tp_index + t) * 3; + if ((e = tp[tp_index_t_3]) === 0) { + + b >>= (tp[tp_index_t_3 + 1]); + k -= (tp[tp_index_t_3 + 1]); + + s.window[q++] = /* (byte) */tp[tp_index_t_3 + 2]; + m--; + break; + } + } else if ((e & 32) !== 0) { + + c = z.avail_in - n; + c = (k >> 3) < c ? k >> 3 : c; + n += c; + p -= c; + k -= c << 3; + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + + return Z_STREAM_END; + } else { + z.msg = "invalid literal/length code"; + + c = z.avail_in - n; + c = (k >> 3) < c ? k >> 3 : c; + n += c; + p -= c; + k -= c << 3; + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + + return Z_DATA_ERROR; + } + } while (true); + } while (m >= 258 && n >= 10); + + // not enough input or output--restore pointers and return + c = z.avail_in - n; + c = (k >> 3) < c ? k >> 3 : c; + n += c; + p -= c; + k -= c << 3; + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + + return Z_OK; + } + + that.init = function(bl, bd, tl, tl_index, td, td_index, z) { + mode = START; + lbits = /* (byte) */bl; + dbits = /* (byte) */bd; + ltree = tl; + ltree_index = tl_index; + dtree = td; + dtree_index = td_index; + tree = null; + }; + + that.proc = function(s, z, r) { + var j; // temporary storage + var t; // temporary pointer + var tindex; // temporary pointer + var e; // extra bits or operation + var b = 0; // bit buffer + var k = 0; // bits in bit buffer + var p = 0; // input data pointer + var n; // bytes available there + var q; // output window write pointer + var m; // bytes to end of window or read pointer + var f; // pointer to copy strings from + + // copy input/output information to locals (UPDATE macro restores) + p = z.next_in_index; + n = z.avail_in; + b = s.bitb; + k = s.bitk; + q = s.write; + m = q < s.read ? s.read - q - 1 : s.end - q; + + // process input and output based on current state + while (true) { + switch (mode) { + // waiting for "i:"=input, "o:"=output, "x:"=nothing + case START: // x: set up for LEN + if (m >= 258 && n >= 10) { + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + r = inflate_fast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, s, z); + + p = z.next_in_index; + n = z.avail_in; + b = s.bitb; + k = s.bitk; + q = s.write; + m = q < s.read ? s.read - q - 1 : s.end - q; + + if (r != Z_OK) { + mode = r == Z_STREAM_END ? WASH : BADCODE; + break; + } + } + need = lbits; + tree = ltree; + tree_index = ltree_index; + + mode = LEN; + case LEN: // i: get length/literal/eob next + j = need; + + while (k < (j)) { + if (n !== 0) + r = Z_OK; + else { + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + tindex = (tree_index + (b & inflate_mask[j])) * 3; + + b >>>= (tree[tindex + 1]); + k -= (tree[tindex + 1]); + + e = tree[tindex]; + + if (e === 0) { // literal + lit = tree[tindex + 2]; + mode = LIT; + break; + } + if ((e & 16) !== 0) { // length + get = e & 15; + len = tree[tindex + 2]; + mode = LENEXT; + break; + } + if ((e & 64) === 0) { // next table + need = e; + tree_index = tindex / 3 + tree[tindex + 2]; + break; + } + if ((e & 32) !== 0) { // end of block + mode = WASH; + break; + } + mode = BADCODE; // invalid code + z.msg = "invalid literal/length code"; + r = Z_DATA_ERROR; + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + + case LENEXT: // i: getting length extra (have base) + j = get; + + while (k < (j)) { + if (n !== 0) + r = Z_OK; + else { + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + len += (b & inflate_mask[j]); + + b >>= j; + k -= j; + + need = dbits; + tree = dtree; + tree_index = dtree_index; + mode = DIST; + case DIST: // i: get distance next + j = need; + + while (k < (j)) { + if (n !== 0) + r = Z_OK; + else { + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + tindex = (tree_index + (b & inflate_mask[j])) * 3; + + b >>= tree[tindex + 1]; + k -= tree[tindex + 1]; + + e = (tree[tindex]); + if ((e & 16) !== 0) { // distance + get = e & 15; + dist = tree[tindex + 2]; + mode = DISTEXT; + break; + } + if ((e & 64) === 0) { // next table + need = e; + tree_index = tindex / 3 + tree[tindex + 2]; + break; + } + mode = BADCODE; // invalid code + z.msg = "invalid distance code"; + r = Z_DATA_ERROR; + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + + case DISTEXT: // i: getting distance extra + j = get; + + while (k < (j)) { + if (n !== 0) + r = Z_OK; + else { + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + dist += (b & inflate_mask[j]); + + b >>= j; + k -= j; + + mode = COPY; + case COPY: // o: copying bytes in window, waiting for space + f = q - dist; + while (f < 0) { // modulo window size-"while" instead + f += s.end; // of "if" handles invalid distances + } + while (len !== 0) { + + if (m === 0) { + if (q == s.end && s.read !== 0) { + q = 0; + m = q < s.read ? s.read - q - 1 : s.end - q; + } + if (m === 0) { + s.write = q; + r = s.inflate_flush(z, r); + q = s.write; + m = q < s.read ? s.read - q - 1 : s.end - q; + + if (q == s.end && s.read !== 0) { + q = 0; + m = q < s.read ? s.read - q - 1 : s.end - q; + } + + if (m === 0) { + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + } + } + } + + s.window[q++] = s.window[f++]; + m--; + + if (f == s.end) + f = 0; + len--; + } + mode = START; + break; + case LIT: // o: got literal, waiting for output space + if (m === 0) { + if (q == s.end && s.read !== 0) { + q = 0; + m = q < s.read ? s.read - q - 1 : s.end - q; + } + if (m === 0) { + s.write = q; + r = s.inflate_flush(z, r); + q = s.write; + m = q < s.read ? s.read - q - 1 : s.end - q; + + if (q == s.end && s.read !== 0) { + q = 0; + m = q < s.read ? s.read - q - 1 : s.end - q; + } + if (m === 0) { + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + } + } + } + r = Z_OK; + + s.window[q++] = /* (byte) */lit; + m--; + + mode = START; + break; + case WASH: // o: got eob, possibly more output + if (k > 7) { // return unused byte, if any + k -= 8; + n++; + p--; // can always return one + } + + s.write = q; + r = s.inflate_flush(z, r); + q = s.write; + m = q < s.read ? s.read - q - 1 : s.end - q; + + if (s.read != s.write) { + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + } + mode = END; + case END: + r = Z_STREAM_END; + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + + case BADCODE: // x: got error + + r = Z_DATA_ERROR; + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + + default: + r = Z_STREAM_ERROR; + + s.bitb = b; + s.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + s.write = q; + return s.inflate_flush(z, r); + } + } + }; + + that.free = function(z) { + // ZFREE(z, c); + }; + + } + + // InfBlocks + + // Table for deflate from PKZIP's appnote.txt. + var border = [ // 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 ]; + + var TYPE = 0; // get type bits (3, including end bit) + var LENS = 1; // get lengths for stored + var STORED = 2;// processing stored block + var TABLE = 3; // get table lengths + var BTREE = 4; // get bit lengths tree for a dynamic + // block + var DTREE = 5; // get length, distance trees for a + // dynamic block + var CODES = 6; // processing fixed or dynamic block + var DRY = 7; // output remaining window bytes + var DONELOCKS = 8; // finished last block, done + var BADBLOCKS = 9; // ot a data error--stuck here + + function InfBlocks(z, w) { + var that = this; + + var mode = TYPE; // current inflate_block mode + + var left = 0; // if STORED, bytes left to copy + + var table = 0; // table lengths (14 bits) + var index = 0; // index into blens (or border) + var blens; // bit lengths of codes + var bb = [ 0 ]; // bit length tree depth + var tb = [ 0 ]; // bit length decoding tree + + var codes = new InfCodes(); // if CODES, current state + + var last = 0; // true if this block is the last block + + var hufts = new Int32Array(MANY * 3); // single malloc for tree space + var check = 0; // check on output + var inftree = new InfTree(); + + that.bitk = 0; // bits in bit buffer + that.bitb = 0; // bit buffer + that.window = new Uint8Array(w); // sliding window + that.end = w; // one byte after sliding window + that.read = 0; // window read pointer + that.write = 0; // window write pointer + + that.reset = function(z, c) { + if (c) + c[0] = check; + // if (mode == BTREE || mode == DTREE) { + // } + if (mode == CODES) { + codes.free(z); + } + mode = TYPE; + that.bitk = 0; + that.bitb = 0; + that.read = that.write = 0; + }; + + that.reset(z, null); + + // copy as much as possible from the sliding window to the output area + that.inflate_flush = function(z, r) { + var n; + var p; + var q; + + // local copies of source and destination pointers + p = z.next_out_index; + q = that.read; + + // compute number of bytes to copy as far as end of window + n = /* (int) */((q <= that.write ? that.write : that.end) - q); + if (n > z.avail_out) + n = z.avail_out; + if (n !== 0 && r == Z_BUF_ERROR) + r = Z_OK; + + // update counters + z.avail_out -= n; + z.total_out += n; + + // copy as far as end of window + z.next_out.set(that.window.subarray(q, q + n), p); + p += n; + q += n; + + // see if more to copy at beginning of window + if (q == that.end) { + // wrap pointers + q = 0; + if (that.write == that.end) + that.write = 0; + + // compute bytes to copy + n = that.write - q; + if (n > z.avail_out) + n = z.avail_out; + if (n !== 0 && r == Z_BUF_ERROR) + r = Z_OK; + + // update counters + z.avail_out -= n; + z.total_out += n; + + // copy + z.next_out.set(that.window.subarray(q, q + n), p); + p += n; + q += n; + } + + // update pointers + z.next_out_index = p; + that.read = q; + + // done + return r; + }; + + that.proc = function(z, r) { + var t; // temporary storage + var b; // bit buffer + var k; // bits in bit buffer + var p; // input data pointer + var n; // bytes available there + var q; // output window write pointer + var m; // bytes to end of window or read pointer + + var i; + + // copy input/output information to locals (UPDATE macro restores) + // { + p = z.next_in_index; + n = z.avail_in; + b = that.bitb; + k = that.bitk; + // } + // { + q = that.write; + m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q); + // } + + // process input based on current state + // DEBUG dtree + while (true) { + switch (mode) { + case TYPE: + + while (k < (3)) { + if (n !== 0) { + r = Z_OK; + } else { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + t = /* (int) */(b & 7); + last = t & 1; + + switch (t >>> 1) { + case 0: // stored + // { + b >>>= (3); + k -= (3); + // } + t = k & 7; // go to byte boundary + + // { + b >>>= (t); + k -= (t); + // } + mode = LENS; // get length of stored block + break; + case 1: // fixed + // { + var bl = []; // new Array(1); + var bd = []; // new Array(1); + var tl = [ [] ]; // new Array(1); + var td = [ [] ]; // new Array(1); + + InfTree.inflate_trees_fixed(bl, bd, tl, td, z); + codes.init(bl[0], bd[0], tl[0], 0, td[0], 0, z); + // } + + // { + b >>>= (3); + k -= (3); + // } + + mode = CODES; + break; + case 2: // dynamic + + // { + b >>>= (3); + k -= (3); + // } + + mode = TABLE; + break; + case 3: // illegal + + // { + b >>>= (3); + k -= (3); + // } + mode = BADBLOCKS; + z.msg = "invalid block type"; + r = Z_DATA_ERROR; + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + break; + case LENS: + + while (k < (32)) { + if (n !== 0) { + r = Z_OK; + } else { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + if ((((~b) >>> 16) & 0xffff) != (b & 0xffff)) { + mode = BADBLOCKS; + z.msg = "invalid stored block lengths"; + r = Z_DATA_ERROR; + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + left = (b & 0xffff); + b = k = 0; // dump bits + mode = left !== 0 ? STORED : (last !== 0 ? DRY : TYPE); + break; + case STORED: + if (n === 0) { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + + if (m === 0) { + if (q == that.end && that.read !== 0) { + q = 0; + m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q); + } + if (m === 0) { + that.write = q; + r = that.inflate_flush(z, r); + q = that.write; + m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q); + if (q == that.end && that.read !== 0) { + q = 0; + m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q); + } + if (m === 0) { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + } + } + r = Z_OK; + + t = left; + if (t > n) + t = n; + if (t > m) + t = m; + that.window.set(z.read_buf(p, t), q); + p += t; + n -= t; + q += t; + m -= t; + if ((left -= t) !== 0) + break; + mode = last !== 0 ? DRY : TYPE; + break; + case TABLE: + + while (k < (14)) { + if (n !== 0) { + r = Z_OK; + } else { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + table = t = (b & 0x3fff); + if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) { + mode = BADBLOCKS; + z.msg = "too many length or distance symbols"; + r = Z_DATA_ERROR; + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f); + if (!blens || blens.length < t) { + blens = []; // new Array(t); + } else { + for (i = 0; i < t; i++) { + blens[i] = 0; + } + } + + // { + b >>>= (14); + k -= (14); + // } + + index = 0; + mode = BTREE; + case BTREE: + while (index < 4 + (table >>> 10)) { + while (k < (3)) { + if (n !== 0) { + r = Z_OK; + } else { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + blens[border[index++]] = b & 7; + + // { + b >>>= (3); + k -= (3); + // } + } + + while (index < 19) { + blens[border[index++]] = 0; + } + + bb[0] = 7; + t = inftree.inflate_trees_bits(blens, bb, tb, hufts, z); + if (t != Z_OK) { + r = t; + if (r == Z_DATA_ERROR) { + blens = null; + mode = BADBLOCKS; + } + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + + index = 0; + mode = DTREE; + case DTREE: + while (true) { + t = table; + if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))) { + break; + } + + var h; + var j, c; + + t = bb[0]; + + while (k < (t)) { + if (n !== 0) { + r = Z_OK; + } else { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + // if (tb[0] == -1) { + // System.err.println("null..."); + // } + + t = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 1]; + c = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 2]; + + if (c < 16) { + b >>>= (t); + k -= (t); + blens[index++] = c; + } else { // c == 16..18 + i = c == 18 ? 7 : c - 14; + j = c == 18 ? 11 : 3; + + while (k < (t + i)) { + if (n !== 0) { + r = Z_OK; + } else { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + n--; + b |= (z.read_byte(p++) & 0xff) << k; + k += 8; + } + + b >>>= (t); + k -= (t); + + j += (b & inflate_mask[i]); + + b >>>= (i); + k -= (i); + + i = index; + t = table; + if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1)) { + blens = null; + mode = BADBLOCKS; + z.msg = "invalid bit length repeat"; + r = Z_DATA_ERROR; + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + + c = c == 16 ? blens[i - 1] : 0; + do { + blens[i++] = c; + } while (--j !== 0); + index = i; + } + } + + tb[0] = -1; + // { + var bl_ = []; // new Array(1); + var bd_ = []; // new Array(1); + var tl_ = []; // new Array(1); + var td_ = []; // new Array(1); + bl_[0] = 9; // must be <= 9 for lookahead assumptions + bd_[0] = 6; // must be <= 9 for lookahead assumptions + + t = table; + t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl_, bd_, tl_, td_, hufts, z); + + if (t != Z_OK) { + if (t == Z_DATA_ERROR) { + blens = null; + mode = BADBLOCKS; + } + r = t; + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + codes.init(bl_[0], bd_[0], hufts, tl_[0], hufts, td_[0], z); + // } + mode = CODES; + case CODES: + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + + if ((r = codes.proc(that, z, r)) != Z_STREAM_END) { + return that.inflate_flush(z, r); + } + r = Z_OK; + codes.free(z); + + p = z.next_in_index; + n = z.avail_in; + b = that.bitb; + k = that.bitk; + q = that.write; + m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q); + + if (last === 0) { + mode = TYPE; + break; + } + mode = DRY; + case DRY: + that.write = q; + r = that.inflate_flush(z, r); + q = that.write; + m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q); + if (that.read != that.write) { + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + mode = DONELOCKS; + case DONELOCKS: + r = Z_STREAM_END; + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + case BADBLOCKS: + r = Z_DATA_ERROR; + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + + default: + r = Z_STREAM_ERROR; + + that.bitb = b; + that.bitk = k; + z.avail_in = n; + z.total_in += p - z.next_in_index; + z.next_in_index = p; + that.write = q; + return that.inflate_flush(z, r); + } + } + }; + + that.free = function(z) { + that.reset(z, null); + that.window = null; + hufts = null; + // ZFREE(z, s); + }; + + that.set_dictionary = function(d, start, n) { + that.window.set(d.subarray(start, start + n), 0); + that.read = that.write = n; + }; + + // Returns true if inflate is currently at the end of a block generated + // by Z_SYNC_FLUSH or Z_FULL_FLUSH. + that.sync_point = function() { + return mode == LENS ? 1 : 0; + }; + + } + + // Inflate + + // preset dictionary flag in zlib header + var PRESET_DICT = 0x20; + + var Z_DEFLATED = 8; + + var METHOD = 0; // waiting for method byte + var FLAG = 1; // waiting for flag byte + var DICT4 = 2; // four dictionary check bytes to go + var DICT3 = 3; // three dictionary check bytes to go + var DICT2 = 4; // two dictionary check bytes to go + var DICT1 = 5; // one dictionary check byte to go + var DICT0 = 6; // waiting for inflateSetDictionary + var BLOCKS = 7; // decompressing blocks + var DONE = 12; // finished check, done + var BAD = 13; // got an error--stay here + + var mark = [ 0, 0, 0xff, 0xff ]; + + function Inflate() { + var that = this; + + that.mode = 0; // current inflate mode + + // mode dependent information + that.method = 0; // if FLAGS, method byte + + // if CHECK, check values to compare + that.was = [ 0 ]; // new Array(1); // computed check value + that.need = 0; // stream check value + + // if BAD, inflateSync's marker bytes count + that.marker = 0; + + // mode independent information + that.wbits = 0; // log2(window size) (8..15, defaults to 15) + + // this.blocks; // current inflate_blocks state + + function inflateReset(z) { + if (!z || !z.istate) + return Z_STREAM_ERROR; + + z.total_in = z.total_out = 0; + z.msg = null; + z.istate.mode = BLOCKS; + z.istate.blocks.reset(z, null); + return Z_OK; + } + + that.inflateEnd = function(z) { + if (that.blocks) + that.blocks.free(z); + that.blocks = null; + // ZFREE(z, z->state); + return Z_OK; + }; + + that.inflateInit = function(z, w) { + z.msg = null; + that.blocks = null; + + // set window size + if (w < 8 || w > 15) { + that.inflateEnd(z); + return Z_STREAM_ERROR; + } + that.wbits = w; + + z.istate.blocks = new InfBlocks(z, 1 << w); + + // reset state + inflateReset(z); + return Z_OK; + }; + + that.inflate = function(z, f) { + var r; + var b; + + if (!z || !z.istate || !z.next_in) + return Z_STREAM_ERROR; + f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK; + r = Z_BUF_ERROR; + while (true) { + // System.out.println("mode: "+z.istate.mode); + switch (z.istate.mode) { + case METHOD: + + if (z.avail_in === 0) + return r; + r = f; + + z.avail_in--; + z.total_in++; + if (((z.istate.method = z.read_byte(z.next_in_index++)) & 0xf) != Z_DEFLATED) { + z.istate.mode = BAD; + z.msg = "unknown compression method"; + z.istate.marker = 5; // can't try inflateSync + break; + } + if ((z.istate.method >> 4) + 8 > z.istate.wbits) { + z.istate.mode = BAD; + z.msg = "invalid window size"; + z.istate.marker = 5; // can't try inflateSync + break; + } + z.istate.mode = FLAG; + case FLAG: + + if (z.avail_in === 0) + return r; + r = f; + + z.avail_in--; + z.total_in++; + b = (z.read_byte(z.next_in_index++)) & 0xff; + + if ((((z.istate.method << 8) + b) % 31) !== 0) { + z.istate.mode = BAD; + z.msg = "incorrect header check"; + z.istate.marker = 5; // can't try inflateSync + break; + } + + if ((b & PRESET_DICT) === 0) { + z.istate.mode = BLOCKS; + break; + } + z.istate.mode = DICT4; + case DICT4: + + if (z.avail_in === 0) + return r; + r = f; + + z.avail_in--; + z.total_in++; + z.istate.need = ((z.read_byte(z.next_in_index++) & 0xff) << 24) & 0xff000000; + z.istate.mode = DICT3; + case DICT3: + + if (z.avail_in === 0) + return r; + r = f; + + z.avail_in--; + z.total_in++; + z.istate.need += ((z.read_byte(z.next_in_index++) & 0xff) << 16) & 0xff0000; + z.istate.mode = DICT2; + case DICT2: + + if (z.avail_in === 0) + return r; + r = f; + + z.avail_in--; + z.total_in++; + z.istate.need += ((z.read_byte(z.next_in_index++) & 0xff) << 8) & 0xff00; + z.istate.mode = DICT1; + case DICT1: + + if (z.avail_in === 0) + return r; + r = f; + + z.avail_in--; + z.total_in++; + z.istate.need += (z.read_byte(z.next_in_index++) & 0xff); + z.istate.mode = DICT0; + return Z_NEED_DICT; + case DICT0: + z.istate.mode = BAD; + z.msg = "need dictionary"; + z.istate.marker = 0; // can try inflateSync + return Z_STREAM_ERROR; + case BLOCKS: + + r = z.istate.blocks.proc(z, r); + if (r == Z_DATA_ERROR) { + z.istate.mode = BAD; + z.istate.marker = 0; // can try inflateSync + break; + } + if (r == Z_OK) { + r = f; + } + if (r != Z_STREAM_END) { + return r; + } + r = f; + z.istate.blocks.reset(z, z.istate.was); + z.istate.mode = DONE; + case DONE: + return Z_STREAM_END; + case BAD: + return Z_DATA_ERROR; + default: + return Z_STREAM_ERROR; + } + } + }; + + that.inflateSetDictionary = function(z, dictionary, dictLength) { + var index = 0; + var length = dictLength; + if (!z || !z.istate || z.istate.mode != DICT0) + return Z_STREAM_ERROR; + + if (length >= (1 << z.istate.wbits)) { + length = (1 << z.istate.wbits) - 1; + index = dictLength - length; + } + z.istate.blocks.set_dictionary(dictionary, index, length); + z.istate.mode = BLOCKS; + return Z_OK; + }; + + that.inflateSync = function(z) { + var n; // number of bytes to look at + var p; // pointer to bytes + var m; // number of marker bytes found in a row + var r, w; // temporaries to save total_in and total_out + + // set up + if (!z || !z.istate) + return Z_STREAM_ERROR; + if (z.istate.mode != BAD) { + z.istate.mode = BAD; + z.istate.marker = 0; + } + if ((n = z.avail_in) === 0) + return Z_BUF_ERROR; + p = z.next_in_index; + m = z.istate.marker; + + // search + while (n !== 0 && m < 4) { + if (z.read_byte(p) == mark[m]) { + m++; + } else if (z.read_byte(p) !== 0) { + m = 0; + } else { + m = 4 - m; + } + p++; + n--; + } + + // restore + z.total_in += p - z.next_in_index; + z.next_in_index = p; + z.avail_in = n; + z.istate.marker = m; + + // return no joy or set up to restart on a new block + if (m != 4) { + return Z_DATA_ERROR; + } + r = z.total_in; + w = z.total_out; + inflateReset(z); + z.total_in = r; + z.total_out = w; + z.istate.mode = BLOCKS; + return Z_OK; + }; + + // Returns true if inflate is currently at the end of a block generated + // by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP + // implementation to provide an additional safety check. PPP uses + // Z_SYNC_FLUSH + // but removes the length bytes of the resulting empty stored block. When + // decompressing, PPP checks that at the end of input packet, inflate is + // waiting for these length bytes. + that.inflateSyncPoint = function(z) { + if (!z || !z.istate || !z.istate.blocks) + return Z_STREAM_ERROR; + return z.istate.blocks.sync_point(); + }; + } + + // ZStream + + function ZStream() { + } + + ZStream.prototype = { + inflateInit : function(bits) { + var that = this; + that.istate = new Inflate(); + if (!bits) + bits = MAX_BITS; + return that.istate.inflateInit(that, bits); + }, + + inflate : function(f) { + var that = this; + if (!that.istate) + return Z_STREAM_ERROR; + return that.istate.inflate(that, f); + }, + + inflateEnd : function() { + var that = this; + if (!that.istate) + return Z_STREAM_ERROR; + var ret = that.istate.inflateEnd(that); + that.istate = null; + return ret; + }, + + inflateSync : function() { + var that = this; + if (!that.istate) + return Z_STREAM_ERROR; + return that.istate.inflateSync(that); + }, + inflateSetDictionary : function(dictionary, dictLength) { + var that = this; + if (!that.istate) + return Z_STREAM_ERROR; + return that.istate.inflateSetDictionary(that, dictionary, dictLength); + }, + read_byte : function(start) { + var that = this; + return that.next_in.subarray(start, start + 1)[0]; + }, + read_buf : function(start, size) { + var that = this; + return that.next_in.subarray(start, start + size); + } + }; + + // Inflater + + function Inflater() { + var that = this; + var z = new ZStream(); + var bufsize = 512; + var flush = Z_NO_FLUSH; + var buf = new Uint8Array(bufsize); + var nomoreinput = false; + + z.inflateInit(); + z.next_out = buf; + + that.append = function(data, onprogress) { + var err, buffers = [], lastIndex = 0, bufferIndex = 0, bufferSize = 0, array; + if (data.length === 0) + return; + z.next_in_index = 0; + z.next_in = data; + z.avail_in = data.length; + do { + z.next_out_index = 0; + z.avail_out = bufsize; + if ((z.avail_in === 0) && (!nomoreinput)) { // if buffer is empty and more input is available, refill it + z.next_in_index = 0; + nomoreinput = true; + } + err = z.inflate(flush); + if (nomoreinput && (err == Z_BUF_ERROR)) + return -1; + if (err != Z_OK && err != Z_STREAM_END) + throw "inflating: " + z.msg; + if ((nomoreinput || err == Z_STREAM_END) && (z.avail_out == data.length)) + return -1; + if (z.next_out_index) + if (z.next_out_index == bufsize) + buffers.push(new Uint8Array(buf)); + else + buffers.push(new Uint8Array(buf.subarray(0, z.next_out_index))); + bufferSize += z.next_out_index; + if (onprogress && z.next_in_index > 0 && z.next_in_index != lastIndex) { + onprogress(z.next_in_index); + lastIndex = z.next_in_index; + } + } while (z.avail_in > 0 || z.avail_out === 0); + array = new Uint8Array(bufferSize); + buffers.forEach(function(chunk) { + array.set(chunk, bufferIndex); + bufferIndex += chunk.length; + }); + return array; + }; + that.flush = function() { + z.inflateEnd(); + }; + } + + var inflater; + + if (obj.zip) + obj.zip.Inflater = Inflater; + else { + inflater = new Inflater(); + obj.addEventListener("message", function(event) { + var message = event.data; + + if (message.append) + obj.postMessage({ + onappend : true, + data : inflater.append(message.data, function(current) { + obj.postMessage({ + progress : true, + current : current + }); + }) + }); + if (message.flush) { + inflater.flush(); + obj.postMessage({ + onflush : true + }); + } + }, false); + } + +})(this); diff --git a/mime-types.js b/mime-types.js new file mode 100644 index 0000000..2271403 --- /dev/null +++ b/mime-types.js @@ -0,0 +1,972 @@ +(function() { + var table = { + "application" : { + "andrew-inset" : "ez", + "annodex" : "anx", + "atom+xml" : "atom", + "atomcat+xml" : "atomcat", + "atomserv+xml" : "atomsrv", + "bbolin" : "lin", + "cap" : [ "cap", "pcap" ], + "cu-seeme" : "cu", + "davmount+xml" : "davmount", + "dsptype" : "tsp", + "ecmascript" : [ "es", "ecma" ], + "futuresplash" : "spl", + "hta" : "hta", + "java-archive" : "jar", + "java-serialized-object" : "ser", + "java-vm" : "class", + "javascript" : "js", + "m3g" : "m3g", + "mac-binhex40" : "hqx", + "mathematica" : [ "nb", "ma", "mb" ], + "msaccess" : "mdb", + "msword" : [ "doc", "dot" ], + "mxf" : "mxf", + "oda" : "oda", + "ogg" : "ogx", + "pdf" : "pdf", + "pgp-keys" : "key", + "pgp-signature" : [ "asc", "sig" ], + "pics-rules" : "prf", + "postscript" : [ "ps", "ai", "eps", "epsi", "epsf", "eps2", "eps3" ], + "rar" : "rar", + "rdf+xml" : "rdf", + "rss+xml" : "rss", + "rtf" : "rtf", + "smil" : [ "smi", "smil" ], + "xhtml+xml" : [ "xhtml", "xht" ], + "xml" : [ "xml", "xsl", "xsd" ], + "xspf+xml" : "xspf", + "zip" : "zip", + "vnd.android.package-archive" : "apk", + "vnd.cinderella" : "cdy", + "vnd.google-earth.kml+xml" : "kml", + "vnd.google-earth.kmz" : "kmz", + "vnd.mozilla.xul+xml" : "xul", + "vnd.ms-excel" : [ "xls", "xlb", "xlt", "xlm", "xla", "xlc", "xlw" ], + "vnd.ms-pki.seccat" : "cat", + "vnd.ms-pki.stl" : "stl", + "vnd.ms-powerpoint" : [ "ppt", "pps", "pot" ], + "vnd.oasis.opendocument.chart" : "odc", + "vnd.oasis.opendocument.database" : "odb", + "vnd.oasis.opendocument.formula" : "odf", + "vnd.oasis.opendocument.graphics" : "odg", + "vnd.oasis.opendocument.graphics-template" : "otg", + "vnd.oasis.opendocument.image" : "odi", + "vnd.oasis.opendocument.presentation" : "odp", + "vnd.oasis.opendocument.presentation-template" : "otp", + "vnd.oasis.opendocument.spreadsheet" : "ods", + "vnd.oasis.opendocument.spreadsheet-template" : "ots", + "vnd.oasis.opendocument.text" : "odt", + "vnd.oasis.opendocument.text-master" : "odm", + "vnd.oasis.opendocument.text-template" : "ott", + "vnd.oasis.opendocument.text-web" : "oth", + "vnd.openxmlformats-officedocument.spreadsheetml.sheet" : "xlsx", + "vnd.openxmlformats-officedocument.spreadsheetml.template" : "xltx", + "vnd.openxmlformats-officedocument.presentationml.presentation" : "pptx", + "vnd.openxmlformats-officedocument.presentationml.slideshow" : "ppsx", + "vnd.openxmlformats-officedocument.presentationml.template" : "potx", + "vnd.openxmlformats-officedocument.wordprocessingml.document" : "docx", + "vnd.openxmlformats-officedocument.wordprocessingml.template" : "dotx", + "vnd.smaf" : "mmf", + "vnd.stardivision.calc" : "sdc", + "vnd.stardivision.chart" : "sds", + "vnd.stardivision.draw" : "sda", + "vnd.stardivision.impress" : "sdd", + "vnd.stardivision.math" : [ "sdf", "smf" ], + "vnd.stardivision.writer" : [ "sdw", "vor" ], + "vnd.stardivision.writer-global" : "sgl", + "vnd.sun.xml.calc" : "sxc", + "vnd.sun.xml.calc.template" : "stc", + "vnd.sun.xml.draw" : "sxd", + "vnd.sun.xml.draw.template" : "std", + "vnd.sun.xml.impress" : "sxi", + "vnd.sun.xml.impress.template" : "sti", + "vnd.sun.xml.math" : "sxm", + "vnd.sun.xml.writer" : "sxw", + "vnd.sun.xml.writer.global" : "sxg", + "vnd.sun.xml.writer.template" : "stw", + "vnd.symbian.install" : [ "sis", "sisx" ], + "vnd.visio" : [ "vsd", "vst", "vss", "vsw" ], + "vnd.wap.wbxml" : "wbxml", + "vnd.wap.wmlc" : "wmlc", + "vnd.wap.wmlscriptc" : "wmlsc", + "vnd.wordperfect" : "wpd", + "vnd.wordperfect5.1" : "wp5", + "x-123" : "wk", + "x-7z-compressed" : "7z", + "x-abiword" : "abw", + "x-apple-diskimage" : "dmg", + "x-bcpio" : "bcpio", + "x-bittorrent" : "torrent", + "x-cbr" : [ "cbr", "cba", "cbt", "cb7" ], + "x-cbz" : "cbz", + "x-cdf" : [ "cdf", "cda" ], + "x-cdlink" : "vcd", + "x-chess-pgn" : "pgn", + "x-cpio" : "cpio", + "x-csh" : "csh", + "x-debian-package" : [ "deb", "udeb" ], + "x-director" : [ "dcr", "dir", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa" ], + "x-dms" : "dms", + "x-doom" : "wad", + "x-dvi" : "dvi", + "x-httpd-eruby" : "rhtml", + "x-font" : "pcf.Z", + "x-freemind" : "mm", + "x-gnumeric" : "gnumeric", + "x-go-sgf" : "sgf", + "x-graphing-calculator" : "gcf", + "x-gtar" : [ "gtar", "taz" ], + "x-hdf" : "hdf", + "x-httpd-php" : [ "phtml", "pht", "php" ], + "x-httpd-php-source" : "phps", + "x-httpd-php3" : "php3", + "x-httpd-php3-preprocessed" : "php3p", + "x-httpd-php4" : "php4", + "x-httpd-php5" : "php5", + "x-ica" : "ica", + "x-info" : "info", + "x-internet-signup" : [ "ins", "isp" ], + "x-iphone" : "iii", + "x-iso9660-image" : "iso", + "x-java-jnlp-file" : "jnlp", + "x-jmol" : "jmz", + "x-killustrator" : "kil", + "x-koan" : [ "skp", "skd", "skt", "skm" ], + "x-kpresenter" : [ "kpr", "kpt" ], + "x-kword" : [ "kwd", "kwt" ], + "x-latex" : "latex", + "x-lha" : "lha", + "x-lyx" : "lyx", + "x-lzh" : "lzh", + "x-lzx" : "lzx", + "x-maker" : [ "frm", "maker", "frame", "fm", "fb", "book", "fbdoc" ], + "x-ms-wmd" : "wmd", + "x-ms-wmz" : "wmz", + "x-msdos-program" : [ "com", "exe", "bat", "dll" ], + "x-msi" : "msi", + "x-netcdf" : [ "nc", "cdf" ], + "x-ns-proxy-autoconfig" : [ "pac", "dat" ], + "x-nwc" : "nwc", + "x-object" : "o", + "x-oz-application" : "oza", + "x-pkcs7-certreqresp" : "p7r", + "x-python-code" : [ "pyc", "pyo" ], + "x-qgis" : [ "qgs", "shp", "shx" ], + "x-quicktimeplayer" : "qtl", + "x-redhat-package-manager" : "rpm", + "x-ruby" : "rb", + "x-sh" : "sh", + "x-shar" : "shar", + "x-shockwave-flash" : [ "swf", "swfl" ], + "x-silverlight" : "scr", + "x-stuffit" : "sit", + "x-sv4cpio" : "sv4cpio", + "x-sv4crc" : "sv4crc", + "x-tar" : "tar", + "x-tcl" : "tcl", + "x-tex-gf" : "gf", + "x-tex-pk" : "pk", + "x-texinfo" : [ "texinfo", "texi" ], + "x-trash" : [ "~", "%", "bak", "old", "sik" ], + "x-troff" : [ "t", "tr", "roff" ], + "x-troff-man" : "man", + "x-troff-me" : "me", + "x-troff-ms" : "ms", + "x-ustar" : "ustar", + "x-wais-source" : "src", + "x-wingz" : "wz", + "x-x509-ca-cert" : [ "crt", "der", "cer" ], + "x-xcf" : "xcf", + "x-xfig" : "fig", + "x-xpinstall" : "xpi", + "applixware" : "aw", + "atomsvc+xml" : "atomsvc", + "ccxml+xml" : "ccxml", + "cdmi-capability" : "cdmia", + "cdmi-container" : "cdmic", + "cdmi-domain" : "cdmid", + "cdmi-object" : "cdmio", + "cdmi-queue" : "cdmiq", + "docbook+xml" : "dbk", + "dssc+der" : "dssc", + "dssc+xml" : "xdssc", + "emma+xml" : "emma", + "epub+zip" : "epub", + "exi" : "exi", + "font-tdpfr" : "pfr", + "gml+xml" : "gml", + "gpx+xml" : "gpx", + "gxf" : "gxf", + "hyperstudio" : "stk", + "inkml+xml" : [ "ink", "inkml" ], + "ipfix" : "ipfix", + "json" : "json", + "jsonml+json" : "jsonml", + "lost+xml" : "lostxml", + "mads+xml" : "mads", + "marc" : "mrc", + "marcxml+xml" : "mrcx", + "mathml+xml" : "mathml", + "mbox" : "mbox", + "mediaservercontrol+xml" : "mscml", + "metalink+xml" : "metalink", + "metalink4+xml" : "meta4", + "mets+xml" : "mets", + "mods+xml" : "mods", + "mp21" : [ "m21", "mp21" ], + "mp4" : "mp4s", + "oebps-package+xml" : "opf", + "omdoc+xml" : "omdoc", + "onenote" : [ "onetoc", "onetoc2", "onetmp", "onepkg" ], + "oxps" : "oxps", + "patch-ops-error+xml" : "xer", + "pgp-encrypted" : "pgp", + "pkcs10" : "p10", + "pkcs7-mime" : [ "p7m", "p7c" ], + "pkcs7-signature" : "p7s", + "pkcs8" : "p8", + "pkix-attr-cert" : "ac", + "pkix-crl" : "crl", + "pkix-pkipath" : "pkipath", + "pkixcmp" : "pki", + "pls+xml" : "pls", + "prs.cww" : "cww", + "pskc+xml" : "pskcxml", + "reginfo+xml" : "rif", + "relax-ng-compact-syntax" : "rnc", + "resource-lists+xml" : "rl", + "resource-lists-diff+xml" : "rld", + "rls-services+xml" : "rs", + "rpki-ghostbusters" : "gbr", + "rpki-manifest" : "mft", + "rpki-roa" : "roa", + "rsd+xml" : "rsd", + "sbml+xml" : "sbml", + "scvp-cv-request" : "scq", + "scvp-cv-response" : "scs", + "scvp-vp-request" : "spq", + "scvp-vp-response" : "spp", + "sdp" : "sdp", + "set-payment-initiation" : "setpay", + "set-registration-initiation" : "setreg", + "shf+xml" : "shf", + "sparql-query" : "rq", + "sparql-results+xml" : "srx", + "srgs" : "gram", + "srgs+xml" : "grxml", + "sru+xml" : "sru", + "ssdl+xml" : "ssdl", + "ssml+xml" : "ssml", + "tei+xml" : [ "tei", "teicorpus" ], + "thraud+xml" : "tfi", + "timestamped-data" : "tsd", + "vnd.3gpp.pic-bw-large" : "plb", + "vnd.3gpp.pic-bw-small" : "psb", + "vnd.3gpp.pic-bw-var" : "pvb", + "vnd.3gpp2.tcap" : "tcap", + "vnd.3m.post-it-notes" : "pwn", + "vnd.accpac.simply.aso" : "aso", + "vnd.accpac.simply.imp" : "imp", + "vnd.acucobol" : "acu", + "vnd.acucorp" : [ "atc", "acutc" ], + "vnd.adobe.air-application-installer-package+zip" : "air", + "vnd.adobe.formscentral.fcdt" : "fcdt", + "vnd.adobe.fxp" : [ "fxp", "fxpl" ], + "vnd.adobe.xdp+xml" : "xdp", + "vnd.adobe.xfdf" : "xfdf", + "vnd.ahead.space" : "ahead", + "vnd.airzip.filesecure.azf" : "azf", + "vnd.airzip.filesecure.azs" : "azs", + "vnd.amazon.ebook" : "azw", + "vnd.americandynamics.acc" : "acc", + "vnd.amiga.ami" : "ami", + "vnd.anser-web-certificate-issue-initiation" : "cii", + "vnd.anser-web-funds-transfer-initiation" : "fti", + "vnd.antix.game-component" : "atx", + "vnd.apple.installer+xml" : "mpkg", + "vnd.apple.mpegurl" : "m3u8", + "vnd.aristanetworks.swi" : "swi", + "vnd.astraea-software.iota" : "iota", + "vnd.audiograph" : "aep", + "vnd.blueice.multipass" : "mpm", + "vnd.bmi" : "bmi", + "vnd.businessobjects" : "rep", + "vnd.chemdraw+xml" : "cdxml", + "vnd.chipnuts.karaoke-mmd" : "mmd", + "vnd.claymore" : "cla", + "vnd.cloanto.rp9" : "rp9", + "vnd.clonk.c4group" : [ "c4g", "c4d", "c4f", "c4p", "c4u" ], + "vnd.cluetrust.cartomobile-config" : "c11amc", + "vnd.cluetrust.cartomobile-config-pkg" : "c11amz", + "vnd.commonspace" : "csp", + "vnd.contact.cmsg" : "cdbcmsg", + "vnd.cosmocaller" : "cmc", + "vnd.crick.clicker" : "clkx", + "vnd.crick.clicker.keyboard" : "clkk", + "vnd.crick.clicker.palette" : "clkp", + "vnd.crick.clicker.template" : "clkt", + "vnd.crick.clicker.wordbank" : "clkw", + "vnd.criticaltools.wbs+xml" : "wbs", + "vnd.ctc-posml" : "pml", + "vnd.cups-ppd" : "ppd", + "vnd.curl.car" : "car", + "vnd.curl.pcurl" : "pcurl", + "vnd.dart" : "dart", + "vnd.data-vision.rdz" : "rdz", + "vnd.dece.data" : [ "uvf", "uvvf", "uvd", "uvvd" ], + "vnd.dece.ttml+xml" : [ "uvt", "uvvt" ], + "vnd.dece.unspecified" : [ "uvx", "uvvx" ], + "vnd.dece.zip" : [ "uvz", "uvvz" ], + "vnd.denovo.fcselayout-link" : "fe_launch", + "vnd.dna" : "dna", + "vnd.dolby.mlp" : "mlp", + "vnd.dpgraph" : "dpg", + "vnd.dreamfactory" : "dfac", + "vnd.ds-keypoint" : "kpxx", + "vnd.dvb.ait" : "ait", + "vnd.dvb.service" : "svc", + "vnd.dynageo" : "geo", + "vnd.ecowin.chart" : "mag", + "vnd.enliven" : "nml", + "vnd.epson.esf" : "esf", + "vnd.epson.msf" : "msf", + "vnd.epson.quickanime" : "qam", + "vnd.epson.salt" : "slt", + "vnd.epson.ssf" : "ssf", + "vnd.eszigno3+xml" : [ "es3", "et3" ], + "vnd.ezpix-album" : "ez2", + "vnd.ezpix-package" : "ez3", + "vnd.fdf" : "fdf", + "vnd.fdsn.mseed" : "mseed", + "vnd.fdsn.seed" : [ "seed", "dataless" ], + "vnd.flographit" : "gph", + "vnd.fluxtime.clip" : "ftc", + "vnd.framemaker" : [ "fm", "frame", "maker", "book" ], + "vnd.frogans.fnc" : "fnc", + "vnd.frogans.ltf" : "ltf", + "vnd.fsc.weblaunch" : "fsc", + "vnd.fujitsu.oasys" : "oas", + "vnd.fujitsu.oasys2" : "oa2", + "vnd.fujitsu.oasys3" : "oa3", + "vnd.fujitsu.oasysgp" : "fg5", + "vnd.fujitsu.oasysprs" : "bh2", + "vnd.fujixerox.ddd" : "ddd", + "vnd.fujixerox.docuworks" : "xdw", + "vnd.fujixerox.docuworks.binder" : "xbd", + "vnd.fuzzysheet" : "fzs", + "vnd.genomatix.tuxedo" : "txd", + "vnd.geogebra.file" : "ggb", + "vnd.geogebra.tool" : "ggt", + "vnd.geometry-explorer" : [ "gex", "gre" ], + "vnd.geonext" : "gxt", + "vnd.geoplan" : "g2w", + "vnd.geospace" : "g3w", + "vnd.gmx" : "gmx", + "vnd.grafeq" : [ "gqf", "gqs" ], + "vnd.groove-account" : "gac", + "vnd.groove-help" : "ghf", + "vnd.groove-identity-message" : "gim", + "vnd.groove-injector" : "grv", + "vnd.groove-tool-message" : "gtm", + "vnd.groove-tool-template" : "tpl", + "vnd.groove-vcard" : "vcg", + "vnd.hal+xml" : "hal", + "vnd.handheld-entertainment+xml" : "zmm", + "vnd.hbci" : "hbci", + "vnd.hhe.lesson-player" : "les", + "vnd.hp-hpgl" : "hpgl", + "vnd.hp-hpid" : "hpid", + "vnd.hp-hps" : "hps", + "vnd.hp-jlyt" : "jlt", + "vnd.hp-pcl" : "pcl", + "vnd.hp-pclxl" : "pclxl", + "vnd.hydrostatix.sof-data" : "sfd-hdstx", + "vnd.ibm.minipay" : "mpy", + "vnd.ibm.modcap" : [ "afp", "listafp", "list3820" ], + "vnd.ibm.rights-management" : "irm", + "vnd.ibm.secure-container" : "sc", + "vnd.iccprofile" : [ "icc", "icm" ], + "vnd.igloader" : "igl", + "vnd.immervision-ivp" : "ivp", + "vnd.immervision-ivu" : "ivu", + "vnd.insors.igm" : "igm", + "vnd.intercon.formnet" : [ "xpw", "xpx" ], + "vnd.intergeo" : "i2g", + "vnd.intu.qbo" : "qbo", + "vnd.intu.qfx" : "qfx", + "vnd.ipunplugged.rcprofile" : "rcprofile", + "vnd.irepository.package+xml" : "irp", + "vnd.is-xpr" : "xpr", + "vnd.isac.fcs" : "fcs", + "vnd.jam" : "jam", + "vnd.jcp.javame.midlet-rms" : "rms", + "vnd.jisp" : "jisp", + "vnd.joost.joda-archive" : "joda", + "vnd.kahootz" : [ "ktz", "ktr" ], + "vnd.kde.karbon" : "karbon", + "vnd.kde.kchart" : "chrt", + "vnd.kde.kformula" : "kfo", + "vnd.kde.kivio" : "flw", + "vnd.kde.kontour" : "kon", + "vnd.kde.kpresenter" : [ "kpr", "kpt" ], + "vnd.kde.kspread" : "ksp", + "vnd.kde.kword" : [ "kwd", "kwt" ], + "vnd.kenameaapp" : "htke", + "vnd.kidspiration" : "kia", + "vnd.kinar" : [ "kne", "knp" ], + "vnd.koan" : [ "skp", "skd", "skt", "skm" ], + "vnd.kodak-descriptor" : "sse", + "vnd.las.las+xml" : "lasxml", + "vnd.llamagraphics.life-balance.desktop" : "lbd", + "vnd.llamagraphics.life-balance.exchange+xml" : "lbe", + "vnd.lotus-1-2-3" : "123", + "vnd.lotus-approach" : "apr", + "vnd.lotus-freelance" : "pre", + "vnd.lotus-notes" : "nsf", + "vnd.lotus-organizer" : "org", + "vnd.lotus-screencam" : "scm", + "vnd.lotus-wordpro" : "lwp", + "vnd.macports.portpkg" : "portpkg", + "vnd.mcd" : "mcd", + "vnd.medcalcdata" : "mc1", + "vnd.mediastation.cdkey" : "cdkey", + "vnd.mfer" : "mwf", + "vnd.mfmp" : "mfm", + "vnd.micrografx.flo" : "flo", + "vnd.micrografx.igx" : "igx", + "vnd.mif" : "mif", + "vnd.mobius.daf" : "daf", + "vnd.mobius.dis" : "dis", + "vnd.mobius.mbk" : "mbk", + "vnd.mobius.mqy" : "mqy", + "vnd.mobius.msl" : "msl", + "vnd.mobius.plc" : "plc", + "vnd.mobius.txf" : "txf", + "vnd.mophun.application" : "mpn", + "vnd.mophun.certificate" : "mpc", + "vnd.ms-artgalry" : "cil", + "vnd.ms-cab-compressed" : "cab", + "vnd.ms-excel.addin.macroenabled.12" : "xlam", + "vnd.ms-excel.sheet.binary.macroenabled.12" : "xlsb", + "vnd.ms-excel.sheet.macroenabled.12" : "xlsm", + "vnd.ms-excel.template.macroenabled.12" : "xltm", + "vnd.ms-fontobject" : "eot", + "vnd.ms-htmlhelp" : "chm", + "vnd.ms-ims" : "ims", + "vnd.ms-lrm" : "lrm", + "vnd.ms-officetheme" : "thmx", + "vnd.ms-powerpoint.addin.macroenabled.12" : "ppam", + "vnd.ms-powerpoint.presentation.macroenabled.12" : "pptm", + "vnd.ms-powerpoint.slide.macroenabled.12" : "sldm", + "vnd.ms-powerpoint.slideshow.macroenabled.12" : "ppsm", + "vnd.ms-powerpoint.template.macroenabled.12" : "potm", + "vnd.ms-project" : [ "mpp", "mpt" ], + "vnd.ms-word.document.macroenabled.12" : "docm", + "vnd.ms-word.template.macroenabled.12" : "dotm", + "vnd.ms-works" : [ "wps", "wks", "wcm", "wdb" ], + "vnd.ms-wpl" : "wpl", + "vnd.ms-xpsdocument" : "xps", + "vnd.mseq" : "mseq", + "vnd.musician" : "mus", + "vnd.muvee.style" : "msty", + "vnd.mynfc" : "taglet", + "vnd.neurolanguage.nlu" : "nlu", + "vnd.nitf" : [ "ntf", "nitf" ], + "vnd.noblenet-directory" : "nnd", + "vnd.noblenet-sealer" : "nns", + "vnd.noblenet-web" : "nnw", + "vnd.nokia.n-gage.data" : "ngdat", + "vnd.nokia.n-gage.symbian.install" : "n-gage", + "vnd.nokia.radio-preset" : "rpst", + "vnd.nokia.radio-presets" : "rpss", + "vnd.novadigm.edm" : "edm", + "vnd.novadigm.edx" : "edx", + "vnd.novadigm.ext" : "ext", + "vnd.oasis.opendocument.chart-template" : "otc", + "vnd.oasis.opendocument.formula-template" : "odft", + "vnd.oasis.opendocument.image-template" : "oti", + "vnd.olpc-sugar" : "xo", + "vnd.oma.dd2+xml" : "dd2", + "vnd.openofficeorg.extension" : "oxt", + "vnd.openxmlformats-officedocument.presentationml.slide" : "sldx", + "vnd.osgeo.mapguide.package" : "mgp", + "vnd.osgi.dp" : "dp", + "vnd.osgi.subsystem" : "esa", + "vnd.palm" : [ "pdb", "pqa", "oprc" ], + "vnd.pawaafile" : "paw", + "vnd.pg.format" : "str", + "vnd.pg.osasli" : "ei6", + "vnd.picsel" : "efif", + "vnd.pmi.widget" : "wg", + "vnd.pocketlearn" : "plf", + "vnd.powerbuilder6" : "pbd", + "vnd.previewsystems.box" : "box", + "vnd.proteus.magazine" : "mgz", + "vnd.publishare-delta-tree" : "qps", + "vnd.pvi.ptid1" : "ptid", + "vnd.quark.quarkxpress" : [ "qxd", "qxt", "qwd", "qwt", "qxl", "qxb" ], + "vnd.realvnc.bed" : "bed", + "vnd.recordare.musicxml" : "mxl", + "vnd.recordare.musicxml+xml" : "musicxml", + "vnd.rig.cryptonote" : "cryptonote", + "vnd.rn-realmedia" : "rm", + "vnd.rn-realmedia-vbr" : "rmvb", + "vnd.route66.link66+xml" : "link66", + "vnd.sailingtracker.track" : "st", + "vnd.seemail" : "see", + "vnd.sema" : "sema", + "vnd.semd" : "semd", + "vnd.semf" : "semf", + "vnd.shana.informed.formdata" : "ifm", + "vnd.shana.informed.formtemplate" : "itp", + "vnd.shana.informed.interchange" : "iif", + "vnd.shana.informed.package" : "ipk", + "vnd.simtech-mindmapper" : [ "twd", "twds" ], + "vnd.smart.teacher" : "teacher", + "vnd.solent.sdkm+xml" : [ "sdkm", "sdkd" ], + "vnd.spotfire.dxp" : "dxp", + "vnd.spotfire.sfs" : "sfs", + "vnd.stepmania.package" : "smzip", + "vnd.stepmania.stepchart" : "sm", + "vnd.sus-calendar" : [ "sus", "susp" ], + "vnd.svd" : "svd", + "vnd.syncml+xml" : "xsm", + "vnd.syncml.dm+wbxml" : "bdm", + "vnd.syncml.dm+xml" : "xdm", + "vnd.tao.intent-module-archive" : "tao", + "vnd.tcpdump.pcap" : [ "pcap", "cap", "dmp" ], + "vnd.tmobile-livetv" : "tmo", + "vnd.trid.tpt" : "tpt", + "vnd.triscape.mxs" : "mxs", + "vnd.trueapp" : "tra", + "vnd.ufdl" : [ "ufd", "ufdl" ], + "vnd.uiq.theme" : "utz", + "vnd.umajin" : "umj", + "vnd.unity" : "unityweb", + "vnd.uoml+xml" : "uoml", + "vnd.vcx" : "vcx", + "vnd.visionary" : "vis", + "vnd.vsf" : "vsf", + "vnd.webturbo" : "wtb", + "vnd.wolfram.player" : "nbp", + "vnd.wqd" : "wqd", + "vnd.wt.stf" : "stf", + "vnd.xara" : "xar", + "vnd.xfdl" : "xfdl", + "vnd.yamaha.hv-dic" : "hvd", + "vnd.yamaha.hv-script" : "hvs", + "vnd.yamaha.hv-voice" : "hvp", + "vnd.yamaha.openscoreformat" : "osf", + "vnd.yamaha.openscoreformat.osfpvg+xml" : "osfpvg", + "vnd.yamaha.smaf-audio" : "saf", + "vnd.yamaha.smaf-phrase" : "spf", + "vnd.yellowriver-custom-menu" : "cmp", + "vnd.zul" : [ "zir", "zirz" ], + "vnd.zzazz.deck+xml" : "zaz", + "voicexml+xml" : "vxml", + "widget" : "wgt", + "winhlp" : "hlp", + "wsdl+xml" : "wsdl", + "wspolicy+xml" : "wspolicy", + "x-ace-compressed" : "ace", + "x-authorware-bin" : [ "aab", "x32", "u32", "vox" ], + "x-authorware-map" : "aam", + "x-authorware-seg" : "aas", + "x-blorb" : [ "blb", "blorb" ], + "x-bzip" : "bz", + "x-bzip2" : [ "bz2", "boz" ], + "x-cfs-compressed" : "cfs", + "x-chat" : "chat", + "x-conference" : "nsc", + "x-dgc-compressed" : "dgc", + "x-dtbncx+xml" : "ncx", + "x-dtbook+xml" : "dtb", + "x-dtbresource+xml" : "res", + "x-eva" : "eva", + "x-font-bdf" : "bdf", + "x-font-ghostscript" : "gsf", + "x-font-linux-psf" : "psf", + "x-font-otf" : "otf", + "x-font-pcf" : "pcf", + "x-font-snf" : "snf", + "x-font-ttf" : [ "ttf", "ttc" ], + "x-font-type1" : [ "pfa", "pfb", "pfm", "afm" ], + "x-font-woff" : "woff", + "x-freearc" : "arc", + "x-gca-compressed" : "gca", + "x-glulx" : "ulx", + "x-gramps-xml" : "gramps", + "x-install-instructions" : "install", + "x-lzh-compressed" : [ "lzh", "lha" ], + "x-mie" : "mie", + "x-mobipocket-ebook" : [ "prc", "mobi" ], + "x-ms-application" : "application", + "x-ms-shortcut" : "lnk", + "x-ms-xbap" : "xbap", + "x-msbinder" : "obd", + "x-mscardfile" : "crd", + "x-msclip" : "clp", + "x-msdownload" : [ "exe", "dll", "com", "bat", "msi" ], + "x-msmediaview" : [ "mvb", "m13", "m14" ], + "x-msmetafile" : [ "wmf", "wmz", "emf", "emz" ], + "x-msmoney" : "mny", + "x-mspublisher" : "pub", + "x-msschedule" : "scd", + "x-msterminal" : "trm", + "x-mswrite" : "wri", + "x-nzb" : "nzb", + "x-pkcs12" : [ "p12", "pfx" ], + "x-pkcs7-certificates" : [ "p7b", "spc" ], + "x-research-info-systems" : "ris", + "x-silverlight-app" : "xap", + "x-sql" : "sql", + "x-stuffitx" : "sitx", + "x-subrip" : "srt", + "x-t3vm-image" : "t3", + "x-tads" : "gam", + "x-tex" : "tex", + "x-tex-tfm" : "tfm", + "x-tgif" : "obj", + "x-xliff+xml" : "xlf", + "x-xz" : "xz", + "x-zmachine" : [ "z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8" ], + "xaml+xml" : "xaml", + "xcap-diff+xml" : "xdf", + "xenc+xml" : "xenc", + "xml-dtd" : "dtd", + "xop+xml" : "xop", + "xproc+xml" : "xpl", + "xslt+xml" : "xslt", + "xv+xml" : [ "mxml", "xhvml", "xvml", "xvm" ], + "yang" : "yang", + "yin+xml" : "yin", + "envoy" : "evy", + "fractals" : "fif", + "internet-property-stream" : "acx", + "olescript" : "axs", + "vnd.ms-outlook" : "msg", + "vnd.ms-pkicertstore" : "sst", + "x-compress" : "z", + "x-compressed" : "tgz", + "x-gzip" : "gz", + "x-perfmon" : [ "pma", "pmc", "pml", "pmr", "pmw" ], + "x-pkcs7-mime" : [ "p7c", "p7m" ], + "ynd.ms-pkipko" : "pko" + }, + "audio" : { + "amr" : "amr", + "amr-wb" : "awb", + "annodex" : "axa", + "basic" : [ "au", "snd" ], + "flac" : "flac", + "midi" : [ "mid", "midi", "kar", "rmi" ], + "mpeg" : [ "mpga", "mpega", "mp2", "mp3", "m4a", "mp2a", "m2a", "m3a" ], + "mpegurl" : "m3u", + "ogg" : [ "oga", "ogg", "spx" ], + "prs.sid" : "sid", + "x-aiff" : [ "aif", "aiff", "aifc" ], + "x-gsm" : "gsm", + "x-ms-wma" : "wma", + "x-ms-wax" : "wax", + "x-pn-realaudio" : "ram", + "x-realaudio" : "ra", + "x-sd2" : "sd2", + "x-wav" : "wav", + "adpcm" : "adp", + "mp4" : "mp4a", + "s3m" : "s3m", + "silk" : "sil", + "vnd.dece.audio" : [ "uva", "uvva" ], + "vnd.digital-winds" : "eol", + "vnd.dra" : "dra", + "vnd.dts" : "dts", + "vnd.dts.hd" : "dtshd", + "vnd.lucent.voice" : "lvp", + "vnd.ms-playready.media.pya" : "pya", + "vnd.nuera.ecelp4800" : "ecelp4800", + "vnd.nuera.ecelp7470" : "ecelp7470", + "vnd.nuera.ecelp9600" : "ecelp9600", + "vnd.rip" : "rip", + "webm" : "weba", + "x-aac" : "aac", + "x-caf" : "caf", + "x-matroska" : "mka", + "x-pn-realaudio-plugin" : "rmp", + "xm" : "xm", + "mid" : [ "mid", "rmi" ] + }, + "chemical" : { + "x-alchemy" : "alc", + "x-cache" : [ "cac", "cache" ], + "x-cache-csf" : "csf", + "x-cactvs-binary" : [ "cbin", "cascii", "ctab" ], + "x-cdx" : "cdx", + "x-chem3d" : "c3d", + "x-cif" : "cif", + "x-cmdf" : "cmdf", + "x-cml" : "cml", + "x-compass" : "cpa", + "x-crossfire" : "bsd", + "x-csml" : [ "csml", "csm" ], + "x-ctx" : "ctx", + "x-cxf" : [ "cxf", "cef" ], + "x-embl-dl-nucleotide" : [ "emb", "embl" ], + "x-gamess-input" : [ "inp", "gam", "gamin" ], + "x-gaussian-checkpoint" : [ "fch", "fchk" ], + "x-gaussian-cube" : "cub", + "x-gaussian-input" : [ "gau", "gjc", "gjf" ], + "x-gaussian-log" : "gal", + "x-gcg8-sequence" : "gcg", + "x-genbank" : "gen", + "x-hin" : "hin", + "x-isostar" : [ "istr", "ist" ], + "x-jcamp-dx" : [ "jdx", "dx" ], + "x-kinemage" : "kin", + "x-macmolecule" : "mcm", + "x-macromodel-input" : [ "mmd", "mmod" ], + "x-mdl-molfile" : "mol", + "x-mdl-rdfile" : "rd", + "x-mdl-rxnfile" : "rxn", + "x-mdl-sdfile" : [ "sd", "sdf" ], + "x-mdl-tgf" : "tgf", + "x-mmcif" : "mcif", + "x-mol2" : "mol2", + "x-molconn-Z" : "b", + "x-mopac-graph" : "gpt", + "x-mopac-input" : [ "mop", "mopcrt", "mpc", "zmt" ], + "x-mopac-out" : "moo", + "x-ncbi-asn1" : "asn", + "x-ncbi-asn1-ascii" : [ "prt", "ent" ], + "x-ncbi-asn1-binary" : [ "val", "aso" ], + "x-pdb" : [ "pdb", "ent" ], + "x-rosdal" : "ros", + "x-swissprot" : "sw", + "x-vamas-iso14976" : "vms", + "x-vmd" : "vmd", + "x-xtel" : "xtel", + "x-xyz" : "xyz" + }, + "image" : { + "gif" : "gif", + "ief" : "ief", + "jpeg" : [ "jpeg", "jpg", "jpe" ], + "pcx" : "pcx", + "png" : "png", + "svg+xml" : [ "svg", "svgz" ], + "tiff" : [ "tiff", "tif" ], + "vnd.djvu" : [ "djvu", "djv" ], + "vnd.wap.wbmp" : "wbmp", + "x-canon-cr2" : "cr2", + "x-canon-crw" : "crw", + "x-cmu-raster" : "ras", + "x-coreldraw" : "cdr", + "x-coreldrawpattern" : "pat", + "x-coreldrawtemplate" : "cdt", + "x-corelphotopaint" : "cpt", + "x-epson-erf" : "erf", + "x-icon" : "ico", + "x-jg" : "art", + "x-jng" : "jng", + "x-nikon-nef" : "nef", + "x-olympus-orf" : "orf", + "x-photoshop" : "psd", + "x-portable-anymap" : "pnm", + "x-portable-bitmap" : "pbm", + "x-portable-graymap" : "pgm", + "x-portable-pixmap" : "ppm", + "x-rgb" : "rgb", + "x-xbitmap" : "xbm", + "x-xpixmap" : "xpm", + "x-xwindowdump" : "xwd", + "bmp" : "bmp", + "cgm" : "cgm", + "g3fax" : "g3", + "ktx" : "ktx", + "prs.btif" : "btif", + "sgi" : "sgi", + "vnd.dece.graphic" : [ "uvi", "uvvi", "uvg", "uvvg" ], + "vnd.dwg" : "dwg", + "vnd.dxf" : "dxf", + "vnd.fastbidsheet" : "fbs", + "vnd.fpx" : "fpx", + "vnd.fst" : "fst", + "vnd.fujixerox.edmics-mmr" : "mmr", + "vnd.fujixerox.edmics-rlc" : "rlc", + "vnd.ms-modi" : "mdi", + "vnd.ms-photo" : "wdp", + "vnd.net-fpx" : "npx", + "vnd.xiff" : "xif", + "webp" : "webp", + "x-3ds" : "3ds", + "x-cmx" : "cmx", + "x-freehand" : [ "fh", "fhc", "fh4", "fh5", "fh7" ], + "x-pict" : [ "pic", "pct" ], + "x-tga" : "tga", + "cis-cod" : "cod", + "pipeg" : "jfif" + }, + "message" : { + "rfc822" : [ "eml", "mime", "mht", "mhtml", "nws" ] + }, + "model" : { + "iges" : [ "igs", "iges" ], + "mesh" : [ "msh", "mesh", "silo" ], + "vrml" : [ "wrl", "vrml" ], + "x3d+vrml" : [ "x3dv", "x3dvz" ], + "x3d+xml" : [ "x3d", "x3dz" ], + "x3d+binary" : [ "x3db", "x3dbz" ], + "vnd.collada+xml" : "dae", + "vnd.dwf" : "dwf", + "vnd.gdl" : "gdl", + "vnd.gtw" : "gtw", + "vnd.mts" : "mts", + "vnd.vtu" : "vtu" + }, + "text" : { + "cache-manifest" : [ "manifest", "appcache" ], + "calendar" : [ "ics", "icz", "ifb" ], + "css" : "css", + "csv" : "csv", + "h323" : "323", + "html" : [ "html", "htm", "shtml", "stm" ], + "iuls" : "uls", + "mathml" : "mml", + "plain" : [ "txt", "text", "brf", "conf", "def", "list", "log", "in", "bas" ], + "richtext" : "rtx", + "scriptlet" : [ "sct", "wsc" ], + "texmacs" : [ "tm", "ts" ], + "tab-separated-values" : "tsv", + "vnd.sun.j2me.app-descriptor" : "jad", + "vnd.wap.wml" : "wml", + "vnd.wap.wmlscript" : "wmls", + "x-bibtex" : "bib", + "x-boo" : "boo", + "x-c++hdr" : [ "h++", "hpp", "hxx", "hh" ], + "x-c++src" : [ "c++", "cpp", "cxx", "cc" ], + "x-component" : "htc", + "x-dsrc" : "d", + "x-diff" : [ "diff", "patch" ], + "x-haskell" : "hs", + "x-java" : "java", + "x-literate-haskell" : "lhs", + "x-moc" : "moc", + "x-pascal" : [ "p", "pas" ], + "x-pcs-gcd" : "gcd", + "x-perl" : [ "pl", "pm" ], + "x-python" : "py", + "x-scala" : "scala", + "x-setext" : "etx", + "x-tcl" : [ "tcl", "tk" ], + "x-tex" : [ "tex", "ltx", "sty", "cls" ], + "x-vcalendar" : "vcs", + "x-vcard" : "vcf", + "n3" : "n3", + "prs.lines.tag" : "dsc", + "sgml" : [ "sgml", "sgm" ], + "troff" : [ "t", "tr", "roff", "man", "me", "ms" ], + "turtle" : "ttl", + "uri-list" : [ "uri", "uris", "urls" ], + "vcard" : "vcard", + "vnd.curl" : "curl", + "vnd.curl.dcurl" : "dcurl", + "vnd.curl.scurl" : "scurl", + "vnd.curl.mcurl" : "mcurl", + "vnd.dvb.subtitle" : "sub", + "vnd.fly" : "fly", + "vnd.fmi.flexstor" : "flx", + "vnd.graphviz" : "gv", + "vnd.in3d.3dml" : "3dml", + "vnd.in3d.spot" : "spot", + "x-asm" : [ "s", "asm" ], + "x-c" : [ "c", "cc", "cxx", "cpp", "h", "hh", "dic" ], + "x-fortran" : [ "f", "for", "f77", "f90" ], + "x-opml" : "opml", + "x-nfo" : "nfo", + "x-sfv" : "sfv", + "x-uuencode" : "uu", + "webviewhtml" : "htt" + }, + "video" : { + "3gpp" : "3gp", + "annodex" : "axv", + "dl" : "dl", + "dv" : [ "dif", "dv" ], + "fli" : "fli", + "gl" : "gl", + "mpeg" : [ "mpeg", "mpg", "mpe", "m1v", "m2v", "mp2", "mpa", "mpv2" ], + "mp4" : [ "mp4", "mp4v", "mpg4" ], + "quicktime" : [ "qt", "mov" ], + "ogg" : "ogv", + "vnd.mpegurl" : [ "mxu", "m4u" ], + "x-flv" : "flv", + "x-la-asf" : [ "lsf", "lsx" ], + "x-mng" : "mng", + "x-ms-asf" : [ "asf", "asx", "asr" ], + "x-ms-wm" : "wm", + "x-ms-wmv" : "wmv", + "x-ms-wmx" : "wmx", + "x-ms-wvx" : "wvx", + "x-msvideo" : "avi", + "x-sgi-movie" : "movie", + "x-matroska" : [ "mpv", "mkv", "mk3d", "mks" ], + "3gpp2" : "3g2", + "h261" : "h261", + "h263" : "h263", + "h264" : "h264", + "jpeg" : "jpgv", + "jpm" : [ "jpm", "jpgm" ], + "mj2" : [ "mj2", "mjp2" ], + "vnd.dece.hd" : [ "uvh", "uvvh" ], + "vnd.dece.mobile" : [ "uvm", "uvvm" ], + "vnd.dece.pd" : [ "uvp", "uvvp" ], + "vnd.dece.sd" : [ "uvs", "uvvs" ], + "vnd.dece.video" : [ "uvv", "uvvv" ], + "vnd.dvb.file" : "dvb", + "vnd.fvt" : "fvt", + "vnd.ms-playready.media.pyv" : "pyv", + "vnd.uvvu.mp4" : [ "uvu", "uvvu" ], + "vnd.vivo" : "viv", + "webm" : "webm", + "x-f4v" : "f4v", + "x-m4v" : "m4v", + "x-ms-vob" : "vob", + "x-smv" : "smv" + }, + "x-conference" : { + "x-cooltalk" : "ice" + }, + "x-world" : { + "x-vrml" : [ "vrm", "vrml", "wrl", "flr", "wrz", "xaf", "xof" ] + } + }; + + var mimeTypes = (function() { + var type, subtype, val, index, mimeTypes = {}; + for (type in table) { + if (table.hasOwnProperty(type)) { + for (subtype in table[type]) { + if (table[type].hasOwnProperty(subtype)) { + val = table[type][subtype]; + if (typeof val == "string") { + mimeTypes[val] = type + "/" + subtype; + } else { + for (index = 0; index < val.length; index++) { + mimeTypes[val[index]] = type + "/" + subtype; + } + } + } + } + } + } + return mimeTypes; + })(); + + zip.getMimeType = function(filename) { + return mimeTypes[filename.split(".").pop()] || "application/octet-stream"; + }; + +})(); diff --git a/zip-fs.js b/zip-fs.js new file mode 100644 index 0000000..ea149ab --- /dev/null +++ b/zip-fs.js @@ -0,0 +1,553 @@ +/* + Copyright (c) 2012 Gildas Lormeau. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the distribution. + + 3. The names of the authors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, + INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, + INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +(function() { + + var CHUNK_SIZE = 512 * 1024; + + var FileWriter = zip.FileWriter, // + TextWriter = zip.TextWriter, // + BlobWriter = zip.BlobWriter, // + Data64URIWriter = zip.Data64URIWriter, // + Reader = zip.Reader, // + TextReader = zip.TextReader, // + BlobReader = zip.BlobReader, // + Data64URIReader = zip.Data64URIReader, // + HttpRangeReader = zip.HttpRangeReader, // + HttpReader = zip.HttpReader, // + createReader = zip.createReader, // + createWriter = zip.createWriter; + + function ZipBlobReader(entry) { + var that = this, blobReader; + + function init(callback, onerror) { + this.size = entry.uncompressedSize; + callback(); + } + + function getData(callback) { + if (that.data) + callback(); + else + entry.getData(new BlobWriter(), function(data) { + that.data = data; + blobReader = new BlobReader(data); + callback(); + }, null, that.checkCrc32); + } + + function readUint8Array(index, length, callback, onerror) { + getData(function() { + blobReader.readUint8Array(index, length, callback, onerror); + }, onerror); + } + + that.size = 0; + that.init = init; + that.readUint8Array = readUint8Array; + } + ZipBlobReader.prototype = new Reader(); + ZipBlobReader.prototype.constructor = ZipBlobReader; + ZipBlobReader.prototype.checkCrc32 = false; + + function getTotalSize(entry) { + var size = 0; + + function process(entry) { + size += entry.uncompressedSize || 0; + entry.children.forEach(process); + } + + process(entry); + return size; + } + + function initReaders(entry, onend, onerror) { + var index = 0; + + function next() { + var child = entry.children[index]; + index++; + if (index < entry.children.length) + process(entry.children[index]); + else + onend(); + } + + function process(child) { + if (child.directory) + initReaders(child, next, onerror); + else { + child.reader = new child.Reader(child.data, onerror); + child.reader.init(function() { + child.uncompressedSize = child.reader.size; + next(); + }); + } + } + + if (entry.children.length) + process(entry.children[index]); + else + onend(); + } + + function detach(entry) { + var children = entry.parent.children; + children.forEach(function(child, index) { + if (child.id == entry.id) + children.splice(index, 1); + }); + } + + function exportZip(zipWriter, entry, onend, onprogress, totalSize) { + var currentIndex = 0; + + function process(zipWriter, entry, onend, onprogress, totalSize) { + var childIndex = 0; + + function exportChild() { + var child = entry.children[childIndex]; + if (child) + zipWriter.add(child.getFullname(), child.reader, function() { + currentIndex += child.uncompressedSize || 0; + process(zipWriter, child, function() { + childIndex++; + exportChild(); + }, onprogress, totalSize); + }, function(index) { + if (onprogress) + onprogress(currentIndex + index, totalSize); + }, { + directory : child.directory, + version : child.zipVersion + }); + else + onend(); + } + + exportChild(); + } + + process(zipWriter, entry, onend, onprogress, totalSize); + } + + function addFileEntry(zipEntry, fileEntry, onend, onerror) { + function getChildren(fileEntry, callback) { + if (fileEntry.isDirectory) + fileEntry.createReader().readEntries(callback); + if (fileEntry.isFile) + callback([]); + } + + function process(zipEntry, fileEntry, onend) { + getChildren(fileEntry, function(children) { + var childIndex = 0; + + function addChild(child) { + function nextChild(childFileEntry) { + process(childFileEntry, child, function() { + childIndex++; + processChild(); + }); + } + + if (child.isDirectory) + nextChild(zipEntry.addDirectory(child.name)); + if (child.isFile) + child.file(function(file) { + var childZipEntry = zipEntry.addBlob(child.name, file); + childZipEntry.uncompressedSize = file.size; + nextChild(childZipEntry); + }, onerror); + } + + function processChild() { + var child = children[childIndex]; + if (child) + addChild(child); + else + onend(); + } + + processChild(); + }); + } + + if (fileEntry.isDirectory) + process(zipEntry, fileEntry, onend); + else + fileEntry.file(function(file) { + zipEntry.addBlob(fileEntry.name, file); + onend(); + }, onerror); + } + + function getFileEntry(fileEntry, entry, onend, onprogress, totalSize, checkCrc32) { + var currentIndex = 0, rootEntry; + + function process(fileEntry, entry, onend, onprogress, totalSize) { + var childIndex = 0; + + function addChild(child) { + function nextChild(childFileEntry) { + currentIndex += child.uncompressedSize || 0; + process(childFileEntry, child, function() { + childIndex++; + processChild(); + }, onprogress, totalSize); + } + + if (child.directory) + fileEntry.getDirectory(child.name, { + create : true + }, nextChild, onerror); + else + fileEntry.getFile(child.name, { + create : true + }, function(file) { + child.getData(new FileWriter(file, zip.getMimeType(child.name)), nextChild, function(index, max) { + if (onprogress) + onprogress(currentIndex + index, totalSize); + }, checkCrc32); + }, onerror); + } + + function processChild() { + var child = entry.children[childIndex]; + if (child) + addChild(child); + else + onend(); + } + + processChild(); + } + + if (entry.directory) + process(fileEntry, entry, onend, onprogress, totalSize); + else + entry.getData(new FileWriter(fileEntry, zip.getMimeType(entry.name)), onend, onprogress, checkCrc32); + } + + function resetFS(fs) { + fs.entries = []; + fs.root = new ZipDirectoryEntry(fs); + } + + function bufferedCopy(reader, writer, onend, onprogress, onerror) { + var chunkIndex = 0; + + function stepCopy() { + var index = chunkIndex * CHUNK_SIZE; + if (onprogress) + onprogress(index, reader.size); + if (index < reader.size) + reader.readUint8Array(index, Math.min(CHUNK_SIZE, reader.size - index), function(array) { + writer.writeUint8Array(new Uint8Array(array), function() { + chunkIndex++; + stepCopy(); + }); + }, onerror); + else + writer.getData(onend); + } + + stepCopy(); + } + + function getEntryData(writer, onend, onprogress, onerror) { + var that = this; + if (!writer || (writer.constructor == that.Writer && that.data)) + onend(that.data); + else { + if (!that.reader) + that.reader = new that.Reader(that.data, onerror); + that.reader.init(function() { + writer.init(function() { + bufferedCopy(that.reader, writer, onend, onprogress, onerror); + }, onerror); + }); + } + } + + function addChild(parent, name, params, directory) { + if (parent.directory) + return directory ? new ZipDirectoryEntry(parent.fs, name, params, parent) : new ZipFileEntry(parent.fs, name, params, parent); + else + throw "Parent entry is not a directory."; + } + + function ZipEntry() { + } + + ZipEntry.prototype = { + init : function(fs, name, params, parent) { + var that = this; + if (fs.root && parent && parent.getChildByName(name)) + throw "Entry filename already exists."; + if (!params) + params = {}; + that.fs = fs; + that.name = name; + that.id = fs.entries.length; + that.parent = parent; + that.children = []; + that.zipVersion = params.zipVersion || 0x14; + that.uncompressedSize = 0; + fs.entries.push(that); + if (parent) + that.parent.children.push(that); + }, + getFileEntry : function(fileEntry, onend, onprogress, onerror, checkCrc32) { + var that = this; + initReaders(that, function() { + getFileEntry(fileEntry, that, onend, onprogress, getTotalSize(that), checkCrc32); + }, onerror); + }, + moveTo : function(target) { + var that = this; + if (target.directory) { + if (!target.isDescendantOf(that)) { + if (that != target) { + if (target.getChildByName(that.name)) + throw "Entry filename already exists."; + detach(that); + that.parent = target; + target.children.push(that); + } + } else + throw "Entry is a ancestor of target entry."; + } else + throw "Target entry is not a directory."; + }, + getFullname : function() { + var that = this, fullname = that.name, entry = that.parent; + while (entry) { + fullname = (entry.name ? entry.name + "/" : "") + fullname; + entry = entry.parent; + } + return fullname; + }, + isDescendantOf : function(ancestor) { + var entry = this.parent; + while (entry && entry.id != ancestor.id) + entry = entry.parent; + return !!entry; + } + }; + ZipEntry.prototype.constructor = ZipEntry; + + var ZipFileEntryProto; + + function ZipFileEntry(fs, name, params, parent) { + var that = this; + ZipEntry.prototype.init.call(that, fs, name, params, parent); + that.Reader = params.Reader; + that.Writer = params.Writer; + that.data = params.data; + that.getData = params.getData || getEntryData; + } + + ZipFileEntry.prototype = ZipFileEntryProto = new ZipEntry(); + ZipFileEntryProto.constructor = ZipFileEntry; + ZipFileEntryProto.getText = function(onend, onprogress, checkCrc32) { + this.getData(new TextWriter(), onend, onprogress, checkCrc32); + }; + ZipFileEntryProto.getBlob = function(mimeType, onend, onprogress, checkCrc32) { + this.getData(new BlobWriter(mimeType), onend, onprogress, checkCrc32); + }; + ZipFileEntryProto.getData64URI = function(mimeType, onend, onprogress, checkCrc32) { + this.getData(new Data64URIWriter(mimeType), onend, onprogress, checkCrc32); + }; + + var ZipDirectoryEntryProto; + + function ZipDirectoryEntry(fs, name, params, parent) { + var that = this; + ZipEntry.prototype.init.call(that, fs, name, params, parent); + that.directory = true; + } + + ZipDirectoryEntry.prototype = ZipDirectoryEntryProto = new ZipEntry(); + ZipDirectoryEntryProto.constructor = ZipDirectoryEntry; + ZipDirectoryEntryProto.addDirectory = function(name) { + return addChild(this, name, null, true); + }; + ZipDirectoryEntryProto.addText = function(name, text) { + return addChild(this, name, { + data : text, + Reader : TextReader, + Writer : TextWriter + }); + }; + ZipDirectoryEntryProto.addBlob = function(name, blob) { + return addChild(this, name, { + data : blob, + Reader : BlobReader, + Writer : BlobWriter + }); + }; + ZipDirectoryEntryProto.addData64URI = function(name, dataURI) { + return addChild(this, name, { + data : dataURI, + Reader : Data64URIReader, + Writer : Data64URIWriter + }); + }; + ZipDirectoryEntryProto.addHttpContent = function(name, URL, useRangeHeader) { + return addChild(this, name, { + data : URL, + Reader : useRangeHeader ? HttpRangeReader : HttpReader + }); + }; + ZipDirectoryEntryProto.addFileEntry = function(fileEntry, onend, onerror) { + addFileEntry(this, fileEntry, onend, onerror); + }; + ZipDirectoryEntryProto.addData = function(name, params) { + return addChild(this, name, params); + }; + ZipDirectoryEntryProto.importBlob = function(blob, onend, onerror) { + this.importZip(new BlobReader(blob), onend, onerror); + }; + ZipDirectoryEntryProto.importText = function(text, onend, onerror) { + this.importZip(new TextReader(text), onend, onerror); + }; + ZipDirectoryEntryProto.importData64URI = function(dataURI, onend, onerror) { + this.importZip(new Data64URIReader(dataURI), onend, onerror); + }; + ZipDirectoryEntryProto.importHttpContent = function(URL, useRangeHeader, onend, onerror) { + this.importZip(useRangeHeader ? new HttpRangeReader(URL) : new HttpReader(URL), onend, onerror); + }; + ZipDirectoryEntryProto.exportBlob = function(onend, onprogress, onerror) { + this.exportZip(new BlobWriter("application/zip"), onend, onprogress, onerror); + }; + ZipDirectoryEntryProto.exportText = function(onend, onprogress, onerror) { + this.exportZip(new TextWriter(), onend, onprogress, onerror); + }; + ZipDirectoryEntryProto.exportFileEntry = function(fileEntry, onend, onprogress, onerror) { + this.exportZip(new FileWriter(fileEntry, "application/zip"), onend, onprogress, onerror); + }; + ZipDirectoryEntryProto.exportData64URI = function(onend, onprogress, onerror) { + this.exportZip(new Data64URIWriter("application/zip"), onend, onprogress, onerror); + }; + ZipDirectoryEntryProto.importZip = function(reader, onend, onerror) { + var that = this; + createReader(reader, function(zipReader) { + zipReader.getEntries(function(entries) { + entries.forEach(function(entry) { + var parent = that, path = entry.filename.split("/"), name = path.pop(); + path.forEach(function(pathPart) { + parent = parent.getChildByName(pathPart) || new ZipDirectoryEntry(that.fs, pathPart, null, parent); + }); + if (!entry.directory) + addChild(parent, name, { + data : entry, + Reader : ZipBlobReader + }); + }); + onend(); + }); + }, onerror); + }; + ZipDirectoryEntryProto.exportZip = function(writer, onend, onprogress, onerror) { + var that = this; + initReaders(that, function() { + createWriter(writer, function(zipWriter) { + exportZip(zipWriter, that, function() { + zipWriter.close(onend); + }, onprogress, getTotalSize(that)); + }, onerror); + }, onerror); + }; + ZipDirectoryEntryProto.getChildByName = function(name) { + var childIndex, child, that = this; + for (childIndex = 0; childIndex < that.children.length; childIndex++) { + child = that.children[childIndex]; + if (child.name == name) + return child; + } + }; + + function FS() { + resetFS(this); + } + FS.prototype = { + remove : function(entry) { + detach(entry); + this.entries[entry.id] = null; + }, + find : function(fullname) { + var index, path = fullname.split("/"), node = this.root; + for (index = 0; node && index < path.length; index++) + node = node.getChildByName(path[index]); + return node; + }, + getById : function(id) { + return this.entries[id]; + }, + importBlob : function(blob, onend, onerror) { + resetFS(this); + this.root.importBlob(blob, onend, onerror); + }, + importText : function(text, onend, onerror) { + resetFS(this); + this.root.importText(text, onend, onerror); + }, + importData64URI : function(dataURI, onend, onerror) { + resetFS(this); + this.root.importData64URI(dataURI, onend, onerror); + }, + importHttpContent : function(URL, useRangeHeader, onend, onerror) { + resetFS(this); + this.root.importHttpContent(URL, useRangeHeader, onend, onerror); + }, + exportBlob : function(onend, onprogress, onerror) { + this.root.exportBlob(onend, onprogress, onerror); + }, + exportText : function(onend, onprogress, onerror) { + this.root.exportText(onend, onprogress, onerror); + }, + exportFileEntry : function(fileEntry, onend, onprogress, onerror) { + this.root.exportFileEntry(fileEntry, onend, onprogress, onerror); + }, + exportData64URI : function(onend, onprogress, onerror) { + this.root.exportData64URI(onend, onprogress, onerror); + } + }; + + zip.fs = { + FS : FS + }; + + zip.getMimeType = function() { + return "application/octet-stream"; + }; + +})(); diff --git a/zip.js b/zip.js new file mode 100644 index 0000000..6f9fbc7 --- /dev/null +++ b/zip.js @@ -0,0 +1,976 @@ +/* + Copyright (c) 2012 Gildas Lormeau. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the distribution. + + 3. The names of the authors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, + INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, + INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +(function(obj) { + + var ERR_BAD_FORMAT = "File format is not recognized."; + var ERR_ENCRYPTED = "File contains encrypted entry."; + var ERR_ZIP64 = "File is using Zip64 (4gb+ file size)."; + var ERR_READ = "Error while reading zip file."; + var ERR_WRITE = "Error while writing zip file."; + var ERR_WRITE_DATA = "Error while writing file data."; + var ERR_READ_DATA = "Error while reading file data."; + var ERR_DUPLICATED_NAME = "File already exists."; + var ERR_HTTP_RANGE = "HTTP Range not supported."; + var CHUNK_SIZE = 512 * 1024; + + var INFLATE_JS = "inflate.js"; + var DEFLATE_JS = "deflate.js"; + + var BlobBuilder = obj.WebKitBlobBuilder || obj.MozBlobBuilder || obj.MSBlobBuilder || obj.BlobBuilder; + + var appendABViewSupported; + + function isAppendABViewSupported() { + if (typeof appendABViewSupported == "undefined") { + var blobBuilder; + blobBuilder = new BlobBuilder(); + blobBuilder.append(getDataHelper(0).view); + appendABViewSupported = blobBuilder.getBlob().size == 0; + } + return appendABViewSupported; + } + + function Crc32() { + var crc = -1, that = this; + that.append = function(data) { + var offset, table = that.table; + for (offset = 0; offset < data.length; offset++) + crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF]; + }; + that.get = function() { + return ~crc; + }; + } + Crc32.prototype.table = (function() { + var i, j, t, table = []; + for (i = 0; i < 256; i++) { + t = i; + for (j = 0; j < 8; j++) + if (t & 1) + t = (t >>> 1) ^ 0xEDB88320; + else + t = t >>> 1; + table[i] = t; + } + return table; + })(); + + function blobSlice(blob, index, length) { + if (blob.slice) + return blob.slice(index, index + length); + else if (blob.webkitSlice) + return blob.webkitSlice(index, index + length); + else if (blob.mozSlice) + return blob.mozSlice(index, index + length); + else if (blob.msSlice) + return blob.msSlice(index, index + length); + } + + function getDataHelper(byteLength, bytes) { + var dataBuffer, dataArray; + dataBuffer = new ArrayBuffer(byteLength); + dataArray = new Uint8Array(dataBuffer); + if (bytes) + dataArray.set(bytes, 0); + return { + buffer : dataBuffer, + array : dataArray, + view : new DataView(dataBuffer) + }; + } + + // Readers + function Reader() { + } + + function TextReader(text) { + var that = this, blobReader; + + function init(callback, onerror) { + var blobBuilder = new BlobBuilder(); + blobBuilder.append(text); + blobReader = new BlobReader(blobBuilder.getBlob("text/plain")); + blobReader.init(function() { + that.size = blobReader.size; + callback(); + }, onerror); + } + + function readUint8Array(index, length, callback, onerror) { + blobReader.readUint8Array(index, length, callback, onerror); + } + + that.size = 0; + that.init = init; + that.readUint8Array = readUint8Array; + } + TextReader.prototype = new Reader(); + TextReader.prototype.constructor = TextReader; + + function Data64URIReader(dataURI) { + var that = this, dataStart; + + function init(callback, onerror) { + var dataEnd = dataURI.length; + while (dataURI.charAt(dataEnd - 1) == "=") + dataEnd--; + dataStart = dataURI.indexOf(",") + 1; + that.size = Math.floor((dataEnd - dataStart) * 0.75); + callback(); + } + + function readUint8Array(index, length, callback, onerror) { + var i, data = getDataHelper(length); + var start = Math.floor(index / 3) * 4; + var end = Math.ceil((index + length) / 3) * 4; + var bytes = obj.atob(dataURI.substring(start + dataStart, end + dataStart)); + var delta = index - Math.floor(start / 4) * 3; + for (i = delta; i < delta + length; i++) + data.array[i - delta] = bytes.charCodeAt(i); + callback(data.array); + } + + that.size = 0; + that.init = init; + that.readUint8Array = readUint8Array; + } + Data64URIReader.prototype = new Reader(); + Data64URIReader.prototype.constructor = Data64URIReader; + + function BlobReader(blob) { + var that = this; + + function init(callback, onerror) { + this.size = blob.size; + callback(); + } + + function readUint8Array(index, length, callback, onerror) { + var reader = new FileReader(); + reader.onload = function(e) { + callback(new Uint8Array(e.target.result)); + }; + reader.onerror = onerror; + reader.readAsArrayBuffer(blobSlice(blob, index, length)); + } + + that.size = 0; + that.init = init; + that.readUint8Array = readUint8Array; + } + BlobReader.prototype = new Reader(); + BlobReader.prototype.constructor = BlobReader; + + function HttpReader(url) { + var that = this; + + function getData(callback, onerror) { + var request; + if (!that.data) { + request = new XMLHttpRequest(); + request.addEventListener("load", function() { + if (!that.size) + that.size = Number(request.getResponseHeader("Content-Length")); + that.data = new Uint8Array(request.response); + callback(); + }, false); + request.addEventListener("error", onerror, false); + request.open("GET", url); + request.responseType = "arraybuffer"; + request.send(); + } else + callback(); + } + + function init(callback, onerror) { + var request = new XMLHttpRequest(); + request.addEventListener("load", function() { + that.size = Number(request.getResponseHeader("Content-Length")); + callback(); + }, false); + request.addEventListener("error", onerror, false); + request.open("HEAD", url); + request.send(); + } + + function readUint8Array(index, length, callback, onerror) { + getData(function() { + callback(new Uint8Array(that.data.subarray(index, index + length))); + }, onerror); + } + + that.size = 0; + that.init = init; + that.readUint8Array = readUint8Array; + } + HttpReader.prototype = new Reader(); + HttpReader.prototype.constructor = HttpReader; + + function HttpRangeReader(url) { + var that = this; + + function init(callback, onerror) { + var request = new XMLHttpRequest(); + request.addEventListener("load", function() { + that.size = Number(request.getResponseHeader("Content-Length")); + if (request.getResponseHeader("Accept-Ranges") == "bytes") + callback(); + else + onerror(ERR_HTTP_RANGE); + }, false); + request.addEventListener("error", onerror, false); + request.open("HEAD", url); + request.send(); + } + + function readArrayBuffer(index, length, callback, onerror) { + var request = new XMLHttpRequest(); + request.open("GET", url); + request.responseType = "arraybuffer"; + request.setRequestHeader("Range", "bytes=" + index + "-" + (index + length - 1)); + request.addEventListener("load", function() { + callback(request.response); + }, false); + request.addEventListener("error", onerror, false); + request.send(); + } + + function readUint8Array(index, length, callback, onerror) { + readArrayBuffer(index, length, function(arraybuffer) { + callback(new Uint8Array(arraybuffer)); + }, onerror); + } + + that.size = 0; + that.init = init; + that.readUint8Array = readUint8Array; + } + HttpRangeReader.prototype = new Reader(); + HttpRangeReader.prototype.constructor = HttpRangeReader; + + // Writers + + function Writer() { + } + Writer.prototype.getData = function(callback) { + callback(this.data); + }; + + function TextWriter() { + var that = this, blobBuilder; + + function init(callback, onerror) { + blobBuilder = new BlobBuilder(); + callback(); + } + + function writeUint8Array(array, callback, onerror) { + blobBuilder.append(isAppendABViewSupported() ? array : array.buffer); + callback(); + } + + function getData(callback) { + var reader = new FileReader(); + reader.onload = function(e) { + callback(e.target.result); + }; + reader.onerror = onerror; + reader.readAsText(blobBuilder.getBlob("text/plain")); + } + + that.init = init; + that.writeUint8Array = writeUint8Array; + that.getData = getData; + } + TextWriter.prototype = new Writer(); + TextWriter.prototype.constructor = TextWriter; + + function Data64URIWriter(contentType) { + var that = this, data = "", pending = ""; + + function init(callback, onerror) { + data += "data:" + (contentType || "") + ";base64,"; + callback(); + } + + function writeUint8Array(array, callback, onerror) { + var i, delta = pending.length, dataString = pending; + pending = ""; + for (i = 0; i < (Math.floor((delta + array.length) / 3) * 3) - delta; i++) + dataString += String.fromCharCode(array[i]); + for (; i < array.length; i++) + pending += String.fromCharCode(array[i]); + if (dataString.length > 2) + data += obj.btoa(dataString); + else + pending = dataString; + callback(); + } + + function getData(callback) { + callback(data + obj.btoa(pending)); + } + + that.init = init; + that.writeUint8Array = writeUint8Array; + that.getData = getData; + } + Data64URIWriter.prototype = new Writer(); + Data64URIWriter.prototype.constructor = Data64URIWriter; + + function FileWriter(fileEntry, contentType) { + var writer, that = this; + + function init(callback, onerror) { + fileEntry.createWriter(function(fileWriter) { + writer = fileWriter; + callback(); + }, onerror); + } + + function writeUint8Array(array, callback, onerror) { + var blobBuilder = new BlobBuilder(); + blobBuilder.append(isAppendABViewSupported() ? array : array.buffer); + writer.onwrite = function() { + writer.onwrite = null; + callback(); + }; + writer.onerror = onerror; + writer.write(blobBuilder.getBlob(contentType)); + } + + function getData(callback) { + fileEntry.file(callback); + } + + that.init = init; + that.writeUint8Array = writeUint8Array; + that.getData = getData; + } + FileWriter.prototype = new Writer(); + FileWriter.prototype.constructor = FileWriter; + + function BlobWriter(contentType) { + var blobBuilder, that = this; + + function init(callback, onerror) { + blobBuilder = new BlobBuilder(); + callback(); + } + + function writeUint8Array(array, callback, onerror) { + blobBuilder.append(isAppendABViewSupported() ? array : array.buffer); + callback(); + } + + function getData(callback) { + callback(blobBuilder.getBlob(contentType)); + } + + that.init = init; + that.writeUint8Array = writeUint8Array; + that.getData = getData; + } + BlobWriter.prototype = new Writer(); + BlobWriter.prototype.constructor = BlobWriter; + + // inflate/deflate core functions + + function launchWorkerProcess(worker, reader, writer, offset, size, onappend, onprogress, onend, onreaderror, onwriteerror) { + var chunkIndex = 0, index, outputSize; + + function onflush() { + worker.removeEventListener("message", onmessage, false); + onend(outputSize); + } + + function onmessage(event) { + var message = event.data, data = message.data; + + if (message.onappend) { + outputSize += data.length; + writer.writeUint8Array(data, function() { + onappend(false, data); + step(); + }, onwriteerror); + } + if (message.onflush) + if (data) { + outputSize += data.length; + writer.writeUint8Array(data, function() { + onappend(false, data); + onflush(); + }, onwriteerror); + } else + onflush(); + if (message.progress && onprogress) + onprogress(index + message.current, size); + } + + function step() { + index = chunkIndex * CHUNK_SIZE; + if (index < size) + reader.readUint8Array(offset + index, Math.min(CHUNK_SIZE, size - index), function(array) { + worker.postMessage({ + append : true, + data : array + }); + chunkIndex++; + if (onprogress) + onprogress(index, size); + onappend(true, array); + }, onreaderror); + else + worker.postMessage({ + flush : true + }); + } + + outputSize = 0; + worker.addEventListener("message", onmessage, false); + step(); + } + + function launchProcess(process, reader, writer, offset, size, onappend, onprogress, onend, onreaderror, onwriteerror) { + var chunkIndex = 0, index, outputSize = 0; + + function step() { + var outputData; + index = chunkIndex * CHUNK_SIZE; + if (index < size) + reader.readUint8Array(offset + index, Math.min(CHUNK_SIZE, size - index), function(inputData) { + var outputData = process.append(inputData, function() { + if (onprogress) + onprogress(offset + index, size); + }); + outputSize += outputData.length; + onappend(true, inputData); + writer.writeUint8Array(outputData, function() { + onappend(false, outputData); + chunkIndex++; + setTimeout(step, 1); + }, onwriteerror); + if (onprogress) + onprogress(index, size); + }, onreaderror); + else { + outputData = process.flush(); + if (outputData) { + outputSize += outputData.length; + writer.writeUint8Array(outputData, function() { + onappend(false, outputData); + onend(outputSize); + }, onwriteerror); + } else + onend(outputSize); + } + } + + step(); + } + + function inflate(reader, writer, offset, size, computeCrc32, onend, onprogress, onreaderror, onwriteerror) { + var worker, crc32 = new Crc32(); + + function oninflateappend(sending, array) { + if (computeCrc32 && !sending) + crc32.append(array); + } + + function oninflateend(outputSize) { + onend(outputSize, crc32.get()); + } + + if (obj.zip.useWebWorkers) { + worker = new Worker(obj.zip.workerScriptsPath + INFLATE_JS); + launchWorkerProcess(worker, reader, writer, offset, size, oninflateappend, onprogress, oninflateend, onreaderror, onwriteerror); + } else + launchProcess(new obj.zip.Inflater(), reader, writer, offset, size, oninflateappend, onprogress, oninflateend, onreaderror, onwriteerror); + return worker; + } + + function deflate(reader, writer, level, onend, onprogress, onreaderror, onwriteerror) { + var worker, crc32 = new Crc32(); + + function ondeflateappend(sending, array) { + if (sending) + crc32.append(array); + } + + function ondeflateend(outputSize) { + onend(outputSize, crc32.get()); + } + + function onmessage() { + worker.removeEventListener("message", onmessage, false); + launchWorkerProcess(worker, reader, writer, 0, reader.size, ondeflateappend, onprogress, ondeflateend, onreaderror, onwriteerror); + } + + if (obj.zip.useWebWorkers) { + worker = new Worker(obj.zip.workerScriptsPath + DEFLATE_JS); + worker.addEventListener("message", onmessage, false); + worker.postMessage({ + init : true, + level : level + }); + } else + launchProcess(new obj.zip.Deflater(), reader, writer, 0, reader.size, ondeflateappend, onprogress, ondeflateend, onreaderror, onwriteerror); + return worker; + } + + function copy(reader, writer, offset, size, computeCrc32, onend, onprogress, onreaderror, onwriteerror) { + var chunkIndex = 0, crc32 = new Crc32(); + + function step() { + var index = chunkIndex * CHUNK_SIZE; + if (index < size) + reader.readUint8Array(offset + index, Math.min(CHUNK_SIZE, size - index), function(array) { + if (computeCrc32) + crc32.append(array); + if (onprogress) + onprogress(index, size, array); + writer.writeUint8Array(array, function() { + chunkIndex++; + step(); + }, onwriteerror); + }, onreaderror); + else + onend(size, crc32.get()); + } + + step(); + } + + // ZipReader + + function decodeASCII(str) { + var i, out = "", charCode, extendedASCII = [ '\u00C7', '\u00FC', '\u00E9', '\u00E2', '\u00E4', '\u00E0', '\u00E5', '\u00E7', '\u00EA', '\u00EB', + '\u00E8', '\u00EF', '\u00EE', '\u00EC', '\u00C4', '\u00C5', '\u00C9', '\u00E6', '\u00C6', '\u00F4', '\u00F6', '\u00F2', '\u00FB', '\u00F9', + '\u00FF', '\u00D6', '\u00DC', '\u00F8', '\u00A3', '\u00D8', '\u00D7', '\u0192', '\u00E1', '\u00ED', '\u00F3', '\u00FA', '\u00F1', '\u00D1', + '\u00AA', '\u00BA', '\u00BF', '\u00AE', '\u00AC', '\u00BD', '\u00BC', '\u00A1', '\u00AB', '\u00BB', '_', '_', '_', '\u00A6', '\u00A6', + '\u00C1', '\u00C2', '\u00C0', '\u00A9', '\u00A6', '\u00A6', '+', '+', '\u00A2', '\u00A5', '+', '+', '-', '-', '+', '-', '+', '\u00E3', + '\u00C3', '+', '+', '-', '-', '\u00A6', '-', '+', '\u00A4', '\u00F0', '\u00D0', '\u00CA', '\u00CB', '\u00C8', 'i', '\u00CD', '\u00CE', + '\u00CF', '+', '+', '_', '_', '\u00A6', '\u00CC', '_', '\u00D3', '\u00DF', '\u00D4', '\u00D2', '\u00F5', '\u00D5', '\u00B5', '\u00FE', + '\u00DE', '\u00DA', '\u00DB', '\u00D9', '\u00FD', '\u00DD', '\u00AF', '\u00B4', '\u00AD', '\u00B1', '_', '\u00BE', '\u00B6', '\u00A7', + '\u00F7', '\u00B8', '\u00B0', '\u00A8', '\u00B7', '\u00B9', '\u00B3', '\u00B2', '_', ' ' ]; + for (i = 0; i < str.length; i++) { + charCode = str.charCodeAt(i) & 0xFF; + if (charCode > 127) + out += extendedASCII[charCode - 128]; + else + out += String.fromCharCode(charCode); + } + return out; + } + + function decodeUTF8(str_data) { + var tmp_arr = [], i = 0, ac = 0, c1 = 0, c2 = 0, c3 = 0; + + str_data += ''; + + while (i < str_data.length) { + c1 = str_data.charCodeAt(i); + if (c1 < 128) { + tmp_arr[ac++] = String.fromCharCode(c1); + i++; + } else if (c1 > 191 && c1 < 224) { + c2 = str_data.charCodeAt(i + 1); + tmp_arr[ac++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63)); + i += 2; + } else { + c2 = str_data.charCodeAt(i + 1); + c3 = str_data.charCodeAt(i + 2); + tmp_arr[ac++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)); + i += 3; + } + } + + return tmp_arr.join(''); + } + + function getString(bytes) { + var i, str = ""; + for (i = 0; i < bytes.length; i++) + str += String.fromCharCode(bytes[i]); + return str; + } + + function getDate(timeRaw) { + var date = (timeRaw & 0xffff0000) >> 16, time = timeRaw & 0x0000ffff; + try { + return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, + (time & 0x001F) * 2, 0); + } catch (e) { + } + } + + function readCommonHeader(entry, data, index, centralDirectory) { + entry.version = data.view.getUint16(index, true); + entry.bitFlag = data.view.getUint16(index + 2, true); + entry.compressionMethod = data.view.getUint16(index + 4, true); + entry.lastModDateRaw = data.view.getUint32(index + 6, true); + entry.lastModDate = getDate(entry.lastModDateRaw); + if ((entry.bitFlag & 0x01) === 0x01) { + onerror(ERR_ENCRYPTED); + return; + } + if (centralDirectory || (entry.bitFlag & 0x0008) != 0x0008) { + entry.crc32 = data.view.getUint32(index + 10, true); + entry.compressedSize = data.view.getUint32(index + 14, true); + entry.uncompressedSize = data.view.getUint32(index + 18, true); + } + if (entry.compressedSize === 0xFFFFFFFF || entry.uncompressedSize === 0xFFFFFFFF) { + onerror(ERR_ZIP64); + return; + } + entry.filenameLength = data.view.getUint16(index + 22, true); + entry.extraFieldLength = data.view.getUint16(index + 24, true); + } + + function createZipReader(reader, onerror) { + function Entry() { + } + + Entry.prototype.getData = function(writer, onend, onprogress, checkCrc32) { + var that = this, worker; + + function terminate(callback, param) { + if (worker) + worker.terminate(); + worker = null; + if (callback) + callback(param); + } + + function testCrc32(crc32) { + var dataCrc32 = getDataHelper(4); + dataCrc32.view.setUint32(0, crc32); + return that.crc32 == dataCrc32.view.getUint32(0); + } + + function getWriterData(uncompressedSize, crc32) { + if (checkCrc32 && !testCrc32(crc32)) + onreaderror(); + else + writer.getData(function(data) { + terminate(onend, data); + }); + } + + function onreaderror() { + terminate(onerror, ERR_READ_DATA); + } + + function onwriteerror() { + terminate(onerror, ERR_WRITE_DATA); + } + + reader.readUint8Array(that.offset, 30, function(bytes) { + var data = getDataHelper(bytes.length, bytes), dataOffset; + if (data.view.getUint32(0) != 0x504b0304) { + onerror(ERR_BAD_FORMAT); + return; + } + readCommonHeader(that, data, 4); + dataOffset = that.offset + 30 + that.filenameLength + that.extraFieldLength; + writer.init(function() { + if (that.compressionMethod === 0) + copy(reader, writer, dataOffset, that.compressedSize, checkCrc32, getWriterData, onprogress, onreaderror, onwriteerror); + else + worker = inflate(reader, writer, dataOffset, that.compressedSize, checkCrc32, getWriterData, onprogress, onreaderror, onwriteerror); + }, onwriteerror); + }, onreaderror); + }; + + return { + getEntries : function(callback) { + if (reader.size < 22) { + onerror(ERR_BAD_FORMAT); + return; + } + reader.readUint8Array(reader.size - 22, 22, function(bytes) { + var dataView = getDataHelper(bytes.length, bytes).view, datalength, fileslength; + if (dataView.getUint32(0) != 0x504b0506) { + onerror(ERR_BAD_FORMAT); + return; + } + datalength = dataView.getUint32(16, true); + fileslength = dataView.getUint16(8, true); + reader.readUint8Array(datalength, reader.size - datalength, function(bytes) { + var i, index = 0, entries = [], entry, filename, comment, data = getDataHelper(bytes.length, bytes); + for (i = 0; i < fileslength; i++) { + entry = new Entry(); + if (data.view.getUint32(index) != 0x504b0102) { + onerror(ERR_BAD_FORMAT); + return; + } + readCommonHeader(entry, data, index + 6, true); + entry.commentLength = data.view.getUint16(index + 32, true); + entry.directory = ((data.view.getUint8(index + 38) & 0x10) == 0x10); + entry.offset = data.view.getUint32(index + 42, true); + filename = getString(data.array.subarray(index + 46, index + 46 + entry.filenameLength)); + entry.filename = ((entry.bitFlag & 0x0800) === 0x0800) ? decodeUTF8(filename) : decodeASCII(filename); + if (!entry.directory && entry.filename.charAt(entry.filename.length - 1) == "/") + entry.directory = true; + comment = getString(data.array.subarray(index + 46 + entry.filenameLength + entry.extraFieldLength, index + 46 + + entry.filenameLength + entry.extraFieldLength + entry.commentLength)); + entry.comment = ((entry.bitFlag & 0x0800) === 0x0800) ? decodeUTF8(comment) : decodeASCII(comment); + entries.push(entry); + index += 46 + entry.filenameLength + entry.extraFieldLength + entry.commentLength; + } + callback(entries); + }, function() { + onerror(ERR_READ); + }); + }, function() { + onerror(ERR_READ); + }); + }, + close : function(callback) { + if (callback) + callback(); + } + }; + } + + // ZipWriter + + function encodeUTF8(string) { + var n, c1, enc, utftext = [], start = 0, end = 0, stringl = string.length; + for (n = 0; n < stringl; n++) { + c1 = string.charCodeAt(n); + enc = null; + if (c1 < 128) + end++; + else if (c1 > 127 && c1 < 2048) + enc = String.fromCharCode((c1 >> 6) | 192) + String.fromCharCode((c1 & 63) | 128); + else + enc = String.fromCharCode((c1 >> 12) | 224) + String.fromCharCode(((c1 >> 6) & 63) | 128) + String.fromCharCode((c1 & 63) | 128); + if (enc != null) { + if (end > start) + utftext += string.slice(start, end); + utftext += enc; + start = end = n + 1; + } + } + if (end > start) + utftext += string.slice(start, stringl); + return utftext; + } + + function getBytes(str) { + var i, array = []; + for (i = 0; i < str.length; i++) + array.push(str.charCodeAt(i)); + return array; + } + + function createZipWriter(writer, onerror, dontDeflate) { + var worker, files = [], filenames = [], datalength = 0; + + function terminate(callback, message) { + if (worker) + worker.terminate(); + worker = null; + if (callback) + callback(message); + } + + function onwriteerror() { + terminate(onerror, ERR_WRITE); + } + + function onreaderror() { + terminate(onerror, ERR_READ_DATA); + } + + return { + add : function(name, reader, onend, onprogress, options) { + var header, filename, date; + + function writeHeader(callback) { + var data; + date = options.lastModDate || new Date(); + header = getDataHelper(26); + files[name] = { + headerArray : header.array, + directory : options.directory, + filename : filename, + offset : datalength, + comment : getBytes(encodeUTF8(options.comment || "")) + }; + header.view.setUint32(0, 0x14000808); + if (options.version) + header.view.setUint8(0, options.version); + if (!dontDeflate && options.level != 0) + header.view.setUint16(4, 0x0800); + header.view.setUint16(6, (((date.getHours() << 6) | date.getMinutes()) << 5) | date.getSeconds() / 2, true); + header.view.setUint16(8, ((((date.getFullYear() - 1980) << 4) | (date.getMonth() + 1)) << 5) | date.getDate(), true); + header.view.setUint16(22, filename.length, true); + data = getDataHelper(30 + filename.length); + data.view.setUint32(0, 0x504b0304); + data.array.set(header.array, 4); + data.array.set([], 30); // FIXME: remove when chrome 18 will be stable (14: OK, 16: KO, 17: OK) + data.array.set(filename, 30); + datalength += data.array.length; + writer.writeUint8Array(data.array, callback, onwriteerror); + } + + function writeFooter(compressedLength, crc32) { + var footer = getDataHelper(16); + datalength += compressedLength || 0; + footer.view.setUint32(0, 0x504b0708); + if (typeof crc32 != "undefined") { + header.view.setUint32(10, crc32, true); + footer.view.setUint32(4, crc32, true); + } + if (reader) { + footer.view.setUint32(8, compressedLength, true); + header.view.setUint32(14, compressedLength, true); + footer.view.setUint32(12, reader.size, true); + header.view.setUint32(18, reader.size, true); + } + writer.writeUint8Array(footer.array, function() { + datalength += 16; + terminate(onend); + }, onwriteerror); + } + + function writeFile() { + options = options || {}; + name = name.trim(); + if (options.directory && name.charAt(name.length - 1) != "/") + name += "/"; + if (files[name]) + throw ERR_DUPLICATED_NAME; + filename = getBytes(encodeUTF8(name)); + filenames.push(name); + writeHeader(function() { + if (reader) + if (dontDeflate || options.level == 0) + copy(reader, writer, 0, reader.size, true, writeFooter, onprogress, onreaderror, onwriteerror); + else + worker = deflate(reader, writer, options.level, writeFooter, onprogress, onreaderror, onwriteerror); + else + writeFooter(); + }, onwriteerror); + } + + if (reader) + reader.init(writeFile, onreaderror); + else + writeFile(); + }, + close : function(callback) { + var data, length = 0, index = 0; + filenames.forEach(function(name) { + var file = files[name]; + length += 46 + file.filename.length + file.comment.length; + }); + data = getDataHelper(length + 22); + filenames.forEach(function(name) { + var file = files[name]; + data.view.setUint32(index, 0x504b0102); + data.view.setUint16(index + 4, 0x1400); + data.array.set(file.headerArray, index + 6); + data.view.setUint16(index + 32, file.comment.length, true); + if (file.directory) + data.view.setUint8(index + 38, 0x10); + data.view.setUint32(index + 42, file.offset, true); + data.array.set(file.filename, index + 46); + data.array.set(file.comment, index + 46 + file.filename.length); + index += 46 + file.filename.length + file.comment.length; + }); + data.view.setUint32(index, 0x504b0506); + data.view.setUint16(index + 8, filenames.length, true); + data.view.setUint16(index + 10, filenames.length, true); + data.view.setUint32(index + 12, length, true); + data.view.setUint32(index + 16, datalength, true); + writer.writeUint8Array(data.array, function() { + terminate(function() { + writer.getData(callback); + }); + }, onwriteerror); + } + }; + } + + if (typeof BlobBuilder == "undefined") { + BlobBuilder = function() { + var that = this, blobParts; + + function initBlobParts() { + if (!blobParts) { + blobParts = [ new Blob() ] + } + } + + that.append = function(data) { + initBlobParts(); + blobParts.push(data); + }; + that.getBlob = function(contentType) { + initBlobParts(); + if (blobParts.length > 1 || blobParts[0].type != contentType) { + blobParts = [ contentType ? new Blob(blobParts, { + type : contentType + }) : new Blob(blobParts) ]; + } + return blobParts[0]; + }; + }; + } + + obj.zip = { + Reader : Reader, + Writer : Writer, + BlobReader : BlobReader, + HttpReader : HttpReader, + HttpRangeReader : HttpRangeReader, + Data64URIReader : Data64URIReader, + TextReader : TextReader, + BlobWriter : BlobWriter, + FileWriter : FileWriter, + Data64URIWriter : Data64URIWriter, + TextWriter : TextWriter, + createReader : function(reader, callback, onerror) { + reader.init(function() { + callback(createZipReader(reader, onerror)); + }, onerror); + }, + createWriter : function(writer, callback, onerror, dontDeflate) { + writer.init(function() { + callback(createZipWriter(writer, onerror, dontDeflate)); + }, onerror); + }, + workerScriptsPath : "", + useWebWorkers : true + }; + +})(this);