langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/internal/toolkit/resources/jquery/jszip/dist/jszip.js
changeset 33920 bd731341c405
equal deleted inserted replaced
33919:e9fccc09cfc6 33920:bd731341c405
       
     1 /*!
       
     2 
       
     3 JSZip - A Javascript class for generating and reading zip files
       
     4 <http://stuartk.com/jszip>
       
     5 
       
     6 (c) 2009-2014 Stuart Knightley <stuart [at] stuartk.com>
       
     7 Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/master/LICENSE.markdown.
       
     8 
       
     9 JSZip uses the library pako released under the MIT license :
       
    10 https://github.com/nodeca/pako/blob/master/LICENSE
       
    11 */
       
    12 !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.JSZip=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
       
    13 'use strict';
       
    14 // private property
       
    15 var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
       
    16 
       
    17 
       
    18 // public method for encoding
       
    19 exports.encode = function(input, utf8) {
       
    20     var output = "";
       
    21     var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
       
    22     var i = 0;
       
    23 
       
    24     while (i < input.length) {
       
    25 
       
    26         chr1 = input.charCodeAt(i++);
       
    27         chr2 = input.charCodeAt(i++);
       
    28         chr3 = input.charCodeAt(i++);
       
    29 
       
    30         enc1 = chr1 >> 2;
       
    31         enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
       
    32         enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
       
    33         enc4 = chr3 & 63;
       
    34 
       
    35         if (isNaN(chr2)) {
       
    36             enc3 = enc4 = 64;
       
    37         }
       
    38         else if (isNaN(chr3)) {
       
    39             enc4 = 64;
       
    40         }
       
    41 
       
    42         output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
       
    43 
       
    44     }
       
    45 
       
    46     return output;
       
    47 };
       
    48 
       
    49 // public method for decoding
       
    50 exports.decode = function(input, utf8) {
       
    51     var output = "";
       
    52     var chr1, chr2, chr3;
       
    53     var enc1, enc2, enc3, enc4;
       
    54     var i = 0;
       
    55 
       
    56     input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
       
    57 
       
    58     while (i < input.length) {
       
    59 
       
    60         enc1 = _keyStr.indexOf(input.charAt(i++));
       
    61         enc2 = _keyStr.indexOf(input.charAt(i++));
       
    62         enc3 = _keyStr.indexOf(input.charAt(i++));
       
    63         enc4 = _keyStr.indexOf(input.charAt(i++));
       
    64 
       
    65         chr1 = (enc1 << 2) | (enc2 >> 4);
       
    66         chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
       
    67         chr3 = ((enc3 & 3) << 6) | enc4;
       
    68 
       
    69         output = output + String.fromCharCode(chr1);
       
    70 
       
    71         if (enc3 != 64) {
       
    72             output = output + String.fromCharCode(chr2);
       
    73         }
       
    74         if (enc4 != 64) {
       
    75             output = output + String.fromCharCode(chr3);
       
    76         }
       
    77 
       
    78     }
       
    79 
       
    80     return output;
       
    81 
       
    82 };
       
    83 
       
    84 },{}],2:[function(_dereq_,module,exports){
       
    85 'use strict';
       
    86 function CompressedObject() {
       
    87     this.compressedSize = 0;
       
    88     this.uncompressedSize = 0;
       
    89     this.crc32 = 0;
       
    90     this.compressionMethod = null;
       
    91     this.compressedContent = null;
       
    92 }
       
    93 
       
    94 CompressedObject.prototype = {
       
    95     /**
       
    96      * Return the decompressed content in an unspecified format.
       
    97      * The format will depend on the decompressor.
       
    98      * @return {Object} the decompressed content.
       
    99      */
       
   100     getContent: function() {
       
   101         return null; // see implementation
       
   102     },
       
   103     /**
       
   104      * Return the compressed content in an unspecified format.
       
   105      * The format will depend on the compressed conten source.
       
   106      * @return {Object} the compressed content.
       
   107      */
       
   108     getCompressedContent: function() {
       
   109         return null; // see implementation
       
   110     }
       
   111 };
       
   112 module.exports = CompressedObject;
       
   113 
       
   114 },{}],3:[function(_dereq_,module,exports){
       
   115 'use strict';
       
   116 exports.STORE = {
       
   117     magic: "\x00\x00",
       
   118     compress: function(content, compressionOptions) {
       
   119         return content; // no compression
       
   120     },
       
   121     uncompress: function(content) {
       
   122         return content; // no compression
       
   123     },
       
   124     compressInputType: null,
       
   125     uncompressInputType: null
       
   126 };
       
   127 exports.DEFLATE = _dereq_('./flate');
       
   128 
       
   129 },{"./flate":8}],4:[function(_dereq_,module,exports){
       
   130 'use strict';
       
   131 
       
   132 var utils = _dereq_('./utils');
       
   133 
       
   134 var table = [
       
   135     0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
       
   136     0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
       
   137     0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
       
   138     0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
       
   139     0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
       
   140     0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
       
   141     0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
       
   142     0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
       
   143     0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
       
   144     0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
       
   145     0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
       
   146     0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
       
   147     0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
       
   148     0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
       
   149     0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
       
   150     0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
       
   151     0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
       
   152     0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
       
   153     0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
       
   154     0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
       
   155     0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
       
   156     0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
       
   157     0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
       
   158     0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
       
   159     0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
       
   160     0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
       
   161     0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
       
   162     0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
       
   163     0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
       
   164     0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
       
   165     0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
       
   166     0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
       
   167     0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
       
   168     0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
       
   169     0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
       
   170     0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
       
   171     0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
       
   172     0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
       
   173     0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
       
   174     0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
       
   175     0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
       
   176     0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
       
   177     0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
       
   178     0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
       
   179     0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
       
   180     0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
       
   181     0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
       
   182     0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
       
   183     0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
       
   184     0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
       
   185     0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
       
   186     0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
       
   187     0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
       
   188     0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
       
   189     0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
       
   190     0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
       
   191     0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
       
   192     0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
       
   193     0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
       
   194     0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
       
   195     0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
       
   196     0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
       
   197     0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
       
   198     0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
       
   199 ];
       
   200 
       
   201 /**
       
   202  *
       
   203  *  Javascript crc32
       
   204  *  http://www.webtoolkit.info/
       
   205  *
       
   206  */
       
   207 module.exports = function crc32(input, crc) {
       
   208     if (typeof input === "undefined" || !input.length) {
       
   209         return 0;
       
   210     }
       
   211 
       
   212     var isArray = utils.getTypeOf(input) !== "string";
       
   213 
       
   214     if (typeof(crc) == "undefined") {
       
   215         crc = 0;
       
   216     }
       
   217     var x = 0;
       
   218     var y = 0;
       
   219     var b = 0;
       
   220 
       
   221     crc = crc ^ (-1);
       
   222     for (var i = 0, iTop = input.length; i < iTop; i++) {
       
   223         b = isArray ? input[i] : input.charCodeAt(i);
       
   224         y = (crc ^ b) & 0xFF;
       
   225         x = table[y];
       
   226         crc = (crc >>> 8) ^ x;
       
   227     }
       
   228 
       
   229     return crc ^ (-1);
       
   230 };
       
   231 // vim: set shiftwidth=4 softtabstop=4:
       
   232 
       
   233 },{"./utils":21}],5:[function(_dereq_,module,exports){
       
   234 'use strict';
       
   235 var utils = _dereq_('./utils');
       
   236 
       
   237 function DataReader(data) {
       
   238     this.data = null; // type : see implementation
       
   239     this.length = 0;
       
   240     this.index = 0;
       
   241 }
       
   242 DataReader.prototype = {
       
   243     /**
       
   244      * Check that the offset will not go too far.
       
   245      * @param {string} offset the additional offset to check.
       
   246      * @throws {Error} an Error if the offset is out of bounds.
       
   247      */
       
   248     checkOffset: function(offset) {
       
   249         this.checkIndex(this.index + offset);
       
   250     },
       
   251     /**
       
   252      * Check that the specifed index will not be too far.
       
   253      * @param {string} newIndex the index to check.
       
   254      * @throws {Error} an Error if the index is out of bounds.
       
   255      */
       
   256     checkIndex: function(newIndex) {
       
   257         if (this.length < newIndex || newIndex < 0) {
       
   258             throw new Error("End of data reached (data length = " + this.length + ", asked index = " + (newIndex) + "). Corrupted zip ?");
       
   259         }
       
   260     },
       
   261     /**
       
   262      * Change the index.
       
   263      * @param {number} newIndex The new index.
       
   264      * @throws {Error} if the new index is out of the data.
       
   265      */
       
   266     setIndex: function(newIndex) {
       
   267         this.checkIndex(newIndex);
       
   268         this.index = newIndex;
       
   269     },
       
   270     /**
       
   271      * Skip the next n bytes.
       
   272      * @param {number} n the number of bytes to skip.
       
   273      * @throws {Error} if the new index is out of the data.
       
   274      */
       
   275     skip: function(n) {
       
   276         this.setIndex(this.index + n);
       
   277     },
       
   278     /**
       
   279      * Get the byte at the specified index.
       
   280      * @param {number} i the index to use.
       
   281      * @return {number} a byte.
       
   282      */
       
   283     byteAt: function(i) {
       
   284         // see implementations
       
   285     },
       
   286     /**
       
   287      * Get the next number with a given byte size.
       
   288      * @param {number} size the number of bytes to read.
       
   289      * @return {number} the corresponding number.
       
   290      */
       
   291     readInt: function(size) {
       
   292         var result = 0,
       
   293             i;
       
   294         this.checkOffset(size);
       
   295         for (i = this.index + size - 1; i >= this.index; i--) {
       
   296             result = (result << 8) + this.byteAt(i);
       
   297         }
       
   298         this.index += size;
       
   299         return result;
       
   300     },
       
   301     /**
       
   302      * Get the next string with a given byte size.
       
   303      * @param {number} size the number of bytes to read.
       
   304      * @return {string} the corresponding string.
       
   305      */
       
   306     readString: function(size) {
       
   307         return utils.transformTo("string", this.readData(size));
       
   308     },
       
   309     /**
       
   310      * Get raw data without conversion, <size> bytes.
       
   311      * @param {number} size the number of bytes to read.
       
   312      * @return {Object} the raw data, implementation specific.
       
   313      */
       
   314     readData: function(size) {
       
   315         // see implementations
       
   316     },
       
   317     /**
       
   318      * Find the last occurence of a zip signature (4 bytes).
       
   319      * @param {string} sig the signature to find.
       
   320      * @return {number} the index of the last occurence, -1 if not found.
       
   321      */
       
   322     lastIndexOfSignature: function(sig) {
       
   323         // see implementations
       
   324     },
       
   325     /**
       
   326      * Get the next date.
       
   327      * @return {Date} the date.
       
   328      */
       
   329     readDate: function() {
       
   330         var dostime = this.readInt(4);
       
   331         return new Date(
       
   332         ((dostime >> 25) & 0x7f) + 1980, // year
       
   333         ((dostime >> 21) & 0x0f) - 1, // month
       
   334         (dostime >> 16) & 0x1f, // day
       
   335         (dostime >> 11) & 0x1f, // hour
       
   336         (dostime >> 5) & 0x3f, // minute
       
   337         (dostime & 0x1f) << 1); // second
       
   338     }
       
   339 };
       
   340 module.exports = DataReader;
       
   341 
       
   342 },{"./utils":21}],6:[function(_dereq_,module,exports){
       
   343 'use strict';
       
   344 exports.base64 = false;
       
   345 exports.binary = false;
       
   346 exports.dir = false;
       
   347 exports.createFolders = false;
       
   348 exports.date = null;
       
   349 exports.compression = null;
       
   350 exports.compressionOptions = null;
       
   351 exports.comment = null;
       
   352 exports.unixPermissions = null;
       
   353 exports.dosPermissions = null;
       
   354 
       
   355 },{}],7:[function(_dereq_,module,exports){
       
   356 'use strict';
       
   357 var utils = _dereq_('./utils');
       
   358 
       
   359 /**
       
   360  * @deprecated
       
   361  * This function will be removed in a future version without replacement.
       
   362  */
       
   363 exports.string2binary = function(str) {
       
   364     return utils.string2binary(str);
       
   365 };
       
   366 
       
   367 /**
       
   368  * @deprecated
       
   369  * This function will be removed in a future version without replacement.
       
   370  */
       
   371 exports.string2Uint8Array = function(str) {
       
   372     return utils.transformTo("uint8array", str);
       
   373 };
       
   374 
       
   375 /**
       
   376  * @deprecated
       
   377  * This function will be removed in a future version without replacement.
       
   378  */
       
   379 exports.uint8Array2String = function(array) {
       
   380     return utils.transformTo("string", array);
       
   381 };
       
   382 
       
   383 /**
       
   384  * @deprecated
       
   385  * This function will be removed in a future version without replacement.
       
   386  */
       
   387 exports.string2Blob = function(str) {
       
   388     var buffer = utils.transformTo("arraybuffer", str);
       
   389     return utils.arrayBuffer2Blob(buffer);
       
   390 };
       
   391 
       
   392 /**
       
   393  * @deprecated
       
   394  * This function will be removed in a future version without replacement.
       
   395  */
       
   396 exports.arrayBuffer2Blob = function(buffer) {
       
   397     return utils.arrayBuffer2Blob(buffer);
       
   398 };
       
   399 
       
   400 /**
       
   401  * @deprecated
       
   402  * This function will be removed in a future version without replacement.
       
   403  */
       
   404 exports.transformTo = function(outputType, input) {
       
   405     return utils.transformTo(outputType, input);
       
   406 };
       
   407 
       
   408 /**
       
   409  * @deprecated
       
   410  * This function will be removed in a future version without replacement.
       
   411  */
       
   412 exports.getTypeOf = function(input) {
       
   413     return utils.getTypeOf(input);
       
   414 };
       
   415 
       
   416 /**
       
   417  * @deprecated
       
   418  * This function will be removed in a future version without replacement.
       
   419  */
       
   420 exports.checkSupport = function(type) {
       
   421     return utils.checkSupport(type);
       
   422 };
       
   423 
       
   424 /**
       
   425  * @deprecated
       
   426  * This value will be removed in a future version without replacement.
       
   427  */
       
   428 exports.MAX_VALUE_16BITS = utils.MAX_VALUE_16BITS;
       
   429 
       
   430 /**
       
   431  * @deprecated
       
   432  * This value will be removed in a future version without replacement.
       
   433  */
       
   434 exports.MAX_VALUE_32BITS = utils.MAX_VALUE_32BITS;
       
   435 
       
   436 
       
   437 /**
       
   438  * @deprecated
       
   439  * This function will be removed in a future version without replacement.
       
   440  */
       
   441 exports.pretty = function(str) {
       
   442     return utils.pretty(str);
       
   443 };
       
   444 
       
   445 /**
       
   446  * @deprecated
       
   447  * This function will be removed in a future version without replacement.
       
   448  */
       
   449 exports.findCompression = function(compressionMethod) {
       
   450     return utils.findCompression(compressionMethod);
       
   451 };
       
   452 
       
   453 /**
       
   454  * @deprecated
       
   455  * This function will be removed in a future version without replacement.
       
   456  */
       
   457 exports.isRegExp = function (object) {
       
   458     return utils.isRegExp(object);
       
   459 };
       
   460 
       
   461 
       
   462 },{"./utils":21}],8:[function(_dereq_,module,exports){
       
   463 'use strict';
       
   464 var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');
       
   465 
       
   466 var pako = _dereq_("pako");
       
   467 exports.uncompressInputType = USE_TYPEDARRAY ? "uint8array" : "array";
       
   468 exports.compressInputType = USE_TYPEDARRAY ? "uint8array" : "array";
       
   469 
       
   470 exports.magic = "\x08\x00";
       
   471 exports.compress = function(input, compressionOptions) {
       
   472     return pako.deflateRaw(input, {
       
   473         level : compressionOptions.level || -1 // default compression
       
   474     });
       
   475 };
       
   476 exports.uncompress =  function(input) {
       
   477     return pako.inflateRaw(input);
       
   478 };
       
   479 
       
   480 },{"pako":24}],9:[function(_dereq_,module,exports){
       
   481 'use strict';
       
   482 
       
   483 var base64 = _dereq_('./base64');
       
   484 
       
   485 /**
       
   486 Usage:
       
   487    zip = new JSZip();
       
   488    zip.file("hello.txt", "Hello, World!").file("tempfile", "nothing");
       
   489    zip.folder("images").file("smile.gif", base64Data, {base64: true});
       
   490    zip.file("Xmas.txt", "Ho ho ho !", {date : new Date("December 25, 2007 00:00:01")});
       
   491    zip.remove("tempfile");
       
   492 
       
   493    base64zip = zip.generate();
       
   494 
       
   495 **/
       
   496 
       
   497 /**
       
   498  * Representation a of zip file in js
       
   499  * @constructor
       
   500  * @param {String=|ArrayBuffer=|Uint8Array=} data the data to load, if any (optional).
       
   501  * @param {Object=} options the options for creating this objects (optional).
       
   502  */
       
   503 function JSZip(data, options) {
       
   504     // if this constructor is used without `new`, it adds `new` before itself:
       
   505     if(!(this instanceof JSZip)) return new JSZip(data, options);
       
   506 
       
   507     // object containing the files :
       
   508     // {
       
   509     //   "folder/" : {...},
       
   510     //   "folder/data.txt" : {...}
       
   511     // }
       
   512     this.files = {};
       
   513 
       
   514     this.comment = null;
       
   515 
       
   516     // Where we are in the hierarchy
       
   517     this.root = "";
       
   518     if (data) {
       
   519         this.load(data, options);
       
   520     }
       
   521     this.clone = function() {
       
   522         var newObj = new JSZip();
       
   523         for (var i in this) {
       
   524             if (typeof this[i] !== "function") {
       
   525                 newObj[i] = this[i];
       
   526             }
       
   527         }
       
   528         return newObj;
       
   529     };
       
   530 }
       
   531 JSZip.prototype = _dereq_('./object');
       
   532 JSZip.prototype.load = _dereq_('./load');
       
   533 JSZip.support = _dereq_('./support');
       
   534 JSZip.defaults = _dereq_('./defaults');
       
   535 
       
   536 /**
       
   537  * @deprecated
       
   538  * This namespace will be removed in a future version without replacement.
       
   539  */
       
   540 JSZip.utils = _dereq_('./deprecatedPublicUtils');
       
   541 
       
   542 JSZip.base64 = {
       
   543     /**
       
   544      * @deprecated
       
   545      * This method will be removed in a future version without replacement.
       
   546      */
       
   547     encode : function(input) {
       
   548         return base64.encode(input);
       
   549     },
       
   550     /**
       
   551      * @deprecated
       
   552      * This method will be removed in a future version without replacement.
       
   553      */
       
   554     decode : function(input) {
       
   555         return base64.decode(input);
       
   556     }
       
   557 };
       
   558 JSZip.compressions = _dereq_('./compressions');
       
   559 module.exports = JSZip;
       
   560 
       
   561 },{"./base64":1,"./compressions":3,"./defaults":6,"./deprecatedPublicUtils":7,"./load":10,"./object":13,"./support":17}],10:[function(_dereq_,module,exports){
       
   562 'use strict';
       
   563 var base64 = _dereq_('./base64');
       
   564 var ZipEntries = _dereq_('./zipEntries');
       
   565 module.exports = function(data, options) {
       
   566     var files, zipEntries, i, input;
       
   567     options = options || {};
       
   568     if (options.base64) {
       
   569         data = base64.decode(data);
       
   570     }
       
   571 
       
   572     zipEntries = new ZipEntries(data, options);
       
   573     files = zipEntries.files;
       
   574     for (i = 0; i < files.length; i++) {
       
   575         input = files[i];
       
   576         this.file(input.fileName, input.decompressed, {
       
   577             binary: true,
       
   578             optimizedBinaryString: true,
       
   579             date: input.date,
       
   580             dir: input.dir,
       
   581             comment : input.fileComment.length ? input.fileComment : null,
       
   582             unixPermissions : input.unixPermissions,
       
   583             dosPermissions : input.dosPermissions,
       
   584             createFolders: options.createFolders
       
   585         });
       
   586     }
       
   587     if (zipEntries.zipComment.length) {
       
   588         this.comment = zipEntries.zipComment;
       
   589     }
       
   590 
       
   591     return this;
       
   592 };
       
   593 
       
   594 },{"./base64":1,"./zipEntries":22}],11:[function(_dereq_,module,exports){
       
   595 (function (Buffer){
       
   596 'use strict';
       
   597 module.exports = function(data, encoding){
       
   598     return new Buffer(data, encoding);
       
   599 };
       
   600 module.exports.test = function(b){
       
   601     return Buffer.isBuffer(b);
       
   602 };
       
   603 
       
   604 }).call(this,(typeof Buffer !== "undefined" ? Buffer : undefined))
       
   605 },{}],12:[function(_dereq_,module,exports){
       
   606 'use strict';
       
   607 var Uint8ArrayReader = _dereq_('./uint8ArrayReader');
       
   608 
       
   609 function NodeBufferReader(data) {
       
   610     this.data = data;
       
   611     this.length = this.data.length;
       
   612     this.index = 0;
       
   613 }
       
   614 NodeBufferReader.prototype = new Uint8ArrayReader();
       
   615 
       
   616 /**
       
   617  * @see DataReader.readData
       
   618  */
       
   619 NodeBufferReader.prototype.readData = function(size) {
       
   620     this.checkOffset(size);
       
   621     var result = this.data.slice(this.index, this.index + size);
       
   622     this.index += size;
       
   623     return result;
       
   624 };
       
   625 module.exports = NodeBufferReader;
       
   626 
       
   627 },{"./uint8ArrayReader":18}],13:[function(_dereq_,module,exports){
       
   628 'use strict';
       
   629 var support = _dereq_('./support');
       
   630 var utils = _dereq_('./utils');
       
   631 var crc32 = _dereq_('./crc32');
       
   632 var signature = _dereq_('./signature');
       
   633 var defaults = _dereq_('./defaults');
       
   634 var base64 = _dereq_('./base64');
       
   635 var compressions = _dereq_('./compressions');
       
   636 var CompressedObject = _dereq_('./compressedObject');
       
   637 var nodeBuffer = _dereq_('./nodeBuffer');
       
   638 var utf8 = _dereq_('./utf8');
       
   639 var StringWriter = _dereq_('./stringWriter');
       
   640 var Uint8ArrayWriter = _dereq_('./uint8ArrayWriter');
       
   641 
       
   642 /**
       
   643  * Returns the raw data of a ZipObject, decompress the content if necessary.
       
   644  * @param {ZipObject} file the file to use.
       
   645  * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
       
   646  */
       
   647 var getRawData = function(file) {
       
   648     if (file._data instanceof CompressedObject) {
       
   649         file._data = file._data.getContent();
       
   650         file.options.binary = true;
       
   651         file.options.base64 = false;
       
   652 
       
   653         if (utils.getTypeOf(file._data) === "uint8array") {
       
   654             var copy = file._data;
       
   655             // when reading an arraybuffer, the CompressedObject mechanism will keep it and subarray() a Uint8Array.
       
   656             // if we request a file in the same format, we might get the same Uint8Array or its ArrayBuffer (the original zip file).
       
   657             file._data = new Uint8Array(copy.length);
       
   658             // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
       
   659             if (copy.length !== 0) {
       
   660                 file._data.set(copy, 0);
       
   661             }
       
   662         }
       
   663     }
       
   664     return file._data;
       
   665 };
       
   666 
       
   667 /**
       
   668  * Returns the data of a ZipObject in a binary form. If the content is an unicode string, encode it.
       
   669  * @param {ZipObject} file the file to use.
       
   670  * @return {String|ArrayBuffer|Uint8Array|Buffer} the data.
       
   671  */
       
   672 var getBinaryData = function(file) {
       
   673     var result = getRawData(file),
       
   674         type = utils.getTypeOf(result);
       
   675     if (type === "string") {
       
   676         if (!file.options.binary) {
       
   677             // unicode text !
       
   678             // unicode string => binary string is a painful process, check if we can avoid it.
       
   679             if (support.nodebuffer) {
       
   680                 return nodeBuffer(result, "utf-8");
       
   681             }
       
   682         }
       
   683         return file.asBinary();
       
   684     }
       
   685     return result;
       
   686 };
       
   687 
       
   688 /**
       
   689  * Transform this._data into a string.
       
   690  * @param {function} filter a function String -> String, applied if not null on the result.
       
   691  * @return {String} the string representing this._data.
       
   692  */
       
   693 var dataToString = function(asUTF8) {
       
   694     var result = getRawData(this);
       
   695     if (result === null || typeof result === "undefined") {
       
   696         return "";
       
   697     }
       
   698     // if the data is a base64 string, we decode it before checking the encoding !
       
   699     if (this.options.base64) {
       
   700         result = base64.decode(result);
       
   701     }
       
   702     if (asUTF8 && this.options.binary) {
       
   703         // JSZip.prototype.utf8decode supports arrays as input
       
   704         // skip to array => string step, utf8decode will do it.
       
   705         result = out.utf8decode(result);
       
   706     }
       
   707     else {
       
   708         // no utf8 transformation, do the array => string step.
       
   709         result = utils.transformTo("string", result);
       
   710     }
       
   711 
       
   712     if (!asUTF8 && !this.options.binary) {
       
   713         result = utils.transformTo("string", out.utf8encode(result));
       
   714     }
       
   715     return result;
       
   716 };
       
   717 /**
       
   718  * A simple object representing a file in the zip file.
       
   719  * @constructor
       
   720  * @param {string} name the name of the file
       
   721  * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data
       
   722  * @param {Object} options the options of the file
       
   723  */
       
   724 var ZipObject = function(name, data, options) {
       
   725     this.name = name;
       
   726     this.dir = options.dir;
       
   727     this.date = options.date;
       
   728     this.comment = options.comment;
       
   729     this.unixPermissions = options.unixPermissions;
       
   730     this.dosPermissions = options.dosPermissions;
       
   731 
       
   732     this._data = data;
       
   733     this.options = options;
       
   734 
       
   735     /*
       
   736      * This object contains initial values for dir and date.
       
   737      * With them, we can check if the user changed the deprecated metadata in
       
   738      * `ZipObject#options` or not.
       
   739      */
       
   740     this._initialMetadata = {
       
   741       dir : options.dir,
       
   742       date : options.date
       
   743     };
       
   744 };
       
   745 
       
   746 ZipObject.prototype = {
       
   747     /**
       
   748      * Return the content as UTF8 string.
       
   749      * @return {string} the UTF8 string.
       
   750      */
       
   751     asText: function() {
       
   752         return dataToString.call(this, true);
       
   753     },
       
   754     /**
       
   755      * Returns the binary content.
       
   756      * @return {string} the content as binary.
       
   757      */
       
   758     asBinary: function() {
       
   759         return dataToString.call(this, false);
       
   760     },
       
   761     /**
       
   762      * Returns the content as a nodejs Buffer.
       
   763      * @return {Buffer} the content as a Buffer.
       
   764      */
       
   765     asNodeBuffer: function() {
       
   766         var result = getBinaryData(this);
       
   767         return utils.transformTo("nodebuffer", result);
       
   768     },
       
   769     /**
       
   770      * Returns the content as an Uint8Array.
       
   771      * @return {Uint8Array} the content as an Uint8Array.
       
   772      */
       
   773     asUint8Array: function() {
       
   774         var result = getBinaryData(this);
       
   775         return utils.transformTo("uint8array", result);
       
   776     },
       
   777     /**
       
   778      * Returns the content as an ArrayBuffer.
       
   779      * @return {ArrayBuffer} the content as an ArrayBufer.
       
   780      */
       
   781     asArrayBuffer: function() {
       
   782         return this.asUint8Array().buffer;
       
   783     }
       
   784 };
       
   785 
       
   786 /**
       
   787  * Transform an integer into a string in hexadecimal.
       
   788  * @private
       
   789  * @param {number} dec the number to convert.
       
   790  * @param {number} bytes the number of bytes to generate.
       
   791  * @returns {string} the result.
       
   792  */
       
   793 var decToHex = function(dec, bytes) {
       
   794     var hex = "",
       
   795         i;
       
   796     for (i = 0; i < bytes; i++) {
       
   797         hex += String.fromCharCode(dec & 0xff);
       
   798         dec = dec >>> 8;
       
   799     }
       
   800     return hex;
       
   801 };
       
   802 
       
   803 /**
       
   804  * Merge the objects passed as parameters into a new one.
       
   805  * @private
       
   806  * @param {...Object} var_args All objects to merge.
       
   807  * @return {Object} a new object with the data of the others.
       
   808  */
       
   809 var extend = function() {
       
   810     var result = {}, i, attr;
       
   811     for (i = 0; i < arguments.length; i++) { // arguments is not enumerable in some browsers
       
   812         for (attr in arguments[i]) {
       
   813             if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
       
   814                 result[attr] = arguments[i][attr];
       
   815             }
       
   816         }
       
   817     }
       
   818     return result;
       
   819 };
       
   820 
       
   821 /**
       
   822  * Transforms the (incomplete) options from the user into the complete
       
   823  * set of options to create a file.
       
   824  * @private
       
   825  * @param {Object} o the options from the user.
       
   826  * @return {Object} the complete set of options.
       
   827  */
       
   828 var prepareFileAttrs = function(o) {
       
   829     o = o || {};
       
   830     if (o.base64 === true && (o.binary === null || o.binary === undefined)) {
       
   831         o.binary = true;
       
   832     }
       
   833     o = extend(o, defaults);
       
   834     o.date = o.date || new Date();
       
   835     if (o.compression !== null) o.compression = o.compression.toUpperCase();
       
   836 
       
   837     return o;
       
   838 };
       
   839 
       
   840 /**
       
   841  * Add a file in the current folder.
       
   842  * @private
       
   843  * @param {string} name the name of the file
       
   844  * @param {String|ArrayBuffer|Uint8Array|Buffer} data the data of the file
       
   845  * @param {Object} o the options of the file
       
   846  * @return {Object} the new file.
       
   847  */
       
   848 var fileAdd = function(name, data, o) {
       
   849     // be sure sub folders exist
       
   850     var dataType = utils.getTypeOf(data),
       
   851         parent;
       
   852 
       
   853     o = prepareFileAttrs(o);
       
   854 
       
   855     if (typeof o.unixPermissions === "string") {
       
   856         o.unixPermissions = parseInt(o.unixPermissions, 8);
       
   857     }
       
   858 
       
   859     // UNX_IFDIR  0040000 see zipinfo.c
       
   860     if (o.unixPermissions && (o.unixPermissions & 0x4000)) {
       
   861         o.dir = true;
       
   862     }
       
   863     // Bit 4    Directory
       
   864     if (o.dosPermissions && (o.dosPermissions & 0x0010)) {
       
   865         o.dir = true;
       
   866     }
       
   867 
       
   868     if (o.dir) {
       
   869         name = forceTrailingSlash(name);
       
   870     }
       
   871 
       
   872     if (o.createFolders && (parent = parentFolder(name))) {
       
   873         folderAdd.call(this, parent, true);
       
   874     }
       
   875 
       
   876     if (o.dir || data === null || typeof data === "undefined") {
       
   877         o.base64 = false;
       
   878         o.binary = false;
       
   879         data = null;
       
   880         dataType = null;
       
   881     }
       
   882     else if (dataType === "string") {
       
   883         if (o.binary && !o.base64) {
       
   884             // optimizedBinaryString == true means that the file has already been filtered with a 0xFF mask
       
   885             if (o.optimizedBinaryString !== true) {
       
   886                 // this is a string, not in a base64 format.
       
   887                 // Be sure that this is a correct "binary string"
       
   888                 data = utils.string2binary(data);
       
   889             }
       
   890         }
       
   891     }
       
   892     else { // arraybuffer, uint8array, ...
       
   893         o.base64 = false;
       
   894         o.binary = true;
       
   895 
       
   896         if (!dataType && !(data instanceof CompressedObject)) {
       
   897             throw new Error("The data of '" + name + "' is in an unsupported format !");
       
   898         }
       
   899 
       
   900         // special case : it's way easier to work with Uint8Array than with ArrayBuffer
       
   901         if (dataType === "arraybuffer") {
       
   902             data = utils.transformTo("uint8array", data);
       
   903         }
       
   904     }
       
   905 
       
   906     var object = new ZipObject(name, data, o);
       
   907     this.files[name] = object;
       
   908     return object;
       
   909 };
       
   910 
       
   911 /**
       
   912  * Find the parent folder of the path.
       
   913  * @private
       
   914  * @param {string} path the path to use
       
   915  * @return {string} the parent folder, or ""
       
   916  */
       
   917 var parentFolder = function (path) {
       
   918     if (path.slice(-1) == '/') {
       
   919         path = path.substring(0, path.length - 1);
       
   920     }
       
   921     var lastSlash = path.lastIndexOf('/');
       
   922     return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
       
   923 };
       
   924 
       
   925 
       
   926 /**
       
   927  * Returns the path with a slash at the end.
       
   928  * @private
       
   929  * @param {String} path the path to check.
       
   930  * @return {String} the path with a trailing slash.
       
   931  */
       
   932 var forceTrailingSlash = function(path) {
       
   933     // Check the name ends with a /
       
   934     if (path.slice(-1) != "/") {
       
   935         path += "/"; // IE doesn't like substr(-1)
       
   936     }
       
   937     return path;
       
   938 };
       
   939 /**
       
   940  * Add a (sub) folder in the current folder.
       
   941  * @private
       
   942  * @param {string} name the folder's name
       
   943  * @param {boolean=} [createFolders] If true, automatically create sub
       
   944  *  folders. Defaults to false.
       
   945  * @return {Object} the new folder.
       
   946  */
       
   947 var folderAdd = function(name, createFolders) {
       
   948     createFolders = (typeof createFolders !== 'undefined') ? createFolders : false;
       
   949 
       
   950     name = forceTrailingSlash(name);
       
   951 
       
   952     // Does this folder already exist?
       
   953     if (!this.files[name]) {
       
   954         fileAdd.call(this, name, null, {
       
   955             dir: true,
       
   956             createFolders: createFolders
       
   957         });
       
   958     }
       
   959     return this.files[name];
       
   960 };
       
   961 
       
   962 /**
       
   963  * Generate a JSZip.CompressedObject for a given zipOject.
       
   964  * @param {ZipObject} file the object to read.
       
   965  * @param {JSZip.compression} compression the compression to use.
       
   966  * @param {Object} compressionOptions the options to use when compressing.
       
   967  * @return {JSZip.CompressedObject} the compressed result.
       
   968  */
       
   969 var generateCompressedObjectFrom = function(file, compression, compressionOptions) {
       
   970     var result = new CompressedObject(),
       
   971         content;
       
   972 
       
   973     // the data has not been decompressed, we might reuse things !
       
   974     if (file._data instanceof CompressedObject) {
       
   975         result.uncompressedSize = file._data.uncompressedSize;
       
   976         result.crc32 = file._data.crc32;
       
   977 
       
   978         if (result.uncompressedSize === 0 || file.dir) {
       
   979             compression = compressions['STORE'];
       
   980             result.compressedContent = "";
       
   981             result.crc32 = 0;
       
   982         }
       
   983         else if (file._data.compressionMethod === compression.magic) {
       
   984             result.compressedContent = file._data.getCompressedContent();
       
   985         }
       
   986         else {
       
   987             content = file._data.getContent();
       
   988             // need to decompress / recompress
       
   989             result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content), compressionOptions);
       
   990         }
       
   991     }
       
   992     else {
       
   993         // have uncompressed data
       
   994         content = getBinaryData(file);
       
   995         if (!content || content.length === 0 || file.dir) {
       
   996             compression = compressions['STORE'];
       
   997             content = "";
       
   998         }
       
   999         result.uncompressedSize = content.length;
       
  1000         result.crc32 = crc32(content);
       
  1001         result.compressedContent = compression.compress(utils.transformTo(compression.compressInputType, content), compressionOptions);
       
  1002     }
       
  1003 
       
  1004     result.compressedSize = result.compressedContent.length;
       
  1005     result.compressionMethod = compression.magic;
       
  1006 
       
  1007     return result;
       
  1008 };
       
  1009 
       
  1010 
       
  1011 
       
  1012 
       
  1013 /**
       
  1014  * Generate the UNIX part of the external file attributes.
       
  1015  * @param {Object} unixPermissions the unix permissions or null.
       
  1016  * @param {Boolean} isDir true if the entry is a directory, false otherwise.
       
  1017  * @return {Number} a 32 bit integer.
       
  1018  *
       
  1019  * adapted from http://unix.stackexchange.com/questions/14705/the-zip-formats-external-file-attribute :
       
  1020  *
       
  1021  * TTTTsstrwxrwxrwx0000000000ADVSHR
       
  1022  * ^^^^____________________________ file type, see zipinfo.c (UNX_*)
       
  1023  *     ^^^_________________________ setuid, setgid, sticky
       
  1024  *        ^^^^^^^^^________________ permissions
       
  1025  *                 ^^^^^^^^^^______ not used ?
       
  1026  *                           ^^^^^^ DOS attribute bits : Archive, Directory, Volume label, System file, Hidden, Read only
       
  1027  */
       
  1028 var generateUnixExternalFileAttr = function (unixPermissions, isDir) {
       
  1029 
       
  1030     var result = unixPermissions;
       
  1031     if (!unixPermissions) {
       
  1032         // I can't use octal values in strict mode, hence the hexa.
       
  1033         //  040775 => 0x41fd
       
  1034         // 0100664 => 0x81b4
       
  1035         result = isDir ? 0x41fd : 0x81b4;
       
  1036     }
       
  1037 
       
  1038     return (result & 0xFFFF) << 16;
       
  1039 };
       
  1040 
       
  1041 /**
       
  1042  * Generate the DOS part of the external file attributes.
       
  1043  * @param {Object} dosPermissions the dos permissions or null.
       
  1044  * @param {Boolean} isDir true if the entry is a directory, false otherwise.
       
  1045  * @return {Number} a 32 bit integer.
       
  1046  *
       
  1047  * Bit 0     Read-Only
       
  1048  * Bit 1     Hidden
       
  1049  * Bit 2     System
       
  1050  * Bit 3     Volume Label
       
  1051  * Bit 4     Directory
       
  1052  * Bit 5     Archive
       
  1053  */
       
  1054 var generateDosExternalFileAttr = function (dosPermissions, isDir) {
       
  1055 
       
  1056     // the dir flag is already set for compatibility
       
  1057 
       
  1058     return (dosPermissions || 0)  & 0x3F;
       
  1059 };
       
  1060 
       
  1061 /**
       
  1062  * Generate the various parts used in the construction of the final zip file.
       
  1063  * @param {string} name the file name.
       
  1064  * @param {ZipObject} file the file content.
       
  1065  * @param {JSZip.CompressedObject} compressedObject the compressed object.
       
  1066  * @param {number} offset the current offset from the start of the zip file.
       
  1067  * @param {String} platform let's pretend we are this platform (change platform dependents fields)
       
  1068  * @return {object} the zip parts.
       
  1069  */
       
  1070 var generateZipParts = function(name, file, compressedObject, offset, platform) {
       
  1071     var data = compressedObject.compressedContent,
       
  1072         utfEncodedFileName = utils.transformTo("string", utf8.utf8encode(file.name)),
       
  1073         comment = file.comment || "",
       
  1074         utfEncodedComment = utils.transformTo("string", utf8.utf8encode(comment)),
       
  1075         useUTF8ForFileName = utfEncodedFileName.length !== file.name.length,
       
  1076         useUTF8ForComment = utfEncodedComment.length !== comment.length,
       
  1077         o = file.options,
       
  1078         dosTime,
       
  1079         dosDate,
       
  1080         extraFields = "",
       
  1081         unicodePathExtraField = "",
       
  1082         unicodeCommentExtraField = "",
       
  1083         dir, date;
       
  1084 
       
  1085 
       
  1086     // handle the deprecated options.dir
       
  1087     if (file._initialMetadata.dir !== file.dir) {
       
  1088         dir = file.dir;
       
  1089     } else {
       
  1090         dir = o.dir;
       
  1091     }
       
  1092 
       
  1093     // handle the deprecated options.date
       
  1094     if(file._initialMetadata.date !== file.date) {
       
  1095         date = file.date;
       
  1096     } else {
       
  1097         date = o.date;
       
  1098     }
       
  1099 
       
  1100     var extFileAttr = 0;
       
  1101     var versionMadeBy = 0;
       
  1102     if (dir) {
       
  1103         // dos or unix, we set the dos dir flag
       
  1104         extFileAttr |= 0x00010;
       
  1105     }
       
  1106     if(platform === "UNIX") {
       
  1107         versionMadeBy = 0x031E; // UNIX, version 3.0
       
  1108         extFileAttr |= generateUnixExternalFileAttr(file.unixPermissions, dir);
       
  1109     } else { // DOS or other, fallback to DOS
       
  1110         versionMadeBy = 0x0014; // DOS, version 2.0
       
  1111         extFileAttr |= generateDosExternalFileAttr(file.dosPermissions, dir);
       
  1112     }
       
  1113 
       
  1114     // date
       
  1115     // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html
       
  1116     // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html
       
  1117     // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html
       
  1118 
       
  1119     dosTime = date.getHours();
       
  1120     dosTime = dosTime << 6;
       
  1121     dosTime = dosTime | date.getMinutes();
       
  1122     dosTime = dosTime << 5;
       
  1123     dosTime = dosTime | date.getSeconds() / 2;
       
  1124 
       
  1125     dosDate = date.getFullYear() - 1980;
       
  1126     dosDate = dosDate << 4;
       
  1127     dosDate = dosDate | (date.getMonth() + 1);
       
  1128     dosDate = dosDate << 5;
       
  1129     dosDate = dosDate | date.getDate();
       
  1130 
       
  1131     if (useUTF8ForFileName) {
       
  1132         // set the unicode path extra field. unzip needs at least one extra
       
  1133         // field to correctly handle unicode path, so using the path is as good
       
  1134         // as any other information. This could improve the situation with
       
  1135         // other archive managers too.
       
  1136         // This field is usually used without the utf8 flag, with a non
       
  1137         // unicode path in the header (winrar, winzip). This helps (a bit)
       
  1138         // with the messy Windows' default compressed folders feature but
       
  1139         // breaks on p7zip which doesn't seek the unicode path extra field.
       
  1140         // So for now, UTF-8 everywhere !
       
  1141         unicodePathExtraField =
       
  1142             // Version
       
  1143             decToHex(1, 1) +
       
  1144             // NameCRC32
       
  1145             decToHex(crc32(utfEncodedFileName), 4) +
       
  1146             // UnicodeName
       
  1147             utfEncodedFileName;
       
  1148 
       
  1149         extraFields +=
       
  1150             // Info-ZIP Unicode Path Extra Field
       
  1151             "\x75\x70" +
       
  1152             // size
       
  1153             decToHex(unicodePathExtraField.length, 2) +
       
  1154             // content
       
  1155             unicodePathExtraField;
       
  1156     }
       
  1157 
       
  1158     if(useUTF8ForComment) {
       
  1159 
       
  1160         unicodeCommentExtraField =
       
  1161             // Version
       
  1162             decToHex(1, 1) +
       
  1163             // CommentCRC32
       
  1164             decToHex(this.crc32(utfEncodedComment), 4) +
       
  1165             // UnicodeName
       
  1166             utfEncodedComment;
       
  1167 
       
  1168         extraFields +=
       
  1169             // Info-ZIP Unicode Path Extra Field
       
  1170             "\x75\x63" +
       
  1171             // size
       
  1172             decToHex(unicodeCommentExtraField.length, 2) +
       
  1173             // content
       
  1174             unicodeCommentExtraField;
       
  1175     }
       
  1176 
       
  1177     var header = "";
       
  1178 
       
  1179     // version needed to extract
       
  1180     header += "\x0A\x00";
       
  1181     // general purpose bit flag
       
  1182     // set bit 11 if utf8
       
  1183     header += (useUTF8ForFileName || useUTF8ForComment) ? "\x00\x08" : "\x00\x00";
       
  1184     // compression method
       
  1185     header += compressedObject.compressionMethod;
       
  1186     // last mod file time
       
  1187     header += decToHex(dosTime, 2);
       
  1188     // last mod file date
       
  1189     header += decToHex(dosDate, 2);
       
  1190     // crc-32
       
  1191     header += decToHex(compressedObject.crc32, 4);
       
  1192     // compressed size
       
  1193     header += decToHex(compressedObject.compressedSize, 4);
       
  1194     // uncompressed size
       
  1195     header += decToHex(compressedObject.uncompressedSize, 4);
       
  1196     // file name length
       
  1197     header += decToHex(utfEncodedFileName.length, 2);
       
  1198     // extra field length
       
  1199     header += decToHex(extraFields.length, 2);
       
  1200 
       
  1201 
       
  1202     var fileRecord = signature.LOCAL_FILE_HEADER + header + utfEncodedFileName + extraFields;
       
  1203 
       
  1204     var dirRecord = signature.CENTRAL_FILE_HEADER +
       
  1205     // version made by (00: DOS)
       
  1206     decToHex(versionMadeBy, 2) +
       
  1207     // file header (common to file and central directory)
       
  1208     header +
       
  1209     // file comment length
       
  1210     decToHex(utfEncodedComment.length, 2) +
       
  1211     // disk number start
       
  1212     "\x00\x00" +
       
  1213     // internal file attributes TODO
       
  1214     "\x00\x00" +
       
  1215     // external file attributes
       
  1216     decToHex(extFileAttr, 4) +
       
  1217     // relative offset of local header
       
  1218     decToHex(offset, 4) +
       
  1219     // file name
       
  1220     utfEncodedFileName +
       
  1221     // extra field
       
  1222     extraFields +
       
  1223     // file comment
       
  1224     utfEncodedComment;
       
  1225 
       
  1226     return {
       
  1227         fileRecord: fileRecord,
       
  1228         dirRecord: dirRecord,
       
  1229         compressedObject: compressedObject
       
  1230     };
       
  1231 };
       
  1232 
       
  1233 
       
  1234 // return the actual prototype of JSZip
       
  1235 var out = {
       
  1236     /**
       
  1237      * Read an existing zip and merge the data in the current JSZip object.
       
  1238      * The implementation is in jszip-load.js, don't forget to include it.
       
  1239      * @param {String|ArrayBuffer|Uint8Array|Buffer} stream  The stream to load
       
  1240      * @param {Object} options Options for loading the stream.
       
  1241      *  options.base64 : is the stream in base64 ? default : false
       
  1242      * @return {JSZip} the current JSZip object
       
  1243      */
       
  1244     load: function(stream, options) {
       
  1245         throw new Error("Load method is not defined. Is the file jszip-load.js included ?");
       
  1246     },
       
  1247 
       
  1248     /**
       
  1249      * Filter nested files/folders with the specified function.
       
  1250      * @param {Function} search the predicate to use :
       
  1251      * function (relativePath, file) {...}
       
  1252      * It takes 2 arguments : the relative path and the file.
       
  1253      * @return {Array} An array of matching elements.
       
  1254      */
       
  1255     filter: function(search) {
       
  1256         var result = [],
       
  1257             filename, relativePath, file, fileClone;
       
  1258         for (filename in this.files) {
       
  1259             if (!this.files.hasOwnProperty(filename)) {
       
  1260                 continue;
       
  1261             }
       
  1262             file = this.files[filename];
       
  1263             // return a new object, don't let the user mess with our internal objects :)
       
  1264             fileClone = new ZipObject(file.name, file._data, extend(file.options));
       
  1265             relativePath = filename.slice(this.root.length, filename.length);
       
  1266             if (filename.slice(0, this.root.length) === this.root && // the file is in the current root
       
  1267             search(relativePath, fileClone)) { // and the file matches the function
       
  1268                 result.push(fileClone);
       
  1269             }
       
  1270         }
       
  1271         return result;
       
  1272     },
       
  1273 
       
  1274     /**
       
  1275      * Add a file to the zip file, or search a file.
       
  1276      * @param   {string|RegExp} name The name of the file to add (if data is defined),
       
  1277      * the name of the file to find (if no data) or a regex to match files.
       
  1278      * @param   {String|ArrayBuffer|Uint8Array|Buffer} data  The file data, either raw or base64 encoded
       
  1279      * @param   {Object} o     File options
       
  1280      * @return  {JSZip|Object|Array} this JSZip object (when adding a file),
       
  1281      * a file (when searching by string) or an array of files (when searching by regex).
       
  1282      */
       
  1283     file: function(name, data, o) {
       
  1284         if (arguments.length === 1) {
       
  1285             if (utils.isRegExp(name)) {
       
  1286                 var regexp = name;
       
  1287                 return this.filter(function(relativePath, file) {
       
  1288                     return !file.dir && regexp.test(relativePath);
       
  1289                 });
       
  1290             }
       
  1291             else { // text
       
  1292                 return this.filter(function(relativePath, file) {
       
  1293                     return !file.dir && relativePath === name;
       
  1294                 })[0] || null;
       
  1295             }
       
  1296         }
       
  1297         else { // more than one argument : we have data !
       
  1298             name = this.root + name;
       
  1299             fileAdd.call(this, name, data, o);
       
  1300         }
       
  1301         return this;
       
  1302     },
       
  1303 
       
  1304     /**
       
  1305      * Add a directory to the zip file, or search.
       
  1306      * @param   {String|RegExp} arg The name of the directory to add, or a regex to search folders.
       
  1307      * @return  {JSZip} an object with the new directory as the root, or an array containing matching folders.
       
  1308      */
       
  1309     folder: function(arg) {
       
  1310         if (!arg) {
       
  1311             return this;
       
  1312         }
       
  1313 
       
  1314         if (utils.isRegExp(arg)) {
       
  1315             return this.filter(function(relativePath, file) {
       
  1316                 return file.dir && arg.test(relativePath);
       
  1317             });
       
  1318         }
       
  1319 
       
  1320         // else, name is a new folder
       
  1321         var name = this.root + arg;
       
  1322         var newFolder = folderAdd.call(this, name);
       
  1323 
       
  1324         // Allow chaining by returning a new object with this folder as the root
       
  1325         var ret = this.clone();
       
  1326         ret.root = newFolder.name;
       
  1327         return ret;
       
  1328     },
       
  1329 
       
  1330     /**
       
  1331      * Delete a file, or a directory and all sub-files, from the zip
       
  1332      * @param {string} name the name of the file to delete
       
  1333      * @return {JSZip} this JSZip object
       
  1334      */
       
  1335     remove: function(name) {
       
  1336         name = this.root + name;
       
  1337         var file = this.files[name];
       
  1338         if (!file) {
       
  1339             // Look for any folders
       
  1340             if (name.slice(-1) != "/") {
       
  1341                 name += "/";
       
  1342             }
       
  1343             file = this.files[name];
       
  1344         }
       
  1345 
       
  1346         if (file && !file.dir) {
       
  1347             // file
       
  1348             delete this.files[name];
       
  1349         } else {
       
  1350             // maybe a folder, delete recursively
       
  1351             var kids = this.filter(function(relativePath, file) {
       
  1352                 return file.name.slice(0, name.length) === name;
       
  1353             });
       
  1354             for (var i = 0; i < kids.length; i++) {
       
  1355                 delete this.files[kids[i].name];
       
  1356             }
       
  1357         }
       
  1358 
       
  1359         return this;
       
  1360     },
       
  1361 
       
  1362     /**
       
  1363      * Generate the complete zip file
       
  1364      * @param {Object} options the options to generate the zip file :
       
  1365      * - base64, (deprecated, use type instead) true to generate base64.
       
  1366      * - compression, "STORE" by default.
       
  1367      * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
       
  1368      * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file
       
  1369      */
       
  1370     generate: function(options) {
       
  1371         options = extend(options || {}, {
       
  1372             base64: true,
       
  1373             compression: "STORE",
       
  1374             compressionOptions : null,
       
  1375             type: "base64",
       
  1376             platform: "DOS",
       
  1377             comment: null,
       
  1378             mimeType: 'application/zip'
       
  1379         });
       
  1380 
       
  1381         utils.checkSupport(options.type);
       
  1382 
       
  1383         // accept nodejs `process.platform`
       
  1384         if(
       
  1385           options.platform === 'darwin' ||
       
  1386           options.platform === 'freebsd' ||
       
  1387           options.platform === 'linux' ||
       
  1388           options.platform === 'sunos'
       
  1389         ) {
       
  1390           options.platform = "UNIX";
       
  1391         }
       
  1392         if (options.platform === 'win32') {
       
  1393           options.platform = "DOS";
       
  1394         }
       
  1395 
       
  1396         var zipData = [],
       
  1397             localDirLength = 0,
       
  1398             centralDirLength = 0,
       
  1399             writer, i,
       
  1400             utfEncodedComment = utils.transformTo("string", this.utf8encode(options.comment || this.comment || ""));
       
  1401 
       
  1402         // first, generate all the zip parts.
       
  1403         for (var name in this.files) {
       
  1404             if (!this.files.hasOwnProperty(name)) {
       
  1405                 continue;
       
  1406             }
       
  1407             var file = this.files[name];
       
  1408 
       
  1409             var compressionName = file.options.compression || options.compression.toUpperCase();
       
  1410             var compression = compressions[compressionName];
       
  1411             if (!compression) {
       
  1412                 throw new Error(compressionName + " is not a valid compression method !");
       
  1413             }
       
  1414             var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};
       
  1415 
       
  1416             var compressedObject = generateCompressedObjectFrom.call(this, file, compression, compressionOptions);
       
  1417 
       
  1418             var zipPart = generateZipParts.call(this, name, file, compressedObject, localDirLength, options.platform);
       
  1419             localDirLength += zipPart.fileRecord.length + compressedObject.compressedSize;
       
  1420             centralDirLength += zipPart.dirRecord.length;
       
  1421             zipData.push(zipPart);
       
  1422         }
       
  1423 
       
  1424         var dirEnd = "";
       
  1425 
       
  1426         // end of central dir signature
       
  1427         dirEnd = signature.CENTRAL_DIRECTORY_END +
       
  1428         // number of this disk
       
  1429         "\x00\x00" +
       
  1430         // number of the disk with the start of the central directory
       
  1431         "\x00\x00" +
       
  1432         // total number of entries in the central directory on this disk
       
  1433         decToHex(zipData.length, 2) +
       
  1434         // total number of entries in the central directory
       
  1435         decToHex(zipData.length, 2) +
       
  1436         // size of the central directory   4 bytes
       
  1437         decToHex(centralDirLength, 4) +
       
  1438         // offset of start of central directory with respect to the starting disk number
       
  1439         decToHex(localDirLength, 4) +
       
  1440         // .ZIP file comment length
       
  1441         decToHex(utfEncodedComment.length, 2) +
       
  1442         // .ZIP file comment
       
  1443         utfEncodedComment;
       
  1444 
       
  1445 
       
  1446         // we have all the parts (and the total length)
       
  1447         // time to create a writer !
       
  1448         var typeName = options.type.toLowerCase();
       
  1449         if(typeName==="uint8array"||typeName==="arraybuffer"||typeName==="blob"||typeName==="nodebuffer") {
       
  1450             writer = new Uint8ArrayWriter(localDirLength + centralDirLength + dirEnd.length);
       
  1451         }else{
       
  1452             writer = new StringWriter(localDirLength + centralDirLength + dirEnd.length);
       
  1453         }
       
  1454 
       
  1455         for (i = 0; i < zipData.length; i++) {
       
  1456             writer.append(zipData[i].fileRecord);
       
  1457             writer.append(zipData[i].compressedObject.compressedContent);
       
  1458         }
       
  1459         for (i = 0; i < zipData.length; i++) {
       
  1460             writer.append(zipData[i].dirRecord);
       
  1461         }
       
  1462 
       
  1463         writer.append(dirEnd);
       
  1464 
       
  1465         var zip = writer.finalize();
       
  1466 
       
  1467 
       
  1468 
       
  1469         switch(options.type.toLowerCase()) {
       
  1470             // case "zip is an Uint8Array"
       
  1471             case "uint8array" :
       
  1472             case "arraybuffer" :
       
  1473             case "nodebuffer" :
       
  1474                return utils.transformTo(options.type.toLowerCase(), zip);
       
  1475             case "blob" :
       
  1476                return utils.arrayBuffer2Blob(utils.transformTo("arraybuffer", zip), options.mimeType);
       
  1477             // case "zip is a string"
       
  1478             case "base64" :
       
  1479                return (options.base64) ? base64.encode(zip) : zip;
       
  1480             default : // case "string" :
       
  1481                return zip;
       
  1482          }
       
  1483 
       
  1484     },
       
  1485 
       
  1486     /**
       
  1487      * @deprecated
       
  1488      * This method will be removed in a future version without replacement.
       
  1489      */
       
  1490     crc32: function (input, crc) {
       
  1491         return crc32(input, crc);
       
  1492     },
       
  1493 
       
  1494     /**
       
  1495      * @deprecated
       
  1496      * This method will be removed in a future version without replacement.
       
  1497      */
       
  1498     utf8encode: function (string) {
       
  1499         return utils.transformTo("string", utf8.utf8encode(string));
       
  1500     },
       
  1501 
       
  1502     /**
       
  1503      * @deprecated
       
  1504      * This method will be removed in a future version without replacement.
       
  1505      */
       
  1506     utf8decode: function (input) {
       
  1507         return utf8.utf8decode(input);
       
  1508     }
       
  1509 };
       
  1510 module.exports = out;
       
  1511 
       
  1512 },{"./base64":1,"./compressedObject":2,"./compressions":3,"./crc32":4,"./defaults":6,"./nodeBuffer":11,"./signature":14,"./stringWriter":16,"./support":17,"./uint8ArrayWriter":19,"./utf8":20,"./utils":21}],14:[function(_dereq_,module,exports){
       
  1513 'use strict';
       
  1514 exports.LOCAL_FILE_HEADER = "PK\x03\x04";
       
  1515 exports.CENTRAL_FILE_HEADER = "PK\x01\x02";
       
  1516 exports.CENTRAL_DIRECTORY_END = "PK\x05\x06";
       
  1517 exports.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x06\x07";
       
  1518 exports.ZIP64_CENTRAL_DIRECTORY_END = "PK\x06\x06";
       
  1519 exports.DATA_DESCRIPTOR = "PK\x07\x08";
       
  1520 
       
  1521 },{}],15:[function(_dereq_,module,exports){
       
  1522 'use strict';
       
  1523 var DataReader = _dereq_('./dataReader');
       
  1524 var utils = _dereq_('./utils');
       
  1525 
       
  1526 function StringReader(data, optimizedBinaryString) {
       
  1527     this.data = data;
       
  1528     if (!optimizedBinaryString) {
       
  1529         this.data = utils.string2binary(this.data);
       
  1530     }
       
  1531     this.length = this.data.length;
       
  1532     this.index = 0;
       
  1533 }
       
  1534 StringReader.prototype = new DataReader();
       
  1535 /**
       
  1536  * @see DataReader.byteAt
       
  1537  */
       
  1538 StringReader.prototype.byteAt = function(i) {
       
  1539     return this.data.charCodeAt(i);
       
  1540 };
       
  1541 /**
       
  1542  * @see DataReader.lastIndexOfSignature
       
  1543  */
       
  1544 StringReader.prototype.lastIndexOfSignature = function(sig) {
       
  1545     return this.data.lastIndexOf(sig);
       
  1546 };
       
  1547 /**
       
  1548  * @see DataReader.readData
       
  1549  */
       
  1550 StringReader.prototype.readData = function(size) {
       
  1551     this.checkOffset(size);
       
  1552     // this will work because the constructor applied the "& 0xff" mask.
       
  1553     var result = this.data.slice(this.index, this.index + size);
       
  1554     this.index += size;
       
  1555     return result;
       
  1556 };
       
  1557 module.exports = StringReader;
       
  1558 
       
  1559 },{"./dataReader":5,"./utils":21}],16:[function(_dereq_,module,exports){
       
  1560 'use strict';
       
  1561 
       
  1562 var utils = _dereq_('./utils');
       
  1563 
       
  1564 /**
       
  1565  * An object to write any content to a string.
       
  1566  * @constructor
       
  1567  */
       
  1568 var StringWriter = function() {
       
  1569     this.data = [];
       
  1570 };
       
  1571 StringWriter.prototype = {
       
  1572     /**
       
  1573      * Append any content to the current string.
       
  1574      * @param {Object} input the content to add.
       
  1575      */
       
  1576     append: function(input) {
       
  1577         input = utils.transformTo("string", input);
       
  1578         this.data.push(input);
       
  1579     },
       
  1580     /**
       
  1581      * Finalize the construction an return the result.
       
  1582      * @return {string} the generated string.
       
  1583      */
       
  1584     finalize: function() {
       
  1585         return this.data.join("");
       
  1586     }
       
  1587 };
       
  1588 
       
  1589 module.exports = StringWriter;
       
  1590 
       
  1591 },{"./utils":21}],17:[function(_dereq_,module,exports){
       
  1592 (function (Buffer){
       
  1593 'use strict';
       
  1594 exports.base64 = true;
       
  1595 exports.array = true;
       
  1596 exports.string = true;
       
  1597 exports.arraybuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
       
  1598 // contains true if JSZip can read/generate nodejs Buffer, false otherwise.
       
  1599 // Browserify will provide a Buffer implementation for browsers, which is
       
  1600 // an augmented Uint8Array (i.e., can be used as either Buffer or U8).
       
  1601 exports.nodebuffer = typeof Buffer !== "undefined";
       
  1602 // contains true if JSZip can read/generate Uint8Array, false otherwise.
       
  1603 exports.uint8array = typeof Uint8Array !== "undefined";
       
  1604 
       
  1605 if (typeof ArrayBuffer === "undefined") {
       
  1606     exports.blob = false;
       
  1607 }
       
  1608 else {
       
  1609     var buffer = new ArrayBuffer(0);
       
  1610     try {
       
  1611         exports.blob = new Blob([buffer], {
       
  1612             type: "application/zip"
       
  1613         }).size === 0;
       
  1614     }
       
  1615     catch (e) {
       
  1616         try {
       
  1617             var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
       
  1618             var builder = new Builder();
       
  1619             builder.append(buffer);
       
  1620             exports.blob = builder.getBlob('application/zip').size === 0;
       
  1621         }
       
  1622         catch (e) {
       
  1623             exports.blob = false;
       
  1624         }
       
  1625     }
       
  1626 }
       
  1627 
       
  1628 }).call(this,(typeof Buffer !== "undefined" ? Buffer : undefined))
       
  1629 },{}],18:[function(_dereq_,module,exports){
       
  1630 'use strict';
       
  1631 var DataReader = _dereq_('./dataReader');
       
  1632 
       
  1633 function Uint8ArrayReader(data) {
       
  1634     if (data) {
       
  1635         this.data = data;
       
  1636         this.length = this.data.length;
       
  1637         this.index = 0;
       
  1638     }
       
  1639 }
       
  1640 Uint8ArrayReader.prototype = new DataReader();
       
  1641 /**
       
  1642  * @see DataReader.byteAt
       
  1643  */
       
  1644 Uint8ArrayReader.prototype.byteAt = function(i) {
       
  1645     return this.data[i];
       
  1646 };
       
  1647 /**
       
  1648  * @see DataReader.lastIndexOfSignature
       
  1649  */
       
  1650 Uint8ArrayReader.prototype.lastIndexOfSignature = function(sig) {
       
  1651     var sig0 = sig.charCodeAt(0),
       
  1652         sig1 = sig.charCodeAt(1),
       
  1653         sig2 = sig.charCodeAt(2),
       
  1654         sig3 = sig.charCodeAt(3);
       
  1655     for (var i = this.length - 4; i >= 0; --i) {
       
  1656         if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i + 3] === sig3) {
       
  1657             return i;
       
  1658         }
       
  1659     }
       
  1660 
       
  1661     return -1;
       
  1662 };
       
  1663 /**
       
  1664  * @see DataReader.readData
       
  1665  */
       
  1666 Uint8ArrayReader.prototype.readData = function(size) {
       
  1667     this.checkOffset(size);
       
  1668     if(size === 0) {
       
  1669         // in IE10, when using subarray(idx, idx), we get the array [0x00] instead of [].
       
  1670         return new Uint8Array(0);
       
  1671     }
       
  1672     var result = this.data.subarray(this.index, this.index + size);
       
  1673     this.index += size;
       
  1674     return result;
       
  1675 };
       
  1676 module.exports = Uint8ArrayReader;
       
  1677 
       
  1678 },{"./dataReader":5}],19:[function(_dereq_,module,exports){
       
  1679 'use strict';
       
  1680 
       
  1681 var utils = _dereq_('./utils');
       
  1682 
       
  1683 /**
       
  1684  * An object to write any content to an Uint8Array.
       
  1685  * @constructor
       
  1686  * @param {number} length The length of the array.
       
  1687  */
       
  1688 var Uint8ArrayWriter = function(length) {
       
  1689     this.data = new Uint8Array(length);
       
  1690     this.index = 0;
       
  1691 };
       
  1692 Uint8ArrayWriter.prototype = {
       
  1693     /**
       
  1694      * Append any content to the current array.
       
  1695      * @param {Object} input the content to add.
       
  1696      */
       
  1697     append: function(input) {
       
  1698         if (input.length !== 0) {
       
  1699             // with an empty Uint8Array, Opera fails with a "Offset larger than array size"
       
  1700             input = utils.transformTo("uint8array", input);
       
  1701             this.data.set(input, this.index);
       
  1702             this.index += input.length;
       
  1703         }
       
  1704     },
       
  1705     /**
       
  1706      * Finalize the construction an return the result.
       
  1707      * @return {Uint8Array} the generated array.
       
  1708      */
       
  1709     finalize: function() {
       
  1710         return this.data;
       
  1711     }
       
  1712 };
       
  1713 
       
  1714 module.exports = Uint8ArrayWriter;
       
  1715 
       
  1716 },{"./utils":21}],20:[function(_dereq_,module,exports){
       
  1717 'use strict';
       
  1718 
       
  1719 var utils = _dereq_('./utils');
       
  1720 var support = _dereq_('./support');
       
  1721 var nodeBuffer = _dereq_('./nodeBuffer');
       
  1722 
       
  1723 /**
       
  1724  * The following functions come from pako, from pako/lib/utils/strings
       
  1725  * released under the MIT license, see pako https://github.com/nodeca/pako/
       
  1726  */
       
  1727 
       
  1728 // Table with utf8 lengths (calculated by first byte of sequence)
       
  1729 // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
       
  1730 // because max possible codepoint is 0x10ffff
       
  1731 var _utf8len = new Array(256);
       
  1732 for (var i=0; i<256; i++) {
       
  1733   _utf8len[i] = (i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1);
       
  1734 }
       
  1735 _utf8len[254]=_utf8len[254]=1; // Invalid sequence start
       
  1736 
       
  1737 // convert string to array (typed, when possible)
       
  1738 var string2buf = function (str) {
       
  1739     var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
       
  1740 
       
  1741     // count binary size
       
  1742     for (m_pos = 0; m_pos < str_len; m_pos++) {
       
  1743         c = str.charCodeAt(m_pos);
       
  1744         if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
       
  1745             c2 = str.charCodeAt(m_pos+1);
       
  1746             if ((c2 & 0xfc00) === 0xdc00) {
       
  1747                 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
       
  1748                 m_pos++;
       
  1749             }
       
  1750         }
       
  1751         buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
       
  1752     }
       
  1753 
       
  1754     // allocate buffer
       
  1755     if (support.uint8array) {
       
  1756         buf = new Uint8Array(buf_len);
       
  1757     } else {
       
  1758         buf = new Array(buf_len);
       
  1759     }
       
  1760 
       
  1761     // convert
       
  1762     for (i=0, m_pos = 0; i < buf_len; m_pos++) {
       
  1763         c = str.charCodeAt(m_pos);
       
  1764         if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
       
  1765             c2 = str.charCodeAt(m_pos+1);
       
  1766             if ((c2 & 0xfc00) === 0xdc00) {
       
  1767                 c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
       
  1768                 m_pos++;
       
  1769             }
       
  1770         }
       
  1771         if (c < 0x80) {
       
  1772             /* one byte */
       
  1773             buf[i++] = c;
       
  1774         } else if (c < 0x800) {
       
  1775             /* two bytes */
       
  1776             buf[i++] = 0xC0 | (c >>> 6);
       
  1777             buf[i++] = 0x80 | (c & 0x3f);
       
  1778         } else if (c < 0x10000) {
       
  1779             /* three bytes */
       
  1780             buf[i++] = 0xE0 | (c >>> 12);
       
  1781             buf[i++] = 0x80 | (c >>> 6 & 0x3f);
       
  1782             buf[i++] = 0x80 | (c & 0x3f);
       
  1783         } else {
       
  1784             /* four bytes */
       
  1785             buf[i++] = 0xf0 | (c >>> 18);
       
  1786             buf[i++] = 0x80 | (c >>> 12 & 0x3f);
       
  1787             buf[i++] = 0x80 | (c >>> 6 & 0x3f);
       
  1788             buf[i++] = 0x80 | (c & 0x3f);
       
  1789         }
       
  1790     }
       
  1791 
       
  1792     return buf;
       
  1793 };
       
  1794 
       
  1795 // Calculate max possible position in utf8 buffer,
       
  1796 // that will not break sequence. If that's not possible
       
  1797 // - (very small limits) return max size as is.
       
  1798 //
       
  1799 // buf[] - utf8 bytes array
       
  1800 // max   - length limit (mandatory);
       
  1801 var utf8border = function(buf, max) {
       
  1802     var pos;
       
  1803 
       
  1804     max = max || buf.length;
       
  1805     if (max > buf.length) { max = buf.length; }
       
  1806 
       
  1807     // go back from last position, until start of sequence found
       
  1808     pos = max-1;
       
  1809     while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
       
  1810 
       
  1811     // Fuckup - very small and broken sequence,
       
  1812     // return max, because we should return something anyway.
       
  1813     if (pos < 0) { return max; }
       
  1814 
       
  1815     // If we came to start of buffer - that means vuffer is too small,
       
  1816     // return max too.
       
  1817     if (pos === 0) { return max; }
       
  1818 
       
  1819     return (pos + _utf8len[buf[pos]] > max) ? pos : max;
       
  1820 };
       
  1821 
       
  1822 // convert array to string
       
  1823 var buf2string = function (buf) {
       
  1824     var str, i, out, c, c_len;
       
  1825     var len = buf.length;
       
  1826 
       
  1827     // Reserve max possible length (2 words per char)
       
  1828     // NB: by unknown reasons, Array is significantly faster for
       
  1829     //     String.fromCharCode.apply than Uint16Array.
       
  1830     var utf16buf = new Array(len*2);
       
  1831 
       
  1832     for (out=0, i=0; i<len;) {
       
  1833         c = buf[i++];
       
  1834         // quick process ascii
       
  1835         if (c < 0x80) { utf16buf[out++] = c; continue; }
       
  1836 
       
  1837         c_len = _utf8len[c];
       
  1838         // skip 5 & 6 byte codes
       
  1839         if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len-1; continue; }
       
  1840 
       
  1841         // apply mask on first byte
       
  1842         c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
       
  1843         // join the rest
       
  1844         while (c_len > 1 && i < len) {
       
  1845             c = (c << 6) | (buf[i++] & 0x3f);
       
  1846             c_len--;
       
  1847         }
       
  1848 
       
  1849         // terminated by end of string?
       
  1850         if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
       
  1851 
       
  1852         if (c < 0x10000) {
       
  1853             utf16buf[out++] = c;
       
  1854         } else {
       
  1855             c -= 0x10000;
       
  1856             utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
       
  1857             utf16buf[out++] = 0xdc00 | (c & 0x3ff);
       
  1858         }
       
  1859     }
       
  1860 
       
  1861     // shrinkBuf(utf16buf, out)
       
  1862     if (utf16buf.length !== out) {
       
  1863         if(utf16buf.subarray) {
       
  1864             utf16buf = utf16buf.subarray(0, out);
       
  1865         } else {
       
  1866             utf16buf.length = out;
       
  1867         }
       
  1868     }
       
  1869 
       
  1870     // return String.fromCharCode.apply(null, utf16buf);
       
  1871     return utils.applyFromCharCode(utf16buf);
       
  1872 };
       
  1873 
       
  1874 
       
  1875 // That's all for the pako functions.
       
  1876 
       
  1877 
       
  1878 /**
       
  1879  * Transform a javascript string into an array (typed if possible) of bytes,
       
  1880  * UTF-8 encoded.
       
  1881  * @param {String} str the string to encode
       
  1882  * @return {Array|Uint8Array|Buffer} the UTF-8 encoded string.
       
  1883  */
       
  1884 exports.utf8encode = function utf8encode(str) {
       
  1885     if (support.nodebuffer) {
       
  1886         return nodeBuffer(str, "utf-8");
       
  1887     }
       
  1888 
       
  1889     return string2buf(str);
       
  1890 };
       
  1891 
       
  1892 
       
  1893 /**
       
  1894  * Transform a bytes array (or a representation) representing an UTF-8 encoded
       
  1895  * string into a javascript string.
       
  1896  * @param {Array|Uint8Array|Buffer} buf the data de decode
       
  1897  * @return {String} the decoded string.
       
  1898  */
       
  1899 exports.utf8decode = function utf8decode(buf) {
       
  1900     if (support.nodebuffer) {
       
  1901         return utils.transformTo("nodebuffer", buf).toString("utf-8");
       
  1902     }
       
  1903 
       
  1904     buf = utils.transformTo(support.uint8array ? "uint8array" : "array", buf);
       
  1905 
       
  1906     // return buf2string(buf);
       
  1907     // Chrome prefers to work with "small" chunks of data
       
  1908     // for the method buf2string.
       
  1909     // Firefox and Chrome has their own shortcut, IE doesn't seem to really care.
       
  1910     var result = [], k = 0, len = buf.length, chunk = 65536;
       
  1911     while (k < len) {
       
  1912         var nextBoundary = utf8border(buf, Math.min(k + chunk, len));
       
  1913         if (support.uint8array) {
       
  1914             result.push(buf2string(buf.subarray(k, nextBoundary)));
       
  1915         } else {
       
  1916             result.push(buf2string(buf.slice(k, nextBoundary)));
       
  1917         }
       
  1918         k = nextBoundary;
       
  1919     }
       
  1920     return result.join("");
       
  1921 
       
  1922 };
       
  1923 // vim: set shiftwidth=4 softtabstop=4:
       
  1924 
       
  1925 },{"./nodeBuffer":11,"./support":17,"./utils":21}],21:[function(_dereq_,module,exports){
       
  1926 'use strict';
       
  1927 var support = _dereq_('./support');
       
  1928 var compressions = _dereq_('./compressions');
       
  1929 var nodeBuffer = _dereq_('./nodeBuffer');
       
  1930 /**
       
  1931  * Convert a string to a "binary string" : a string containing only char codes between 0 and 255.
       
  1932  * @param {string} str the string to transform.
       
  1933  * @return {String} the binary string.
       
  1934  */
       
  1935 exports.string2binary = function(str) {
       
  1936     var result = "";
       
  1937     for (var i = 0; i < str.length; i++) {
       
  1938         result += String.fromCharCode(str.charCodeAt(i) & 0xff);
       
  1939     }
       
  1940     return result;
       
  1941 };
       
  1942 exports.arrayBuffer2Blob = function(buffer, mimeType) {
       
  1943     exports.checkSupport("blob");
       
  1944 	mimeType = mimeType || 'application/zip';
       
  1945 
       
  1946     try {
       
  1947         // Blob constructor
       
  1948         return new Blob([buffer], {
       
  1949             type: mimeType
       
  1950         });
       
  1951     }
       
  1952     catch (e) {
       
  1953 
       
  1954         try {
       
  1955             // deprecated, browser only, old way
       
  1956             var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
       
  1957             var builder = new Builder();
       
  1958             builder.append(buffer);
       
  1959             return builder.getBlob(mimeType);
       
  1960         }
       
  1961         catch (e) {
       
  1962 
       
  1963             // well, fuck ?!
       
  1964             throw new Error("Bug : can't construct the Blob.");
       
  1965         }
       
  1966     }
       
  1967 
       
  1968 
       
  1969 };
       
  1970 /**
       
  1971  * The identity function.
       
  1972  * @param {Object} input the input.
       
  1973  * @return {Object} the same input.
       
  1974  */
       
  1975 function identity(input) {
       
  1976     return input;
       
  1977 }
       
  1978 
       
  1979 /**
       
  1980  * Fill in an array with a string.
       
  1981  * @param {String} str the string to use.
       
  1982  * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
       
  1983  * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
       
  1984  */
       
  1985 function stringToArrayLike(str, array) {
       
  1986     for (var i = 0; i < str.length; ++i) {
       
  1987         array[i] = str.charCodeAt(i) & 0xFF;
       
  1988     }
       
  1989     return array;
       
  1990 }
       
  1991 
       
  1992 /**
       
  1993  * Transform an array-like object to a string.
       
  1994  * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
       
  1995  * @return {String} the result.
       
  1996  */
       
  1997 function arrayLikeToString(array) {
       
  1998     // Performances notes :
       
  1999     // --------------------
       
  2000     // String.fromCharCode.apply(null, array) is the fastest, see
       
  2001     // see http://jsperf.com/converting-a-uint8array-to-a-string/2
       
  2002     // but the stack is limited (and we can get huge arrays !).
       
  2003     //
       
  2004     // result += String.fromCharCode(array[i]); generate too many strings !
       
  2005     //
       
  2006     // This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2
       
  2007     var chunk = 65536;
       
  2008     var result = [],
       
  2009         len = array.length,
       
  2010         type = exports.getTypeOf(array),
       
  2011         k = 0,
       
  2012         canUseApply = true;
       
  2013       try {
       
  2014          switch(type) {
       
  2015             case "uint8array":
       
  2016                String.fromCharCode.apply(null, new Uint8Array(0));
       
  2017                break;
       
  2018             case "nodebuffer":
       
  2019                String.fromCharCode.apply(null, nodeBuffer(0));
       
  2020                break;
       
  2021          }
       
  2022       } catch(e) {
       
  2023          canUseApply = false;
       
  2024       }
       
  2025 
       
  2026       // no apply : slow and painful algorithm
       
  2027       // default browser on android 4.*
       
  2028       if (!canUseApply) {
       
  2029          var resultStr = "";
       
  2030          for(var i = 0; i < array.length;i++) {
       
  2031             resultStr += String.fromCharCode(array[i]);
       
  2032          }
       
  2033     return resultStr;
       
  2034     }
       
  2035     while (k < len && chunk > 1) {
       
  2036         try {
       
  2037             if (type === "array" || type === "nodebuffer") {
       
  2038                 result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
       
  2039             }
       
  2040             else {
       
  2041                 result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
       
  2042             }
       
  2043             k += chunk;
       
  2044         }
       
  2045         catch (e) {
       
  2046             chunk = Math.floor(chunk / 2);
       
  2047         }
       
  2048     }
       
  2049     return result.join("");
       
  2050 }
       
  2051 
       
  2052 exports.applyFromCharCode = arrayLikeToString;
       
  2053 
       
  2054 
       
  2055 /**
       
  2056  * Copy the data from an array-like to an other array-like.
       
  2057  * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array.
       
  2058  * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated.
       
  2059  * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array.
       
  2060  */
       
  2061 function arrayLikeToArrayLike(arrayFrom, arrayTo) {
       
  2062     for (var i = 0; i < arrayFrom.length; i++) {
       
  2063         arrayTo[i] = arrayFrom[i];
       
  2064     }
       
  2065     return arrayTo;
       
  2066 }
       
  2067 
       
  2068 // a matrix containing functions to transform everything into everything.
       
  2069 var transform = {};
       
  2070 
       
  2071 // string to ?
       
  2072 transform["string"] = {
       
  2073     "string": identity,
       
  2074     "array": function(input) {
       
  2075         return stringToArrayLike(input, new Array(input.length));
       
  2076     },
       
  2077     "arraybuffer": function(input) {
       
  2078         return transform["string"]["uint8array"](input).buffer;
       
  2079     },
       
  2080     "uint8array": function(input) {
       
  2081         return stringToArrayLike(input, new Uint8Array(input.length));
       
  2082     },
       
  2083     "nodebuffer": function(input) {
       
  2084         return stringToArrayLike(input, nodeBuffer(input.length));
       
  2085     }
       
  2086 };
       
  2087 
       
  2088 // array to ?
       
  2089 transform["array"] = {
       
  2090     "string": arrayLikeToString,
       
  2091     "array": identity,
       
  2092     "arraybuffer": function(input) {
       
  2093         return (new Uint8Array(input)).buffer;
       
  2094     },
       
  2095     "uint8array": function(input) {
       
  2096         return new Uint8Array(input);
       
  2097     },
       
  2098     "nodebuffer": function(input) {
       
  2099         return nodeBuffer(input);
       
  2100     }
       
  2101 };
       
  2102 
       
  2103 // arraybuffer to ?
       
  2104 transform["arraybuffer"] = {
       
  2105     "string": function(input) {
       
  2106         return arrayLikeToString(new Uint8Array(input));
       
  2107     },
       
  2108     "array": function(input) {
       
  2109         return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
       
  2110     },
       
  2111     "arraybuffer": identity,
       
  2112     "uint8array": function(input) {
       
  2113         return new Uint8Array(input);
       
  2114     },
       
  2115     "nodebuffer": function(input) {
       
  2116         return nodeBuffer(new Uint8Array(input));
       
  2117     }
       
  2118 };
       
  2119 
       
  2120 // uint8array to ?
       
  2121 transform["uint8array"] = {
       
  2122     "string": arrayLikeToString,
       
  2123     "array": function(input) {
       
  2124         return arrayLikeToArrayLike(input, new Array(input.length));
       
  2125     },
       
  2126     "arraybuffer": function(input) {
       
  2127         return input.buffer;
       
  2128     },
       
  2129     "uint8array": identity,
       
  2130     "nodebuffer": function(input) {
       
  2131         return nodeBuffer(input);
       
  2132     }
       
  2133 };
       
  2134 
       
  2135 // nodebuffer to ?
       
  2136 transform["nodebuffer"] = {
       
  2137     "string": arrayLikeToString,
       
  2138     "array": function(input) {
       
  2139         return arrayLikeToArrayLike(input, new Array(input.length));
       
  2140     },
       
  2141     "arraybuffer": function(input) {
       
  2142         return transform["nodebuffer"]["uint8array"](input).buffer;
       
  2143     },
       
  2144     "uint8array": function(input) {
       
  2145         return arrayLikeToArrayLike(input, new Uint8Array(input.length));
       
  2146     },
       
  2147     "nodebuffer": identity
       
  2148 };
       
  2149 
       
  2150 /**
       
  2151  * Transform an input into any type.
       
  2152  * The supported output type are : string, array, uint8array, arraybuffer, nodebuffer.
       
  2153  * If no output type is specified, the unmodified input will be returned.
       
  2154  * @param {String} outputType the output type.
       
  2155  * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert.
       
  2156  * @throws {Error} an Error if the browser doesn't support the requested output type.
       
  2157  */
       
  2158 exports.transformTo = function(outputType, input) {
       
  2159     if (!input) {
       
  2160         // undefined, null, etc
       
  2161         // an empty string won't harm.
       
  2162         input = "";
       
  2163     }
       
  2164     if (!outputType) {
       
  2165         return input;
       
  2166     }
       
  2167     exports.checkSupport(outputType);
       
  2168     var inputType = exports.getTypeOf(input);
       
  2169     var result = transform[inputType][outputType](input);
       
  2170     return result;
       
  2171 };
       
  2172 
       
  2173 /**
       
  2174  * Return the type of the input.
       
  2175  * The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
       
  2176  * @param {Object} input the input to identify.
       
  2177  * @return {String} the (lowercase) type of the input.
       
  2178  */
       
  2179 exports.getTypeOf = function(input) {
       
  2180     if (typeof input === "string") {
       
  2181         return "string";
       
  2182     }
       
  2183     if (Object.prototype.toString.call(input) === "[object Array]") {
       
  2184         return "array";
       
  2185     }
       
  2186     if (support.nodebuffer && nodeBuffer.test(input)) {
       
  2187         return "nodebuffer";
       
  2188     }
       
  2189     if (support.uint8array && input instanceof Uint8Array) {
       
  2190         return "uint8array";
       
  2191     }
       
  2192     if (support.arraybuffer && input instanceof ArrayBuffer) {
       
  2193         return "arraybuffer";
       
  2194     }
       
  2195 };
       
  2196 
       
  2197 /**
       
  2198  * Throw an exception if the type is not supported.
       
  2199  * @param {String} type the type to check.
       
  2200  * @throws {Error} an Error if the browser doesn't support the requested type.
       
  2201  */
       
  2202 exports.checkSupport = function(type) {
       
  2203     var supported = support[type.toLowerCase()];
       
  2204     if (!supported) {
       
  2205         throw new Error(type + " is not supported by this browser");
       
  2206     }
       
  2207 };
       
  2208 exports.MAX_VALUE_16BITS = 65535;
       
  2209 exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1
       
  2210 
       
  2211 /**
       
  2212  * Prettify a string read as binary.
       
  2213  * @param {string} str the string to prettify.
       
  2214  * @return {string} a pretty string.
       
  2215  */
       
  2216 exports.pretty = function(str) {
       
  2217     var res = '',
       
  2218         code, i;
       
  2219     for (i = 0; i < (str || "").length; i++) {
       
  2220         code = str.charCodeAt(i);
       
  2221         res += '\\x' + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
       
  2222     }
       
  2223     return res;
       
  2224 };
       
  2225 
       
  2226 /**
       
  2227  * Find a compression registered in JSZip.
       
  2228  * @param {string} compressionMethod the method magic to find.
       
  2229  * @return {Object|null} the JSZip compression object, null if none found.
       
  2230  */
       
  2231 exports.findCompression = function(compressionMethod) {
       
  2232     for (var method in compressions) {
       
  2233         if (!compressions.hasOwnProperty(method)) {
       
  2234             continue;
       
  2235         }
       
  2236         if (compressions[method].magic === compressionMethod) {
       
  2237             return compressions[method];
       
  2238         }
       
  2239     }
       
  2240     return null;
       
  2241 };
       
  2242 /**
       
  2243 * Cross-window, cross-Node-context regular expression detection
       
  2244 * @param  {Object}  object Anything
       
  2245 * @return {Boolean}        true if the object is a regular expression,
       
  2246 * false otherwise
       
  2247 */
       
  2248 exports.isRegExp = function (object) {
       
  2249     return Object.prototype.toString.call(object) === "[object RegExp]";
       
  2250 };
       
  2251 
       
  2252 
       
  2253 },{"./compressions":3,"./nodeBuffer":11,"./support":17}],22:[function(_dereq_,module,exports){
       
  2254 'use strict';
       
  2255 var StringReader = _dereq_('./stringReader');
       
  2256 var NodeBufferReader = _dereq_('./nodeBufferReader');
       
  2257 var Uint8ArrayReader = _dereq_('./uint8ArrayReader');
       
  2258 var utils = _dereq_('./utils');
       
  2259 var sig = _dereq_('./signature');
       
  2260 var ZipEntry = _dereq_('./zipEntry');
       
  2261 var support = _dereq_('./support');
       
  2262 var jszipProto = _dereq_('./object');
       
  2263 //  class ZipEntries {{{
       
  2264 /**
       
  2265  * All the entries in the zip file.
       
  2266  * @constructor
       
  2267  * @param {String|ArrayBuffer|Uint8Array} data the binary stream to load.
       
  2268  * @param {Object} loadOptions Options for loading the stream.
       
  2269  */
       
  2270 function ZipEntries(data, loadOptions) {
       
  2271     this.files = [];
       
  2272     this.loadOptions = loadOptions;
       
  2273     if (data) {
       
  2274         this.load(data);
       
  2275     }
       
  2276 }
       
  2277 ZipEntries.prototype = {
       
  2278     /**
       
  2279      * Check that the reader is on the speficied signature.
       
  2280      * @param {string} expectedSignature the expected signature.
       
  2281      * @throws {Error} if it is an other signature.
       
  2282      */
       
  2283     checkSignature: function(expectedSignature) {
       
  2284         var signature = this.reader.readString(4);
       
  2285         if (signature !== expectedSignature) {
       
  2286             throw new Error("Corrupted zip or bug : unexpected signature " + "(" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
       
  2287         }
       
  2288     },
       
  2289     /**
       
  2290      * Read the end of the central directory.
       
  2291      */
       
  2292     readBlockEndOfCentral: function() {
       
  2293         this.diskNumber = this.reader.readInt(2);
       
  2294         this.diskWithCentralDirStart = this.reader.readInt(2);
       
  2295         this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
       
  2296         this.centralDirRecords = this.reader.readInt(2);
       
  2297         this.centralDirSize = this.reader.readInt(4);
       
  2298         this.centralDirOffset = this.reader.readInt(4);
       
  2299 
       
  2300         this.zipCommentLength = this.reader.readInt(2);
       
  2301         // warning : the encoding depends of the system locale
       
  2302         // On a linux machine with LANG=en_US.utf8, this field is utf8 encoded.
       
  2303         // On a windows machine, this field is encoded with the localized windows code page.
       
  2304         this.zipComment = this.reader.readString(this.zipCommentLength);
       
  2305         // To get consistent behavior with the generation part, we will assume that
       
  2306         // this is utf8 encoded.
       
  2307         this.zipComment = jszipProto.utf8decode(this.zipComment);
       
  2308     },
       
  2309     /**
       
  2310      * Read the end of the Zip 64 central directory.
       
  2311      * Not merged with the method readEndOfCentral :
       
  2312      * The end of central can coexist with its Zip64 brother,
       
  2313      * I don't want to read the wrong number of bytes !
       
  2314      */
       
  2315     readBlockZip64EndOfCentral: function() {
       
  2316         this.zip64EndOfCentralSize = this.reader.readInt(8);
       
  2317         this.versionMadeBy = this.reader.readString(2);
       
  2318         this.versionNeeded = this.reader.readInt(2);
       
  2319         this.diskNumber = this.reader.readInt(4);
       
  2320         this.diskWithCentralDirStart = this.reader.readInt(4);
       
  2321         this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
       
  2322         this.centralDirRecords = this.reader.readInt(8);
       
  2323         this.centralDirSize = this.reader.readInt(8);
       
  2324         this.centralDirOffset = this.reader.readInt(8);
       
  2325 
       
  2326         this.zip64ExtensibleData = {};
       
  2327         var extraDataSize = this.zip64EndOfCentralSize - 44,
       
  2328             index = 0,
       
  2329             extraFieldId,
       
  2330             extraFieldLength,
       
  2331             extraFieldValue;
       
  2332         while (index < extraDataSize) {
       
  2333             extraFieldId = this.reader.readInt(2);
       
  2334             extraFieldLength = this.reader.readInt(4);
       
  2335             extraFieldValue = this.reader.readString(extraFieldLength);
       
  2336             this.zip64ExtensibleData[extraFieldId] = {
       
  2337                 id: extraFieldId,
       
  2338                 length: extraFieldLength,
       
  2339                 value: extraFieldValue
       
  2340             };
       
  2341         }
       
  2342     },
       
  2343     /**
       
  2344      * Read the end of the Zip 64 central directory locator.
       
  2345      */
       
  2346     readBlockZip64EndOfCentralLocator: function() {
       
  2347         this.diskWithZip64CentralDirStart = this.reader.readInt(4);
       
  2348         this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8);
       
  2349         this.disksCount = this.reader.readInt(4);
       
  2350         if (this.disksCount > 1) {
       
  2351             throw new Error("Multi-volumes zip are not supported");
       
  2352         }
       
  2353     },
       
  2354     /**
       
  2355      * Read the local files, based on the offset read in the central part.
       
  2356      */
       
  2357     readLocalFiles: function() {
       
  2358         var i, file;
       
  2359         for (i = 0; i < this.files.length; i++) {
       
  2360             file = this.files[i];
       
  2361             this.reader.setIndex(file.localHeaderOffset);
       
  2362             this.checkSignature(sig.LOCAL_FILE_HEADER);
       
  2363             file.readLocalPart(this.reader);
       
  2364             file.handleUTF8();
       
  2365             file.processAttributes();
       
  2366         }
       
  2367     },
       
  2368     /**
       
  2369      * Read the central directory.
       
  2370      */
       
  2371     readCentralDir: function() {
       
  2372         var file;
       
  2373 
       
  2374         this.reader.setIndex(this.centralDirOffset);
       
  2375         while (this.reader.readString(4) === sig.CENTRAL_FILE_HEADER) {
       
  2376             file = new ZipEntry({
       
  2377                 zip64: this.zip64
       
  2378             }, this.loadOptions);
       
  2379             file.readCentralPart(this.reader);
       
  2380             this.files.push(file);
       
  2381         }
       
  2382     },
       
  2383     /**
       
  2384      * Read the end of central directory.
       
  2385      */
       
  2386     readEndOfCentral: function() {
       
  2387         var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END);
       
  2388         if (offset === -1) {
       
  2389             // Check if the content is a truncated zip or complete garbage.
       
  2390             // A "LOCAL_FILE_HEADER" is not required at the beginning (auto
       
  2391             // extractible zip for example) but it can give a good hint.
       
  2392             // If an ajax request was used without responseType, we will also
       
  2393             // get unreadable data.
       
  2394             var isGarbage = true;
       
  2395             try {
       
  2396                 this.reader.setIndex(0);
       
  2397                 this.checkSignature(sig.LOCAL_FILE_HEADER);
       
  2398                 isGarbage = false;
       
  2399             } catch (e) {}
       
  2400 
       
  2401             if (isGarbage) {
       
  2402                 throw new Error("Can't find end of central directory : is this a zip file ? " +
       
  2403                                 "If it is, see http://stuk.github.io/jszip/documentation/howto/read_zip.html");
       
  2404             } else {
       
  2405                 throw new Error("Corrupted zip : can't find end of central directory");
       
  2406             }
       
  2407         }
       
  2408         this.reader.setIndex(offset);
       
  2409         this.checkSignature(sig.CENTRAL_DIRECTORY_END);
       
  2410         this.readBlockEndOfCentral();
       
  2411 
       
  2412 
       
  2413         /* extract from the zip spec :
       
  2414             4)  If one of the fields in the end of central directory
       
  2415                 record is too small to hold required data, the field
       
  2416                 should be set to -1 (0xFFFF or 0xFFFFFFFF) and the
       
  2417                 ZIP64 format record should be created.
       
  2418             5)  The end of central directory record and the
       
  2419                 Zip64 end of central directory locator record must
       
  2420                 reside on the same disk when splitting or spanning
       
  2421                 an archive.
       
  2422          */
       
  2423         if (this.diskNumber === utils.MAX_VALUE_16BITS || this.diskWithCentralDirStart === utils.MAX_VALUE_16BITS || this.centralDirRecordsOnThisDisk === utils.MAX_VALUE_16BITS || this.centralDirRecords === utils.MAX_VALUE_16BITS || this.centralDirSize === utils.MAX_VALUE_32BITS || this.centralDirOffset === utils.MAX_VALUE_32BITS) {
       
  2424             this.zip64 = true;
       
  2425 
       
  2426             /*
       
  2427             Warning : the zip64 extension is supported, but ONLY if the 64bits integer read from
       
  2428             the zip file can fit into a 32bits integer. This cannot be solved : Javascript represents
       
  2429             all numbers as 64-bit double precision IEEE 754 floating point numbers.
       
  2430             So, we have 53bits for integers and bitwise operations treat everything as 32bits.
       
  2431             see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Bitwise_Operators
       
  2432             and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf section 8.5
       
  2433             */
       
  2434 
       
  2435             // should look for a zip64 EOCD locator
       
  2436             offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
       
  2437             if (offset === -1) {
       
  2438                 throw new Error("Corrupted zip : can't find the ZIP64 end of central directory locator");
       
  2439             }
       
  2440             this.reader.setIndex(offset);
       
  2441             this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
       
  2442             this.readBlockZip64EndOfCentralLocator();
       
  2443 
       
  2444             // now the zip64 EOCD record
       
  2445             this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir);
       
  2446             this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
       
  2447             this.readBlockZip64EndOfCentral();
       
  2448         }
       
  2449     },
       
  2450     prepareReader: function(data) {
       
  2451         var type = utils.getTypeOf(data);
       
  2452         if (type === "string" && !support.uint8array) {
       
  2453             this.reader = new StringReader(data, this.loadOptions.optimizedBinaryString);
       
  2454         }
       
  2455         else if (type === "nodebuffer") {
       
  2456             this.reader = new NodeBufferReader(data);
       
  2457         }
       
  2458         else {
       
  2459             this.reader = new Uint8ArrayReader(utils.transformTo("uint8array", data));
       
  2460         }
       
  2461     },
       
  2462     /**
       
  2463      * Read a zip file and create ZipEntries.
       
  2464      * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
       
  2465      */
       
  2466     load: function(data) {
       
  2467         this.prepareReader(data);
       
  2468         this.readEndOfCentral();
       
  2469         this.readCentralDir();
       
  2470         this.readLocalFiles();
       
  2471     }
       
  2472 };
       
  2473 // }}} end of ZipEntries
       
  2474 module.exports = ZipEntries;
       
  2475 
       
  2476 },{"./nodeBufferReader":12,"./object":13,"./signature":14,"./stringReader":15,"./support":17,"./uint8ArrayReader":18,"./utils":21,"./zipEntry":23}],23:[function(_dereq_,module,exports){
       
  2477 'use strict';
       
  2478 var StringReader = _dereq_('./stringReader');
       
  2479 var utils = _dereq_('./utils');
       
  2480 var CompressedObject = _dereq_('./compressedObject');
       
  2481 var jszipProto = _dereq_('./object');
       
  2482 
       
  2483 var MADE_BY_DOS = 0x00;
       
  2484 var MADE_BY_UNIX = 0x03;
       
  2485 
       
  2486 // class ZipEntry {{{
       
  2487 /**
       
  2488  * An entry in the zip file.
       
  2489  * @constructor
       
  2490  * @param {Object} options Options of the current file.
       
  2491  * @param {Object} loadOptions Options for loading the stream.
       
  2492  */
       
  2493 function ZipEntry(options, loadOptions) {
       
  2494     this.options = options;
       
  2495     this.loadOptions = loadOptions;
       
  2496 }
       
  2497 ZipEntry.prototype = {
       
  2498     /**
       
  2499      * say if the file is encrypted.
       
  2500      * @return {boolean} true if the file is encrypted, false otherwise.
       
  2501      */
       
  2502     isEncrypted: function() {
       
  2503         // bit 1 is set
       
  2504         return (this.bitFlag & 0x0001) === 0x0001;
       
  2505     },
       
  2506     /**
       
  2507      * say if the file has utf-8 filename/comment.
       
  2508      * @return {boolean} true if the filename/comment is in utf-8, false otherwise.
       
  2509      */
       
  2510     useUTF8: function() {
       
  2511         // bit 11 is set
       
  2512         return (this.bitFlag & 0x0800) === 0x0800;
       
  2513     },
       
  2514     /**
       
  2515      * Prepare the function used to generate the compressed content from this ZipFile.
       
  2516      * @param {DataReader} reader the reader to use.
       
  2517      * @param {number} from the offset from where we should read the data.
       
  2518      * @param {number} length the length of the data to read.
       
  2519      * @return {Function} the callback to get the compressed content (the type depends of the DataReader class).
       
  2520      */
       
  2521     prepareCompressedContent: function(reader, from, length) {
       
  2522         return function() {
       
  2523             var previousIndex = reader.index;
       
  2524             reader.setIndex(from);
       
  2525             var compressedFileData = reader.readData(length);
       
  2526             reader.setIndex(previousIndex);
       
  2527 
       
  2528             return compressedFileData;
       
  2529         };
       
  2530     },
       
  2531     /**
       
  2532      * Prepare the function used to generate the uncompressed content from this ZipFile.
       
  2533      * @param {DataReader} reader the reader to use.
       
  2534      * @param {number} from the offset from where we should read the data.
       
  2535      * @param {number} length the length of the data to read.
       
  2536      * @param {JSZip.compression} compression the compression used on this file.
       
  2537      * @param {number} uncompressedSize the uncompressed size to expect.
       
  2538      * @return {Function} the callback to get the uncompressed content (the type depends of the DataReader class).
       
  2539      */
       
  2540     prepareContent: function(reader, from, length, compression, uncompressedSize) {
       
  2541         return function() {
       
  2542 
       
  2543             var compressedFileData = utils.transformTo(compression.uncompressInputType, this.getCompressedContent());
       
  2544             var uncompressedFileData = compression.uncompress(compressedFileData);
       
  2545 
       
  2546             if (uncompressedFileData.length !== uncompressedSize) {
       
  2547                 throw new Error("Bug : uncompressed data size mismatch");
       
  2548             }
       
  2549 
       
  2550             return uncompressedFileData;
       
  2551         };
       
  2552     },
       
  2553     /**
       
  2554      * Read the local part of a zip file and add the info in this object.
       
  2555      * @param {DataReader} reader the reader to use.
       
  2556      */
       
  2557     readLocalPart: function(reader) {
       
  2558         var compression, localExtraFieldsLength;
       
  2559 
       
  2560         // we already know everything from the central dir !
       
  2561         // If the central dir data are false, we are doomed.
       
  2562         // On the bright side, the local part is scary  : zip64, data descriptors, both, etc.
       
  2563         // The less data we get here, the more reliable this should be.
       
  2564         // Let's skip the whole header and dash to the data !
       
  2565         reader.skip(22);
       
  2566         // in some zip created on windows, the filename stored in the central dir contains \ instead of /.
       
  2567         // Strangely, the filename here is OK.
       
  2568         // I would love to treat these zip files as corrupted (see http://www.info-zip.org/FAQ.html#backslashes
       
  2569         // or APPNOTE#4.4.17.1, "All slashes MUST be forward slashes '/'") but there are a lot of bad zip generators...
       
  2570         // Search "unzip mismatching "local" filename continuing with "central" filename version" on
       
  2571         // the internet.
       
  2572         //
       
  2573         // I think I see the logic here : the central directory is used to display
       
  2574         // content and the local directory is used to extract the files. Mixing / and \
       
  2575         // may be used to display \ to windows users and use / when extracting the files.
       
  2576         // Unfortunately, this lead also to some issues : http://seclists.org/fulldisclosure/2009/Sep/394
       
  2577         this.fileNameLength = reader.readInt(2);
       
  2578         localExtraFieldsLength = reader.readInt(2); // can't be sure this will be the same as the central dir
       
  2579         this.fileName = reader.readString(this.fileNameLength);
       
  2580         reader.skip(localExtraFieldsLength);
       
  2581 
       
  2582         if (this.compressedSize == -1 || this.uncompressedSize == -1) {
       
  2583             throw new Error("Bug or corrupted zip : didn't get enough informations from the central directory " + "(compressedSize == -1 || uncompressedSize == -1)");
       
  2584         }
       
  2585 
       
  2586         compression = utils.findCompression(this.compressionMethod);
       
  2587         if (compression === null) { // no compression found
       
  2588             throw new Error("Corrupted zip : compression " + utils.pretty(this.compressionMethod) + " unknown (inner file : " + this.fileName + ")");
       
  2589         }
       
  2590         this.decompressed = new CompressedObject();
       
  2591         this.decompressed.compressedSize = this.compressedSize;
       
  2592         this.decompressed.uncompressedSize = this.uncompressedSize;
       
  2593         this.decompressed.crc32 = this.crc32;
       
  2594         this.decompressed.compressionMethod = this.compressionMethod;
       
  2595         this.decompressed.getCompressedContent = this.prepareCompressedContent(reader, reader.index, this.compressedSize, compression);
       
  2596         this.decompressed.getContent = this.prepareContent(reader, reader.index, this.compressedSize, compression, this.uncompressedSize);
       
  2597 
       
  2598         // we need to compute the crc32...
       
  2599         if (this.loadOptions.checkCRC32) {
       
  2600             this.decompressed = utils.transformTo("string", this.decompressed.getContent());
       
  2601             if (jszipProto.crc32(this.decompressed) !== this.crc32) {
       
  2602                 throw new Error("Corrupted zip : CRC32 mismatch");
       
  2603             }
       
  2604         }
       
  2605     },
       
  2606 
       
  2607     /**
       
  2608      * Read the central part of a zip file and add the info in this object.
       
  2609      * @param {DataReader} reader the reader to use.
       
  2610      */
       
  2611     readCentralPart: function(reader) {
       
  2612         this.versionMadeBy = reader.readInt(2);
       
  2613         this.versionNeeded = reader.readInt(2);
       
  2614         this.bitFlag = reader.readInt(2);
       
  2615         this.compressionMethod = reader.readString(2);
       
  2616         this.date = reader.readDate();
       
  2617         this.crc32 = reader.readInt(4);
       
  2618         this.compressedSize = reader.readInt(4);
       
  2619         this.uncompressedSize = reader.readInt(4);
       
  2620         this.fileNameLength = reader.readInt(2);
       
  2621         this.extraFieldsLength = reader.readInt(2);
       
  2622         this.fileCommentLength = reader.readInt(2);
       
  2623         this.diskNumberStart = reader.readInt(2);
       
  2624         this.internalFileAttributes = reader.readInt(2);
       
  2625         this.externalFileAttributes = reader.readInt(4);
       
  2626         this.localHeaderOffset = reader.readInt(4);
       
  2627 
       
  2628         if (this.isEncrypted()) {
       
  2629             throw new Error("Encrypted zip are not supported");
       
  2630         }
       
  2631 
       
  2632         this.fileName = reader.readString(this.fileNameLength);
       
  2633         this.readExtraFields(reader);
       
  2634         this.parseZIP64ExtraField(reader);
       
  2635         this.fileComment = reader.readString(this.fileCommentLength);
       
  2636     },
       
  2637 
       
  2638     /**
       
  2639      * Parse the external file attributes and get the unix/dos permissions.
       
  2640      */
       
  2641     processAttributes: function () {
       
  2642         this.unixPermissions = null;
       
  2643         this.dosPermissions = null;
       
  2644         var madeBy = this.versionMadeBy >> 8;
       
  2645 
       
  2646         // Check if we have the DOS directory flag set.
       
  2647         // We look for it in the DOS and UNIX permissions
       
  2648         // but some unknown platform could set it as a compatibility flag.
       
  2649         this.dir = this.externalFileAttributes & 0x0010 ? true : false;
       
  2650 
       
  2651         if(madeBy === MADE_BY_DOS) {
       
  2652             // first 6 bits (0 to 5)
       
  2653             this.dosPermissions = this.externalFileAttributes & 0x3F;
       
  2654         }
       
  2655 
       
  2656         if(madeBy === MADE_BY_UNIX) {
       
  2657             this.unixPermissions = (this.externalFileAttributes >> 16) & 0xFFFF;
       
  2658             // the octal permissions are in (this.unixPermissions & 0x01FF).toString(8);
       
  2659         }
       
  2660 
       
  2661         // fail safe : if the name ends with a / it probably means a folder
       
  2662         if (!this.dir && this.fileName.slice(-1) === '/') {
       
  2663             this.dir = true;
       
  2664         }
       
  2665     },
       
  2666 
       
  2667     /**
       
  2668      * Parse the ZIP64 extra field and merge the info in the current ZipEntry.
       
  2669      * @param {DataReader} reader the reader to use.
       
  2670      */
       
  2671     parseZIP64ExtraField: function(reader) {
       
  2672 
       
  2673         if (!this.extraFields[0x0001]) {
       
  2674             return;
       
  2675         }
       
  2676 
       
  2677         // should be something, preparing the extra reader
       
  2678         var extraReader = new StringReader(this.extraFields[0x0001].value);
       
  2679 
       
  2680         // I really hope that these 64bits integer can fit in 32 bits integer, because js
       
  2681         // won't let us have more.
       
  2682         if (this.uncompressedSize === utils.MAX_VALUE_32BITS) {
       
  2683             this.uncompressedSize = extraReader.readInt(8);
       
  2684         }
       
  2685         if (this.compressedSize === utils.MAX_VALUE_32BITS) {
       
  2686             this.compressedSize = extraReader.readInt(8);
       
  2687         }
       
  2688         if (this.localHeaderOffset === utils.MAX_VALUE_32BITS) {
       
  2689             this.localHeaderOffset = extraReader.readInt(8);
       
  2690         }
       
  2691         if (this.diskNumberStart === utils.MAX_VALUE_32BITS) {
       
  2692             this.diskNumberStart = extraReader.readInt(4);
       
  2693         }
       
  2694     },
       
  2695     /**
       
  2696      * Read the central part of a zip file and add the info in this object.
       
  2697      * @param {DataReader} reader the reader to use.
       
  2698      */
       
  2699     readExtraFields: function(reader) {
       
  2700         var start = reader.index,
       
  2701             extraFieldId,
       
  2702             extraFieldLength,
       
  2703             extraFieldValue;
       
  2704 
       
  2705         this.extraFields = this.extraFields || {};
       
  2706 
       
  2707         while (reader.index < start + this.extraFieldsLength) {
       
  2708             extraFieldId = reader.readInt(2);
       
  2709             extraFieldLength = reader.readInt(2);
       
  2710             extraFieldValue = reader.readString(extraFieldLength);
       
  2711 
       
  2712             this.extraFields[extraFieldId] = {
       
  2713                 id: extraFieldId,
       
  2714                 length: extraFieldLength,
       
  2715                 value: extraFieldValue
       
  2716             };
       
  2717         }
       
  2718     },
       
  2719     /**
       
  2720      * Apply an UTF8 transformation if needed.
       
  2721      */
       
  2722     handleUTF8: function() {
       
  2723         if (this.useUTF8()) {
       
  2724             this.fileName = jszipProto.utf8decode(this.fileName);
       
  2725             this.fileComment = jszipProto.utf8decode(this.fileComment);
       
  2726         } else {
       
  2727             var upath = this.findExtraFieldUnicodePath();
       
  2728             if (upath !== null) {
       
  2729                 this.fileName = upath;
       
  2730             }
       
  2731             var ucomment = this.findExtraFieldUnicodeComment();
       
  2732             if (ucomment !== null) {
       
  2733                 this.fileComment = ucomment;
       
  2734             }
       
  2735         }
       
  2736     },
       
  2737 
       
  2738     /**
       
  2739      * Find the unicode path declared in the extra field, if any.
       
  2740      * @return {String} the unicode path, null otherwise.
       
  2741      */
       
  2742     findExtraFieldUnicodePath: function() {
       
  2743         var upathField = this.extraFields[0x7075];
       
  2744         if (upathField) {
       
  2745             var extraReader = new StringReader(upathField.value);
       
  2746 
       
  2747             // wrong version
       
  2748             if (extraReader.readInt(1) !== 1) {
       
  2749                 return null;
       
  2750             }
       
  2751 
       
  2752             // the crc of the filename changed, this field is out of date.
       
  2753             if (jszipProto.crc32(this.fileName) !== extraReader.readInt(4)) {
       
  2754                 return null;
       
  2755             }
       
  2756 
       
  2757             return jszipProto.utf8decode(extraReader.readString(upathField.length - 5));
       
  2758         }
       
  2759         return null;
       
  2760     },
       
  2761 
       
  2762     /**
       
  2763      * Find the unicode comment declared in the extra field, if any.
       
  2764      * @return {String} the unicode comment, null otherwise.
       
  2765      */
       
  2766     findExtraFieldUnicodeComment: function() {
       
  2767         var ucommentField = this.extraFields[0x6375];
       
  2768         if (ucommentField) {
       
  2769             var extraReader = new StringReader(ucommentField.value);
       
  2770 
       
  2771             // wrong version
       
  2772             if (extraReader.readInt(1) !== 1) {
       
  2773                 return null;
       
  2774             }
       
  2775 
       
  2776             // the crc of the comment changed, this field is out of date.
       
  2777             if (jszipProto.crc32(this.fileComment) !== extraReader.readInt(4)) {
       
  2778                 return null;
       
  2779             }
       
  2780 
       
  2781             return jszipProto.utf8decode(extraReader.readString(ucommentField.length - 5));
       
  2782         }
       
  2783         return null;
       
  2784     }
       
  2785 };
       
  2786 module.exports = ZipEntry;
       
  2787 
       
  2788 },{"./compressedObject":2,"./object":13,"./stringReader":15,"./utils":21}],24:[function(_dereq_,module,exports){
       
  2789 // Top level file is just a mixin of submodules & constants
       
  2790 'use strict';
       
  2791 
       
  2792 var assign    = _dereq_('./lib/utils/common').assign;
       
  2793 
       
  2794 var deflate   = _dereq_('./lib/deflate');
       
  2795 var inflate   = _dereq_('./lib/inflate');
       
  2796 var constants = _dereq_('./lib/zlib/constants');
       
  2797 
       
  2798 var pako = {};
       
  2799 
       
  2800 assign(pako, deflate, inflate, constants);
       
  2801 
       
  2802 module.exports = pako;
       
  2803 },{"./lib/deflate":25,"./lib/inflate":26,"./lib/utils/common":27,"./lib/zlib/constants":30}],25:[function(_dereq_,module,exports){
       
  2804 'use strict';
       
  2805 
       
  2806 
       
  2807 var zlib_deflate = _dereq_('./zlib/deflate.js');
       
  2808 var utils = _dereq_('./utils/common');
       
  2809 var strings = _dereq_('./utils/strings');
       
  2810 var msg = _dereq_('./zlib/messages');
       
  2811 var zstream = _dereq_('./zlib/zstream');
       
  2812 
       
  2813 
       
  2814 /* Public constants ==========================================================*/
       
  2815 /* ===========================================================================*/
       
  2816 
       
  2817 var Z_NO_FLUSH      = 0;
       
  2818 var Z_FINISH        = 4;
       
  2819 
       
  2820 var Z_OK            = 0;
       
  2821 var Z_STREAM_END    = 1;
       
  2822 
       
  2823 var Z_DEFAULT_COMPRESSION = -1;
       
  2824 
       
  2825 var Z_DEFAULT_STRATEGY    = 0;
       
  2826 
       
  2827 var Z_DEFLATED  = 8;
       
  2828 
       
  2829 /* ===========================================================================*/
       
  2830 
       
  2831 
       
  2832 /**
       
  2833  * class Deflate
       
  2834  *
       
  2835  * Generic JS-style wrapper for zlib calls. If you don't need
       
  2836  * streaming behaviour - use more simple functions: [[deflate]],
       
  2837  * [[deflateRaw]] and [[gzip]].
       
  2838  **/
       
  2839 
       
  2840 /* internal
       
  2841  * Deflate.chunks -> Array
       
  2842  *
       
  2843  * Chunks of output data, if [[Deflate#onData]] not overriden.
       
  2844  **/
       
  2845 
       
  2846 /**
       
  2847  * Deflate.result -> Uint8Array|Array
       
  2848  *
       
  2849  * Compressed result, generated by default [[Deflate#onData]]
       
  2850  * and [[Deflate#onEnd]] handlers. Filled after you push last chunk
       
  2851  * (call [[Deflate#push]] with `Z_FINISH` / `true` param).
       
  2852  **/
       
  2853 
       
  2854 /**
       
  2855  * Deflate.err -> Number
       
  2856  *
       
  2857  * Error code after deflate finished. 0 (Z_OK) on success.
       
  2858  * You will not need it in real life, because deflate errors
       
  2859  * are possible only on wrong options or bad `onData` / `onEnd`
       
  2860  * custom handlers.
       
  2861  **/
       
  2862 
       
  2863 /**
       
  2864  * Deflate.msg -> String
       
  2865  *
       
  2866  * Error message, if [[Deflate.err]] != 0
       
  2867  **/
       
  2868 
       
  2869 
       
  2870 /**
       
  2871  * new Deflate(options)
       
  2872  * - options (Object): zlib deflate options.
       
  2873  *
       
  2874  * Creates new deflator instance with specified params. Throws exception
       
  2875  * on bad params. Supported options:
       
  2876  *
       
  2877  * - `level`
       
  2878  * - `windowBits`
       
  2879  * - `memLevel`
       
  2880  * - `strategy`
       
  2881  *
       
  2882  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
       
  2883  * for more information on these.
       
  2884  *
       
  2885  * Additional options, for internal needs:
       
  2886  *
       
  2887  * - `chunkSize` - size of generated data chunks (16K by default)
       
  2888  * - `raw` (Boolean) - do raw deflate
       
  2889  * - `gzip` (Boolean) - create gzip wrapper
       
  2890  * - `to` (String) - if equal to 'string', then result will be "binary string"
       
  2891  *    (each char code [0..255])
       
  2892  * - `header` (Object) - custom header for gzip
       
  2893  *   - `text` (Boolean) - true if compressed data believed to be text
       
  2894  *   - `time` (Number) - modification time, unix timestamp
       
  2895  *   - `os` (Number) - operation system code
       
  2896  *   - `extra` (Array) - array of bytes with extra data (max 65536)
       
  2897  *   - `name` (String) - file name (binary string)
       
  2898  *   - `comment` (String) - comment (binary string)
       
  2899  *   - `hcrc` (Boolean) - true if header crc should be added
       
  2900  *
       
  2901  * ##### Example:
       
  2902  *
       
  2903  * ```javascript
       
  2904  * var pako = require('pako')
       
  2905  *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
       
  2906  *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
       
  2907  *
       
  2908  * var deflate = new pako.Deflate({ level: 3});
       
  2909  *
       
  2910  * deflate.push(chunk1, false);
       
  2911  * deflate.push(chunk2, true);  // true -> last chunk
       
  2912  *
       
  2913  * if (deflate.err) { throw new Error(deflate.err); }
       
  2914  *
       
  2915  * console.log(deflate.result);
       
  2916  * ```
       
  2917  **/
       
  2918 var Deflate = function(options) {
       
  2919 
       
  2920   this.options = utils.assign({
       
  2921     level: Z_DEFAULT_COMPRESSION,
       
  2922     method: Z_DEFLATED,
       
  2923     chunkSize: 16384,
       
  2924     windowBits: 15,
       
  2925     memLevel: 8,
       
  2926     strategy: Z_DEFAULT_STRATEGY,
       
  2927     to: ''
       
  2928   }, options || {});
       
  2929 
       
  2930   var opt = this.options;
       
  2931 
       
  2932   if (opt.raw && (opt.windowBits > 0)) {
       
  2933     opt.windowBits = -opt.windowBits;
       
  2934   }
       
  2935 
       
  2936   else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) {
       
  2937     opt.windowBits += 16;
       
  2938   }
       
  2939 
       
  2940   this.err    = 0;      // error code, if happens (0 = Z_OK)
       
  2941   this.msg    = '';     // error message
       
  2942   this.ended  = false;  // used to avoid multiple onEnd() calls
       
  2943   this.chunks = [];     // chunks of compressed data
       
  2944 
       
  2945   this.strm = new zstream();
       
  2946   this.strm.avail_out = 0;
       
  2947 
       
  2948   var status = zlib_deflate.deflateInit2(
       
  2949     this.strm,
       
  2950     opt.level,
       
  2951     opt.method,
       
  2952     opt.windowBits,
       
  2953     opt.memLevel,
       
  2954     opt.strategy
       
  2955   );
       
  2956 
       
  2957   if (status !== Z_OK) {
       
  2958     throw new Error(msg[status]);
       
  2959   }
       
  2960 
       
  2961   if (opt.header) {
       
  2962     zlib_deflate.deflateSetHeader(this.strm, opt.header);
       
  2963   }
       
  2964 };
       
  2965 
       
  2966 /**
       
  2967  * Deflate#push(data[, mode]) -> Boolean
       
  2968  * - data (Uint8Array|Array|String): input data. Strings will be converted to
       
  2969  *   utf8 byte sequence.
       
  2970  * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
       
  2971  *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
       
  2972  *
       
  2973  * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with
       
  2974  * new compressed chunks. Returns `true` on success. The last data block must have
       
  2975  * mode Z_FINISH (or `true`). That flush internal pending buffers and call
       
  2976  * [[Deflate#onEnd]].
       
  2977  *
       
  2978  * On fail call [[Deflate#onEnd]] with error code and return false.
       
  2979  *
       
  2980  * We strongly recommend to use `Uint8Array` on input for best speed (output
       
  2981  * array format is detected automatically). Also, don't skip last param and always
       
  2982  * use the same type in your code (boolean or number). That will improve JS speed.
       
  2983  *
       
  2984  * For regular `Array`-s make sure all elements are [0..255].
       
  2985  *
       
  2986  * ##### Example
       
  2987  *
       
  2988  * ```javascript
       
  2989  * push(chunk, false); // push one of data chunks
       
  2990  * ...
       
  2991  * push(chunk, true);  // push last chunk
       
  2992  * ```
       
  2993  **/
       
  2994 Deflate.prototype.push = function(data, mode) {
       
  2995   var strm = this.strm;
       
  2996   var chunkSize = this.options.chunkSize;
       
  2997   var status, _mode;
       
  2998 
       
  2999   if (this.ended) { return false; }
       
  3000 
       
  3001   _mode = (mode === ~~mode) ? mode : ((mode === true) ? Z_FINISH : Z_NO_FLUSH);
       
  3002 
       
  3003   // Convert data if needed
       
  3004   if (typeof data === 'string') {
       
  3005     // If we need to compress text, change encoding to utf8.
       
  3006     strm.input = strings.string2buf(data);
       
  3007   } else {
       
  3008     strm.input = data;
       
  3009   }
       
  3010 
       
  3011   strm.next_in = 0;
       
  3012   strm.avail_in = strm.input.length;
       
  3013 
       
  3014   do {
       
  3015     if (strm.avail_out === 0) {
       
  3016       strm.output = new utils.Buf8(chunkSize);
       
  3017       strm.next_out = 0;
       
  3018       strm.avail_out = chunkSize;
       
  3019     }
       
  3020     status = zlib_deflate.deflate(strm, _mode);    /* no bad return value */
       
  3021 
       
  3022     if (status !== Z_STREAM_END && status !== Z_OK) {
       
  3023       this.onEnd(status);
       
  3024       this.ended = true;
       
  3025       return false;
       
  3026     }
       
  3027     if (strm.avail_out === 0 || (strm.avail_in === 0 && _mode === Z_FINISH)) {
       
  3028       if (this.options.to === 'string') {
       
  3029         this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out)));
       
  3030       } else {
       
  3031         this.onData(utils.shrinkBuf(strm.output, strm.next_out));
       
  3032       }
       
  3033     }
       
  3034   } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END);
       
  3035 
       
  3036   // Finalize on the last chunk.
       
  3037   if (_mode === Z_FINISH) {
       
  3038     status = zlib_deflate.deflateEnd(this.strm);
       
  3039     this.onEnd(status);
       
  3040     this.ended = true;
       
  3041     return status === Z_OK;
       
  3042   }
       
  3043 
       
  3044   return true;
       
  3045 };
       
  3046 
       
  3047 
       
  3048 /**
       
  3049  * Deflate#onData(chunk) -> Void
       
  3050  * - chunk (Uint8Array|Array|String): ouput data. Type of array depends
       
  3051  *   on js engine support. When string output requested, each chunk
       
  3052  *   will be string.
       
  3053  *
       
  3054  * By default, stores data blocks in `chunks[]` property and glue
       
  3055  * those in `onEnd`. Override this handler, if you need another behaviour.
       
  3056  **/
       
  3057 Deflate.prototype.onData = function(chunk) {
       
  3058   this.chunks.push(chunk);
       
  3059 };
       
  3060 
       
  3061 
       
  3062 /**
       
  3063  * Deflate#onEnd(status) -> Void
       
  3064  * - status (Number): deflate status. 0 (Z_OK) on success,
       
  3065  *   other if not.
       
  3066  *
       
  3067  * Called once after you tell deflate that input stream complete
       
  3068  * or error happenned. By default - join collected chunks,
       
  3069  * free memory and fill `results` / `err` properties.
       
  3070  **/
       
  3071 Deflate.prototype.onEnd = function(status) {
       
  3072   // On success - join
       
  3073   if (status === Z_OK) {
       
  3074     if (this.options.to === 'string') {
       
  3075       this.result = this.chunks.join('');
       
  3076     } else {
       
  3077       this.result = utils.flattenChunks(this.chunks);
       
  3078     }
       
  3079   }
       
  3080   this.chunks = [];
       
  3081   this.err = status;
       
  3082   this.msg = this.strm.msg;
       
  3083 };
       
  3084 
       
  3085 
       
  3086 /**
       
  3087  * deflate(data[, options]) -> Uint8Array|Array|String
       
  3088  * - data (Uint8Array|Array|String): input data to compress.
       
  3089  * - options (Object): zlib deflate options.
       
  3090  *
       
  3091  * Compress `data` with deflate alrorythm and `options`.
       
  3092  *
       
  3093  * Supported options are:
       
  3094  *
       
  3095  * - level
       
  3096  * - windowBits
       
  3097  * - memLevel
       
  3098  * - strategy
       
  3099  *
       
  3100  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
       
  3101  * for more information on these.
       
  3102  *
       
  3103  * Sugar (options):
       
  3104  *
       
  3105  * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
       
  3106  *   negative windowBits implicitly.
       
  3107  * - `to` (String) - if equal to 'string', then result will be "binary string"
       
  3108  *    (each char code [0..255])
       
  3109  *
       
  3110  * ##### Example:
       
  3111  *
       
  3112  * ```javascript
       
  3113  * var pako = require('pako')
       
  3114  *   , data = Uint8Array([1,2,3,4,5,6,7,8,9]);
       
  3115  *
       
  3116  * console.log(pako.deflate(data));
       
  3117  * ```
       
  3118  **/
       
  3119 function deflate(input, options) {
       
  3120   var deflator = new Deflate(options);
       
  3121 
       
  3122   deflator.push(input, true);
       
  3123 
       
  3124   // That will never happens, if you don't cheat with options :)
       
  3125   if (deflator.err) { throw deflator.msg; }
       
  3126 
       
  3127   return deflator.result;
       
  3128 }
       
  3129 
       
  3130 
       
  3131 /**
       
  3132  * deflateRaw(data[, options]) -> Uint8Array|Array|String
       
  3133  * - data (Uint8Array|Array|String): input data to compress.
       
  3134  * - options (Object): zlib deflate options.
       
  3135  *
       
  3136  * The same as [[deflate]], but creates raw data, without wrapper
       
  3137  * (header and adler32 crc).
       
  3138  **/
       
  3139 function deflateRaw(input, options) {
       
  3140   options = options || {};
       
  3141   options.raw = true;
       
  3142   return deflate(input, options);
       
  3143 }
       
  3144 
       
  3145 
       
  3146 /**
       
  3147  * gzip(data[, options]) -> Uint8Array|Array|String
       
  3148  * - data (Uint8Array|Array|String): input data to compress.
       
  3149  * - options (Object): zlib deflate options.
       
  3150  *
       
  3151  * The same as [[deflate]], but create gzip wrapper instead of
       
  3152  * deflate one.
       
  3153  **/
       
  3154 function gzip(input, options) {
       
  3155   options = options || {};
       
  3156   options.gzip = true;
       
  3157   return deflate(input, options);
       
  3158 }
       
  3159 
       
  3160 
       
  3161 exports.Deflate = Deflate;
       
  3162 exports.deflate = deflate;
       
  3163 exports.deflateRaw = deflateRaw;
       
  3164 exports.gzip = gzip;
       
  3165 },{"./utils/common":27,"./utils/strings":28,"./zlib/deflate.js":32,"./zlib/messages":37,"./zlib/zstream":39}],26:[function(_dereq_,module,exports){
       
  3166 'use strict';
       
  3167 
       
  3168 
       
  3169 var zlib_inflate = _dereq_('./zlib/inflate.js');
       
  3170 var utils = _dereq_('./utils/common');
       
  3171 var strings = _dereq_('./utils/strings');
       
  3172 var c = _dereq_('./zlib/constants');
       
  3173 var msg = _dereq_('./zlib/messages');
       
  3174 var zstream = _dereq_('./zlib/zstream');
       
  3175 var gzheader = _dereq_('./zlib/gzheader');
       
  3176 
       
  3177 
       
  3178 /**
       
  3179  * class Inflate
       
  3180  *
       
  3181  * Generic JS-style wrapper for zlib calls. If you don't need
       
  3182  * streaming behaviour - use more simple functions: [[inflate]]
       
  3183  * and [[inflateRaw]].
       
  3184  **/
       
  3185 
       
  3186 /* internal
       
  3187  * inflate.chunks -> Array
       
  3188  *
       
  3189  * Chunks of output data, if [[Inflate#onData]] not overriden.
       
  3190  **/
       
  3191 
       
  3192 /**
       
  3193  * Inflate.result -> Uint8Array|Array|String
       
  3194  *
       
  3195  * Uncompressed result, generated by default [[Inflate#onData]]
       
  3196  * and [[Inflate#onEnd]] handlers. Filled after you push last chunk
       
  3197  * (call [[Inflate#push]] with `Z_FINISH` / `true` param).
       
  3198  **/
       
  3199 
       
  3200 /**
       
  3201  * Inflate.err -> Number
       
  3202  *
       
  3203  * Error code after inflate finished. 0 (Z_OK) on success.
       
  3204  * Should be checked if broken data possible.
       
  3205  **/
       
  3206 
       
  3207 /**
       
  3208  * Inflate.msg -> String
       
  3209  *
       
  3210  * Error message, if [[Inflate.err]] != 0
       
  3211  **/
       
  3212 
       
  3213 
       
  3214 /**
       
  3215  * new Inflate(options)
       
  3216  * - options (Object): zlib inflate options.
       
  3217  *
       
  3218  * Creates new inflator instance with specified params. Throws exception
       
  3219  * on bad params. Supported options:
       
  3220  *
       
  3221  * - `windowBits`
       
  3222  *
       
  3223  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
       
  3224  * for more information on these.
       
  3225  *
       
  3226  * Additional options, for internal needs:
       
  3227  *
       
  3228  * - `chunkSize` - size of generated data chunks (16K by default)
       
  3229  * - `raw` (Boolean) - do raw inflate
       
  3230  * - `to` (String) - if equal to 'string', then result will be converted
       
  3231  *   from utf8 to utf16 (javascript) string. When string output requested,
       
  3232  *   chunk length can differ from `chunkSize`, depending on content.
       
  3233  *
       
  3234  * By default, when no options set, autodetect deflate/gzip data format via
       
  3235  * wrapper header.
       
  3236  *
       
  3237  * ##### Example:
       
  3238  *
       
  3239  * ```javascript
       
  3240  * var pako = require('pako')
       
  3241  *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
       
  3242  *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
       
  3243  *
       
  3244  * var inflate = new pako.Inflate({ level: 3});
       
  3245  *
       
  3246  * inflate.push(chunk1, false);
       
  3247  * inflate.push(chunk2, true);  // true -> last chunk
       
  3248  *
       
  3249  * if (inflate.err) { throw new Error(inflate.err); }
       
  3250  *
       
  3251  * console.log(inflate.result);
       
  3252  * ```
       
  3253  **/
       
  3254 var Inflate = function(options) {
       
  3255 
       
  3256   this.options = utils.assign({
       
  3257     chunkSize: 16384,
       
  3258     windowBits: 0,
       
  3259     to: ''
       
  3260   }, options || {});
       
  3261 
       
  3262   var opt = this.options;
       
  3263 
       
  3264   // Force window size for `raw` data, if not set directly,
       
  3265   // because we have no header for autodetect.
       
  3266   if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
       
  3267     opt.windowBits = -opt.windowBits;
       
  3268     if (opt.windowBits === 0) { opt.windowBits = -15; }
       
  3269   }
       
  3270 
       
  3271   // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
       
  3272   if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
       
  3273       !(options && options.windowBits)) {
       
  3274     opt.windowBits += 32;
       
  3275   }
       
  3276 
       
  3277   // Gzip header has no info about windows size, we can do autodetect only
       
  3278   // for deflate. So, if window size not set, force it to max when gzip possible
       
  3279   if ((opt.windowBits > 15) && (opt.windowBits < 48)) {
       
  3280     // bit 3 (16) -> gzipped data
       
  3281     // bit 4 (32) -> autodetect gzip/deflate
       
  3282     if ((opt.windowBits & 15) === 0) {
       
  3283       opt.windowBits |= 15;
       
  3284     }
       
  3285   }
       
  3286 
       
  3287   this.err    = 0;      // error code, if happens (0 = Z_OK)
       
  3288   this.msg    = '';     // error message
       
  3289   this.ended  = false;  // used to avoid multiple onEnd() calls
       
  3290   this.chunks = [];     // chunks of compressed data
       
  3291 
       
  3292   this.strm   = new zstream();
       
  3293   this.strm.avail_out = 0;
       
  3294 
       
  3295   var status  = zlib_inflate.inflateInit2(
       
  3296     this.strm,
       
  3297     opt.windowBits
       
  3298   );
       
  3299 
       
  3300   if (status !== c.Z_OK) {
       
  3301     throw new Error(msg[status]);
       
  3302   }
       
  3303 
       
  3304   this.header = new gzheader();
       
  3305 
       
  3306   zlib_inflate.inflateGetHeader(this.strm, this.header);
       
  3307 };
       
  3308 
       
  3309 /**
       
  3310  * Inflate#push(data[, mode]) -> Boolean
       
  3311  * - data (Uint8Array|Array|String): input data
       
  3312  * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
       
  3313  *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
       
  3314  *
       
  3315  * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
       
  3316  * new output chunks. Returns `true` on success. The last data block must have
       
  3317  * mode Z_FINISH (or `true`). That flush internal pending buffers and call
       
  3318  * [[Inflate#onEnd]].
       
  3319  *
       
  3320  * On fail call [[Inflate#onEnd]] with error code and return false.
       
  3321  *
       
  3322  * We strongly recommend to use `Uint8Array` on input for best speed (output
       
  3323  * format is detected automatically). Also, don't skip last param and always
       
  3324  * use the same type in your code (boolean or number). That will improve JS speed.
       
  3325  *
       
  3326  * For regular `Array`-s make sure all elements are [0..255].
       
  3327  *
       
  3328  * ##### Example
       
  3329  *
       
  3330  * ```javascript
       
  3331  * push(chunk, false); // push one of data chunks
       
  3332  * ...
       
  3333  * push(chunk, true);  // push last chunk
       
  3334  * ```
       
  3335  **/
       
  3336 Inflate.prototype.push = function(data, mode) {
       
  3337   var strm = this.strm;
       
  3338   var chunkSize = this.options.chunkSize;
       
  3339   var status, _mode;
       
  3340   var next_out_utf8, tail, utf8str;
       
  3341 
       
  3342   if (this.ended) { return false; }
       
  3343   _mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);
       
  3344 
       
  3345   // Convert data if needed
       
  3346   if (typeof data === 'string') {
       
  3347     // Only binary strings can be decompressed on practice
       
  3348     strm.input = strings.binstring2buf(data);
       
  3349   } else {
       
  3350     strm.input = data;
       
  3351   }
       
  3352 
       
  3353   strm.next_in = 0;
       
  3354   strm.avail_in = strm.input.length;
       
  3355 
       
  3356   do {
       
  3357     if (strm.avail_out === 0) {
       
  3358       strm.output = new utils.Buf8(chunkSize);
       
  3359       strm.next_out = 0;
       
  3360       strm.avail_out = chunkSize;
       
  3361     }
       
  3362 
       
  3363     status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH);    /* no bad return value */
       
  3364 
       
  3365     if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
       
  3366       this.onEnd(status);
       
  3367       this.ended = true;
       
  3368       return false;
       
  3369     }
       
  3370 
       
  3371     if (strm.next_out) {
       
  3372       if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && _mode === c.Z_FINISH)) {
       
  3373 
       
  3374         if (this.options.to === 'string') {
       
  3375 
       
  3376           next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
       
  3377 
       
  3378           tail = strm.next_out - next_out_utf8;
       
  3379           utf8str = strings.buf2string(strm.output, next_out_utf8);
       
  3380 
       
  3381           // move tail
       
  3382           strm.next_out = tail;
       
  3383           strm.avail_out = chunkSize - tail;
       
  3384           if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }
       
  3385 
       
  3386           this.onData(utf8str);
       
  3387 
       
  3388         } else {
       
  3389           this.onData(utils.shrinkBuf(strm.output, strm.next_out));
       
  3390         }
       
  3391       }
       
  3392     }
       
  3393   } while ((strm.avail_in > 0) && status !== c.Z_STREAM_END);
       
  3394 
       
  3395   if (status === c.Z_STREAM_END) {
       
  3396     _mode = c.Z_FINISH;
       
  3397   }
       
  3398   // Finalize on the last chunk.
       
  3399   if (_mode === c.Z_FINISH) {
       
  3400     status = zlib_inflate.inflateEnd(this.strm);
       
  3401     this.onEnd(status);
       
  3402     this.ended = true;
       
  3403     return status === c.Z_OK;
       
  3404   }
       
  3405 
       
  3406   return true;
       
  3407 };
       
  3408 
       
  3409 
       
  3410 /**
       
  3411  * Inflate#onData(chunk) -> Void
       
  3412  * - chunk (Uint8Array|Array|String): ouput data. Type of array depends
       
  3413  *   on js engine support. When string output requested, each chunk
       
  3414  *   will be string.
       
  3415  *
       
  3416  * By default, stores data blocks in `chunks[]` property and glue
       
  3417  * those in `onEnd`. Override this handler, if you need another behaviour.
       
  3418  **/
       
  3419 Inflate.prototype.onData = function(chunk) {
       
  3420   this.chunks.push(chunk);
       
  3421 };
       
  3422 
       
  3423 
       
  3424 /**
       
  3425  * Inflate#onEnd(status) -> Void
       
  3426  * - status (Number): inflate status. 0 (Z_OK) on success,
       
  3427  *   other if not.
       
  3428  *
       
  3429  * Called once after you tell inflate that input stream complete
       
  3430  * or error happenned. By default - join collected chunks,
       
  3431  * free memory and fill `results` / `err` properties.
       
  3432  **/
       
  3433 Inflate.prototype.onEnd = function(status) {
       
  3434   // On success - join
       
  3435   if (status === c.Z_OK) {
       
  3436     if (this.options.to === 'string') {
       
  3437       // Glue & convert here, until we teach pako to send
       
  3438       // utf8 alligned strings to onData
       
  3439       this.result = this.chunks.join('');
       
  3440     } else {
       
  3441       this.result = utils.flattenChunks(this.chunks);
       
  3442     }
       
  3443   }
       
  3444   this.chunks = [];
       
  3445   this.err = status;
       
  3446   this.msg = this.strm.msg;
       
  3447 };
       
  3448 
       
  3449 
       
  3450 /**
       
  3451  * inflate(data[, options]) -> Uint8Array|Array|String
       
  3452  * - data (Uint8Array|Array|String): input data to decompress.
       
  3453  * - options (Object): zlib inflate options.
       
  3454  *
       
  3455  * Decompress `data` with inflate/ungzip and `options`. Autodetect
       
  3456  * format via wrapper header by default. That's why we don't provide
       
  3457  * separate `ungzip` method.
       
  3458  *
       
  3459  * Supported options are:
       
  3460  *
       
  3461  * - windowBits
       
  3462  *
       
  3463  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
       
  3464  * for more information.
       
  3465  *
       
  3466  * Sugar (options):
       
  3467  *
       
  3468  * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
       
  3469  *   negative windowBits implicitly.
       
  3470  * - `to` (String) - if equal to 'string', then result will be converted
       
  3471  *   from utf8 to utf16 (javascript) string. When string output requested,
       
  3472  *   chunk length can differ from `chunkSize`, depending on content.
       
  3473  *
       
  3474  *
       
  3475  * ##### Example:
       
  3476  *
       
  3477  * ```javascript
       
  3478  * var pako = require('pako')
       
  3479  *   , input = pako.deflate([1,2,3,4,5,6,7,8,9])
       
  3480  *   , output;
       
  3481  *
       
  3482  * try {
       
  3483  *   output = pako.inflate(input);
       
  3484  * } catch (err)
       
  3485  *   console.log(err);
       
  3486  * }
       
  3487  * ```
       
  3488  **/
       
  3489 function inflate(input, options) {
       
  3490   var inflator = new Inflate(options);
       
  3491 
       
  3492   inflator.push(input, true);
       
  3493 
       
  3494   // That will never happens, if you don't cheat with options :)
       
  3495   if (inflator.err) { throw inflator.msg; }
       
  3496 
       
  3497   return inflator.result;
       
  3498 }
       
  3499 
       
  3500 
       
  3501 /**
       
  3502  * inflateRaw(data[, options]) -> Uint8Array|Array|String
       
  3503  * - data (Uint8Array|Array|String): input data to decompress.
       
  3504  * - options (Object): zlib inflate options.
       
  3505  *
       
  3506  * The same as [[inflate]], but creates raw data, without wrapper
       
  3507  * (header and adler32 crc).
       
  3508  **/
       
  3509 function inflateRaw(input, options) {
       
  3510   options = options || {};
       
  3511   options.raw = true;
       
  3512   return inflate(input, options);
       
  3513 }
       
  3514 
       
  3515 
       
  3516 /**
       
  3517  * ungzip(data[, options]) -> Uint8Array|Array|String
       
  3518  * - data (Uint8Array|Array|String): input data to decompress.
       
  3519  * - options (Object): zlib inflate options.
       
  3520  *
       
  3521  * Just shortcut to [[inflate]], because it autodetects format
       
  3522  * by header.content. Done for convenience.
       
  3523  **/
       
  3524 
       
  3525 
       
  3526 exports.Inflate = Inflate;
       
  3527 exports.inflate = inflate;
       
  3528 exports.inflateRaw = inflateRaw;
       
  3529 exports.ungzip  = inflate;
       
  3530 
       
  3531 },{"./utils/common":27,"./utils/strings":28,"./zlib/constants":30,"./zlib/gzheader":33,"./zlib/inflate.js":35,"./zlib/messages":37,"./zlib/zstream":39}],27:[function(_dereq_,module,exports){
       
  3532 'use strict';
       
  3533 
       
  3534 
       
  3535 var TYPED_OK =  (typeof Uint8Array !== 'undefined') &&
       
  3536                 (typeof Uint16Array !== 'undefined') &&
       
  3537                 (typeof Int32Array !== 'undefined');
       
  3538 
       
  3539 
       
  3540 exports.assign = function (obj /*from1, from2, from3, ...*/) {
       
  3541   var sources = Array.prototype.slice.call(arguments, 1);
       
  3542   while (sources.length) {
       
  3543     var source = sources.shift();
       
  3544     if (!source) { continue; }
       
  3545 
       
  3546     if (typeof(source) !== 'object') {
       
  3547       throw new TypeError(source + 'must be non-object');
       
  3548     }
       
  3549 
       
  3550     for (var p in source) {
       
  3551       if (source.hasOwnProperty(p)) {
       
  3552         obj[p] = source[p];
       
  3553       }
       
  3554     }
       
  3555   }
       
  3556 
       
  3557   return obj;
       
  3558 };
       
  3559 
       
  3560 
       
  3561 // reduce buffer size, avoiding mem copy
       
  3562 exports.shrinkBuf = function (buf, size) {
       
  3563   if (buf.length === size) { return buf; }
       
  3564   if (buf.subarray) { return buf.subarray(0, size); }
       
  3565   buf.length = size;
       
  3566   return buf;
       
  3567 };
       
  3568 
       
  3569 
       
  3570 var fnTyped = {
       
  3571   arraySet: function (dest, src, src_offs, len, dest_offs) {
       
  3572     if (src.subarray && dest.subarray) {
       
  3573       dest.set(src.subarray(src_offs, src_offs+len), dest_offs);
       
  3574       return;
       
  3575     }
       
  3576     // Fallback to ordinary array
       
  3577     for(var i=0; i<len; i++) {
       
  3578       dest[dest_offs + i] = src[src_offs + i];
       
  3579     }
       
  3580   },
       
  3581   // Join array of chunks to single array.
       
  3582   flattenChunks: function(chunks) {
       
  3583     var i, l, len, pos, chunk, result;
       
  3584 
       
  3585     // calculate data length
       
  3586     len = 0;
       
  3587     for (i=0, l=chunks.length; i<l; i++) {
       
  3588       len += chunks[i].length;
       
  3589     }
       
  3590 
       
  3591     // join chunks
       
  3592     result = new Uint8Array(len);
       
  3593     pos = 0;
       
  3594     for (i=0, l=chunks.length; i<l; i++) {
       
  3595       chunk = chunks[i];
       
  3596       result.set(chunk, pos);
       
  3597       pos += chunk.length;
       
  3598     }
       
  3599 
       
  3600     return result;
       
  3601   }
       
  3602 };
       
  3603 
       
  3604 var fnUntyped = {
       
  3605   arraySet: function (dest, src, src_offs, len, dest_offs) {
       
  3606     for(var i=0; i<len; i++) {
       
  3607       dest[dest_offs + i] = src[src_offs + i];
       
  3608     }
       
  3609   },
       
  3610   // Join array of chunks to single array.
       
  3611   flattenChunks: function(chunks) {
       
  3612     return [].concat.apply([], chunks);
       
  3613   }
       
  3614 };
       
  3615 
       
  3616 
       
  3617 // Enable/Disable typed arrays use, for testing
       
  3618 //
       
  3619 exports.setTyped = function (on) {
       
  3620   if (on) {
       
  3621     exports.Buf8  = Uint8Array;
       
  3622     exports.Buf16 = Uint16Array;
       
  3623     exports.Buf32 = Int32Array;
       
  3624     exports.assign(exports, fnTyped);
       
  3625   } else {
       
  3626     exports.Buf8  = Array;
       
  3627     exports.Buf16 = Array;
       
  3628     exports.Buf32 = Array;
       
  3629     exports.assign(exports, fnUntyped);
       
  3630   }
       
  3631 };
       
  3632 
       
  3633 exports.setTyped(TYPED_OK);
       
  3634 },{}],28:[function(_dereq_,module,exports){
       
  3635 // String encode/decode helpers
       
  3636 'use strict';
       
  3637 
       
  3638 
       
  3639 var utils = _dereq_('./common');
       
  3640 
       
  3641 
       
  3642 // Quick check if we can use fast array to bin string conversion
       
  3643 //
       
  3644 // - apply(Array) can fail on Android 2.2
       
  3645 // - apply(Uint8Array) can fail on iOS 5.1 Safary
       
  3646 //
       
  3647 var STR_APPLY_OK = true;
       
  3648 var STR_APPLY_UIA_OK = true;
       
  3649 
       
  3650 try { String.fromCharCode.apply(null, [0]); } catch(__) { STR_APPLY_OK = false; }
       
  3651 try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch(__) { STR_APPLY_UIA_OK = false; }
       
  3652 
       
  3653 
       
  3654 // Table with utf8 lengths (calculated by first byte of sequence)
       
  3655 // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
       
  3656 // because max possible codepoint is 0x10ffff
       
  3657 var _utf8len = new utils.Buf8(256);
       
  3658 for (var i=0; i<256; i++) {
       
  3659   _utf8len[i] = (i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1);
       
  3660 }
       
  3661 _utf8len[254]=_utf8len[254]=1; // Invalid sequence start
       
  3662 
       
  3663 
       
  3664 // convert string to array (typed, when possible)
       
  3665 exports.string2buf = function (str) {
       
  3666   var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
       
  3667 
       
  3668   // count binary size
       
  3669   for (m_pos = 0; m_pos < str_len; m_pos++) {
       
  3670     c = str.charCodeAt(m_pos);
       
  3671     if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
       
  3672       c2 = str.charCodeAt(m_pos+1);
       
  3673       if ((c2 & 0xfc00) === 0xdc00) {
       
  3674         c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
       
  3675         m_pos++;
       
  3676       }
       
  3677     }
       
  3678     buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
       
  3679   }
       
  3680 
       
  3681   // allocate buffer
       
  3682   buf = new utils.Buf8(buf_len);
       
  3683 
       
  3684   // convert
       
  3685   for (i=0, m_pos = 0; i < buf_len; m_pos++) {
       
  3686     c = str.charCodeAt(m_pos);
       
  3687     if ((c & 0xfc00) === 0xd800 && (m_pos+1 < str_len)) {
       
  3688       c2 = str.charCodeAt(m_pos+1);
       
  3689       if ((c2 & 0xfc00) === 0xdc00) {
       
  3690         c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
       
  3691         m_pos++;
       
  3692       }
       
  3693     }
       
  3694     if (c < 0x80) {
       
  3695       /* one byte */
       
  3696       buf[i++] = c;
       
  3697     } else if (c < 0x800) {
       
  3698       /* two bytes */
       
  3699       buf[i++] = 0xC0 | (c >>> 6);
       
  3700       buf[i++] = 0x80 | (c & 0x3f);
       
  3701     } else if (c < 0x10000) {
       
  3702       /* three bytes */
       
  3703       buf[i++] = 0xE0 | (c >>> 12);
       
  3704       buf[i++] = 0x80 | (c >>> 6 & 0x3f);
       
  3705       buf[i++] = 0x80 | (c & 0x3f);
       
  3706     } else {
       
  3707       /* four bytes */
       
  3708       buf[i++] = 0xf0 | (c >>> 18);
       
  3709       buf[i++] = 0x80 | (c >>> 12 & 0x3f);
       
  3710       buf[i++] = 0x80 | (c >>> 6 & 0x3f);
       
  3711       buf[i++] = 0x80 | (c & 0x3f);
       
  3712     }
       
  3713   }
       
  3714 
       
  3715   return buf;
       
  3716 };
       
  3717 
       
  3718 // Helper (used in 2 places)
       
  3719 function buf2binstring(buf, len) {
       
  3720   // use fallback for big arrays to avoid stack overflow
       
  3721   if (len < 65537) {
       
  3722     if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {
       
  3723       return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
       
  3724     }
       
  3725   }
       
  3726 
       
  3727   var result = '';
       
  3728   for(var i=0; i < len; i++) {
       
  3729     result += String.fromCharCode(buf[i]);
       
  3730   }
       
  3731   return result;
       
  3732 }
       
  3733 
       
  3734 
       
  3735 // Convert byte array to binary string
       
  3736 exports.buf2binstring = function(buf) {
       
  3737   return buf2binstring(buf, buf.length);
       
  3738 };
       
  3739 
       
  3740 
       
  3741 // Convert binary string (typed, when possible)
       
  3742 exports.binstring2buf = function(str) {
       
  3743   var buf = new utils.Buf8(str.length);
       
  3744   for(var i=0, len=buf.length; i < len; i++) {
       
  3745     buf[i] = str.charCodeAt(i);
       
  3746   }
       
  3747   return buf;
       
  3748 };
       
  3749 
       
  3750 
       
  3751 // convert array to string
       
  3752 exports.buf2string = function (buf, max) {
       
  3753   var i, out, c, c_len;
       
  3754   var len = max || buf.length;
       
  3755 
       
  3756   // Reserve max possible length (2 words per char)
       
  3757   // NB: by unknown reasons, Array is significantly faster for
       
  3758   //     String.fromCharCode.apply than Uint16Array.
       
  3759   var utf16buf = new Array(len*2);
       
  3760 
       
  3761   for (out=0, i=0; i<len;) {
       
  3762     c = buf[i++];
       
  3763     // quick process ascii
       
  3764     if (c < 0x80) { utf16buf[out++] = c; continue; }
       
  3765 
       
  3766     c_len = _utf8len[c];
       
  3767     // skip 5 & 6 byte codes
       
  3768     if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len-1; continue; }
       
  3769 
       
  3770     // apply mask on first byte
       
  3771     c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
       
  3772     // join the rest
       
  3773     while (c_len > 1 && i < len) {
       
  3774       c = (c << 6) | (buf[i++] & 0x3f);
       
  3775       c_len--;
       
  3776     }
       
  3777 
       
  3778     // terminated by end of string?
       
  3779     if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
       
  3780 
       
  3781     if (c < 0x10000) {
       
  3782       utf16buf[out++] = c;
       
  3783     } else {
       
  3784       c -= 0x10000;
       
  3785       utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
       
  3786       utf16buf[out++] = 0xdc00 | (c & 0x3ff);
       
  3787     }
       
  3788   }
       
  3789 
       
  3790   return buf2binstring(utf16buf, out);
       
  3791 };
       
  3792 
       
  3793 
       
  3794 // Calculate max possible position in utf8 buffer,
       
  3795 // that will not break sequence. If that's not possible
       
  3796 // - (very small limits) return max size as is.
       
  3797 //
       
  3798 // buf[] - utf8 bytes array
       
  3799 // max   - length limit (mandatory);
       
  3800 exports.utf8border = function(buf, max) {
       
  3801   var pos;
       
  3802 
       
  3803   max = max || buf.length;
       
  3804   if (max > buf.length) { max = buf.length; }
       
  3805 
       
  3806   // go back from last position, until start of sequence found
       
  3807   pos = max-1;
       
  3808   while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
       
  3809 
       
  3810   // Fuckup - very small and broken sequence,
       
  3811   // return max, because we should return something anyway.
       
  3812   if (pos < 0) { return max; }
       
  3813 
       
  3814   // If we came to start of buffer - that means vuffer is too small,
       
  3815   // return max too.
       
  3816   if (pos === 0) { return max; }
       
  3817 
       
  3818   return (pos + _utf8len[buf[pos]] > max) ? pos : max;
       
  3819 };
       
  3820 
       
  3821 },{"./common":27}],29:[function(_dereq_,module,exports){
       
  3822 'use strict';
       
  3823 
       
  3824 // Note: adler32 takes 12% for level 0 and 2% for level 6.
       
  3825 // It doesn't worth to make additional optimizationa as in original.
       
  3826 // Small size is preferable.
       
  3827 
       
  3828 function adler32(adler, buf, len, pos) {
       
  3829   var s1 = (adler & 0xffff) |0
       
  3830     , s2 = ((adler >>> 16) & 0xffff) |0
       
  3831     , n = 0;
       
  3832 
       
  3833   while (len !== 0) {
       
  3834     // Set limit ~ twice less than 5552, to keep
       
  3835     // s2 in 31-bits, because we force signed ints.
       
  3836     // in other case %= will fail.
       
  3837     n = len > 2000 ? 2000 : len;
       
  3838     len -= n;
       
  3839 
       
  3840     do {
       
  3841       s1 = (s1 + buf[pos++]) |0;
       
  3842       s2 = (s2 + s1) |0;
       
  3843     } while (--n);
       
  3844 
       
  3845     s1 %= 65521;
       
  3846     s2 %= 65521;
       
  3847   }
       
  3848 
       
  3849   return (s1 | (s2 << 16)) |0;
       
  3850 }
       
  3851 
       
  3852 
       
  3853 module.exports = adler32;
       
  3854 },{}],30:[function(_dereq_,module,exports){
       
  3855 module.exports = {
       
  3856 
       
  3857   /* Allowed flush values; see deflate() and inflate() below for details */
       
  3858   Z_NO_FLUSH:         0,
       
  3859   Z_PARTIAL_FLUSH:    1,
       
  3860   Z_SYNC_FLUSH:       2,
       
  3861   Z_FULL_FLUSH:       3,
       
  3862   Z_FINISH:           4,
       
  3863   Z_BLOCK:            5,
       
  3864   Z_TREES:            6,
       
  3865 
       
  3866   /* Return codes for the compression/decompression functions. Negative values
       
  3867   * are errors, positive values are used for special but normal events.
       
  3868   */
       
  3869   Z_OK:               0,
       
  3870   Z_STREAM_END:       1,
       
  3871   Z_NEED_DICT:        2,
       
  3872   Z_ERRNO:           -1,
       
  3873   Z_STREAM_ERROR:    -2,
       
  3874   Z_DATA_ERROR:      -3,
       
  3875   //Z_MEM_ERROR:     -4,
       
  3876   Z_BUF_ERROR:       -5,
       
  3877   //Z_VERSION_ERROR: -6,
       
  3878 
       
  3879   /* compression levels */
       
  3880   Z_NO_COMPRESSION:         0,
       
  3881   Z_BEST_SPEED:             1,
       
  3882   Z_BEST_COMPRESSION:       9,
       
  3883   Z_DEFAULT_COMPRESSION:   -1,
       
  3884 
       
  3885 
       
  3886   Z_FILTERED:               1,
       
  3887   Z_HUFFMAN_ONLY:           2,
       
  3888   Z_RLE:                    3,
       
  3889   Z_FIXED:                  4,
       
  3890   Z_DEFAULT_STRATEGY:       0,
       
  3891 
       
  3892   /* Possible values of the data_type field (though see inflate()) */
       
  3893   Z_BINARY:                 0,
       
  3894   Z_TEXT:                   1,
       
  3895   //Z_ASCII:                1, // = Z_TEXT (deprecated)
       
  3896   Z_UNKNOWN:                2,
       
  3897 
       
  3898   /* The deflate compression method */
       
  3899   Z_DEFLATED:               8
       
  3900   //Z_NULL:                 null // Use -1 or null inline, depending on var type
       
  3901 };
       
  3902 },{}],31:[function(_dereq_,module,exports){
       
  3903 'use strict';
       
  3904 
       
  3905 // Note: we can't get significant speed boost here.
       
  3906 // So write code to minimize size - no pregenerated tables
       
  3907 // and array tools dependencies.
       
  3908 
       
  3909 
       
  3910 // Use ordinary array, since untyped makes no boost here
       
  3911 function makeTable() {
       
  3912   var c, table = [];
       
  3913 
       
  3914   for(var n =0; n < 256; n++){
       
  3915     c = n;
       
  3916     for(var k =0; k < 8; k++){
       
  3917       c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
       
  3918     }
       
  3919     table[n] = c;
       
  3920   }
       
  3921 
       
  3922   return table;
       
  3923 }
       
  3924 
       
  3925 // Create table on load. Just 255 signed longs. Not a problem.
       
  3926 var crcTable = makeTable();
       
  3927 
       
  3928 
       
  3929 function crc32(crc, buf, len, pos) {
       
  3930   var t = crcTable
       
  3931     , end = pos + len;
       
  3932 
       
  3933   crc = crc ^ (-1);
       
  3934 
       
  3935   for (var i = pos; i < end; i++ ) {
       
  3936     crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
       
  3937   }
       
  3938 
       
  3939   return (crc ^ (-1)); // >>> 0;
       
  3940 }
       
  3941 
       
  3942 
       
  3943 module.exports = crc32;
       
  3944 },{}],32:[function(_dereq_,module,exports){
       
  3945 'use strict';
       
  3946 
       
  3947 var utils   = _dereq_('../utils/common');
       
  3948 var trees   = _dereq_('./trees');
       
  3949 var adler32 = _dereq_('./adler32');
       
  3950 var crc32   = _dereq_('./crc32');
       
  3951 var msg   = _dereq_('./messages');
       
  3952 
       
  3953 /* Public constants ==========================================================*/
       
  3954 /* ===========================================================================*/
       
  3955 
       
  3956 
       
  3957 /* Allowed flush values; see deflate() and inflate() below for details */
       
  3958 var Z_NO_FLUSH      = 0;
       
  3959 var Z_PARTIAL_FLUSH = 1;
       
  3960 //var Z_SYNC_FLUSH    = 2;
       
  3961 var Z_FULL_FLUSH    = 3;
       
  3962 var Z_FINISH        = 4;
       
  3963 var Z_BLOCK         = 5;
       
  3964 //var Z_TREES         = 6;
       
  3965 
       
  3966 
       
  3967 /* Return codes for the compression/decompression functions. Negative values
       
  3968  * are errors, positive values are used for special but normal events.
       
  3969  */
       
  3970 var Z_OK            = 0;
       
  3971 var Z_STREAM_END    = 1;
       
  3972 //var Z_NEED_DICT     = 2;
       
  3973 //var Z_ERRNO         = -1;
       
  3974 var Z_STREAM_ERROR  = -2;
       
  3975 var Z_DATA_ERROR    = -3;
       
  3976 //var Z_MEM_ERROR     = -4;
       
  3977 var Z_BUF_ERROR     = -5;
       
  3978 //var Z_VERSION_ERROR = -6;
       
  3979 
       
  3980 
       
  3981 /* compression levels */
       
  3982 //var Z_NO_COMPRESSION      = 0;
       
  3983 //var Z_BEST_SPEED          = 1;
       
  3984 //var Z_BEST_COMPRESSION    = 9;
       
  3985 var Z_DEFAULT_COMPRESSION = -1;
       
  3986 
       
  3987 
       
  3988 var Z_FILTERED            = 1;
       
  3989 var Z_HUFFMAN_ONLY        = 2;
       
  3990 var Z_RLE                 = 3;
       
  3991 var Z_FIXED               = 4;
       
  3992 var Z_DEFAULT_STRATEGY    = 0;
       
  3993 
       
  3994 /* Possible values of the data_type field (though see inflate()) */
       
  3995 //var Z_BINARY              = 0;
       
  3996 //var Z_TEXT                = 1;
       
  3997 //var Z_ASCII               = 1; // = Z_TEXT
       
  3998 var Z_UNKNOWN             = 2;
       
  3999 
       
  4000 
       
  4001 /* The deflate compression method */
       
  4002 var Z_DEFLATED  = 8;
       
  4003 
       
  4004 /*============================================================================*/
       
  4005 
       
  4006 
       
  4007 var MAX_MEM_LEVEL = 9;
       
  4008 /* Maximum value for memLevel in deflateInit2 */
       
  4009 var MAX_WBITS = 15;
       
  4010 /* 32K LZ77 window */
       
  4011 var DEF_MEM_LEVEL = 8;
       
  4012 
       
  4013 
       
  4014 var LENGTH_CODES  = 29;
       
  4015 /* number of length codes, not counting the special END_BLOCK code */
       
  4016 var LITERALS      = 256;
       
  4017 /* number of literal bytes 0..255 */
       
  4018 var L_CODES       = LITERALS + 1 + LENGTH_CODES;
       
  4019 /* number of Literal or Length codes, including the END_BLOCK code */
       
  4020 var D_CODES       = 30;
       
  4021 /* number of distance codes */
       
  4022 var BL_CODES      = 19;
       
  4023 /* number of codes used to transfer the bit lengths */
       
  4024 var HEAP_SIZE     = 2*L_CODES + 1;
       
  4025 /* maximum heap size */
       
  4026 var MAX_BITS  = 15;
       
  4027 /* All codes must not exceed MAX_BITS bits */
       
  4028 
       
  4029 var MIN_MATCH = 3;
       
  4030 var MAX_MATCH = 258;
       
  4031 var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
       
  4032 
       
  4033 var PRESET_DICT = 0x20;
       
  4034 
       
  4035 var INIT_STATE = 42;
       
  4036 var EXTRA_STATE = 69;
       
  4037 var NAME_STATE = 73;
       
  4038 var COMMENT_STATE = 91;
       
  4039 var HCRC_STATE = 103;
       
  4040 var BUSY_STATE = 113;
       
  4041 var FINISH_STATE = 666;
       
  4042 
       
  4043 var BS_NEED_MORE      = 1; /* block not completed, need more input or more output */
       
  4044 var BS_BLOCK_DONE     = 2; /* block flush performed */
       
  4045 var BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */
       
  4046 var BS_FINISH_DONE    = 4; /* finish done, accept no more input or output */
       
  4047 
       
  4048 var OS_CODE = 0x03; // Unix :) . Don't detect, use this default.
       
  4049 
       
  4050 function err(strm, errorCode) {
       
  4051   strm.msg = msg[errorCode];
       
  4052   return errorCode;
       
  4053 }
       
  4054 
       
  4055 function rank(f) {
       
  4056   return ((f) << 1) - ((f) > 4 ? 9 : 0);
       
  4057 }
       
  4058 
       
  4059 function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
       
  4060 
       
  4061 
       
  4062 /* =========================================================================
       
  4063  * Flush as much pending output as possible. All deflate() output goes
       
  4064  * through this function so some applications may wish to modify it
       
  4065  * to avoid allocating a large strm->output buffer and copying into it.
       
  4066  * (See also read_buf()).
       
  4067  */
       
  4068 function flush_pending(strm) {
       
  4069   var s = strm.state;
       
  4070 
       
  4071   //_tr_flush_bits(s);
       
  4072   var len = s.pending;
       
  4073   if (len > strm.avail_out) {
       
  4074     len = strm.avail_out;
       
  4075   }
       
  4076   if (len === 0) { return; }
       
  4077 
       
  4078   utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
       
  4079   strm.next_out += len;
       
  4080   s.pending_out += len;
       
  4081   strm.total_out += len;
       
  4082   strm.avail_out -= len;
       
  4083   s.pending -= len;
       
  4084   if (s.pending === 0) {
       
  4085     s.pending_out = 0;
       
  4086   }
       
  4087 }
       
  4088 
       
  4089 
       
  4090 function flush_block_only (s, last) {
       
  4091   trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
       
  4092   s.block_start = s.strstart;
       
  4093   flush_pending(s.strm);
       
  4094 }
       
  4095 
       
  4096 
       
  4097 function put_byte(s, b) {
       
  4098   s.pending_buf[s.pending++] = b;
       
  4099 }
       
  4100 
       
  4101 
       
  4102 /* =========================================================================
       
  4103  * Put a short in the pending buffer. The 16-bit value is put in MSB order.
       
  4104  * IN assertion: the stream state is correct and there is enough room in
       
  4105  * pending_buf.
       
  4106  */
       
  4107 function putShortMSB(s, b) {
       
  4108 //  put_byte(s, (Byte)(b >> 8));
       
  4109 //  put_byte(s, (Byte)(b & 0xff));
       
  4110   s.pending_buf[s.pending++] = (b >>> 8) & 0xff;
       
  4111   s.pending_buf[s.pending++] = b & 0xff;
       
  4112 }
       
  4113 
       
  4114 
       
  4115 /* ===========================================================================
       
  4116  * Read a new buffer from the current input stream, update the adler32
       
  4117  * and total number of bytes read.  All deflate() input goes through
       
  4118  * this function so some applications may wish to modify it to avoid
       
  4119  * allocating a large strm->input buffer and copying from it.
       
  4120  * (See also flush_pending()).
       
  4121  */
       
  4122 function read_buf(strm, buf, start, size) {
       
  4123   var len = strm.avail_in;
       
  4124 
       
  4125   if (len > size) { len = size; }
       
  4126   if (len === 0) { return 0; }
       
  4127 
       
  4128   strm.avail_in -= len;
       
  4129 
       
  4130   utils.arraySet(buf, strm.input, strm.next_in, len, start);
       
  4131   if (strm.state.wrap === 1) {
       
  4132     strm.adler = adler32(strm.adler, buf, len, start);
       
  4133   }
       
  4134 
       
  4135   else if (strm.state.wrap === 2) {
       
  4136     strm.adler = crc32(strm.adler, buf, len, start);
       
  4137   }
       
  4138 
       
  4139   strm.next_in += len;
       
  4140   strm.total_in += len;
       
  4141 
       
  4142   return len;
       
  4143 }
       
  4144 
       
  4145 
       
  4146 /* ===========================================================================
       
  4147  * Set match_start to the longest match starting at the given string and
       
  4148  * return its length. Matches shorter or equal to prev_length are discarded,
       
  4149  * in which case the result is equal to prev_length and match_start is
       
  4150  * garbage.
       
  4151  * IN assertions: cur_match is the head of the hash chain for the current
       
  4152  *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
       
  4153  * OUT assertion: the match length is not greater than s->lookahead.
       
  4154  */
       
  4155 function longest_match(s, cur_match) {
       
  4156   var chain_length = s.max_chain_length;      /* max hash chain length */
       
  4157   var scan = s.strstart; /* current string */
       
  4158   var match;                       /* matched string */
       
  4159   var len;                           /* length of current match */
       
  4160   var best_len = s.prev_length;              /* best match length so far */
       
  4161   var nice_match = s.nice_match;             /* stop if match long enough */
       
  4162   var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ?
       
  4163       s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/;
       
  4164 
       
  4165   var _win = s.window; // shortcut
       
  4166 
       
  4167   var wmask = s.w_mask;
       
  4168   var prev  = s.prev;
       
  4169 
       
  4170   /* Stop when cur_match becomes <= limit. To simplify the code,
       
  4171    * we prevent matches with the string of window index 0.
       
  4172    */
       
  4173 
       
  4174   var strend = s.strstart + MAX_MATCH;
       
  4175   var scan_end1  = _win[scan + best_len - 1];
       
  4176   var scan_end   = _win[scan + best_len];
       
  4177 
       
  4178   /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
       
  4179    * It is easy to get rid of this optimization if necessary.
       
  4180    */
       
  4181   // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
       
  4182 
       
  4183   /* Do not waste too much time if we already have a good match: */
       
  4184   if (s.prev_length >= s.good_match) {
       
  4185     chain_length >>= 2;
       
  4186   }
       
  4187   /* Do not look for matches beyond the end of the input. This is necessary
       
  4188    * to make deflate deterministic.
       
  4189    */
       
  4190   if (nice_match > s.lookahead) { nice_match = s.lookahead; }
       
  4191 
       
  4192   // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
       
  4193 
       
  4194   do {
       
  4195     // Assert(cur_match < s->strstart, "no future");
       
  4196     match = cur_match;
       
  4197 
       
  4198     /* Skip to next match if the match length cannot increase
       
  4199      * or if the match length is less than 2.  Note that the checks below
       
  4200      * for insufficient lookahead only occur occasionally for performance
       
  4201      * reasons.  Therefore uninitialized memory will be accessed, and
       
  4202      * conditional jumps will be made that depend on those values.
       
  4203      * However the length of the match is limited to the lookahead, so
       
  4204      * the output of deflate is not affected by the uninitialized values.
       
  4205      */
       
  4206 
       
  4207     if (_win[match + best_len]     !== scan_end  ||
       
  4208         _win[match + best_len - 1] !== scan_end1 ||
       
  4209         _win[match]                !== _win[scan] ||
       
  4210         _win[++match]              !== _win[scan + 1]) {
       
  4211       continue;
       
  4212     }
       
  4213 
       
  4214     /* The check at best_len-1 can be removed because it will be made
       
  4215      * again later. (This heuristic is not always a win.)
       
  4216      * It is not necessary to compare scan[2] and match[2] since they
       
  4217      * are always equal when the other bytes match, given that
       
  4218      * the hash keys are equal and that HASH_BITS >= 8.
       
  4219      */
       
  4220     scan += 2;
       
  4221     match++;
       
  4222     // Assert(*scan == *match, "match[2]?");
       
  4223 
       
  4224     /* We check for insufficient lookahead only every 8th comparison;
       
  4225      * the 256th check will be made at strstart+258.
       
  4226      */
       
  4227     do {
       
  4228       /*jshint noempty:false*/
       
  4229     } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
       
  4230              _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
       
  4231              _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
       
  4232              _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
       
  4233              scan < strend);
       
  4234 
       
  4235     // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
       
  4236 
       
  4237     len = MAX_MATCH - (strend - scan);
       
  4238     scan = strend - MAX_MATCH;
       
  4239 
       
  4240     if (len > best_len) {
       
  4241       s.match_start = cur_match;
       
  4242       best_len = len;
       
  4243       if (len >= nice_match) {
       
  4244         break;
       
  4245       }
       
  4246       scan_end1  = _win[scan + best_len - 1];
       
  4247       scan_end   = _win[scan + best_len];
       
  4248     }
       
  4249   } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);
       
  4250 
       
  4251   if (best_len <= s.lookahead) {
       
  4252     return best_len;
       
  4253   }
       
  4254   return s.lookahead;
       
  4255 }
       
  4256 
       
  4257 
       
  4258 /* ===========================================================================
       
  4259  * Fill the window when the lookahead becomes insufficient.
       
  4260  * Updates strstart and lookahead.
       
  4261  *
       
  4262  * IN assertion: lookahead < MIN_LOOKAHEAD
       
  4263  * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
       
  4264  *    At least one byte has been read, or avail_in == 0; reads are
       
  4265  *    performed for at least two bytes (required for the zip translate_eol
       
  4266  *    option -- not supported here).
       
  4267  */
       
  4268 function fill_window(s) {
       
  4269   var _w_size = s.w_size;
       
  4270   var p, n, m, more, str;
       
  4271 
       
  4272   //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
       
  4273 
       
  4274   do {
       
  4275     more = s.window_size - s.lookahead - s.strstart;
       
  4276 
       
  4277     // JS ints have 32 bit, block below not needed
       
  4278     /* Deal with !@#$% 64K limit: */
       
  4279     //if (sizeof(int) <= 2) {
       
  4280     //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
       
  4281     //        more = wsize;
       
  4282     //
       
  4283     //  } else if (more == (unsigned)(-1)) {
       
  4284     //        /* Very unlikely, but possible on 16 bit machine if
       
  4285     //         * strstart == 0 && lookahead == 1 (input done a byte at time)
       
  4286     //         */
       
  4287     //        more--;
       
  4288     //    }
       
  4289     //}
       
  4290 
       
  4291 
       
  4292     /* If the window is almost full and there is insufficient lookahead,
       
  4293      * move the upper half to the lower one to make room in the upper half.
       
  4294      */
       
  4295     if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
       
  4296 
       
  4297       utils.arraySet(s.window, s.window, _w_size, _w_size, 0);
       
  4298       s.match_start -= _w_size;
       
  4299       s.strstart -= _w_size;
       
  4300       /* we now have strstart >= MAX_DIST */
       
  4301       s.block_start -= _w_size;
       
  4302 
       
  4303       /* Slide the hash table (could be avoided with 32 bit values
       
  4304        at the expense of memory usage). We slide even when level == 0
       
  4305        to keep the hash table consistent if we switch back to level > 0
       
  4306        later. (Using level 0 permanently is not an optimal usage of
       
  4307        zlib, so we don't care about this pathological case.)
       
  4308        */
       
  4309 
       
  4310       n = s.hash_size;
       
  4311       p = n;
       
  4312       do {
       
  4313         m = s.head[--p];
       
  4314         s.head[p] = (m >= _w_size ? m - _w_size : 0);
       
  4315       } while (--n);
       
  4316 
       
  4317       n = _w_size;
       
  4318       p = n;
       
  4319       do {
       
  4320         m = s.prev[--p];
       
  4321         s.prev[p] = (m >= _w_size ? m - _w_size : 0);
       
  4322         /* If n is not on any hash chain, prev[n] is garbage but
       
  4323          * its value will never be used.
       
  4324          */
       
  4325       } while (--n);
       
  4326 
       
  4327       more += _w_size;
       
  4328     }
       
  4329     if (s.strm.avail_in === 0) {
       
  4330       break;
       
  4331     }
       
  4332 
       
  4333     /* If there was no sliding:
       
  4334      *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
       
  4335      *    more == window_size - lookahead - strstart
       
  4336      * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
       
  4337      * => more >= window_size - 2*WSIZE + 2
       
  4338      * In the BIG_MEM or MMAP case (not yet supported),
       
  4339      *   window_size == input_size + MIN_LOOKAHEAD  &&
       
  4340      *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
       
  4341      * Otherwise, window_size == 2*WSIZE so more >= 2.
       
  4342      * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
       
  4343      */
       
  4344     //Assert(more >= 2, "more < 2");
       
  4345     n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
       
  4346     s.lookahead += n;
       
  4347 
       
  4348     /* Initialize the hash value now that we have some input: */
       
  4349     if (s.lookahead + s.insert >= MIN_MATCH) {
       
  4350       str = s.strstart - s.insert;
       
  4351       s.ins_h = s.window[str];
       
  4352 
       
  4353       /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */
       
  4354       s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask;
       
  4355 //#if MIN_MATCH != 3
       
  4356 //        Call update_hash() MIN_MATCH-3 more times
       
  4357 //#endif
       
  4358       while (s.insert) {
       
  4359         /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
       
  4360         s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH-1]) & s.hash_mask;
       
  4361 
       
  4362         s.prev[str & s.w_mask] = s.head[s.ins_h];
       
  4363         s.head[s.ins_h] = str;
       
  4364         str++;
       
  4365         s.insert--;
       
  4366         if (s.lookahead + s.insert < MIN_MATCH) {
       
  4367           break;
       
  4368         }
       
  4369       }
       
  4370     }
       
  4371     /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
       
  4372      * but this is not important since only literal bytes will be emitted.
       
  4373      */
       
  4374 
       
  4375   } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
       
  4376 
       
  4377   /* If the WIN_INIT bytes after the end of the current data have never been
       
  4378    * written, then zero those bytes in order to avoid memory check reports of
       
  4379    * the use of uninitialized (or uninitialised as Julian writes) bytes by
       
  4380    * the longest match routines.  Update the high water mark for the next
       
  4381    * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
       
  4382    * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
       
  4383    */
       
  4384 //  if (s.high_water < s.window_size) {
       
  4385 //    var curr = s.strstart + s.lookahead;
       
  4386 //    var init = 0;
       
  4387 //
       
  4388 //    if (s.high_water < curr) {
       
  4389 //      /* Previous high water mark below current data -- zero WIN_INIT
       
  4390 //       * bytes or up to end of window, whichever is less.
       
  4391 //       */
       
  4392 //      init = s.window_size - curr;
       
  4393 //      if (init > WIN_INIT)
       
  4394 //        init = WIN_INIT;
       
  4395 //      zmemzero(s->window + curr, (unsigned)init);
       
  4396 //      s->high_water = curr + init;
       
  4397 //    }
       
  4398 //    else if (s->high_water < (ulg)curr + WIN_INIT) {
       
  4399 //      /* High water mark at or above current data, but below current data
       
  4400 //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
       
  4401 //       * to end of window, whichever is less.
       
  4402 //       */
       
  4403 //      init = (ulg)curr + WIN_INIT - s->high_water;
       
  4404 //      if (init > s->window_size - s->high_water)
       
  4405 //        init = s->window_size - s->high_water;
       
  4406 //      zmemzero(s->window + s->high_water, (unsigned)init);
       
  4407 //      s->high_water += init;
       
  4408 //    }
       
  4409 //  }
       
  4410 //
       
  4411 //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
       
  4412 //    "not enough room for search");
       
  4413 }
       
  4414 
       
  4415 /* ===========================================================================
       
  4416  * Copy without compression as much as possible from the input stream, return
       
  4417  * the current block state.
       
  4418  * This function does not insert new strings in the dictionary since
       
  4419  * uncompressible data is probably not useful. This function is used
       
  4420  * only for the level=0 compression option.
       
  4421  * NOTE: this function should be optimized to avoid extra copying from
       
  4422  * window to pending_buf.
       
  4423  */
       
  4424 function deflate_stored(s, flush) {
       
  4425   /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
       
  4426    * to pending_buf_size, and each stored block has a 5 byte header:
       
  4427    */
       
  4428   var max_block_size = 0xffff;
       
  4429 
       
  4430   if (max_block_size > s.pending_buf_size - 5) {
       
  4431     max_block_size = s.pending_buf_size - 5;
       
  4432   }
       
  4433 
       
  4434   /* Copy as much as possible from input to output: */
       
  4435   for (;;) {
       
  4436     /* Fill the window as much as possible: */
       
  4437     if (s.lookahead <= 1) {
       
  4438 
       
  4439       //Assert(s->strstart < s->w_size+MAX_DIST(s) ||
       
  4440       //  s->block_start >= (long)s->w_size, "slide too late");
       
  4441 //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||
       
  4442 //        s.block_start >= s.w_size)) {
       
  4443 //        throw  new Error("slide too late");
       
  4444 //      }
       
  4445 
       
  4446       fill_window(s);
       
  4447       if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
       
  4448         return BS_NEED_MORE;
       
  4449       }
       
  4450 
       
  4451       if (s.lookahead === 0) {
       
  4452         break;
       
  4453       }
       
  4454       /* flush the current block */
       
  4455     }
       
  4456     //Assert(s->block_start >= 0L, "block gone");
       
  4457 //    if (s.block_start < 0) throw new Error("block gone");
       
  4458 
       
  4459     s.strstart += s.lookahead;
       
  4460     s.lookahead = 0;
       
  4461 
       
  4462     /* Emit a stored block if pending_buf will be full: */
       
  4463     var max_start = s.block_start + max_block_size;
       
  4464 
       
  4465     if (s.strstart === 0 || s.strstart >= max_start) {
       
  4466       /* strstart == 0 is possible when wraparound on 16-bit machine */
       
  4467       s.lookahead = s.strstart - max_start;
       
  4468       s.strstart = max_start;
       
  4469       /*** FLUSH_BLOCK(s, 0); ***/
       
  4470       flush_block_only(s, false);
       
  4471       if (s.strm.avail_out === 0) {
       
  4472         return BS_NEED_MORE;
       
  4473       }
       
  4474       /***/
       
  4475 
       
  4476 
       
  4477     }
       
  4478     /* Flush if we may have to slide, otherwise block_start may become
       
  4479      * negative and the data will be gone:
       
  4480      */
       
  4481     if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) {
       
  4482       /*** FLUSH_BLOCK(s, 0); ***/
       
  4483       flush_block_only(s, false);
       
  4484       if (s.strm.avail_out === 0) {
       
  4485         return BS_NEED_MORE;
       
  4486       }
       
  4487       /***/
       
  4488     }
       
  4489   }
       
  4490 
       
  4491   s.insert = 0;
       
  4492 
       
  4493   if (flush === Z_FINISH) {
       
  4494     /*** FLUSH_BLOCK(s, 1); ***/
       
  4495     flush_block_only(s, true);
       
  4496     if (s.strm.avail_out === 0) {
       
  4497       return BS_FINISH_STARTED;
       
  4498     }
       
  4499     /***/
       
  4500     return BS_FINISH_DONE;
       
  4501   }
       
  4502 
       
  4503   if (s.strstart > s.block_start) {
       
  4504     /*** FLUSH_BLOCK(s, 0); ***/
       
  4505     flush_block_only(s, false);
       
  4506     if (s.strm.avail_out === 0) {
       
  4507       return BS_NEED_MORE;
       
  4508     }
       
  4509     /***/
       
  4510   }
       
  4511 
       
  4512   return BS_NEED_MORE;
       
  4513 }
       
  4514 
       
  4515 /* ===========================================================================
       
  4516  * Compress as much as possible from the input stream, return the current
       
  4517  * block state.
       
  4518  * This function does not perform lazy evaluation of matches and inserts
       
  4519  * new strings in the dictionary only for unmatched strings or for short
       
  4520  * matches. It is used only for the fast compression options.
       
  4521  */
       
  4522 function deflate_fast(s, flush) {
       
  4523   var hash_head;        /* head of the hash chain */
       
  4524   var bflush;           /* set if current block must be flushed */
       
  4525 
       
  4526   for (;;) {
       
  4527     /* Make sure that we always have enough lookahead, except
       
  4528      * at the end of the input file. We need MAX_MATCH bytes
       
  4529      * for the next match, plus MIN_MATCH bytes to insert the
       
  4530      * string following the next match.
       
  4531      */
       
  4532     if (s.lookahead < MIN_LOOKAHEAD) {
       
  4533       fill_window(s);
       
  4534       if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
       
  4535         return BS_NEED_MORE;
       
  4536       }
       
  4537       if (s.lookahead === 0) {
       
  4538         break; /* flush the current block */
       
  4539       }
       
  4540     }
       
  4541 
       
  4542     /* Insert the string window[strstart .. strstart+2] in the
       
  4543      * dictionary, and set hash_head to the head of the hash chain:
       
  4544      */
       
  4545     hash_head = 0/*NIL*/;
       
  4546     if (s.lookahead >= MIN_MATCH) {
       
  4547       /*** INSERT_STRING(s, s.strstart, hash_head); ***/
       
  4548       s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
       
  4549       hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
       
  4550       s.head[s.ins_h] = s.strstart;
       
  4551       /***/
       
  4552     }
       
  4553 
       
  4554     /* Find the longest match, discarding those <= prev_length.
       
  4555      * At this point we have always match_length < MIN_MATCH
       
  4556      */
       
  4557     if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) {
       
  4558       /* To simplify the code, we prevent matches with the string
       
  4559        * of window index 0 (in particular we have to avoid a match
       
  4560        * of the string with itself at the start of the input file).
       
  4561        */
       
  4562       s.match_length = longest_match(s, hash_head);
       
  4563       /* longest_match() sets match_start */
       
  4564     }
       
  4565     if (s.match_length >= MIN_MATCH) {
       
  4566       // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only
       
  4567 
       
  4568       /*** _tr_tally_dist(s, s.strstart - s.match_start,
       
  4569                      s.match_length - MIN_MATCH, bflush); ***/
       
  4570       bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
       
  4571 
       
  4572       s.lookahead -= s.match_length;
       
  4573 
       
  4574       /* Insert new strings in the hash table only if the match length
       
  4575        * is not too large. This saves time but degrades compression.
       
  4576        */
       
  4577       if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) {
       
  4578         s.match_length--; /* string at strstart already in table */
       
  4579         do {
       
  4580           s.strstart++;
       
  4581           /*** INSERT_STRING(s, s.strstart, hash_head); ***/
       
  4582           s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
       
  4583           hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
       
  4584           s.head[s.ins_h] = s.strstart;
       
  4585           /***/
       
  4586           /* strstart never exceeds WSIZE-MAX_MATCH, so there are
       
  4587            * always MIN_MATCH bytes ahead.
       
  4588            */
       
  4589         } while (--s.match_length !== 0);
       
  4590         s.strstart++;
       
  4591       } else
       
  4592       {
       
  4593         s.strstart += s.match_length;
       
  4594         s.match_length = 0;
       
  4595         s.ins_h = s.window[s.strstart];
       
  4596         /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
       
  4597         s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask;
       
  4598 
       
  4599 //#if MIN_MATCH != 3
       
  4600 //                Call UPDATE_HASH() MIN_MATCH-3 more times
       
  4601 //#endif
       
  4602         /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
       
  4603          * matter since it will be recomputed at next deflate call.
       
  4604          */
       
  4605       }
       
  4606     } else {
       
  4607       /* No match, output a literal byte */
       
  4608       //Tracevv((stderr,"%c", s.window[s.strstart]));
       
  4609       /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
       
  4610       bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
       
  4611 
       
  4612       s.lookahead--;
       
  4613       s.strstart++;
       
  4614     }
       
  4615     if (bflush) {
       
  4616       /*** FLUSH_BLOCK(s, 0); ***/
       
  4617       flush_block_only(s, false);
       
  4618       if (s.strm.avail_out === 0) {
       
  4619         return BS_NEED_MORE;
       
  4620       }
       
  4621       /***/
       
  4622     }
       
  4623   }
       
  4624   s.insert = ((s.strstart < (MIN_MATCH-1)) ? s.strstart : MIN_MATCH-1);
       
  4625   if (flush === Z_FINISH) {
       
  4626     /*** FLUSH_BLOCK(s, 1); ***/
       
  4627     flush_block_only(s, true);
       
  4628     if (s.strm.avail_out === 0) {
       
  4629       return BS_FINISH_STARTED;
       
  4630     }
       
  4631     /***/
       
  4632     return BS_FINISH_DONE;
       
  4633   }
       
  4634   if (s.last_lit) {
       
  4635     /*** FLUSH_BLOCK(s, 0); ***/
       
  4636     flush_block_only(s, false);
       
  4637     if (s.strm.avail_out === 0) {
       
  4638       return BS_NEED_MORE;
       
  4639     }
       
  4640     /***/
       
  4641   }
       
  4642   return BS_BLOCK_DONE;
       
  4643 }
       
  4644 
       
  4645 /* ===========================================================================
       
  4646  * Same as above, but achieves better compression. We use a lazy
       
  4647  * evaluation for matches: a match is finally adopted only if there is
       
  4648  * no better match at the next window position.
       
  4649  */
       
  4650 function deflate_slow(s, flush) {
       
  4651   var hash_head;          /* head of hash chain */
       
  4652   var bflush;              /* set if current block must be flushed */
       
  4653 
       
  4654   var max_insert;
       
  4655 
       
  4656   /* Process the input block. */
       
  4657   for (;;) {
       
  4658     /* Make sure that we always have enough lookahead, except
       
  4659      * at the end of the input file. We need MAX_MATCH bytes
       
  4660      * for the next match, plus MIN_MATCH bytes to insert the
       
  4661      * string following the next match.
       
  4662      */
       
  4663     if (s.lookahead < MIN_LOOKAHEAD) {
       
  4664       fill_window(s);
       
  4665       if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
       
  4666         return BS_NEED_MORE;
       
  4667       }
       
  4668       if (s.lookahead === 0) { break; } /* flush the current block */
       
  4669     }
       
  4670 
       
  4671     /* Insert the string window[strstart .. strstart+2] in the
       
  4672      * dictionary, and set hash_head to the head of the hash chain:
       
  4673      */
       
  4674     hash_head = 0/*NIL*/;
       
  4675     if (s.lookahead >= MIN_MATCH) {
       
  4676       /*** INSERT_STRING(s, s.strstart, hash_head); ***/
       
  4677       s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
       
  4678       hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
       
  4679       s.head[s.ins_h] = s.strstart;
       
  4680       /***/
       
  4681     }
       
  4682 
       
  4683     /* Find the longest match, discarding those <= prev_length.
       
  4684      */
       
  4685     s.prev_length = s.match_length;
       
  4686     s.prev_match = s.match_start;
       
  4687     s.match_length = MIN_MATCH-1;
       
  4688 
       
  4689     if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&
       
  4690         s.strstart - hash_head <= (s.w_size-MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
       
  4691       /* To simplify the code, we prevent matches with the string
       
  4692        * of window index 0 (in particular we have to avoid a match
       
  4693        * of the string with itself at the start of the input file).
       
  4694        */
       
  4695       s.match_length = longest_match(s, hash_head);
       
  4696       /* longest_match() sets match_start */
       
  4697 
       
  4698       if (s.match_length <= 5 &&
       
  4699          (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {
       
  4700 
       
  4701         /* If prev_match is also MIN_MATCH, match_start is garbage
       
  4702          * but we will ignore the current match anyway.
       
  4703          */
       
  4704         s.match_length = MIN_MATCH-1;
       
  4705       }
       
  4706     }
       
  4707     /* If there was a match at the previous step and the current
       
  4708      * match is not better, output the previous match:
       
  4709      */
       
  4710     if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
       
  4711       max_insert = s.strstart + s.lookahead - MIN_MATCH;
       
  4712       /* Do not insert strings in hash table beyond this. */
       
  4713 
       
  4714       //check_match(s, s.strstart-1, s.prev_match, s.prev_length);
       
  4715 
       
  4716       /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
       
  4717                      s.prev_length - MIN_MATCH, bflush);***/
       
  4718       bflush = trees._tr_tally(s, s.strstart - 1- s.prev_match, s.prev_length - MIN_MATCH);
       
  4719       /* Insert in hash table all strings up to the end of the match.
       
  4720        * strstart-1 and strstart are already inserted. If there is not
       
  4721        * enough lookahead, the last two strings are not inserted in
       
  4722        * the hash table.
       
  4723        */
       
  4724       s.lookahead -= s.prev_length-1;
       
  4725       s.prev_length -= 2;
       
  4726       do {
       
  4727         if (++s.strstart <= max_insert) {
       
  4728           /*** INSERT_STRING(s, s.strstart, hash_head); ***/
       
  4729           s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
       
  4730           hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
       
  4731           s.head[s.ins_h] = s.strstart;
       
  4732           /***/
       
  4733         }
       
  4734       } while (--s.prev_length !== 0);
       
  4735       s.match_available = 0;
       
  4736       s.match_length = MIN_MATCH-1;
       
  4737       s.strstart++;
       
  4738 
       
  4739       if (bflush) {
       
  4740         /*** FLUSH_BLOCK(s, 0); ***/
       
  4741         flush_block_only(s, false);
       
  4742         if (s.strm.avail_out === 0) {
       
  4743           return BS_NEED_MORE;
       
  4744         }
       
  4745         /***/
       
  4746       }
       
  4747 
       
  4748     } else if (s.match_available) {
       
  4749       /* If there was no match at the previous position, output a
       
  4750        * single literal. If there was a match but the current match
       
  4751        * is longer, truncate the previous match to a single literal.
       
  4752        */
       
  4753       //Tracevv((stderr,"%c", s->window[s->strstart-1]));
       
  4754       /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
       
  4755       bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]);
       
  4756 
       
  4757       if (bflush) {
       
  4758         /*** FLUSH_BLOCK_ONLY(s, 0) ***/
       
  4759         flush_block_only(s, false);
       
  4760         /***/
       
  4761       }
       
  4762       s.strstart++;
       
  4763       s.lookahead--;
       
  4764       if (s.strm.avail_out === 0) {
       
  4765         return BS_NEED_MORE;
       
  4766       }
       
  4767     } else {
       
  4768       /* There is no previous match to compare with, wait for
       
  4769        * the next step to decide.
       
  4770        */
       
  4771       s.match_available = 1;
       
  4772       s.strstart++;
       
  4773       s.lookahead--;
       
  4774     }
       
  4775   }
       
  4776   //Assert (flush != Z_NO_FLUSH, "no flush?");
       
  4777   if (s.match_available) {
       
  4778     //Tracevv((stderr,"%c", s->window[s->strstart-1]));
       
  4779     /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
       
  4780     bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]);
       
  4781 
       
  4782     s.match_available = 0;
       
  4783   }
       
  4784   s.insert = s.strstart < MIN_MATCH-1 ? s.strstart : MIN_MATCH-1;
       
  4785   if (flush === Z_FINISH) {
       
  4786     /*** FLUSH_BLOCK(s, 1); ***/
       
  4787     flush_block_only(s, true);
       
  4788     if (s.strm.avail_out === 0) {
       
  4789       return BS_FINISH_STARTED;
       
  4790     }
       
  4791     /***/
       
  4792     return BS_FINISH_DONE;
       
  4793   }
       
  4794   if (s.last_lit) {
       
  4795     /*** FLUSH_BLOCK(s, 0); ***/
       
  4796     flush_block_only(s, false);
       
  4797     if (s.strm.avail_out === 0) {
       
  4798       return BS_NEED_MORE;
       
  4799     }
       
  4800     /***/
       
  4801   }
       
  4802 
       
  4803   return BS_BLOCK_DONE;
       
  4804 }
       
  4805 
       
  4806 
       
  4807 /* ===========================================================================
       
  4808  * For Z_RLE, simply look for runs of bytes, generate matches only of distance
       
  4809  * one.  Do not maintain a hash table.  (It will be regenerated if this run of
       
  4810  * deflate switches away from Z_RLE.)
       
  4811  */
       
  4812 function deflate_rle(s, flush) {
       
  4813   var bflush;            /* set if current block must be flushed */
       
  4814   var prev;              /* byte at distance one to match */
       
  4815   var scan, strend;      /* scan goes up to strend for length of run */
       
  4816 
       
  4817   var _win = s.window;
       
  4818 
       
  4819   for (;;) {
       
  4820     /* Make sure that we always have enough lookahead, except
       
  4821      * at the end of the input file. We need MAX_MATCH bytes
       
  4822      * for the longest run, plus one for the unrolled loop.
       
  4823      */
       
  4824     if (s.lookahead <= MAX_MATCH) {
       
  4825       fill_window(s);
       
  4826       if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {
       
  4827         return BS_NEED_MORE;
       
  4828       }
       
  4829       if (s.lookahead === 0) { break; } /* flush the current block */
       
  4830     }
       
  4831 
       
  4832     /* See how many times the previous byte repeats */
       
  4833     s.match_length = 0;
       
  4834     if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
       
  4835       scan = s.strstart - 1;
       
  4836       prev = _win[scan];
       
  4837       if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
       
  4838         strend = s.strstart + MAX_MATCH;
       
  4839         do {
       
  4840           /*jshint noempty:false*/
       
  4841         } while (prev === _win[++scan] && prev === _win[++scan] &&
       
  4842                  prev === _win[++scan] && prev === _win[++scan] &&
       
  4843                  prev === _win[++scan] && prev === _win[++scan] &&
       
  4844                  prev === _win[++scan] && prev === _win[++scan] &&
       
  4845                  scan < strend);
       
  4846         s.match_length = MAX_MATCH - (strend - scan);
       
  4847         if (s.match_length > s.lookahead) {
       
  4848           s.match_length = s.lookahead;
       
  4849         }
       
  4850       }
       
  4851       //Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
       
  4852     }
       
  4853 
       
  4854     /* Emit match if have run of MIN_MATCH or longer, else emit literal */
       
  4855     if (s.match_length >= MIN_MATCH) {
       
  4856       //check_match(s, s.strstart, s.strstart - 1, s.match_length);
       
  4857 
       
  4858       /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/
       
  4859       bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
       
  4860 
       
  4861       s.lookahead -= s.match_length;
       
  4862       s.strstart += s.match_length;
       
  4863       s.match_length = 0;
       
  4864     } else {
       
  4865       /* No match, output a literal byte */
       
  4866       //Tracevv((stderr,"%c", s->window[s->strstart]));
       
  4867       /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
       
  4868       bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
       
  4869 
       
  4870       s.lookahead--;
       
  4871       s.strstart++;
       
  4872     }
       
  4873     if (bflush) {
       
  4874       /*** FLUSH_BLOCK(s, 0); ***/
       
  4875       flush_block_only(s, false);
       
  4876       if (s.strm.avail_out === 0) {
       
  4877         return BS_NEED_MORE;
       
  4878       }
       
  4879       /***/
       
  4880     }
       
  4881   }
       
  4882   s.insert = 0;
       
  4883   if (flush === Z_FINISH) {
       
  4884     /*** FLUSH_BLOCK(s, 1); ***/
       
  4885     flush_block_only(s, true);
       
  4886     if (s.strm.avail_out === 0) {
       
  4887       return BS_FINISH_STARTED;
       
  4888     }
       
  4889     /***/
       
  4890     return BS_FINISH_DONE;
       
  4891   }
       
  4892   if (s.last_lit) {
       
  4893     /*** FLUSH_BLOCK(s, 0); ***/
       
  4894     flush_block_only(s, false);
       
  4895     if (s.strm.avail_out === 0) {
       
  4896       return BS_NEED_MORE;
       
  4897     }
       
  4898     /***/
       
  4899   }
       
  4900   return BS_BLOCK_DONE;
       
  4901 }
       
  4902 
       
  4903 /* ===========================================================================
       
  4904  * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
       
  4905  * (It will be regenerated if this run of deflate switches away from Huffman.)
       
  4906  */
       
  4907 function deflate_huff(s, flush) {
       
  4908   var bflush;             /* set if current block must be flushed */
       
  4909 
       
  4910   for (;;) {
       
  4911     /* Make sure that we have a literal to write. */
       
  4912     if (s.lookahead === 0) {
       
  4913       fill_window(s);
       
  4914       if (s.lookahead === 0) {
       
  4915         if (flush === Z_NO_FLUSH) {
       
  4916           return BS_NEED_MORE;
       
  4917         }
       
  4918         break;      /* flush the current block */
       
  4919       }
       
  4920     }
       
  4921 
       
  4922     /* Output a literal byte */
       
  4923     s.match_length = 0;
       
  4924     //Tracevv((stderr,"%c", s->window[s->strstart]));
       
  4925     /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
       
  4926     bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
       
  4927     s.lookahead--;
       
  4928     s.strstart++;
       
  4929     if (bflush) {
       
  4930       /*** FLUSH_BLOCK(s, 0); ***/
       
  4931       flush_block_only(s, false);
       
  4932       if (s.strm.avail_out === 0) {
       
  4933         return BS_NEED_MORE;
       
  4934       }
       
  4935       /***/
       
  4936     }
       
  4937   }
       
  4938   s.insert = 0;
       
  4939   if (flush === Z_FINISH) {
       
  4940     /*** FLUSH_BLOCK(s, 1); ***/
       
  4941     flush_block_only(s, true);
       
  4942     if (s.strm.avail_out === 0) {
       
  4943       return BS_FINISH_STARTED;
       
  4944     }
       
  4945     /***/
       
  4946     return BS_FINISH_DONE;
       
  4947   }
       
  4948   if (s.last_lit) {
       
  4949     /*** FLUSH_BLOCK(s, 0); ***/
       
  4950     flush_block_only(s, false);
       
  4951     if (s.strm.avail_out === 0) {
       
  4952       return BS_NEED_MORE;
       
  4953     }
       
  4954     /***/
       
  4955   }
       
  4956   return BS_BLOCK_DONE;
       
  4957 }
       
  4958 
       
  4959 /* Values for max_lazy_match, good_match and max_chain_length, depending on
       
  4960  * the desired pack level (0..9). The values given below have been tuned to
       
  4961  * exclude worst case performance for pathological files. Better values may be
       
  4962  * found for specific files.
       
  4963  */
       
  4964 var Config = function (good_length, max_lazy, nice_length, max_chain, func) {
       
  4965   this.good_length = good_length;
       
  4966   this.max_lazy = max_lazy;
       
  4967   this.nice_length = nice_length;
       
  4968   this.max_chain = max_chain;
       
  4969   this.func = func;
       
  4970 };
       
  4971 
       
  4972 var configuration_table;
       
  4973 
       
  4974 configuration_table = [
       
  4975   /*      good lazy nice chain */
       
  4976   new Config(0, 0, 0, 0, deflate_stored),          /* 0 store only */
       
  4977   new Config(4, 4, 8, 4, deflate_fast),            /* 1 max speed, no lazy matches */
       
  4978   new Config(4, 5, 16, 8, deflate_fast),           /* 2 */
       
  4979   new Config(4, 6, 32, 32, deflate_fast),          /* 3 */
       
  4980 
       
  4981   new Config(4, 4, 16, 16, deflate_slow),          /* 4 lazy matches */
       
  4982   new Config(8, 16, 32, 32, deflate_slow),         /* 5 */
       
  4983   new Config(8, 16, 128, 128, deflate_slow),       /* 6 */
       
  4984   new Config(8, 32, 128, 256, deflate_slow),       /* 7 */
       
  4985   new Config(32, 128, 258, 1024, deflate_slow),    /* 8 */
       
  4986   new Config(32, 258, 258, 4096, deflate_slow)     /* 9 max compression */
       
  4987 ];
       
  4988 
       
  4989 
       
  4990 /* ===========================================================================
       
  4991  * Initialize the "longest match" routines for a new zlib stream
       
  4992  */
       
  4993 function lm_init(s) {
       
  4994   s.window_size = 2 * s.w_size;
       
  4995 
       
  4996   /*** CLEAR_HASH(s); ***/
       
  4997   zero(s.head); // Fill with NIL (= 0);
       
  4998 
       
  4999   /* Set the default configuration parameters:
       
  5000    */
       
  5001   s.max_lazy_match = configuration_table[s.level].max_lazy;
       
  5002   s.good_match = configuration_table[s.level].good_length;
       
  5003   s.nice_match = configuration_table[s.level].nice_length;
       
  5004   s.max_chain_length = configuration_table[s.level].max_chain;
       
  5005 
       
  5006   s.strstart = 0;
       
  5007   s.block_start = 0;
       
  5008   s.lookahead = 0;
       
  5009   s.insert = 0;
       
  5010   s.match_length = s.prev_length = MIN_MATCH - 1;
       
  5011   s.match_available = 0;
       
  5012   s.ins_h = 0;
       
  5013 }
       
  5014 
       
  5015 
       
  5016 function DeflateState() {
       
  5017   this.strm = null;            /* pointer back to this zlib stream */
       
  5018   this.status = 0;            /* as the name implies */
       
  5019   this.pending_buf = null;      /* output still pending */
       
  5020   this.pending_buf_size = 0;  /* size of pending_buf */
       
  5021   this.pending_out = 0;       /* next pending byte to output to the stream */
       
  5022   this.pending = 0;           /* nb of bytes in the pending buffer */
       
  5023   this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
       
  5024   this.gzhead = null;         /* gzip header information to write */
       
  5025   this.gzindex = 0;           /* where in extra, name, or comment */
       
  5026   this.method = Z_DEFLATED; /* can only be DEFLATED */
       
  5027   this.last_flush = -1;   /* value of flush param for previous deflate call */
       
  5028 
       
  5029   this.w_size = 0;  /* LZ77 window size (32K by default) */
       
  5030   this.w_bits = 0;  /* log2(w_size)  (8..16) */
       
  5031   this.w_mask = 0;  /* w_size - 1 */
       
  5032 
       
  5033   this.window = null;
       
  5034   /* Sliding window. Input bytes are read into the second half of the window,
       
  5035    * and move to the first half later to keep a dictionary of at least wSize
       
  5036    * bytes. With this organization, matches are limited to a distance of
       
  5037    * wSize-MAX_MATCH bytes, but this ensures that IO is always
       
  5038    * performed with a length multiple of the block size.
       
  5039    */
       
  5040 
       
  5041   this.window_size = 0;
       
  5042   /* Actual size of window: 2*wSize, except when the user input buffer
       
  5043    * is directly used as sliding window.
       
  5044    */
       
  5045 
       
  5046   this.prev = null;
       
  5047   /* Link to older string with same hash index. To limit the size of this
       
  5048    * array to 64K, this link is maintained only for the last 32K strings.
       
  5049    * An index in this array is thus a window index modulo 32K.
       
  5050    */
       
  5051 
       
  5052   this.head = null;   /* Heads of the hash chains or NIL. */
       
  5053 
       
  5054   this.ins_h = 0;       /* hash index of string to be inserted */
       
  5055   this.hash_size = 0;   /* number of elements in hash table */
       
  5056   this.hash_bits = 0;   /* log2(hash_size) */
       
  5057   this.hash_mask = 0;   /* hash_size-1 */
       
  5058 
       
  5059   this.hash_shift = 0;
       
  5060   /* Number of bits by which ins_h must be shifted at each input
       
  5061    * step. It must be such that after MIN_MATCH steps, the oldest
       
  5062    * byte no longer takes part in the hash key, that is:
       
  5063    *   hash_shift * MIN_MATCH >= hash_bits
       
  5064    */
       
  5065 
       
  5066   this.block_start = 0;
       
  5067   /* Window position at the beginning of the current output block. Gets
       
  5068    * negative when the window is moved backwards.
       
  5069    */
       
  5070 
       
  5071   this.match_length = 0;      /* length of best match */
       
  5072   this.prev_match = 0;        /* previous match */
       
  5073   this.match_available = 0;   /* set if previous match exists */
       
  5074   this.strstart = 0;          /* start of string to insert */
       
  5075   this.match_start = 0;       /* start of matching string */
       
  5076   this.lookahead = 0;         /* number of valid bytes ahead in window */
       
  5077 
       
  5078   this.prev_length = 0;
       
  5079   /* Length of the best match at previous step. Matches not greater than this
       
  5080    * are discarded. This is used in the lazy match evaluation.
       
  5081    */
       
  5082 
       
  5083   this.max_chain_length = 0;
       
  5084   /* To speed up deflation, hash chains are never searched beyond this
       
  5085    * length.  A higher limit improves compression ratio but degrades the
       
  5086    * speed.
       
  5087    */
       
  5088 
       
  5089   this.max_lazy_match = 0;
       
  5090   /* Attempt to find a better match only when the current match is strictly
       
  5091    * smaller than this value. This mechanism is used only for compression
       
  5092    * levels >= 4.
       
  5093    */
       
  5094   // That's alias to max_lazy_match, don't use directly
       
  5095   //this.max_insert_length = 0;
       
  5096   /* Insert new strings in the hash table only if the match length is not
       
  5097    * greater than this length. This saves time but degrades compression.
       
  5098    * max_insert_length is used only for compression levels <= 3.
       
  5099    */
       
  5100 
       
  5101   this.level = 0;     /* compression level (1..9) */
       
  5102   this.strategy = 0;  /* favor or force Huffman coding*/
       
  5103 
       
  5104   this.good_match = 0;
       
  5105   /* Use a faster search when the previous match is longer than this */
       
  5106 
       
  5107   this.nice_match = 0; /* Stop searching when current match exceeds this */
       
  5108 
       
  5109               /* used by trees.c: */
       
  5110 
       
  5111   /* Didn't use ct_data typedef below to suppress compiler warning */
       
  5112 
       
  5113   // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
       
  5114   // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
       
  5115   // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
       
  5116 
       
  5117   // Use flat array of DOUBLE size, with interleaved fata,
       
  5118   // because JS does not support effective
       
  5119   this.dyn_ltree  = new utils.Buf16(HEAP_SIZE * 2);
       
  5120   this.dyn_dtree  = new utils.Buf16((2*D_CODES+1) * 2);
       
  5121   this.bl_tree    = new utils.Buf16((2*BL_CODES+1) * 2);
       
  5122   zero(this.dyn_ltree);
       
  5123   zero(this.dyn_dtree);
       
  5124   zero(this.bl_tree);
       
  5125 
       
  5126   this.l_desc   = null;         /* desc. for literal tree */
       
  5127   this.d_desc   = null;         /* desc. for distance tree */
       
  5128   this.bl_desc  = null;         /* desc. for bit length tree */
       
  5129 
       
  5130   //ush bl_count[MAX_BITS+1];
       
  5131   this.bl_count = new utils.Buf16(MAX_BITS+1);
       
  5132   /* number of codes at each bit length for an optimal tree */
       
  5133 
       
  5134   //int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
       
  5135   this.heap = new utils.Buf16(2*L_CODES+1);  /* heap used to build the Huffman trees */
       
  5136   zero(this.heap);
       
  5137 
       
  5138   this.heap_len = 0;               /* number of elements in the heap */
       
  5139   this.heap_max = 0;               /* element of largest frequency */
       
  5140   /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
       
  5141    * The same heap array is used to build all trees.
       
  5142    */
       
  5143 
       
  5144   this.depth = new utils.Buf16(2*L_CODES+1); //uch depth[2*L_CODES+1];
       
  5145   zero(this.depth);
       
  5146   /* Depth of each subtree used as tie breaker for trees of equal frequency
       
  5147    */
       
  5148 
       
  5149   this.l_buf = 0;          /* buffer index for literals or lengths */
       
  5150 
       
  5151   this.lit_bufsize = 0;
       
  5152   /* Size of match buffer for literals/lengths.  There are 4 reasons for
       
  5153    * limiting lit_bufsize to 64K:
       
  5154    *   - frequencies can be kept in 16 bit counters
       
  5155    *   - if compression is not successful for the first block, all input
       
  5156    *     data is still in the window so we can still emit a stored block even
       
  5157    *     when input comes from standard input.  (This can also be done for
       
  5158    *     all blocks if lit_bufsize is not greater than 32K.)
       
  5159    *   - if compression is not successful for a file smaller than 64K, we can
       
  5160    *     even emit a stored file instead of a stored block (saving 5 bytes).
       
  5161    *     This is applicable only for zip (not gzip or zlib).
       
  5162    *   - creating new Huffman trees less frequently may not provide fast
       
  5163    *     adaptation to changes in the input data statistics. (Take for
       
  5164    *     example a binary file with poorly compressible code followed by
       
  5165    *     a highly compressible string table.) Smaller buffer sizes give
       
  5166    *     fast adaptation but have of course the overhead of transmitting
       
  5167    *     trees more frequently.
       
  5168    *   - I can't count above 4
       
  5169    */
       
  5170 
       
  5171   this.last_lit = 0;      /* running index in l_buf */
       
  5172 
       
  5173   this.d_buf = 0;
       
  5174   /* Buffer index for distances. To simplify the code, d_buf and l_buf have
       
  5175    * the same number of elements. To use different lengths, an extra flag
       
  5176    * array would be necessary.
       
  5177    */
       
  5178 
       
  5179   this.opt_len = 0;       /* bit length of current block with optimal trees */
       
  5180   this.static_len = 0;    /* bit length of current block with static trees */
       
  5181   this.matches = 0;       /* number of string matches in current block */
       
  5182   this.insert = 0;        /* bytes at end of window left to insert */
       
  5183 
       
  5184 
       
  5185   this.bi_buf = 0;
       
  5186   /* Output buffer. bits are inserted starting at the bottom (least
       
  5187    * significant bits).
       
  5188    */
       
  5189   this.bi_valid = 0;
       
  5190   /* Number of valid bits in bi_buf.  All bits above the last valid bit
       
  5191    * are always zero.
       
  5192    */
       
  5193 
       
  5194   // Used for window memory init. We safely ignore it for JS. That makes
       
  5195   // sense only for pointers and memory check tools.
       
  5196   //this.high_water = 0;
       
  5197   /* High water mark offset in window for initialized bytes -- bytes above
       
  5198    * this are set to zero in order to avoid memory check warnings when
       
  5199    * longest match routines access bytes past the input.  This is then
       
  5200    * updated to the new high water mark.
       
  5201    */
       
  5202 }
       
  5203 
       
  5204 
       
  5205 function deflateResetKeep(strm) {
       
  5206   var s;
       
  5207 
       
  5208   if (!strm || !strm.state) {
       
  5209     return err(strm, Z_STREAM_ERROR);
       
  5210   }
       
  5211 
       
  5212   strm.total_in = strm.total_out = 0;
       
  5213   strm.data_type = Z_UNKNOWN;
       
  5214 
       
  5215   s = strm.state;
       
  5216   s.pending = 0;
       
  5217   s.pending_out = 0;
       
  5218 
       
  5219   if (s.wrap < 0) {
       
  5220     s.wrap = -s.wrap;
       
  5221     /* was made negative by deflate(..., Z_FINISH); */
       
  5222   }
       
  5223   s.status = (s.wrap ? INIT_STATE : BUSY_STATE);
       
  5224   strm.adler = (s.wrap === 2) ?
       
  5225     0  // crc32(0, Z_NULL, 0)
       
  5226   :
       
  5227     1; // adler32(0, Z_NULL, 0)
       
  5228   s.last_flush = Z_NO_FLUSH;
       
  5229   trees._tr_init(s);
       
  5230   return Z_OK;
       
  5231 }
       
  5232 
       
  5233 
       
  5234 function deflateReset(strm) {
       
  5235   var ret = deflateResetKeep(strm);
       
  5236   if (ret === Z_OK) {
       
  5237     lm_init(strm.state);
       
  5238   }
       
  5239   return ret;
       
  5240 }
       
  5241 
       
  5242 
       
  5243 function deflateSetHeader(strm, head) {
       
  5244   if (!strm || !strm.state) { return Z_STREAM_ERROR; }
       
  5245   if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }
       
  5246   strm.state.gzhead = head;
       
  5247   return Z_OK;
       
  5248 }
       
  5249 
       
  5250 
       
  5251 function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
       
  5252   if (!strm) { // === Z_NULL
       
  5253     return Z_STREAM_ERROR;
       
  5254   }
       
  5255   var wrap = 1;
       
  5256 
       
  5257   if (level === Z_DEFAULT_COMPRESSION) {
       
  5258     level = 6;
       
  5259   }
       
  5260 
       
  5261   if (windowBits < 0) { /* suppress zlib wrapper */
       
  5262     wrap = 0;
       
  5263     windowBits = -windowBits;
       
  5264   }
       
  5265 
       
  5266   else if (windowBits > 15) {
       
  5267     wrap = 2;           /* write gzip wrapper instead */
       
  5268     windowBits -= 16;
       
  5269   }
       
  5270 
       
  5271 
       
  5272   if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED ||
       
  5273     windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
       
  5274     strategy < 0 || strategy > Z_FIXED) {
       
  5275     return err(strm, Z_STREAM_ERROR);
       
  5276   }
       
  5277 
       
  5278 
       
  5279   if (windowBits === 8) {
       
  5280     windowBits = 9;
       
  5281   }
       
  5282   /* until 256-byte window bug fixed */
       
  5283 
       
  5284   var s = new DeflateState();
       
  5285 
       
  5286   strm.state = s;
       
  5287   s.strm = strm;
       
  5288 
       
  5289   s.wrap = wrap;
       
  5290   s.gzhead = null;
       
  5291   s.w_bits = windowBits;
       
  5292   s.w_size = 1 << s.w_bits;
       
  5293   s.w_mask = s.w_size - 1;
       
  5294 
       
  5295   s.hash_bits = memLevel + 7;
       
  5296   s.hash_size = 1 << s.hash_bits;
       
  5297   s.hash_mask = s.hash_size - 1;
       
  5298   s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
       
  5299 
       
  5300   s.window = new utils.Buf8(s.w_size * 2);
       
  5301   s.head = new utils.Buf16(s.hash_size);
       
  5302   s.prev = new utils.Buf16(s.w_size);
       
  5303 
       
  5304   // Don't need mem init magic for JS.
       
  5305   //s.high_water = 0;  /* nothing written to s->window yet */
       
  5306 
       
  5307   s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
       
  5308 
       
  5309   s.pending_buf_size = s.lit_bufsize * 4;
       
  5310   s.pending_buf = new utils.Buf8(s.pending_buf_size);
       
  5311 
       
  5312   s.d_buf = s.lit_bufsize >> 1;
       
  5313   s.l_buf = (1 + 2) * s.lit_bufsize;
       
  5314 
       
  5315   s.level = level;
       
  5316   s.strategy = strategy;
       
  5317   s.method = method;
       
  5318 
       
  5319   return deflateReset(strm);
       
  5320 }
       
  5321 
       
  5322 function deflateInit(strm, level) {
       
  5323   return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
       
  5324 }
       
  5325 
       
  5326 
       
  5327 function deflate(strm, flush) {
       
  5328   var old_flush, s;
       
  5329   var beg, val; // for gzip header write only
       
  5330 
       
  5331   if (!strm || !strm.state ||
       
  5332     flush > Z_BLOCK || flush < 0) {
       
  5333     return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
       
  5334   }
       
  5335 
       
  5336   s = strm.state;
       
  5337 
       
  5338   if (!strm.output ||
       
  5339       (!strm.input && strm.avail_in !== 0) ||
       
  5340       (s.status === FINISH_STATE && flush !== Z_FINISH)) {
       
  5341     return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);
       
  5342   }
       
  5343 
       
  5344   s.strm = strm; /* just in case */
       
  5345   old_flush = s.last_flush;
       
  5346   s.last_flush = flush;
       
  5347 
       
  5348   /* Write the header */
       
  5349   if (s.status === INIT_STATE) {
       
  5350 
       
  5351     if (s.wrap === 2) { // GZIP header
       
  5352       strm.adler = 0;  //crc32(0L, Z_NULL, 0);
       
  5353       put_byte(s, 31);
       
  5354       put_byte(s, 139);
       
  5355       put_byte(s, 8);
       
  5356       if (!s.gzhead) { // s->gzhead == Z_NULL
       
  5357         put_byte(s, 0);
       
  5358         put_byte(s, 0);
       
  5359         put_byte(s, 0);
       
  5360         put_byte(s, 0);
       
  5361         put_byte(s, 0);
       
  5362         put_byte(s, s.level === 9 ? 2 :
       
  5363                     (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
       
  5364                      4 : 0));
       
  5365         put_byte(s, OS_CODE);
       
  5366         s.status = BUSY_STATE;
       
  5367       }
       
  5368       else {
       
  5369         put_byte(s, (s.gzhead.text ? 1 : 0) +
       
  5370                     (s.gzhead.hcrc ? 2 : 0) +
       
  5371                     (!s.gzhead.extra ? 0 : 4) +
       
  5372                     (!s.gzhead.name ? 0 : 8) +
       
  5373                     (!s.gzhead.comment ? 0 : 16)
       
  5374                 );
       
  5375         put_byte(s, s.gzhead.time & 0xff);
       
  5376         put_byte(s, (s.gzhead.time >> 8) & 0xff);
       
  5377         put_byte(s, (s.gzhead.time >> 16) & 0xff);
       
  5378         put_byte(s, (s.gzhead.time >> 24) & 0xff);
       
  5379         put_byte(s, s.level === 9 ? 2 :
       
  5380                     (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
       
  5381                      4 : 0));
       
  5382         put_byte(s, s.gzhead.os & 0xff);
       
  5383         if (s.gzhead.extra && s.gzhead.extra.length) {
       
  5384           put_byte(s, s.gzhead.extra.length & 0xff);
       
  5385           put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);
       
  5386         }
       
  5387         if (s.gzhead.hcrc) {
       
  5388           strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);
       
  5389         }
       
  5390         s.gzindex = 0;
       
  5391         s.status = EXTRA_STATE;
       
  5392       }
       
  5393     }
       
  5394     else // DEFLATE header
       
  5395     {
       
  5396       var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;
       
  5397       var level_flags = -1;
       
  5398 
       
  5399       if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
       
  5400         level_flags = 0;
       
  5401       } else if (s.level < 6) {
       
  5402         level_flags = 1;
       
  5403       } else if (s.level === 6) {
       
  5404         level_flags = 2;
       
  5405       } else {
       
  5406         level_flags = 3;
       
  5407       }
       
  5408       header |= (level_flags << 6);
       
  5409       if (s.strstart !== 0) { header |= PRESET_DICT; }
       
  5410       header += 31 - (header % 31);
       
  5411 
       
  5412       s.status = BUSY_STATE;
       
  5413       putShortMSB(s, header);
       
  5414 
       
  5415       /* Save the adler32 of the preset dictionary: */
       
  5416       if (s.strstart !== 0) {
       
  5417         putShortMSB(s, strm.adler >>> 16);
       
  5418         putShortMSB(s, strm.adler & 0xffff);
       
  5419       }
       
  5420       strm.adler = 1; // adler32(0L, Z_NULL, 0);
       
  5421     }
       
  5422   }
       
  5423 
       
  5424 //#ifdef GZIP
       
  5425   if (s.status === EXTRA_STATE) {
       
  5426     if (s.gzhead.extra/* != Z_NULL*/) {
       
  5427       beg = s.pending;  /* start of bytes to update crc */
       
  5428 
       
  5429       while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {
       
  5430         if (s.pending === s.pending_buf_size) {
       
  5431           if (s.gzhead.hcrc && s.pending > beg) {
       
  5432             strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
       
  5433           }
       
  5434           flush_pending(strm);
       
  5435           beg = s.pending;
       
  5436           if (s.pending === s.pending_buf_size) {
       
  5437             break;
       
  5438           }
       
  5439         }
       
  5440         put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);
       
  5441         s.gzindex++;
       
  5442       }
       
  5443       if (s.gzhead.hcrc && s.pending > beg) {
       
  5444         strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
       
  5445       }
       
  5446       if (s.gzindex === s.gzhead.extra.length) {
       
  5447         s.gzindex = 0;
       
  5448         s.status = NAME_STATE;
       
  5449       }
       
  5450     }
       
  5451     else {
       
  5452       s.status = NAME_STATE;
       
  5453     }
       
  5454   }
       
  5455   if (s.status === NAME_STATE) {
       
  5456     if (s.gzhead.name/* != Z_NULL*/) {
       
  5457       beg = s.pending;  /* start of bytes to update crc */
       
  5458       //int val;
       
  5459 
       
  5460       do {
       
  5461         if (s.pending === s.pending_buf_size) {
       
  5462           if (s.gzhead.hcrc && s.pending > beg) {
       
  5463             strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
       
  5464           }
       
  5465           flush_pending(strm);
       
  5466           beg = s.pending;
       
  5467           if (s.pending === s.pending_buf_size) {
       
  5468             val = 1;
       
  5469             break;
       
  5470           }
       
  5471         }
       
  5472         // JS specific: little magic to add zero terminator to end of string
       
  5473         if (s.gzindex < s.gzhead.name.length) {
       
  5474           val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;
       
  5475         } else {
       
  5476           val = 0;
       
  5477         }
       
  5478         put_byte(s, val);
       
  5479       } while (val !== 0);
       
  5480 
       
  5481       if (s.gzhead.hcrc && s.pending > beg){
       
  5482         strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
       
  5483       }
       
  5484       if (val === 0) {
       
  5485         s.gzindex = 0;
       
  5486         s.status = COMMENT_STATE;
       
  5487       }
       
  5488     }
       
  5489     else {
       
  5490       s.status = COMMENT_STATE;
       
  5491     }
       
  5492   }
       
  5493   if (s.status === COMMENT_STATE) {
       
  5494     if (s.gzhead.comment/* != Z_NULL*/) {
       
  5495       beg = s.pending;  /* start of bytes to update crc */
       
  5496       //int val;
       
  5497 
       
  5498       do {
       
  5499         if (s.pending === s.pending_buf_size) {
       
  5500           if (s.gzhead.hcrc && s.pending > beg) {
       
  5501             strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
       
  5502           }
       
  5503           flush_pending(strm);
       
  5504           beg = s.pending;
       
  5505           if (s.pending === s.pending_buf_size) {
       
  5506             val = 1;
       
  5507             break;
       
  5508           }
       
  5509         }
       
  5510         // JS specific: little magic to add zero terminator to end of string
       
  5511         if (s.gzindex < s.gzhead.comment.length) {
       
  5512           val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;
       
  5513         } else {
       
  5514           val = 0;
       
  5515         }
       
  5516         put_byte(s, val);
       
  5517       } while (val !== 0);
       
  5518 
       
  5519       if (s.gzhead.hcrc && s.pending > beg) {
       
  5520         strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
       
  5521       }
       
  5522       if (val === 0) {
       
  5523         s.status = HCRC_STATE;
       
  5524       }
       
  5525     }
       
  5526     else {
       
  5527       s.status = HCRC_STATE;
       
  5528     }
       
  5529   }
       
  5530   if (s.status === HCRC_STATE) {
       
  5531     if (s.gzhead.hcrc) {
       
  5532       if (s.pending + 2 > s.pending_buf_size) {
       
  5533         flush_pending(strm);
       
  5534       }
       
  5535       if (s.pending + 2 <= s.pending_buf_size) {
       
  5536         put_byte(s, strm.adler & 0xff);
       
  5537         put_byte(s, (strm.adler >> 8) & 0xff);
       
  5538         strm.adler = 0; //crc32(0L, Z_NULL, 0);
       
  5539         s.status = BUSY_STATE;
       
  5540       }
       
  5541     }
       
  5542     else {
       
  5543       s.status = BUSY_STATE;
       
  5544     }
       
  5545   }
       
  5546 //#endif
       
  5547 
       
  5548   /* Flush as much pending output as possible */
       
  5549   if (s.pending !== 0) {
       
  5550     flush_pending(strm);
       
  5551     if (strm.avail_out === 0) {
       
  5552       /* Since avail_out is 0, deflate will be called again with
       
  5553        * more output space, but possibly with both pending and
       
  5554        * avail_in equal to zero. There won't be anything to do,
       
  5555        * but this is not an error situation so make sure we
       
  5556        * return OK instead of BUF_ERROR at next call of deflate:
       
  5557        */
       
  5558       s.last_flush = -1;
       
  5559       return Z_OK;
       
  5560     }
       
  5561 
       
  5562     /* Make sure there is something to do and avoid duplicate consecutive
       
  5563      * flushes. For repeated and useless calls with Z_FINISH, we keep
       
  5564      * returning Z_STREAM_END instead of Z_BUF_ERROR.
       
  5565      */
       
  5566   } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
       
  5567     flush !== Z_FINISH) {
       
  5568     return err(strm, Z_BUF_ERROR);
       
  5569   }
       
  5570 
       
  5571   /* User must not provide more input after the first FINISH: */
       
  5572   if (s.status === FINISH_STATE && strm.avail_in !== 0) {
       
  5573     return err(strm, Z_BUF_ERROR);
       
  5574   }
       
  5575 
       
  5576   /* Start a new block or continue the current one.
       
  5577    */
       
  5578   if (strm.avail_in !== 0 || s.lookahead !== 0 ||
       
  5579     (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {
       
  5580     var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) :
       
  5581       (s.strategy === Z_RLE ? deflate_rle(s, flush) :
       
  5582         configuration_table[s.level].func(s, flush));
       
  5583 
       
  5584     if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
       
  5585       s.status = FINISH_STATE;
       
  5586     }
       
  5587     if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
       
  5588       if (strm.avail_out === 0) {
       
  5589         s.last_flush = -1;
       
  5590         /* avoid BUF_ERROR next call, see above */
       
  5591       }
       
  5592       return Z_OK;
       
  5593       /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
       
  5594        * of deflate should use the same flush parameter to make sure
       
  5595        * that the flush is complete. So we don't have to output an
       
  5596        * empty block here, this will be done at next call. This also
       
  5597        * ensures that for a very small output buffer, we emit at most
       
  5598        * one empty block.
       
  5599        */
       
  5600     }
       
  5601     if (bstate === BS_BLOCK_DONE) {
       
  5602       if (flush === Z_PARTIAL_FLUSH) {
       
  5603         trees._tr_align(s);
       
  5604       }
       
  5605       else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
       
  5606 
       
  5607         trees._tr_stored_block(s, 0, 0, false);
       
  5608         /* For a full flush, this empty block will be recognized
       
  5609          * as a special marker by inflate_sync().
       
  5610          */
       
  5611         if (flush === Z_FULL_FLUSH) {
       
  5612           /*** CLEAR_HASH(s); ***/             /* forget history */
       
  5613           zero(s.head); // Fill with NIL (= 0);
       
  5614 
       
  5615           if (s.lookahead === 0) {
       
  5616             s.strstart = 0;
       
  5617             s.block_start = 0;
       
  5618             s.insert = 0;
       
  5619           }
       
  5620         }
       
  5621       }
       
  5622       flush_pending(strm);
       
  5623       if (strm.avail_out === 0) {
       
  5624         s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */
       
  5625         return Z_OK;
       
  5626       }
       
  5627     }
       
  5628   }
       
  5629   //Assert(strm->avail_out > 0, "bug2");
       
  5630   //if (strm.avail_out <= 0) { throw new Error("bug2");}
       
  5631 
       
  5632   if (flush !== Z_FINISH) { return Z_OK; }
       
  5633   if (s.wrap <= 0) { return Z_STREAM_END; }
       
  5634 
       
  5635   /* Write the trailer */
       
  5636   if (s.wrap === 2) {
       
  5637     put_byte(s, strm.adler & 0xff);
       
  5638     put_byte(s, (strm.adler >> 8) & 0xff);
       
  5639     put_byte(s, (strm.adler >> 16) & 0xff);
       
  5640     put_byte(s, (strm.adler >> 24) & 0xff);
       
  5641     put_byte(s, strm.total_in & 0xff);
       
  5642     put_byte(s, (strm.total_in >> 8) & 0xff);
       
  5643     put_byte(s, (strm.total_in >> 16) & 0xff);
       
  5644     put_byte(s, (strm.total_in >> 24) & 0xff);
       
  5645   }
       
  5646   else
       
  5647   {
       
  5648     putShortMSB(s, strm.adler >>> 16);
       
  5649     putShortMSB(s, strm.adler & 0xffff);
       
  5650   }
       
  5651 
       
  5652   flush_pending(strm);
       
  5653   /* If avail_out is zero, the application will call deflate again
       
  5654    * to flush the rest.
       
  5655    */
       
  5656   if (s.wrap > 0) { s.wrap = -s.wrap; }
       
  5657   /* write the trailer only once! */
       
  5658   return s.pending !== 0 ? Z_OK : Z_STREAM_END;
       
  5659 }
       
  5660 
       
  5661 function deflateEnd(strm) {
       
  5662   var status;
       
  5663 
       
  5664   if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
       
  5665     return Z_STREAM_ERROR;
       
  5666   }
       
  5667 
       
  5668   status = strm.state.status;
       
  5669   if (status !== INIT_STATE &&
       
  5670     status !== EXTRA_STATE &&
       
  5671     status !== NAME_STATE &&
       
  5672     status !== COMMENT_STATE &&
       
  5673     status !== HCRC_STATE &&
       
  5674     status !== BUSY_STATE &&
       
  5675     status !== FINISH_STATE
       
  5676   ) {
       
  5677     return err(strm, Z_STREAM_ERROR);
       
  5678   }
       
  5679 
       
  5680   strm.state = null;
       
  5681 
       
  5682   return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
       
  5683 }
       
  5684 
       
  5685 /* =========================================================================
       
  5686  * Copy the source state to the destination state
       
  5687  */
       
  5688 //function deflateCopy(dest, source) {
       
  5689 //
       
  5690 //}
       
  5691 
       
  5692 exports.deflateInit = deflateInit;
       
  5693 exports.deflateInit2 = deflateInit2;
       
  5694 exports.deflateReset = deflateReset;
       
  5695 exports.deflateResetKeep = deflateResetKeep;
       
  5696 exports.deflateSetHeader = deflateSetHeader;
       
  5697 exports.deflate = deflate;
       
  5698 exports.deflateEnd = deflateEnd;
       
  5699 exports.deflateInfo = 'pako deflate (from Nodeca project)';
       
  5700 
       
  5701 /* Not implemented
       
  5702 exports.deflateBound = deflateBound;
       
  5703 exports.deflateCopy = deflateCopy;
       
  5704 exports.deflateSetDictionary = deflateSetDictionary;
       
  5705 exports.deflateParams = deflateParams;
       
  5706 exports.deflatePending = deflatePending;
       
  5707 exports.deflatePrime = deflatePrime;
       
  5708 exports.deflateTune = deflateTune;
       
  5709 */
       
  5710 },{"../utils/common":27,"./adler32":29,"./crc32":31,"./messages":37,"./trees":38}],33:[function(_dereq_,module,exports){
       
  5711 'use strict';
       
  5712 
       
  5713 
       
  5714 function GZheader() {
       
  5715   /* true if compressed data believed to be text */
       
  5716   this.text       = 0;
       
  5717   /* modification time */
       
  5718   this.time       = 0;
       
  5719   /* extra flags (not used when writing a gzip file) */
       
  5720   this.xflags     = 0;
       
  5721   /* operating system */
       
  5722   this.os         = 0;
       
  5723   /* pointer to extra field or Z_NULL if none */
       
  5724   this.extra      = null;
       
  5725   /* extra field length (valid if extra != Z_NULL) */
       
  5726   this.extra_len  = 0; // Actually, we don't need it in JS,
       
  5727                        // but leave for few code modifications
       
  5728 
       
  5729   //
       
  5730   // Setup limits is not necessary because in js we should not preallocate memory 
       
  5731   // for inflate use constant limit in 65536 bytes
       
  5732   //
       
  5733 
       
  5734   /* space at extra (only when reading header) */
       
  5735   // this.extra_max  = 0;
       
  5736   /* pointer to zero-terminated file name or Z_NULL */
       
  5737   this.name       = '';
       
  5738   /* space at name (only when reading header) */
       
  5739   // this.name_max   = 0;
       
  5740   /* pointer to zero-terminated comment or Z_NULL */
       
  5741   this.comment    = '';
       
  5742   /* space at comment (only when reading header) */
       
  5743   // this.comm_max   = 0;
       
  5744   /* true if there was or will be a header crc */
       
  5745   this.hcrc       = 0;
       
  5746   /* true when done reading gzip header (not used when writing a gzip file) */
       
  5747   this.done       = false;
       
  5748 }
       
  5749 
       
  5750 module.exports = GZheader;
       
  5751 },{}],34:[function(_dereq_,module,exports){
       
  5752 'use strict';
       
  5753 
       
  5754 // See state defs from inflate.js
       
  5755 var BAD = 30;       /* got a data error -- remain here until reset */
       
  5756 var TYPE = 12;      /* i: waiting for type bits, including last-flag bit */
       
  5757 
       
  5758 /*
       
  5759    Decode literal, length, and distance codes and write out the resulting
       
  5760    literal and match bytes until either not enough input or output is
       
  5761    available, an end-of-block is encountered, or a data error is encountered.
       
  5762    When large enough input and output buffers are supplied to inflate(), for
       
  5763    example, a 16K input buffer and a 64K output buffer, more than 95% of the
       
  5764    inflate execution time is spent in this routine.
       
  5765 
       
  5766    Entry assumptions:
       
  5767 
       
  5768         state.mode === LEN
       
  5769         strm.avail_in >= 6
       
  5770         strm.avail_out >= 258
       
  5771         start >= strm.avail_out
       
  5772         state.bits < 8
       
  5773 
       
  5774    On return, state.mode is one of:
       
  5775 
       
  5776         LEN -- ran out of enough output space or enough available input
       
  5777         TYPE -- reached end of block code, inflate() to interpret next block
       
  5778         BAD -- error in block data
       
  5779 
       
  5780    Notes:
       
  5781 
       
  5782     - The maximum input bits used by a length/distance pair is 15 bits for the
       
  5783       length code, 5 bits for the length extra, 15 bits for the distance code,
       
  5784       and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
       
  5785       Therefore if strm.avail_in >= 6, then there is enough input to avoid
       
  5786       checking for available input while decoding.
       
  5787 
       
  5788     - The maximum bytes that a single length/distance pair can output is 258
       
  5789       bytes, which is the maximum length that can be coded.  inflate_fast()
       
  5790       requires strm.avail_out >= 258 for each loop to avoid checking for
       
  5791       output space.
       
  5792  */
       
  5793 module.exports = function inflate_fast(strm, start) {
       
  5794   var state;
       
  5795   var _in;                    /* local strm.input */
       
  5796   var last;                   /* have enough input while in < last */
       
  5797   var _out;                   /* local strm.output */
       
  5798   var beg;                    /* inflate()'s initial strm.output */
       
  5799   var end;                    /* while out < end, enough space available */
       
  5800 //#ifdef INFLATE_STRICT
       
  5801   var dmax;                   /* maximum distance from zlib header */
       
  5802 //#endif
       
  5803   var wsize;                  /* window size or zero if not using window */
       
  5804   var whave;                  /* valid bytes in the window */
       
  5805   var wnext;                  /* window write index */
       
  5806   var window;                 /* allocated sliding window, if wsize != 0 */
       
  5807   var hold;                   /* local strm.hold */
       
  5808   var bits;                   /* local strm.bits */
       
  5809   var lcode;                  /* local strm.lencode */
       
  5810   var dcode;                  /* local strm.distcode */
       
  5811   var lmask;                  /* mask for first level of length codes */
       
  5812   var dmask;                  /* mask for first level of distance codes */
       
  5813   var here;                   /* retrieved table entry */
       
  5814   var op;                     /* code bits, operation, extra bits, or */
       
  5815                               /*  window position, window bytes to copy */
       
  5816   var len;                    /* match length, unused bytes */
       
  5817   var dist;                   /* match distance */
       
  5818   var from;                   /* where to copy match from */
       
  5819   var from_source;
       
  5820 
       
  5821 
       
  5822   var input, output; // JS specific, because we have no pointers
       
  5823 
       
  5824   /* copy state to local variables */
       
  5825   state = strm.state;
       
  5826   //here = state.here;
       
  5827   _in = strm.next_in;
       
  5828   input = strm.input;
       
  5829   last = _in + (strm.avail_in - 5);
       
  5830   _out = strm.next_out;
       
  5831   output = strm.output;
       
  5832   beg = _out - (start - strm.avail_out);
       
  5833   end = _out + (strm.avail_out - 257);
       
  5834 //#ifdef INFLATE_STRICT
       
  5835   dmax = state.dmax;
       
  5836 //#endif
       
  5837   wsize = state.wsize;
       
  5838   whave = state.whave;
       
  5839   wnext = state.wnext;
       
  5840   window = state.window;
       
  5841   hold = state.hold;
       
  5842   bits = state.bits;
       
  5843   lcode = state.lencode;
       
  5844   dcode = state.distcode;
       
  5845   lmask = (1 << state.lenbits) - 1;
       
  5846   dmask = (1 << state.distbits) - 1;
       
  5847 
       
  5848 
       
  5849   /* decode literals and length/distances until end-of-block or not enough
       
  5850      input data or output space */
       
  5851 
       
  5852   top:
       
  5853   do {
       
  5854     if (bits < 15) {
       
  5855       hold += input[_in++] << bits;
       
  5856       bits += 8;
       
  5857       hold += input[_in++] << bits;
       
  5858       bits += 8;
       
  5859     }
       
  5860 
       
  5861     here = lcode[hold & lmask];
       
  5862 
       
  5863     dolen:
       
  5864     for (;;) { // Goto emulation
       
  5865       op = here >>> 24/*here.bits*/;
       
  5866       hold >>>= op;
       
  5867       bits -= op;
       
  5868       op = (here >>> 16) & 0xff/*here.op*/;
       
  5869       if (op === 0) {                          /* literal */
       
  5870         //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
       
  5871         //        "inflate:         literal '%c'\n" :
       
  5872         //        "inflate:         literal 0x%02x\n", here.val));
       
  5873         output[_out++] = here & 0xffff/*here.val*/;
       
  5874       }
       
  5875       else if (op & 16) {                     /* length base */
       
  5876         len = here & 0xffff/*here.val*/;
       
  5877         op &= 15;                           /* number of extra bits */
       
  5878         if (op) {
       
  5879           if (bits < op) {
       
  5880             hold += input[_in++] << bits;
       
  5881             bits += 8;
       
  5882           }
       
  5883           len += hold & ((1 << op) - 1);
       
  5884           hold >>>= op;
       
  5885           bits -= op;
       
  5886         }
       
  5887         //Tracevv((stderr, "inflate:         length %u\n", len));
       
  5888         if (bits < 15) {
       
  5889           hold += input[_in++] << bits;
       
  5890           bits += 8;
       
  5891           hold += input[_in++] << bits;
       
  5892           bits += 8;
       
  5893         }
       
  5894         here = dcode[hold & dmask];
       
  5895 
       
  5896         dodist:
       
  5897         for (;;) { // goto emulation
       
  5898           op = here >>> 24/*here.bits*/;
       
  5899           hold >>>= op;
       
  5900           bits -= op;
       
  5901           op = (here >>> 16) & 0xff/*here.op*/;
       
  5902 
       
  5903           if (op & 16) {                      /* distance base */
       
  5904             dist = here & 0xffff/*here.val*/;
       
  5905             op &= 15;                       /* number of extra bits */
       
  5906             if (bits < op) {
       
  5907               hold += input[_in++] << bits;
       
  5908               bits += 8;
       
  5909               if (bits < op) {
       
  5910                 hold += input[_in++] << bits;
       
  5911                 bits += 8;
       
  5912               }
       
  5913             }
       
  5914             dist += hold & ((1 << op) - 1);
       
  5915 //#ifdef INFLATE_STRICT
       
  5916             if (dist > dmax) {
       
  5917               strm.msg = 'invalid distance too far back';
       
  5918               state.mode = BAD;
       
  5919               break top;
       
  5920             }
       
  5921 //#endif
       
  5922             hold >>>= op;
       
  5923             bits -= op;
       
  5924             //Tracevv((stderr, "inflate:         distance %u\n", dist));
       
  5925             op = _out - beg;                /* max distance in output */
       
  5926             if (dist > op) {                /* see if copy from window */
       
  5927               op = dist - op;               /* distance back in window */
       
  5928               if (op > whave) {
       
  5929                 if (state.sane) {
       
  5930                   strm.msg = 'invalid distance too far back';
       
  5931                   state.mode = BAD;
       
  5932                   break top;
       
  5933                 }
       
  5934 
       
  5935 // (!) This block is disabled in zlib defailts,
       
  5936 // don't enable it for binary compatibility
       
  5937 //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
       
  5938 //                if (len <= op - whave) {
       
  5939 //                  do {
       
  5940 //                    output[_out++] = 0;
       
  5941 //                  } while (--len);
       
  5942 //                  continue top;
       
  5943 //                }
       
  5944 //                len -= op - whave;
       
  5945 //                do {
       
  5946 //                  output[_out++] = 0;
       
  5947 //                } while (--op > whave);
       
  5948 //                if (op === 0) {
       
  5949 //                  from = _out - dist;
       
  5950 //                  do {
       
  5951 //                    output[_out++] = output[from++];
       
  5952 //                  } while (--len);
       
  5953 //                  continue top;
       
  5954 //                }
       
  5955 //#endif
       
  5956               }
       
  5957               from = 0; // window index
       
  5958               from_source = window;
       
  5959               if (wnext === 0) {           /* very common case */
       
  5960                 from += wsize - op;
       
  5961                 if (op < len) {         /* some from window */
       
  5962                   len -= op;
       
  5963                   do {
       
  5964                     output[_out++] = window[from++];
       
  5965                   } while (--op);
       
  5966                   from = _out - dist;  /* rest from output */
       
  5967                   from_source = output;
       
  5968                 }
       
  5969               }
       
  5970               else if (wnext < op) {      /* wrap around window */
       
  5971                 from += wsize + wnext - op;
       
  5972                 op -= wnext;
       
  5973                 if (op < len) {         /* some from end of window */
       
  5974                   len -= op;
       
  5975                   do {
       
  5976                     output[_out++] = window[from++];
       
  5977                   } while (--op);
       
  5978                   from = 0;
       
  5979                   if (wnext < len) {  /* some from start of window */
       
  5980                     op = wnext;
       
  5981                     len -= op;
       
  5982                     do {
       
  5983                       output[_out++] = window[from++];
       
  5984                     } while (--op);
       
  5985                     from = _out - dist;      /* rest from output */
       
  5986                     from_source = output;
       
  5987                   }
       
  5988                 }
       
  5989               }
       
  5990               else {                      /* contiguous in window */
       
  5991                 from += wnext - op;
       
  5992                 if (op < len) {         /* some from window */
       
  5993                   len -= op;
       
  5994                   do {
       
  5995                     output[_out++] = window[from++];
       
  5996                   } while (--op);
       
  5997                   from = _out - dist;  /* rest from output */
       
  5998                   from_source = output;
       
  5999                 }
       
  6000               }
       
  6001               while (len > 2) {
       
  6002                 output[_out++] = from_source[from++];
       
  6003                 output[_out++] = from_source[from++];
       
  6004                 output[_out++] = from_source[from++];
       
  6005                 len -= 3;
       
  6006               }
       
  6007               if (len) {
       
  6008                 output[_out++] = from_source[from++];
       
  6009                 if (len > 1) {
       
  6010                   output[_out++] = from_source[from++];
       
  6011                 }
       
  6012               }
       
  6013             }
       
  6014             else {
       
  6015               from = _out - dist;          /* copy direct from output */
       
  6016               do {                        /* minimum length is three */
       
  6017                 output[_out++] = output[from++];
       
  6018                 output[_out++] = output[from++];
       
  6019                 output[_out++] = output[from++];
       
  6020                 len -= 3;
       
  6021               } while (len > 2);
       
  6022               if (len) {
       
  6023                 output[_out++] = output[from++];
       
  6024                 if (len > 1) {
       
  6025                   output[_out++] = output[from++];
       
  6026                 }
       
  6027               }
       
  6028             }
       
  6029           }
       
  6030           else if ((op & 64) === 0) {          /* 2nd level distance code */
       
  6031             here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
       
  6032             continue dodist;
       
  6033           }
       
  6034           else {
       
  6035             strm.msg = 'invalid distance code';
       
  6036             state.mode = BAD;
       
  6037             break top;
       
  6038           }
       
  6039 
       
  6040           break; // need to emulate goto via "continue"
       
  6041         }
       
  6042       }
       
  6043       else if ((op & 64) === 0) {              /* 2nd level length code */
       
  6044         here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
       
  6045         continue dolen;
       
  6046       }
       
  6047       else if (op & 32) {                     /* end-of-block */
       
  6048         //Tracevv((stderr, "inflate:         end of block\n"));
       
  6049         state.mode = TYPE;
       
  6050         break top;
       
  6051       }
       
  6052       else {
       
  6053         strm.msg = 'invalid literal/length code';
       
  6054         state.mode = BAD;
       
  6055         break top;
       
  6056       }
       
  6057 
       
  6058       break; // need to emulate goto via "continue"
       
  6059     }
       
  6060   } while (_in < last && _out < end);
       
  6061 
       
  6062   /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
       
  6063   len = bits >> 3;
       
  6064   _in -= len;
       
  6065   bits -= len << 3;
       
  6066   hold &= (1 << bits) - 1;
       
  6067 
       
  6068   /* update state and return */
       
  6069   strm.next_in = _in;
       
  6070   strm.next_out = _out;
       
  6071   strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
       
  6072   strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
       
  6073   state.hold = hold;
       
  6074   state.bits = bits;
       
  6075   return;
       
  6076 };
       
  6077 
       
  6078 },{}],35:[function(_dereq_,module,exports){
       
  6079 'use strict';
       
  6080 
       
  6081 
       
  6082 var utils = _dereq_('../utils/common');
       
  6083 var adler32 = _dereq_('./adler32');
       
  6084 var crc32   = _dereq_('./crc32');
       
  6085 var inflate_fast = _dereq_('./inffast');
       
  6086 var inflate_table = _dereq_('./inftrees');
       
  6087 
       
  6088 var CODES = 0;
       
  6089 var LENS = 1;
       
  6090 var DISTS = 2;
       
  6091 
       
  6092 /* Public constants ==========================================================*/
       
  6093 /* ===========================================================================*/
       
  6094 
       
  6095 
       
  6096 /* Allowed flush values; see deflate() and inflate() below for details */
       
  6097 //var Z_NO_FLUSH      = 0;
       
  6098 //var Z_PARTIAL_FLUSH = 1;
       
  6099 //var Z_SYNC_FLUSH    = 2;
       
  6100 //var Z_FULL_FLUSH    = 3;
       
  6101 var Z_FINISH        = 4;
       
  6102 var Z_BLOCK         = 5;
       
  6103 var Z_TREES         = 6;
       
  6104 
       
  6105 
       
  6106 /* Return codes for the compression/decompression functions. Negative values
       
  6107  * are errors, positive values are used for special but normal events.
       
  6108  */
       
  6109 var Z_OK            = 0;
       
  6110 var Z_STREAM_END    = 1;
       
  6111 var Z_NEED_DICT     = 2;
       
  6112 //var Z_ERRNO         = -1;
       
  6113 var Z_STREAM_ERROR  = -2;
       
  6114 var Z_DATA_ERROR    = -3;
       
  6115 var Z_MEM_ERROR     = -4;
       
  6116 var Z_BUF_ERROR     = -5;
       
  6117 //var Z_VERSION_ERROR = -6;
       
  6118 
       
  6119 /* The deflate compression method */
       
  6120 var Z_DEFLATED  = 8;
       
  6121 
       
  6122 
       
  6123 /* STATES ====================================================================*/
       
  6124 /* ===========================================================================*/
       
  6125 
       
  6126 
       
  6127 var    HEAD = 1;       /* i: waiting for magic header */
       
  6128 var    FLAGS = 2;      /* i: waiting for method and flags (gzip) */
       
  6129 var    TIME = 3;       /* i: waiting for modification time (gzip) */
       
  6130 var    OS = 4;         /* i: waiting for extra flags and operating system (gzip) */
       
  6131 var    EXLEN = 5;      /* i: waiting for extra length (gzip) */
       
  6132 var    EXTRA = 6;      /* i: waiting for extra bytes (gzip) */
       
  6133 var    NAME = 7;       /* i: waiting for end of file name (gzip) */
       
  6134 var    COMMENT = 8;    /* i: waiting for end of comment (gzip) */
       
  6135 var    HCRC = 9;       /* i: waiting for header crc (gzip) */
       
  6136 var    DICTID = 10;    /* i: waiting for dictionary check value */
       
  6137 var    DICT = 11;      /* waiting for inflateSetDictionary() call */
       
  6138 var        TYPE = 12;      /* i: waiting for type bits, including last-flag bit */
       
  6139 var        TYPEDO = 13;    /* i: same, but skip check to exit inflate on new block */
       
  6140 var        STORED = 14;    /* i: waiting for stored size (length and complement) */
       
  6141 var        COPY_ = 15;     /* i/o: same as COPY below, but only first time in */
       
  6142 var        COPY = 16;      /* i/o: waiting for input or output to copy stored block */
       
  6143 var        TABLE = 17;     /* i: waiting for dynamic block table lengths */
       
  6144 var        LENLENS = 18;   /* i: waiting for code length code lengths */
       
  6145 var        CODELENS = 19;  /* i: waiting for length/lit and distance code lengths */
       
  6146 var            LEN_ = 20;      /* i: same as LEN below, but only first time in */
       
  6147 var            LEN = 21;       /* i: waiting for length/lit/eob code */
       
  6148 var            LENEXT = 22;    /* i: waiting for length extra bits */
       
  6149 var            DIST = 23;      /* i: waiting for distance code */
       
  6150 var            DISTEXT = 24;   /* i: waiting for distance extra bits */
       
  6151 var            MATCH = 25;     /* o: waiting for output space to copy string */
       
  6152 var            LIT = 26;       /* o: waiting for output space to write literal */
       
  6153 var    CHECK = 27;     /* i: waiting for 32-bit check value */
       
  6154 var    LENGTH = 28;    /* i: waiting for 32-bit length (gzip) */
       
  6155 var    DONE = 29;      /* finished check, done -- remain here until reset */
       
  6156 var    BAD = 30;       /* got a data error -- remain here until reset */
       
  6157 var    MEM = 31;       /* got an inflate() memory error -- remain here until reset */
       
  6158 var    SYNC = 32;      /* looking for synchronization bytes to restart inflate() */
       
  6159 
       
  6160 /* ===========================================================================*/
       
  6161 
       
  6162 
       
  6163 
       
  6164 var ENOUGH_LENS = 852;
       
  6165 var ENOUGH_DISTS = 592;
       
  6166 //var ENOUGH =  (ENOUGH_LENS+ENOUGH_DISTS);
       
  6167 
       
  6168 var MAX_WBITS = 15;
       
  6169 /* 32K LZ77 window */
       
  6170 var DEF_WBITS = MAX_WBITS;
       
  6171 
       
  6172 
       
  6173 function ZSWAP32(q) {
       
  6174   return  (((q >>> 24) & 0xff) +
       
  6175           ((q >>> 8) & 0xff00) +
       
  6176           ((q & 0xff00) << 8) +
       
  6177           ((q & 0xff) << 24));
       
  6178 }
       
  6179 
       
  6180 
       
  6181 function InflateState() {
       
  6182   this.mode = 0;             /* current inflate mode */
       
  6183   this.last = false;          /* true if processing last block */
       
  6184   this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */
       
  6185   this.havedict = false;      /* true if dictionary provided */
       
  6186   this.flags = 0;             /* gzip header method and flags (0 if zlib) */
       
  6187   this.dmax = 0;              /* zlib header max distance (INFLATE_STRICT) */
       
  6188   this.check = 0;             /* protected copy of check value */
       
  6189   this.total = 0;             /* protected copy of output count */
       
  6190   // TODO: may be {}
       
  6191   this.head = null;           /* where to save gzip header information */
       
  6192 
       
  6193   /* sliding window */
       
  6194   this.wbits = 0;             /* log base 2 of requested window size */
       
  6195   this.wsize = 0;             /* window size or zero if not using window */
       
  6196   this.whave = 0;             /* valid bytes in the window */
       
  6197   this.wnext = 0;             /* window write index */
       
  6198   this.window = null;         /* allocated sliding window, if needed */
       
  6199 
       
  6200   /* bit accumulator */
       
  6201   this.hold = 0;              /* input bit accumulator */
       
  6202   this.bits = 0;              /* number of bits in "in" */
       
  6203 
       
  6204   /* for string and stored block copying */
       
  6205   this.length = 0;            /* literal or length of data to copy */
       
  6206   this.offset = 0;            /* distance back to copy string from */
       
  6207 
       
  6208   /* for table and code decoding */
       
  6209   this.extra = 0;             /* extra bits needed */
       
  6210 
       
  6211   /* fixed and dynamic code tables */
       
  6212   this.lencode = null;          /* starting table for length/literal codes */
       
  6213   this.distcode = null;         /* starting table for distance codes */
       
  6214   this.lenbits = 0;           /* index bits for lencode */
       
  6215   this.distbits = 0;          /* index bits for distcode */
       
  6216 
       
  6217   /* dynamic table building */
       
  6218   this.ncode = 0;             /* number of code length code lengths */
       
  6219   this.nlen = 0;              /* number of length code lengths */
       
  6220   this.ndist = 0;             /* number of distance code lengths */
       
  6221   this.have = 0;              /* number of code lengths in lens[] */
       
  6222   this.next = null;              /* next available space in codes[] */
       
  6223 
       
  6224   this.lens = new utils.Buf16(320); /* temporary storage for code lengths */
       
  6225   this.work = new utils.Buf16(288); /* work area for code table building */
       
  6226 
       
  6227   /*
       
  6228    because we don't have pointers in js, we use lencode and distcode directly
       
  6229    as buffers so we don't need codes
       
  6230   */
       
  6231   //this.codes = new utils.Buf32(ENOUGH);       /* space for code tables */
       
  6232   this.lendyn = null;              /* dynamic table for length/literal codes (JS specific) */
       
  6233   this.distdyn = null;             /* dynamic table for distance codes (JS specific) */
       
  6234   this.sane = 0;                   /* if false, allow invalid distance too far */
       
  6235   this.back = 0;                   /* bits back of last unprocessed length/lit */
       
  6236   this.was = 0;                    /* initial length of match */
       
  6237 }
       
  6238 
       
  6239 function inflateResetKeep(strm) {
       
  6240   var state;
       
  6241 
       
  6242   if (!strm || !strm.state) { return Z_STREAM_ERROR; }
       
  6243   state = strm.state;
       
  6244   strm.total_in = strm.total_out = state.total = 0;
       
  6245   strm.msg = ''; /*Z_NULL*/
       
  6246   if (state.wrap) {       /* to support ill-conceived Java test suite */
       
  6247     strm.adler = state.wrap & 1;
       
  6248   }
       
  6249   state.mode = HEAD;
       
  6250   state.last = 0;
       
  6251   state.havedict = 0;
       
  6252   state.dmax = 32768;
       
  6253   state.head = null/*Z_NULL*/;
       
  6254   state.hold = 0;
       
  6255   state.bits = 0;
       
  6256   //state.lencode = state.distcode = state.next = state.codes;
       
  6257   state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
       
  6258   state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
       
  6259 
       
  6260   state.sane = 1;
       
  6261   state.back = -1;
       
  6262   //Tracev((stderr, "inflate: reset\n"));
       
  6263   return Z_OK;
       
  6264 }
       
  6265 
       
  6266 function inflateReset(strm) {
       
  6267   var state;
       
  6268 
       
  6269   if (!strm || !strm.state) { return Z_STREAM_ERROR; }
       
  6270   state = strm.state;
       
  6271   state.wsize = 0;
       
  6272   state.whave = 0;
       
  6273   state.wnext = 0;
       
  6274   return inflateResetKeep(strm);
       
  6275 
       
  6276 }
       
  6277 
       
  6278 function inflateReset2(strm, windowBits) {
       
  6279   var wrap;
       
  6280   var state;
       
  6281 
       
  6282   /* get the state */
       
  6283   if (!strm || !strm.state) { return Z_STREAM_ERROR; }
       
  6284   state = strm.state;
       
  6285 
       
  6286   /* extract wrap request from windowBits parameter */
       
  6287   if (windowBits < 0) {
       
  6288     wrap = 0;
       
  6289     windowBits = -windowBits;
       
  6290   }
       
  6291   else {
       
  6292     wrap = (windowBits >> 4) + 1;
       
  6293     if (windowBits < 48) {
       
  6294       windowBits &= 15;
       
  6295     }
       
  6296   }
       
  6297 
       
  6298   /* set number of window bits, free window if different */
       
  6299   if (windowBits && (windowBits < 8 || windowBits > 15)) {
       
  6300     return Z_STREAM_ERROR;
       
  6301   }
       
  6302   if (state.window !== null && state.wbits !== windowBits) {
       
  6303     state.window = null;
       
  6304   }
       
  6305 
       
  6306   /* update state and reset the rest of it */
       
  6307   state.wrap = wrap;
       
  6308   state.wbits = windowBits;
       
  6309   return inflateReset(strm);
       
  6310 }
       
  6311 
       
  6312 function inflateInit2(strm, windowBits) {
       
  6313   var ret;
       
  6314   var state;
       
  6315 
       
  6316   if (!strm) { return Z_STREAM_ERROR; }
       
  6317   //strm.msg = Z_NULL;                 /* in case we return an error */
       
  6318 
       
  6319   state = new InflateState();
       
  6320 
       
  6321   //if (state === Z_NULL) return Z_MEM_ERROR;
       
  6322   //Tracev((stderr, "inflate: allocated\n"));
       
  6323   strm.state = state;
       
  6324   state.window = null/*Z_NULL*/;
       
  6325   ret = inflateReset2(strm, windowBits);
       
  6326   if (ret !== Z_OK) {
       
  6327     strm.state = null/*Z_NULL*/;
       
  6328   }
       
  6329   return ret;
       
  6330 }
       
  6331 
       
  6332 function inflateInit(strm) {
       
  6333   return inflateInit2(strm, DEF_WBITS);
       
  6334 }
       
  6335 
       
  6336 
       
  6337 /*
       
  6338  Return state with length and distance decoding tables and index sizes set to
       
  6339  fixed code decoding.  Normally this returns fixed tables from inffixed.h.
       
  6340  If BUILDFIXED is defined, then instead this routine builds the tables the
       
  6341  first time it's called, and returns those tables the first time and
       
  6342  thereafter.  This reduces the size of the code by about 2K bytes, in
       
  6343  exchange for a little execution time.  However, BUILDFIXED should not be
       
  6344  used for threaded applications, since the rewriting of the tables and virgin
       
  6345  may not be thread-safe.
       
  6346  */
       
  6347 var virgin = true;
       
  6348 
       
  6349 var lenfix, distfix; // We have no pointers in JS, so keep tables separate
       
  6350 
       
  6351 function fixedtables(state) {
       
  6352   /* build fixed huffman tables if first call (may not be thread safe) */
       
  6353   if (virgin) {
       
  6354     var sym;
       
  6355 
       
  6356     lenfix = new utils.Buf32(512);
       
  6357     distfix = new utils.Buf32(32);
       
  6358 
       
  6359     /* literal/length table */
       
  6360     sym = 0;
       
  6361     while (sym < 144) { state.lens[sym++] = 8; }
       
  6362     while (sym < 256) { state.lens[sym++] = 9; }
       
  6363     while (sym < 280) { state.lens[sym++] = 7; }
       
  6364     while (sym < 288) { state.lens[sym++] = 8; }
       
  6365 
       
  6366     inflate_table(LENS,  state.lens, 0, 288, lenfix,   0, state.work, {bits: 9});
       
  6367 
       
  6368     /* distance table */
       
  6369     sym = 0;
       
  6370     while (sym < 32) { state.lens[sym++] = 5; }
       
  6371 
       
  6372     inflate_table(DISTS, state.lens, 0, 32,   distfix, 0, state.work, {bits: 5});
       
  6373 
       
  6374     /* do this just once */
       
  6375     virgin = false;
       
  6376   }
       
  6377 
       
  6378   state.lencode = lenfix;
       
  6379   state.lenbits = 9;
       
  6380   state.distcode = distfix;
       
  6381   state.distbits = 5;
       
  6382 }
       
  6383 
       
  6384 
       
  6385 /*
       
  6386  Update the window with the last wsize (normally 32K) bytes written before
       
  6387  returning.  If window does not exist yet, create it.  This is only called
       
  6388  when a window is already in use, or when output has been written during this
       
  6389  inflate call, but the end of the deflate stream has not been reached yet.
       
  6390  It is also called to create a window for dictionary data when a dictionary
       
  6391  is loaded.
       
  6392 
       
  6393  Providing output buffers larger than 32K to inflate() should provide a speed
       
  6394  advantage, since only the last 32K of output is copied to the sliding window
       
  6395  upon return from inflate(), and since all distances after the first 32K of
       
  6396  output will fall in the output data, making match copies simpler and faster.
       
  6397  The advantage may be dependent on the size of the processor's data caches.
       
  6398  */
       
  6399 function updatewindow(strm, src, end, copy) {
       
  6400   var dist;
       
  6401   var state = strm.state;
       
  6402 
       
  6403   /* if it hasn't been done already, allocate space for the window */
       
  6404   if (state.window === null) {
       
  6405     state.wsize = 1 << state.wbits;
       
  6406     state.wnext = 0;
       
  6407     state.whave = 0;
       
  6408 
       
  6409     state.window = new utils.Buf8(state.wsize);
       
  6410   }
       
  6411 
       
  6412   /* copy state->wsize or less output bytes into the circular window */
       
  6413   if (copy >= state.wsize) {
       
  6414     utils.arraySet(state.window,src, end - state.wsize, state.wsize, 0);
       
  6415     state.wnext = 0;
       
  6416     state.whave = state.wsize;
       
  6417   }
       
  6418   else {
       
  6419     dist = state.wsize - state.wnext;
       
  6420     if (dist > copy) {
       
  6421       dist = copy;
       
  6422     }
       
  6423     //zmemcpy(state->window + state->wnext, end - copy, dist);
       
  6424     utils.arraySet(state.window,src, end - copy, dist, state.wnext);
       
  6425     copy -= dist;
       
  6426     if (copy) {
       
  6427       //zmemcpy(state->window, end - copy, copy);
       
  6428       utils.arraySet(state.window,src, end - copy, copy, 0);
       
  6429       state.wnext = copy;
       
  6430       state.whave = state.wsize;
       
  6431     }
       
  6432     else {
       
  6433       state.wnext += dist;
       
  6434       if (state.wnext === state.wsize) { state.wnext = 0; }
       
  6435       if (state.whave < state.wsize) { state.whave += dist; }
       
  6436     }
       
  6437   }
       
  6438   return 0;
       
  6439 }
       
  6440 
       
  6441 function inflate(strm, flush) {
       
  6442   var state;
       
  6443   var input, output;          // input/output buffers
       
  6444   var next;                   /* next input INDEX */
       
  6445   var put;                    /* next output INDEX */
       
  6446   var have, left;             /* available input and output */
       
  6447   var hold;                   /* bit buffer */
       
  6448   var bits;                   /* bits in bit buffer */
       
  6449   var _in, _out;              /* save starting available input and output */
       
  6450   var copy;                   /* number of stored or match bytes to copy */
       
  6451   var from;                   /* where to copy match bytes from */
       
  6452   var from_source;
       
  6453   var here = 0;               /* current decoding table entry */
       
  6454   var here_bits, here_op, here_val; // paked "here" denormalized (JS specific)
       
  6455   //var last;                   /* parent table entry */
       
  6456   var last_bits, last_op, last_val; // paked "last" denormalized (JS specific)
       
  6457   var len;                    /* length to copy for repeats, bits to drop */
       
  6458   var ret;                    /* return code */
       
  6459   var hbuf = new utils.Buf8(4);    /* buffer for gzip header crc calculation */
       
  6460   var opts;
       
  6461 
       
  6462   var n; // temporary var for NEED_BITS
       
  6463 
       
  6464   var order = /* permutation of code lengths */
       
  6465     [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
       
  6466 
       
  6467 
       
  6468   if (!strm || !strm.state || !strm.output ||
       
  6469       (!strm.input && strm.avail_in !== 0)) {
       
  6470     return Z_STREAM_ERROR;
       
  6471   }
       
  6472 
       
  6473   state = strm.state;
       
  6474   if (state.mode === TYPE) { state.mode = TYPEDO; }    /* skip check */
       
  6475 
       
  6476 
       
  6477   //--- LOAD() ---
       
  6478   put = strm.next_out;
       
  6479   output = strm.output;
       
  6480   left = strm.avail_out;
       
  6481   next = strm.next_in;
       
  6482   input = strm.input;
       
  6483   have = strm.avail_in;
       
  6484   hold = state.hold;
       
  6485   bits = state.bits;
       
  6486   //---
       
  6487 
       
  6488   _in = have;
       
  6489   _out = left;
       
  6490   ret = Z_OK;
       
  6491 
       
  6492   inf_leave: // goto emulation
       
  6493   for (;;) {
       
  6494     switch (state.mode) {
       
  6495     case HEAD:
       
  6496       if (state.wrap === 0) {
       
  6497         state.mode = TYPEDO;
       
  6498         break;
       
  6499       }
       
  6500       //=== NEEDBITS(16);
       
  6501       while (bits < 16) {
       
  6502         if (have === 0) { break inf_leave; }
       
  6503         have--;
       
  6504         hold += input[next++] << bits;
       
  6505         bits += 8;
       
  6506       }
       
  6507       //===//
       
  6508       if ((state.wrap & 2) && hold === 0x8b1f) {  /* gzip header */
       
  6509         state.check = 0/*crc32(0L, Z_NULL, 0)*/;
       
  6510         //=== CRC2(state.check, hold);
       
  6511         hbuf[0] = hold & 0xff;
       
  6512         hbuf[1] = (hold >>> 8) & 0xff;
       
  6513         state.check = crc32(state.check, hbuf, 2, 0);
       
  6514         //===//
       
  6515 
       
  6516         //=== INITBITS();
       
  6517         hold = 0;
       
  6518         bits = 0;
       
  6519         //===//
       
  6520         state.mode = FLAGS;
       
  6521         break;
       
  6522       }
       
  6523       state.flags = 0;           /* expect zlib header */
       
  6524       if (state.head) {
       
  6525         state.head.done = false;
       
  6526       }
       
  6527       if (!(state.wrap & 1) ||   /* check if zlib header allowed */
       
  6528         (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {
       
  6529         strm.msg = 'incorrect header check';
       
  6530         state.mode = BAD;
       
  6531         break;
       
  6532       }
       
  6533       if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {
       
  6534         strm.msg = 'unknown compression method';
       
  6535         state.mode = BAD;
       
  6536         break;
       
  6537       }
       
  6538       //--- DROPBITS(4) ---//
       
  6539       hold >>>= 4;
       
  6540       bits -= 4;
       
  6541       //---//
       
  6542       len = (hold & 0x0f)/*BITS(4)*/ + 8;
       
  6543       if (state.wbits === 0) {
       
  6544         state.wbits = len;
       
  6545       }
       
  6546       else if (len > state.wbits) {
       
  6547         strm.msg = 'invalid window size';
       
  6548         state.mode = BAD;
       
  6549         break;
       
  6550       }
       
  6551       state.dmax = 1 << len;
       
  6552       //Tracev((stderr, "inflate:   zlib header ok\n"));
       
  6553       strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
       
  6554       state.mode = hold & 0x200 ? DICTID : TYPE;
       
  6555       //=== INITBITS();
       
  6556       hold = 0;
       
  6557       bits = 0;
       
  6558       //===//
       
  6559       break;
       
  6560     case FLAGS:
       
  6561       //=== NEEDBITS(16); */
       
  6562       while (bits < 16) {
       
  6563         if (have === 0) { break inf_leave; }
       
  6564         have--;
       
  6565         hold += input[next++] << bits;
       
  6566         bits += 8;
       
  6567       }
       
  6568       //===//
       
  6569       state.flags = hold;
       
  6570       if ((state.flags & 0xff) !== Z_DEFLATED) {
       
  6571         strm.msg = 'unknown compression method';
       
  6572         state.mode = BAD;
       
  6573         break;
       
  6574       }
       
  6575       if (state.flags & 0xe000) {
       
  6576         strm.msg = 'unknown header flags set';
       
  6577         state.mode = BAD;
       
  6578         break;
       
  6579       }
       
  6580       if (state.head) {
       
  6581         state.head.text = ((hold >> 8) & 1);
       
  6582       }
       
  6583       if (state.flags & 0x0200) {
       
  6584         //=== CRC2(state.check, hold);
       
  6585         hbuf[0] = hold & 0xff;
       
  6586         hbuf[1] = (hold >>> 8) & 0xff;
       
  6587         state.check = crc32(state.check, hbuf, 2, 0);
       
  6588         //===//
       
  6589       }
       
  6590       //=== INITBITS();
       
  6591       hold = 0;
       
  6592       bits = 0;
       
  6593       //===//
       
  6594       state.mode = TIME;
       
  6595       /* falls through */
       
  6596     case TIME:
       
  6597       //=== NEEDBITS(32); */
       
  6598       while (bits < 32) {
       
  6599         if (have === 0) { break inf_leave; }
       
  6600         have--;
       
  6601         hold += input[next++] << bits;
       
  6602         bits += 8;
       
  6603       }
       
  6604       //===//
       
  6605       if (state.head) {
       
  6606         state.head.time = hold;
       
  6607       }
       
  6608       if (state.flags & 0x0200) {
       
  6609         //=== CRC4(state.check, hold)
       
  6610         hbuf[0] = hold & 0xff;
       
  6611         hbuf[1] = (hold >>> 8) & 0xff;
       
  6612         hbuf[2] = (hold >>> 16) & 0xff;
       
  6613         hbuf[3] = (hold >>> 24) & 0xff;
       
  6614         state.check = crc32(state.check, hbuf, 4, 0);
       
  6615         //===
       
  6616       }
       
  6617       //=== INITBITS();
       
  6618       hold = 0;
       
  6619       bits = 0;
       
  6620       //===//
       
  6621       state.mode = OS;
       
  6622       /* falls through */
       
  6623     case OS:
       
  6624       //=== NEEDBITS(16); */
       
  6625       while (bits < 16) {
       
  6626         if (have === 0) { break inf_leave; }
       
  6627         have--;
       
  6628         hold += input[next++] << bits;
       
  6629         bits += 8;
       
  6630       }
       
  6631       //===//
       
  6632       if (state.head) {
       
  6633         state.head.xflags = (hold & 0xff);
       
  6634         state.head.os = (hold >> 8);
       
  6635       }
       
  6636       if (state.flags & 0x0200) {
       
  6637         //=== CRC2(state.check, hold);
       
  6638         hbuf[0] = hold & 0xff;
       
  6639         hbuf[1] = (hold >>> 8) & 0xff;
       
  6640         state.check = crc32(state.check, hbuf, 2, 0);
       
  6641         //===//
       
  6642       }
       
  6643       //=== INITBITS();
       
  6644       hold = 0;
       
  6645       bits = 0;
       
  6646       //===//
       
  6647       state.mode = EXLEN;
       
  6648       /* falls through */
       
  6649     case EXLEN:
       
  6650       if (state.flags & 0x0400) {
       
  6651         //=== NEEDBITS(16); */
       
  6652         while (bits < 16) {
       
  6653           if (have === 0) { break inf_leave; }
       
  6654           have--;
       
  6655           hold += input[next++] << bits;
       
  6656           bits += 8;
       
  6657         }
       
  6658         //===//
       
  6659         state.length = hold;
       
  6660         if (state.head) {
       
  6661           state.head.extra_len = hold;
       
  6662         }
       
  6663         if (state.flags & 0x0200) {
       
  6664           //=== CRC2(state.check, hold);
       
  6665           hbuf[0] = hold & 0xff;
       
  6666           hbuf[1] = (hold >>> 8) & 0xff;
       
  6667           state.check = crc32(state.check, hbuf, 2, 0);
       
  6668           //===//
       
  6669         }
       
  6670         //=== INITBITS();
       
  6671         hold = 0;
       
  6672         bits = 0;
       
  6673         //===//
       
  6674       }
       
  6675       else if (state.head) {
       
  6676         state.head.extra = null/*Z_NULL*/;
       
  6677       }
       
  6678       state.mode = EXTRA;
       
  6679       /* falls through */
       
  6680     case EXTRA:
       
  6681       if (state.flags & 0x0400) {
       
  6682         copy = state.length;
       
  6683         if (copy > have) { copy = have; }
       
  6684         if (copy) {
       
  6685           if (state.head) {
       
  6686             len = state.head.extra_len - state.length;
       
  6687             if (!state.head.extra) {
       
  6688               // Use untyped array for more conveniend processing later
       
  6689               state.head.extra = new Array(state.head.extra_len);
       
  6690             }
       
  6691             utils.arraySet(
       
  6692               state.head.extra,
       
  6693               input,
       
  6694               next,
       
  6695               // extra field is limited to 65536 bytes
       
  6696               // - no need for additional size check
       
  6697               copy,
       
  6698               /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
       
  6699               len
       
  6700             );
       
  6701             //zmemcpy(state.head.extra + len, next,
       
  6702             //        len + copy > state.head.extra_max ?
       
  6703             //        state.head.extra_max - len : copy);
       
  6704           }
       
  6705           if (state.flags & 0x0200) {
       
  6706             state.check = crc32(state.check, input, copy, next);
       
  6707           }
       
  6708           have -= copy;
       
  6709           next += copy;
       
  6710           state.length -= copy;
       
  6711         }
       
  6712         if (state.length) { break inf_leave; }
       
  6713       }
       
  6714       state.length = 0;
       
  6715       state.mode = NAME;
       
  6716       /* falls through */
       
  6717     case NAME:
       
  6718       if (state.flags & 0x0800) {
       
  6719         if (have === 0) { break inf_leave; }
       
  6720         copy = 0;
       
  6721         do {
       
  6722           // TODO: 2 or 1 bytes?
       
  6723           len = input[next + copy++];
       
  6724           /* use constant limit because in js we should not preallocate memory */
       
  6725           if (state.head && len &&
       
  6726               (state.length < 65536 /*state.head.name_max*/)) {
       
  6727             state.head.name += String.fromCharCode(len);
       
  6728           }
       
  6729         } while (len && copy < have);
       
  6730 
       
  6731         if (state.flags & 0x0200) {
       
  6732           state.check = crc32(state.check, input, copy, next);
       
  6733         }
       
  6734         have -= copy;
       
  6735         next += copy;
       
  6736         if (len) { break inf_leave; }
       
  6737       }
       
  6738       else if (state.head) {
       
  6739         state.head.name = null;
       
  6740       }
       
  6741       state.length = 0;
       
  6742       state.mode = COMMENT;
       
  6743       /* falls through */
       
  6744     case COMMENT:
       
  6745       if (state.flags & 0x1000) {
       
  6746         if (have === 0) { break inf_leave; }
       
  6747         copy = 0;
       
  6748         do {
       
  6749           len = input[next + copy++];
       
  6750           /* use constant limit because in js we should not preallocate memory */
       
  6751           if (state.head && len &&
       
  6752               (state.length < 65536 /*state.head.comm_max*/)) {
       
  6753             state.head.comment += String.fromCharCode(len);
       
  6754           }
       
  6755         } while (len && copy < have);
       
  6756         if (state.flags & 0x0200) {
       
  6757           state.check = crc32(state.check, input, copy, next);
       
  6758         }
       
  6759         have -= copy;
       
  6760         next += copy;
       
  6761         if (len) { break inf_leave; }
       
  6762       }
       
  6763       else if (state.head) {
       
  6764         state.head.comment = null;
       
  6765       }
       
  6766       state.mode = HCRC;
       
  6767       /* falls through */
       
  6768     case HCRC:
       
  6769       if (state.flags & 0x0200) {
       
  6770         //=== NEEDBITS(16); */
       
  6771         while (bits < 16) {
       
  6772           if (have === 0) { break inf_leave; }
       
  6773           have--;
       
  6774           hold += input[next++] << bits;
       
  6775           bits += 8;
       
  6776         }
       
  6777         //===//
       
  6778         if (hold !== (state.check & 0xffff)) {
       
  6779           strm.msg = 'header crc mismatch';
       
  6780           state.mode = BAD;
       
  6781           break;
       
  6782         }
       
  6783         //=== INITBITS();
       
  6784         hold = 0;
       
  6785         bits = 0;
       
  6786         //===//
       
  6787       }
       
  6788       if (state.head) {
       
  6789         state.head.hcrc = ((state.flags >> 9) & 1);
       
  6790         state.head.done = true;
       
  6791       }
       
  6792       strm.adler = state.check = 0 /*crc32(0L, Z_NULL, 0)*/;
       
  6793       state.mode = TYPE;
       
  6794       break;
       
  6795     case DICTID:
       
  6796       //=== NEEDBITS(32); */
       
  6797       while (bits < 32) {
       
  6798         if (have === 0) { break inf_leave; }
       
  6799         have--;
       
  6800         hold += input[next++] << bits;
       
  6801         bits += 8;
       
  6802       }
       
  6803       //===//
       
  6804       strm.adler = state.check = ZSWAP32(hold);
       
  6805       //=== INITBITS();
       
  6806       hold = 0;
       
  6807       bits = 0;
       
  6808       //===//
       
  6809       state.mode = DICT;
       
  6810       /* falls through */
       
  6811     case DICT:
       
  6812       if (state.havedict === 0) {
       
  6813         //--- RESTORE() ---
       
  6814         strm.next_out = put;
       
  6815         strm.avail_out = left;
       
  6816         strm.next_in = next;
       
  6817         strm.avail_in = have;
       
  6818         state.hold = hold;
       
  6819         state.bits = bits;
       
  6820         //---
       
  6821         return Z_NEED_DICT;
       
  6822       }
       
  6823       strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
       
  6824       state.mode = TYPE;
       
  6825       /* falls through */
       
  6826     case TYPE:
       
  6827       if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }
       
  6828       /* falls through */
       
  6829     case TYPEDO:
       
  6830       if (state.last) {
       
  6831         //--- BYTEBITS() ---//
       
  6832         hold >>>= bits & 7;
       
  6833         bits -= bits & 7;
       
  6834         //---//
       
  6835         state.mode = CHECK;
       
  6836         break;
       
  6837       }
       
  6838       //=== NEEDBITS(3); */
       
  6839       while (bits < 3) {
       
  6840         if (have === 0) { break inf_leave; }
       
  6841         have--;
       
  6842         hold += input[next++] << bits;
       
  6843         bits += 8;
       
  6844       }
       
  6845       //===//
       
  6846       state.last = (hold & 0x01)/*BITS(1)*/;
       
  6847       //--- DROPBITS(1) ---//
       
  6848       hold >>>= 1;
       
  6849       bits -= 1;
       
  6850       //---//
       
  6851 
       
  6852       switch ((hold & 0x03)/*BITS(2)*/) {
       
  6853       case 0:                             /* stored block */
       
  6854         //Tracev((stderr, "inflate:     stored block%s\n",
       
  6855         //        state.last ? " (last)" : ""));
       
  6856         state.mode = STORED;
       
  6857         break;
       
  6858       case 1:                             /* fixed block */
       
  6859         fixedtables(state);
       
  6860         //Tracev((stderr, "inflate:     fixed codes block%s\n",
       
  6861         //        state.last ? " (last)" : ""));
       
  6862         state.mode = LEN_;             /* decode codes */
       
  6863         if (flush === Z_TREES) {
       
  6864           //--- DROPBITS(2) ---//
       
  6865           hold >>>= 2;
       
  6866           bits -= 2;
       
  6867           //---//
       
  6868           break inf_leave;
       
  6869         }
       
  6870         break;
       
  6871       case 2:                             /* dynamic block */
       
  6872         //Tracev((stderr, "inflate:     dynamic codes block%s\n",
       
  6873         //        state.last ? " (last)" : ""));
       
  6874         state.mode = TABLE;
       
  6875         break;
       
  6876       case 3:
       
  6877         strm.msg = 'invalid block type';
       
  6878         state.mode = BAD;
       
  6879       }
       
  6880       //--- DROPBITS(2) ---//
       
  6881       hold >>>= 2;
       
  6882       bits -= 2;
       
  6883       //---//
       
  6884       break;
       
  6885     case STORED:
       
  6886       //--- BYTEBITS() ---// /* go to byte boundary */
       
  6887       hold >>>= bits & 7;
       
  6888       bits -= bits & 7;
       
  6889       //---//
       
  6890       //=== NEEDBITS(32); */
       
  6891       while (bits < 32) {
       
  6892         if (have === 0) { break inf_leave; }
       
  6893         have--;
       
  6894         hold += input[next++] << bits;
       
  6895         bits += 8;
       
  6896       }
       
  6897       //===//
       
  6898       if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
       
  6899         strm.msg = 'invalid stored block lengths';
       
  6900         state.mode = BAD;
       
  6901         break;
       
  6902       }
       
  6903       state.length = hold & 0xffff;
       
  6904       //Tracev((stderr, "inflate:       stored length %u\n",
       
  6905       //        state.length));
       
  6906       //=== INITBITS();
       
  6907       hold = 0;
       
  6908       bits = 0;
       
  6909       //===//
       
  6910       state.mode = COPY_;
       
  6911       if (flush === Z_TREES) { break inf_leave; }
       
  6912       /* falls through */
       
  6913     case COPY_:
       
  6914       state.mode = COPY;
       
  6915       /* falls through */
       
  6916     case COPY:
       
  6917       copy = state.length;
       
  6918       if (copy) {
       
  6919         if (copy > have) { copy = have; }
       
  6920         if (copy > left) { copy = left; }
       
  6921         if (copy === 0) { break inf_leave; }
       
  6922         //--- zmemcpy(put, next, copy); ---
       
  6923         utils.arraySet(output, input, next, copy, put);
       
  6924         //---//
       
  6925         have -= copy;
       
  6926         next += copy;
       
  6927         left -= copy;
       
  6928         put += copy;
       
  6929         state.length -= copy;
       
  6930         break;
       
  6931       }
       
  6932       //Tracev((stderr, "inflate:       stored end\n"));
       
  6933       state.mode = TYPE;
       
  6934       break;
       
  6935     case TABLE:
       
  6936       //=== NEEDBITS(14); */
       
  6937       while (bits < 14) {
       
  6938         if (have === 0) { break inf_leave; }
       
  6939         have--;
       
  6940         hold += input[next++] << bits;
       
  6941         bits += 8;
       
  6942       }
       
  6943       //===//
       
  6944       state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;
       
  6945       //--- DROPBITS(5) ---//
       
  6946       hold >>>= 5;
       
  6947       bits -= 5;
       
  6948       //---//
       
  6949       state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;
       
  6950       //--- DROPBITS(5) ---//
       
  6951       hold >>>= 5;
       
  6952       bits -= 5;
       
  6953       //---//
       
  6954       state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;
       
  6955       //--- DROPBITS(4) ---//
       
  6956       hold >>>= 4;
       
  6957       bits -= 4;
       
  6958       //---//
       
  6959 //#ifndef PKZIP_BUG_WORKAROUND
       
  6960       if (state.nlen > 286 || state.ndist > 30) {
       
  6961         strm.msg = 'too many length or distance symbols';
       
  6962         state.mode = BAD;
       
  6963         break;
       
  6964       }
       
  6965 //#endif
       
  6966       //Tracev((stderr, "inflate:       table sizes ok\n"));
       
  6967       state.have = 0;
       
  6968       state.mode = LENLENS;
       
  6969       /* falls through */
       
  6970     case LENLENS:
       
  6971       while (state.have < state.ncode) {
       
  6972         //=== NEEDBITS(3);
       
  6973         while (bits < 3) {
       
  6974           if (have === 0) { break inf_leave; }
       
  6975           have--;
       
  6976           hold += input[next++] << bits;
       
  6977           bits += 8;
       
  6978         }
       
  6979         //===//
       
  6980         state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);
       
  6981         //--- DROPBITS(3) ---//
       
  6982         hold >>>= 3;
       
  6983         bits -= 3;
       
  6984         //---//
       
  6985       }
       
  6986       while (state.have < 19) {
       
  6987         state.lens[order[state.have++]] = 0;
       
  6988       }
       
  6989       // We have separate tables & no pointers. 2 commented lines below not needed.
       
  6990       //state.next = state.codes;
       
  6991       //state.lencode = state.next;
       
  6992       // Switch to use dynamic table
       
  6993       state.lencode = state.lendyn;
       
  6994       state.lenbits = 7;
       
  6995 
       
  6996       opts = {bits: state.lenbits};
       
  6997       ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
       
  6998       state.lenbits = opts.bits;
       
  6999 
       
  7000       if (ret) {
       
  7001         strm.msg = 'invalid code lengths set';
       
  7002         state.mode = BAD;
       
  7003         break;
       
  7004       }
       
  7005       //Tracev((stderr, "inflate:       code lengths ok\n"));
       
  7006       state.have = 0;
       
  7007       state.mode = CODELENS;
       
  7008       /* falls through */
       
  7009     case CODELENS:
       
  7010       while (state.have < state.nlen + state.ndist) {
       
  7011         for (;;) {
       
  7012           here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/
       
  7013           here_bits = here >>> 24;
       
  7014           here_op = (here >>> 16) & 0xff;
       
  7015           here_val = here & 0xffff;
       
  7016 
       
  7017           if ((here_bits) <= bits) { break; }
       
  7018           //--- PULLBYTE() ---//
       
  7019           if (have === 0) { break inf_leave; }
       
  7020           have--;
       
  7021           hold += input[next++] << bits;
       
  7022           bits += 8;
       
  7023           //---//
       
  7024         }
       
  7025         if (here_val < 16) {
       
  7026           //--- DROPBITS(here.bits) ---//
       
  7027           hold >>>= here_bits;
       
  7028           bits -= here_bits;
       
  7029           //---//
       
  7030           state.lens[state.have++] = here_val;
       
  7031         }
       
  7032         else {
       
  7033           if (here_val === 16) {
       
  7034             //=== NEEDBITS(here.bits + 2);
       
  7035             n = here_bits + 2;
       
  7036             while (bits < n) {
       
  7037               if (have === 0) { break inf_leave; }
       
  7038               have--;
       
  7039               hold += input[next++] << bits;
       
  7040               bits += 8;
       
  7041             }
       
  7042             //===//
       
  7043             //--- DROPBITS(here.bits) ---//
       
  7044             hold >>>= here_bits;
       
  7045             bits -= here_bits;
       
  7046             //---//
       
  7047             if (state.have === 0) {
       
  7048               strm.msg = 'invalid bit length repeat';
       
  7049               state.mode = BAD;
       
  7050               break;
       
  7051             }
       
  7052             len = state.lens[state.have - 1];
       
  7053             copy = 3 + (hold & 0x03);//BITS(2);
       
  7054             //--- DROPBITS(2) ---//
       
  7055             hold >>>= 2;
       
  7056             bits -= 2;
       
  7057             //---//
       
  7058           }
       
  7059           else if (here_val === 17) {
       
  7060             //=== NEEDBITS(here.bits + 3);
       
  7061             n = here_bits + 3;
       
  7062             while (bits < n) {
       
  7063               if (have === 0) { break inf_leave; }
       
  7064               have--;
       
  7065               hold += input[next++] << bits;
       
  7066               bits += 8;
       
  7067             }
       
  7068             //===//
       
  7069             //--- DROPBITS(here.bits) ---//
       
  7070             hold >>>= here_bits;
       
  7071             bits -= here_bits;
       
  7072             //---//
       
  7073             len = 0;
       
  7074             copy = 3 + (hold & 0x07);//BITS(3);
       
  7075             //--- DROPBITS(3) ---//
       
  7076             hold >>>= 3;
       
  7077             bits -= 3;
       
  7078             //---//
       
  7079           }
       
  7080           else {
       
  7081             //=== NEEDBITS(here.bits + 7);
       
  7082             n = here_bits + 7;
       
  7083             while (bits < n) {
       
  7084               if (have === 0) { break inf_leave; }
       
  7085               have--;
       
  7086               hold += input[next++] << bits;
       
  7087               bits += 8;
       
  7088             }
       
  7089             //===//
       
  7090             //--- DROPBITS(here.bits) ---//
       
  7091             hold >>>= here_bits;
       
  7092             bits -= here_bits;
       
  7093             //---//
       
  7094             len = 0;
       
  7095             copy = 11 + (hold & 0x7f);//BITS(7);
       
  7096             //--- DROPBITS(7) ---//
       
  7097             hold >>>= 7;
       
  7098             bits -= 7;
       
  7099             //---//
       
  7100           }
       
  7101           if (state.have + copy > state.nlen + state.ndist) {
       
  7102             strm.msg = 'invalid bit length repeat';
       
  7103             state.mode = BAD;
       
  7104             break;
       
  7105           }
       
  7106           while (copy--) {
       
  7107             state.lens[state.have++] = len;
       
  7108           }
       
  7109         }
       
  7110       }
       
  7111 
       
  7112       /* handle error breaks in while */
       
  7113       if (state.mode === BAD) { break; }
       
  7114 
       
  7115       /* check for end-of-block code (better have one) */
       
  7116       if (state.lens[256] === 0) {
       
  7117         strm.msg = 'invalid code -- missing end-of-block';
       
  7118         state.mode = BAD;
       
  7119         break;
       
  7120       }
       
  7121 
       
  7122       /* build code tables -- note: do not change the lenbits or distbits
       
  7123          values here (9 and 6) without reading the comments in inftrees.h
       
  7124          concerning the ENOUGH constants, which depend on those values */
       
  7125       state.lenbits = 9;
       
  7126 
       
  7127       opts = {bits: state.lenbits};
       
  7128       ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
       
  7129       // We have separate tables & no pointers. 2 commented lines below not needed.
       
  7130       // state.next_index = opts.table_index;
       
  7131       state.lenbits = opts.bits;
       
  7132       // state.lencode = state.next;
       
  7133 
       
  7134       if (ret) {
       
  7135         strm.msg = 'invalid literal/lengths set';
       
  7136         state.mode = BAD;
       
  7137         break;
       
  7138       }
       
  7139 
       
  7140       state.distbits = 6;
       
  7141       //state.distcode.copy(state.codes);
       
  7142       // Switch to use dynamic table
       
  7143       state.distcode = state.distdyn;
       
  7144       opts = {bits: state.distbits};
       
  7145       ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
       
  7146       // We have separate tables & no pointers. 2 commented lines below not needed.
       
  7147       // state.next_index = opts.table_index;
       
  7148       state.distbits = opts.bits;
       
  7149       // state.distcode = state.next;
       
  7150 
       
  7151       if (ret) {
       
  7152         strm.msg = 'invalid distances set';
       
  7153         state.mode = BAD;
       
  7154         break;
       
  7155       }
       
  7156       //Tracev((stderr, 'inflate:       codes ok\n'));
       
  7157       state.mode = LEN_;
       
  7158       if (flush === Z_TREES) { break inf_leave; }
       
  7159       /* falls through */
       
  7160     case LEN_:
       
  7161       state.mode = LEN;
       
  7162       /* falls through */
       
  7163     case LEN:
       
  7164       if (have >= 6 && left >= 258) {
       
  7165         //--- RESTORE() ---
       
  7166         strm.next_out = put;
       
  7167         strm.avail_out = left;
       
  7168         strm.next_in = next;
       
  7169         strm.avail_in = have;
       
  7170         state.hold = hold;
       
  7171         state.bits = bits;
       
  7172         //---
       
  7173         inflate_fast(strm, _out);
       
  7174         //--- LOAD() ---
       
  7175         put = strm.next_out;
       
  7176         output = strm.output;
       
  7177         left = strm.avail_out;
       
  7178         next = strm.next_in;
       
  7179         input = strm.input;
       
  7180         have = strm.avail_in;
       
  7181         hold = state.hold;
       
  7182         bits = state.bits;
       
  7183         //---
       
  7184 
       
  7185         if (state.mode === TYPE) {
       
  7186           state.back = -1;
       
  7187         }
       
  7188         break;
       
  7189       }
       
  7190       state.back = 0;
       
  7191       for (;;) {
       
  7192         here = state.lencode[hold & ((1 << state.lenbits) -1)];  /*BITS(state.lenbits)*/
       
  7193         here_bits = here >>> 24;
       
  7194         here_op = (here >>> 16) & 0xff;
       
  7195         here_val = here & 0xffff;
       
  7196 
       
  7197         if (here_bits <= bits) { break; }
       
  7198         //--- PULLBYTE() ---//
       
  7199         if (have === 0) { break inf_leave; }
       
  7200         have--;
       
  7201         hold += input[next++] << bits;
       
  7202         bits += 8;
       
  7203         //---//
       
  7204       }
       
  7205       if (here_op && (here_op & 0xf0) === 0) {
       
  7206         last_bits = here_bits;
       
  7207         last_op = here_op;
       
  7208         last_val = here_val;
       
  7209         for (;;) {
       
  7210           here = state.lencode[last_val +
       
  7211                   ((hold & ((1 << (last_bits + last_op)) -1))/*BITS(last.bits + last.op)*/ >> last_bits)];
       
  7212           here_bits = here >>> 24;
       
  7213           here_op = (here >>> 16) & 0xff;
       
  7214           here_val = here & 0xffff;
       
  7215 
       
  7216           if ((last_bits + here_bits) <= bits) { break; }
       
  7217           //--- PULLBYTE() ---//
       
  7218           if (have === 0) { break inf_leave; }
       
  7219           have--;
       
  7220           hold += input[next++] << bits;
       
  7221           bits += 8;
       
  7222           //---//
       
  7223         }
       
  7224         //--- DROPBITS(last.bits) ---//
       
  7225         hold >>>= last_bits;
       
  7226         bits -= last_bits;
       
  7227         //---//
       
  7228         state.back += last_bits;
       
  7229       }
       
  7230       //--- DROPBITS(here.bits) ---//
       
  7231       hold >>>= here_bits;
       
  7232       bits -= here_bits;
       
  7233       //---//
       
  7234       state.back += here_bits;
       
  7235       state.length = here_val;
       
  7236       if (here_op === 0) {
       
  7237         //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
       
  7238         //        "inflate:         literal '%c'\n" :
       
  7239         //        "inflate:         literal 0x%02x\n", here.val));
       
  7240         state.mode = LIT;
       
  7241         break;
       
  7242       }
       
  7243       if (here_op & 32) {
       
  7244         //Tracevv((stderr, "inflate:         end of block\n"));
       
  7245         state.back = -1;
       
  7246         state.mode = TYPE;
       
  7247         break;
       
  7248       }
       
  7249       if (here_op & 64) {
       
  7250         strm.msg = 'invalid literal/length code';
       
  7251         state.mode = BAD;
       
  7252         break;
       
  7253       }
       
  7254       state.extra = here_op & 15;
       
  7255       state.mode = LENEXT;
       
  7256       /* falls through */
       
  7257     case LENEXT:
       
  7258       if (state.extra) {
       
  7259         //=== NEEDBITS(state.extra);
       
  7260         n = state.extra;
       
  7261         while (bits < n) {
       
  7262           if (have === 0) { break inf_leave; }
       
  7263           have--;
       
  7264           hold += input[next++] << bits;
       
  7265           bits += 8;
       
  7266         }
       
  7267         //===//
       
  7268         state.length += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/;
       
  7269         //--- DROPBITS(state.extra) ---//
       
  7270         hold >>>= state.extra;
       
  7271         bits -= state.extra;
       
  7272         //---//
       
  7273         state.back += state.extra;
       
  7274       }
       
  7275       //Tracevv((stderr, "inflate:         length %u\n", state.length));
       
  7276       state.was = state.length;
       
  7277       state.mode = DIST;
       
  7278       /* falls through */
       
  7279     case DIST:
       
  7280       for (;;) {
       
  7281         here = state.distcode[hold & ((1 << state.distbits) -1)];/*BITS(state.distbits)*/
       
  7282         here_bits = here >>> 24;
       
  7283         here_op = (here >>> 16) & 0xff;
       
  7284         here_val = here & 0xffff;
       
  7285 
       
  7286         if ((here_bits) <= bits) { break; }
       
  7287         //--- PULLBYTE() ---//
       
  7288         if (have === 0) { break inf_leave; }
       
  7289         have--;
       
  7290         hold += input[next++] << bits;
       
  7291         bits += 8;
       
  7292         //---//
       
  7293       }
       
  7294       if ((here_op & 0xf0) === 0) {
       
  7295         last_bits = here_bits;
       
  7296         last_op = here_op;
       
  7297         last_val = here_val;
       
  7298         for (;;) {
       
  7299           here = state.distcode[last_val +
       
  7300                   ((hold & ((1 << (last_bits + last_op)) -1))/*BITS(last.bits + last.op)*/ >> last_bits)];
       
  7301           here_bits = here >>> 24;
       
  7302           here_op = (here >>> 16) & 0xff;
       
  7303           here_val = here & 0xffff;
       
  7304 
       
  7305           if ((last_bits + here_bits) <= bits) { break; }
       
  7306           //--- PULLBYTE() ---//
       
  7307           if (have === 0) { break inf_leave; }
       
  7308           have--;
       
  7309           hold += input[next++] << bits;
       
  7310           bits += 8;
       
  7311           //---//
       
  7312         }
       
  7313         //--- DROPBITS(last.bits) ---//
       
  7314         hold >>>= last_bits;
       
  7315         bits -= last_bits;
       
  7316         //---//
       
  7317         state.back += last_bits;
       
  7318       }
       
  7319       //--- DROPBITS(here.bits) ---//
       
  7320       hold >>>= here_bits;
       
  7321       bits -= here_bits;
       
  7322       //---//
       
  7323       state.back += here_bits;
       
  7324       if (here_op & 64) {
       
  7325         strm.msg = 'invalid distance code';
       
  7326         state.mode = BAD;
       
  7327         break;
       
  7328       }
       
  7329       state.offset = here_val;
       
  7330       state.extra = (here_op) & 15;
       
  7331       state.mode = DISTEXT;
       
  7332       /* falls through */
       
  7333     case DISTEXT:
       
  7334       if (state.extra) {
       
  7335         //=== NEEDBITS(state.extra);
       
  7336         n = state.extra;
       
  7337         while (bits < n) {
       
  7338           if (have === 0) { break inf_leave; }
       
  7339           have--;
       
  7340           hold += input[next++] << bits;
       
  7341           bits += 8;
       
  7342         }
       
  7343         //===//
       
  7344         state.offset += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/;
       
  7345         //--- DROPBITS(state.extra) ---//
       
  7346         hold >>>= state.extra;
       
  7347         bits -= state.extra;
       
  7348         //---//
       
  7349         state.back += state.extra;
       
  7350       }
       
  7351 //#ifdef INFLATE_STRICT
       
  7352       if (state.offset > state.dmax) {
       
  7353         strm.msg = 'invalid distance too far back';
       
  7354         state.mode = BAD;
       
  7355         break;
       
  7356       }
       
  7357 //#endif
       
  7358       //Tracevv((stderr, "inflate:         distance %u\n", state.offset));
       
  7359       state.mode = MATCH;
       
  7360       /* falls through */
       
  7361     case MATCH:
       
  7362       if (left === 0) { break inf_leave; }
       
  7363       copy = _out - left;
       
  7364       if (state.offset > copy) {         /* copy from window */
       
  7365         copy = state.offset - copy;
       
  7366         if (copy > state.whave) {
       
  7367           if (state.sane) {
       
  7368             strm.msg = 'invalid distance too far back';
       
  7369             state.mode = BAD;
       
  7370             break;
       
  7371           }
       
  7372 // (!) This block is disabled in zlib defailts,
       
  7373 // don't enable it for binary compatibility
       
  7374 //#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
       
  7375 //          Trace((stderr, "inflate.c too far\n"));
       
  7376 //          copy -= state.whave;
       
  7377 //          if (copy > state.length) { copy = state.length; }
       
  7378 //          if (copy > left) { copy = left; }
       
  7379 //          left -= copy;
       
  7380 //          state.length -= copy;
       
  7381 //          do {
       
  7382 //            output[put++] = 0;
       
  7383 //          } while (--copy);
       
  7384 //          if (state.length === 0) { state.mode = LEN; }
       
  7385 //          break;
       
  7386 //#endif
       
  7387         }
       
  7388         if (copy > state.wnext) {
       
  7389           copy -= state.wnext;
       
  7390           from = state.wsize - copy;
       
  7391         }
       
  7392         else {
       
  7393           from = state.wnext - copy;
       
  7394         }
       
  7395         if (copy > state.length) { copy = state.length; }
       
  7396         from_source = state.window;
       
  7397       }
       
  7398       else {                              /* copy from output */
       
  7399         from_source = output;
       
  7400         from = put - state.offset;
       
  7401         copy = state.length;
       
  7402       }
       
  7403       if (copy > left) { copy = left; }
       
  7404       left -= copy;
       
  7405       state.length -= copy;
       
  7406       do {
       
  7407         output[put++] = from_source[from++];
       
  7408       } while (--copy);
       
  7409       if (state.length === 0) { state.mode = LEN; }
       
  7410       break;
       
  7411     case LIT:
       
  7412       if (left === 0) { break inf_leave; }
       
  7413       output[put++] = state.length;
       
  7414       left--;
       
  7415       state.mode = LEN;
       
  7416       break;
       
  7417     case CHECK:
       
  7418       if (state.wrap) {
       
  7419         //=== NEEDBITS(32);
       
  7420         while (bits < 32) {
       
  7421           if (have === 0) { break inf_leave; }
       
  7422           have--;
       
  7423           // Use '|' insdead of '+' to make sure that result is signed
       
  7424           hold |= input[next++] << bits;
       
  7425           bits += 8;
       
  7426         }
       
  7427         //===//
       
  7428         _out -= left;
       
  7429         strm.total_out += _out;
       
  7430         state.total += _out;
       
  7431         if (_out) {
       
  7432           strm.adler = state.check =
       
  7433               /*UPDATE(state.check, put - _out, _out);*/
       
  7434               (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));
       
  7435 
       
  7436         }
       
  7437         _out = left;
       
  7438         // NB: crc32 stored as signed 32-bit int, ZSWAP32 returns signed too
       
  7439         if ((state.flags ? hold : ZSWAP32(hold)) !== state.check) {
       
  7440           strm.msg = 'incorrect data check';
       
  7441           state.mode = BAD;
       
  7442           break;
       
  7443         }
       
  7444         //=== INITBITS();
       
  7445         hold = 0;
       
  7446         bits = 0;
       
  7447         //===//
       
  7448         //Tracev((stderr, "inflate:   check matches trailer\n"));
       
  7449       }
       
  7450       state.mode = LENGTH;
       
  7451       /* falls through */
       
  7452     case LENGTH:
       
  7453       if (state.wrap && state.flags) {
       
  7454         //=== NEEDBITS(32);
       
  7455         while (bits < 32) {
       
  7456           if (have === 0) { break inf_leave; }
       
  7457           have--;
       
  7458           hold += input[next++] << bits;
       
  7459           bits += 8;
       
  7460         }
       
  7461         //===//
       
  7462         if (hold !== (state.total & 0xffffffff)) {
       
  7463           strm.msg = 'incorrect length check';
       
  7464           state.mode = BAD;
       
  7465           break;
       
  7466         }
       
  7467         //=== INITBITS();
       
  7468         hold = 0;
       
  7469         bits = 0;
       
  7470         //===//
       
  7471         //Tracev((stderr, "inflate:   length matches trailer\n"));
       
  7472       }
       
  7473       state.mode = DONE;
       
  7474       /* falls through */
       
  7475     case DONE:
       
  7476       ret = Z_STREAM_END;
       
  7477       break inf_leave;
       
  7478     case BAD:
       
  7479       ret = Z_DATA_ERROR;
       
  7480       break inf_leave;
       
  7481     case MEM:
       
  7482       return Z_MEM_ERROR;
       
  7483     case SYNC:
       
  7484       /* falls through */
       
  7485     default:
       
  7486       return Z_STREAM_ERROR;
       
  7487     }
       
  7488   }
       
  7489 
       
  7490   // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"
       
  7491 
       
  7492   /*
       
  7493      Return from inflate(), updating the total counts and the check value.
       
  7494      If there was no progress during the inflate() call, return a buffer
       
  7495      error.  Call updatewindow() to create and/or update the window state.
       
  7496      Note: a memory error from inflate() is non-recoverable.
       
  7497    */
       
  7498 
       
  7499   //--- RESTORE() ---
       
  7500   strm.next_out = put;
       
  7501   strm.avail_out = left;
       
  7502   strm.next_in = next;
       
  7503   strm.avail_in = have;
       
  7504   state.hold = hold;
       
  7505   state.bits = bits;
       
  7506   //---
       
  7507 
       
  7508   if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
       
  7509                       (state.mode < CHECK || flush !== Z_FINISH))) {
       
  7510     if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {
       
  7511       state.mode = MEM;
       
  7512       return Z_MEM_ERROR;
       
  7513     }
       
  7514   }
       
  7515   _in -= strm.avail_in;
       
  7516   _out -= strm.avail_out;
       
  7517   strm.total_in += _in;
       
  7518   strm.total_out += _out;
       
  7519   state.total += _out;
       
  7520   if (state.wrap && _out) {
       
  7521     strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
       
  7522       (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
       
  7523   }
       
  7524   strm.data_type = state.bits + (state.last ? 64 : 0) +
       
  7525                     (state.mode === TYPE ? 128 : 0) +
       
  7526                     (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
       
  7527   if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
       
  7528     ret = Z_BUF_ERROR;
       
  7529   }
       
  7530   return ret;
       
  7531 }
       
  7532 
       
  7533 function inflateEnd(strm) {
       
  7534 
       
  7535   if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
       
  7536     return Z_STREAM_ERROR;
       
  7537   }
       
  7538 
       
  7539   var state = strm.state;
       
  7540   if (state.window) {
       
  7541     state.window = null;
       
  7542   }
       
  7543   strm.state = null;
       
  7544   return Z_OK;
       
  7545 }
       
  7546 
       
  7547 function inflateGetHeader(strm, head) {
       
  7548   var state;
       
  7549 
       
  7550   /* check state */
       
  7551   if (!strm || !strm.state) { return Z_STREAM_ERROR; }
       
  7552   state = strm.state;
       
  7553   if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }
       
  7554 
       
  7555   /* save header structure */
       
  7556   state.head = head;
       
  7557   head.done = false;
       
  7558   return Z_OK;
       
  7559 }
       
  7560 
       
  7561 
       
  7562 exports.inflateReset = inflateReset;
       
  7563 exports.inflateReset2 = inflateReset2;
       
  7564 exports.inflateResetKeep = inflateResetKeep;
       
  7565 exports.inflateInit = inflateInit;
       
  7566 exports.inflateInit2 = inflateInit2;
       
  7567 exports.inflate = inflate;
       
  7568 exports.inflateEnd = inflateEnd;
       
  7569 exports.inflateGetHeader = inflateGetHeader;
       
  7570 exports.inflateInfo = 'pako inflate (from Nodeca project)';
       
  7571 
       
  7572 /* Not implemented
       
  7573 exports.inflateCopy = inflateCopy;
       
  7574 exports.inflateGetDictionary = inflateGetDictionary;
       
  7575 exports.inflateMark = inflateMark;
       
  7576 exports.inflatePrime = inflatePrime;
       
  7577 exports.inflateSetDictionary = inflateSetDictionary;
       
  7578 exports.inflateSync = inflateSync;
       
  7579 exports.inflateSyncPoint = inflateSyncPoint;
       
  7580 exports.inflateUndermine = inflateUndermine;
       
  7581 */
       
  7582 },{"../utils/common":27,"./adler32":29,"./crc32":31,"./inffast":34,"./inftrees":36}],36:[function(_dereq_,module,exports){
       
  7583 'use strict';
       
  7584 
       
  7585 
       
  7586 var utils = _dereq_('../utils/common');
       
  7587 
       
  7588 var MAXBITS = 15;
       
  7589 var ENOUGH_LENS = 852;
       
  7590 var ENOUGH_DISTS = 592;
       
  7591 //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
       
  7592 
       
  7593 var CODES = 0;
       
  7594 var LENS = 1;
       
  7595 var DISTS = 2;
       
  7596 
       
  7597 var lbase = [ /* Length codes 257..285 base */
       
  7598   3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
       
  7599   35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
       
  7600 ];
       
  7601 
       
  7602 var lext = [ /* Length codes 257..285 extra */
       
  7603   16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
       
  7604   19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
       
  7605 ];
       
  7606 
       
  7607 var dbase = [ /* Distance codes 0..29 base */
       
  7608   1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
       
  7609   257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
       
  7610   8193, 12289, 16385, 24577, 0, 0
       
  7611 ];
       
  7612 
       
  7613 var dext = [ /* Distance codes 0..29 extra */
       
  7614   16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
       
  7615   23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
       
  7616   28, 28, 29, 29, 64, 64
       
  7617 ];
       
  7618 
       
  7619 module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)
       
  7620 {
       
  7621   var bits = opts.bits;
       
  7622       //here = opts.here; /* table entry for duplication */
       
  7623 
       
  7624   var len = 0;               /* a code's length in bits */
       
  7625   var sym = 0;               /* index of code symbols */
       
  7626   var min = 0, max = 0;          /* minimum and maximum code lengths */
       
  7627   var root = 0;              /* number of index bits for root table */
       
  7628   var curr = 0;              /* number of index bits for current table */
       
  7629   var drop = 0;              /* code bits to drop for sub-table */
       
  7630   var left = 0;                   /* number of prefix codes available */
       
  7631   var used = 0;              /* code entries in table used */
       
  7632   var huff = 0;              /* Huffman code */
       
  7633   var incr;              /* for incrementing code, index */
       
  7634   var fill;              /* index for replicating entries */
       
  7635   var low;               /* low bits for current root entry */
       
  7636   var mask;              /* mask for low root bits */
       
  7637   var next;             /* next available space in table */
       
  7638   var base = null;     /* base value table to use */
       
  7639   var base_index = 0;
       
  7640 //  var shoextra;    /* extra bits table to use */
       
  7641   var end;                    /* use base and extra for symbol > end */
       
  7642   var count = new utils.Buf16(MAXBITS+1); //[MAXBITS+1];    /* number of codes of each length */
       
  7643   var offs = new utils.Buf16(MAXBITS+1); //[MAXBITS+1];     /* offsets in table for each length */
       
  7644   var extra = null;
       
  7645   var extra_index = 0;
       
  7646 
       
  7647   var here_bits, here_op, here_val;
       
  7648 
       
  7649   /*
       
  7650    Process a set of code lengths to create a canonical Huffman code.  The
       
  7651    code lengths are lens[0..codes-1].  Each length corresponds to the
       
  7652    symbols 0..codes-1.  The Huffman code is generated by first sorting the
       
  7653    symbols by length from short to long, and retaining the symbol order
       
  7654    for codes with equal lengths.  Then the code starts with all zero bits
       
  7655    for the first code of the shortest length, and the codes are integer
       
  7656    increments for the same length, and zeros are appended as the length
       
  7657    increases.  For the deflate format, these bits are stored backwards
       
  7658    from their more natural integer increment ordering, and so when the
       
  7659    decoding tables are built in the large loop below, the integer codes
       
  7660    are incremented backwards.
       
  7661 
       
  7662    This routine assumes, but does not check, that all of the entries in
       
  7663    lens[] are in the range 0..MAXBITS.  The caller must assure this.
       
  7664    1..MAXBITS is interpreted as that code length.  zero means that that
       
  7665    symbol does not occur in this code.
       
  7666 
       
  7667    The codes are sorted by computing a count of codes for each length,
       
  7668    creating from that a table of starting indices for each length in the
       
  7669    sorted table, and then entering the symbols in order in the sorted
       
  7670    table.  The sorted table is work[], with that space being provided by
       
  7671    the caller.
       
  7672 
       
  7673    The length counts are used for other purposes as well, i.e. finding
       
  7674    the minimum and maximum length codes, determining if there are any
       
  7675    codes at all, checking for a valid set of lengths, and looking ahead
       
  7676    at length counts to determine sub-table sizes when building the
       
  7677    decoding tables.
       
  7678    */
       
  7679 
       
  7680   /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
       
  7681   for (len = 0; len <= MAXBITS; len++) {
       
  7682     count[len] = 0;
       
  7683   }
       
  7684   for (sym = 0; sym < codes; sym++) {
       
  7685     count[lens[lens_index + sym]]++;
       
  7686   }
       
  7687 
       
  7688   /* bound code lengths, force root to be within code lengths */
       
  7689   root = bits;
       
  7690   for (max = MAXBITS; max >= 1; max--) {
       
  7691     if (count[max] !== 0) { break; }
       
  7692   }
       
  7693   if (root > max) {
       
  7694     root = max;
       
  7695   }
       
  7696   if (max === 0) {                     /* no symbols to code at all */
       
  7697     //table.op[opts.table_index] = 64;  //here.op = (var char)64;    /* invalid code marker */
       
  7698     //table.bits[opts.table_index] = 1;   //here.bits = (var char)1;
       
  7699     //table.val[opts.table_index++] = 0;   //here.val = (var short)0;
       
  7700     table[table_index++] = (1 << 24) | (64 << 16) | 0;
       
  7701 
       
  7702 
       
  7703     //table.op[opts.table_index] = 64;
       
  7704     //table.bits[opts.table_index] = 1;
       
  7705     //table.val[opts.table_index++] = 0;
       
  7706     table[table_index++] = (1 << 24) | (64 << 16) | 0;
       
  7707 
       
  7708     opts.bits = 1;
       
  7709     return 0;     /* no symbols, but wait for decoding to report error */
       
  7710   }
       
  7711   for (min = 1; min < max; min++) {
       
  7712     if (count[min] !== 0) { break; }
       
  7713   }
       
  7714   if (root < min) {
       
  7715     root = min;
       
  7716   }
       
  7717 
       
  7718   /* check for an over-subscribed or incomplete set of lengths */
       
  7719   left = 1;
       
  7720   for (len = 1; len <= MAXBITS; len++) {
       
  7721     left <<= 1;
       
  7722     left -= count[len];
       
  7723     if (left < 0) {
       
  7724       return -1;
       
  7725     }        /* over-subscribed */
       
  7726   }
       
  7727   if (left > 0 && (type === CODES || max !== 1)) {
       
  7728     return -1;                      /* incomplete set */
       
  7729   }
       
  7730 
       
  7731   /* generate offsets into symbol table for each length for sorting */
       
  7732   offs[1] = 0;
       
  7733   for (len = 1; len < MAXBITS; len++) {
       
  7734     offs[len + 1] = offs[len] + count[len];
       
  7735   }
       
  7736 
       
  7737   /* sort symbols by length, by symbol order within each length */
       
  7738   for (sym = 0; sym < codes; sym++) {
       
  7739     if (lens[lens_index + sym] !== 0) {
       
  7740       work[offs[lens[lens_index + sym]]++] = sym;
       
  7741     }
       
  7742   }
       
  7743 
       
  7744   /*
       
  7745    Create and fill in decoding tables.  In this loop, the table being
       
  7746    filled is at next and has curr index bits.  The code being used is huff
       
  7747    with length len.  That code is converted to an index by dropping drop
       
  7748    bits off of the bottom.  For codes where len is less than drop + curr,
       
  7749    those top drop + curr - len bits are incremented through all values to
       
  7750    fill the table with replicated entries.
       
  7751 
       
  7752    root is the number of index bits for the root table.  When len exceeds
       
  7753    root, sub-tables are created pointed to by the root entry with an index
       
  7754    of the low root bits of huff.  This is saved in low to check for when a
       
  7755    new sub-table should be started.  drop is zero when the root table is
       
  7756    being filled, and drop is root when sub-tables are being filled.
       
  7757 
       
  7758    When a new sub-table is needed, it is necessary to look ahead in the
       
  7759    code lengths to determine what size sub-table is needed.  The length
       
  7760    counts are used for this, and so count[] is decremented as codes are
       
  7761    entered in the tables.
       
  7762 
       
  7763    used keeps track of how many table entries have been allocated from the
       
  7764    provided *table space.  It is checked for LENS and DIST tables against
       
  7765    the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
       
  7766    the initial root table size constants.  See the comments in inftrees.h
       
  7767    for more information.
       
  7768 
       
  7769    sym increments through all symbols, and the loop terminates when
       
  7770    all codes of length max, i.e. all codes, have been processed.  This
       
  7771    routine permits incomplete codes, so another loop after this one fills
       
  7772    in the rest of the decoding tables with invalid code markers.
       
  7773    */
       
  7774 
       
  7775   /* set up for code type */
       
  7776   // poor man optimization - use if-else instead of switch,
       
  7777   // to avoid deopts in old v8
       
  7778   if (type === CODES) {
       
  7779       base = extra = work;    /* dummy value--not used */
       
  7780       end = 19;
       
  7781   } else if (type === LENS) {
       
  7782       base = lbase;
       
  7783       base_index -= 257;
       
  7784       extra = lext;
       
  7785       extra_index -= 257;
       
  7786       end = 256;
       
  7787   } else {                    /* DISTS */
       
  7788       base = dbase;
       
  7789       extra = dext;
       
  7790       end = -1;
       
  7791   }
       
  7792 
       
  7793   /* initialize opts for loop */
       
  7794   huff = 0;                   /* starting code */
       
  7795   sym = 0;                    /* starting code symbol */
       
  7796   len = min;                  /* starting code length */
       
  7797   next = table_index;              /* current table to fill in */
       
  7798   curr = root;                /* current table index bits */
       
  7799   drop = 0;                   /* current bits to drop from code for index */
       
  7800   low = -1;                   /* trigger new sub-table when len > root */
       
  7801   used = 1 << root;          /* use root table entries */
       
  7802   mask = used - 1;            /* mask for comparing low */
       
  7803 
       
  7804   /* check available table space */
       
  7805   if ((type === LENS && used > ENOUGH_LENS) ||
       
  7806     (type === DISTS && used > ENOUGH_DISTS)) {
       
  7807     return 1;
       
  7808   }
       
  7809 
       
  7810   var i=0;
       
  7811   /* process all codes and make table entries */
       
  7812   for (;;) {
       
  7813     i++;
       
  7814     /* create table entry */
       
  7815     here_bits = len - drop;
       
  7816     if (work[sym] < end) {
       
  7817       here_op = 0;
       
  7818       here_val = work[sym];
       
  7819     }
       
  7820     else if (work[sym] > end) {
       
  7821       here_op = extra[extra_index + work[sym]];
       
  7822       here_val = base[base_index + work[sym]];
       
  7823     }
       
  7824     else {
       
  7825       here_op = 32 + 64;         /* end of block */
       
  7826       here_val = 0;
       
  7827     }
       
  7828 
       
  7829     /* replicate for those indices with low len bits equal to huff */
       
  7830     incr = 1 << (len - drop);
       
  7831     fill = 1 << curr;
       
  7832     min = fill;                 /* save offset to next table */
       
  7833     do {
       
  7834       fill -= incr;
       
  7835       table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;
       
  7836     } while (fill !== 0);
       
  7837 
       
  7838     /* backwards increment the len-bit code huff */
       
  7839     incr = 1 << (len - 1);
       
  7840     while (huff & incr) {
       
  7841       incr >>= 1;
       
  7842     }
       
  7843     if (incr !== 0) {
       
  7844       huff &= incr - 1;
       
  7845       huff += incr;
       
  7846     } else {
       
  7847       huff = 0;
       
  7848     }
       
  7849 
       
  7850     /* go to next symbol, update count, len */
       
  7851     sym++;
       
  7852     if (--count[len] === 0) {
       
  7853       if (len === max) { break; }
       
  7854       len = lens[lens_index + work[sym]];
       
  7855     }
       
  7856 
       
  7857     /* create new sub-table if needed */
       
  7858     if (len > root && (huff & mask) !== low) {
       
  7859       /* if first time, transition to sub-tables */
       
  7860       if (drop === 0) {
       
  7861         drop = root;
       
  7862       }
       
  7863 
       
  7864       /* increment past last table */
       
  7865       next += min;            /* here min is 1 << curr */
       
  7866 
       
  7867       /* determine length of next table */
       
  7868       curr = len - drop;
       
  7869       left = 1 << curr;
       
  7870       while (curr + drop < max) {
       
  7871         left -= count[curr + drop];
       
  7872         if (left <= 0) { break; }
       
  7873         curr++;
       
  7874         left <<= 1;
       
  7875       }
       
  7876 
       
  7877       /* check for enough space */
       
  7878       used += 1 << curr;
       
  7879       if ((type === LENS && used > ENOUGH_LENS) ||
       
  7880         (type === DISTS && used > ENOUGH_DISTS)) {
       
  7881         return 1;
       
  7882       }
       
  7883 
       
  7884       /* point entry in root table to sub-table */
       
  7885       low = huff & mask;
       
  7886       /*table.op[low] = curr;
       
  7887       table.bits[low] = root;
       
  7888       table.val[low] = next - opts.table_index;*/
       
  7889       table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;
       
  7890     }
       
  7891   }
       
  7892 
       
  7893   /* fill in remaining table entry if code is incomplete (guaranteed to have
       
  7894    at most one remaining entry, since if the code is incomplete, the
       
  7895    maximum code length that was allowed to get this far is one bit) */
       
  7896   if (huff !== 0) {
       
  7897     //table.op[next + huff] = 64;            /* invalid code marker */
       
  7898     //table.bits[next + huff] = len - drop;
       
  7899     //table.val[next + huff] = 0;
       
  7900     table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;
       
  7901   }
       
  7902 
       
  7903   /* set return parameters */
       
  7904   //opts.table_index += used;
       
  7905   opts.bits = root;
       
  7906   return 0;
       
  7907 };
       
  7908 
       
  7909 },{"../utils/common":27}],37:[function(_dereq_,module,exports){
       
  7910 'use strict';
       
  7911 
       
  7912 module.exports = {
       
  7913   '2':    'need dictionary',     /* Z_NEED_DICT       2  */
       
  7914   '1':    'stream end',          /* Z_STREAM_END      1  */
       
  7915   '0':    '',                    /* Z_OK              0  */
       
  7916   '-1':   'file error',          /* Z_ERRNO         (-1) */
       
  7917   '-2':   'stream error',        /* Z_STREAM_ERROR  (-2) */
       
  7918   '-3':   'data error',          /* Z_DATA_ERROR    (-3) */
       
  7919   '-4':   'insufficient memory', /* Z_MEM_ERROR     (-4) */
       
  7920   '-5':   'buffer error',        /* Z_BUF_ERROR     (-5) */
       
  7921   '-6':   'incompatible version' /* Z_VERSION_ERROR (-6) */
       
  7922 };
       
  7923 },{}],38:[function(_dereq_,module,exports){
       
  7924 'use strict';
       
  7925 
       
  7926 
       
  7927 var utils = _dereq_('../utils/common');
       
  7928 
       
  7929 /* Public constants ==========================================================*/
       
  7930 /* ===========================================================================*/
       
  7931 
       
  7932 
       
  7933 //var Z_FILTERED          = 1;
       
  7934 //var Z_HUFFMAN_ONLY      = 2;
       
  7935 //var Z_RLE               = 3;
       
  7936 var Z_FIXED               = 4;
       
  7937 //var Z_DEFAULT_STRATEGY  = 0;
       
  7938 
       
  7939 /* Possible values of the data_type field (though see inflate()) */
       
  7940 var Z_BINARY              = 0;
       
  7941 var Z_TEXT                = 1;
       
  7942 //var Z_ASCII             = 1; // = Z_TEXT
       
  7943 var Z_UNKNOWN             = 2;
       
  7944 
       
  7945 /*============================================================================*/
       
  7946 
       
  7947 
       
  7948 function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
       
  7949 
       
  7950 // From zutil.h
       
  7951 
       
  7952 var STORED_BLOCK = 0;
       
  7953 var STATIC_TREES = 1;
       
  7954 var DYN_TREES    = 2;
       
  7955 /* The three kinds of block type */
       
  7956 
       
  7957 var MIN_MATCH    = 3;
       
  7958 var MAX_MATCH    = 258;
       
  7959 /* The minimum and maximum match lengths */
       
  7960 
       
  7961 // From deflate.h
       
  7962 /* ===========================================================================
       
  7963  * Internal compression state.
       
  7964  */
       
  7965 
       
  7966 var LENGTH_CODES  = 29;
       
  7967 /* number of length codes, not counting the special END_BLOCK code */
       
  7968 
       
  7969 var LITERALS      = 256;
       
  7970 /* number of literal bytes 0..255 */
       
  7971 
       
  7972 var L_CODES       = LITERALS + 1 + LENGTH_CODES;
       
  7973 /* number of Literal or Length codes, including the END_BLOCK code */
       
  7974 
       
  7975 var D_CODES       = 30;
       
  7976 /* number of distance codes */
       
  7977 
       
  7978 var BL_CODES      = 19;
       
  7979 /* number of codes used to transfer the bit lengths */
       
  7980 
       
  7981 var HEAP_SIZE     = 2*L_CODES + 1;
       
  7982 /* maximum heap size */
       
  7983 
       
  7984 var MAX_BITS      = 15;
       
  7985 /* All codes must not exceed MAX_BITS bits */
       
  7986 
       
  7987 var Buf_size      = 16;
       
  7988 /* size of bit buffer in bi_buf */
       
  7989 
       
  7990 
       
  7991 /* ===========================================================================
       
  7992  * Constants
       
  7993  */
       
  7994 
       
  7995 var MAX_BL_BITS = 7;
       
  7996 /* Bit length codes must not exceed MAX_BL_BITS bits */
       
  7997 
       
  7998 var END_BLOCK   = 256;
       
  7999 /* end of block literal code */
       
  8000 
       
  8001 var REP_3_6     = 16;
       
  8002 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
       
  8003 
       
  8004 var REPZ_3_10   = 17;
       
  8005 /* repeat a zero length 3-10 times  (3 bits of repeat count) */
       
  8006 
       
  8007 var REPZ_11_138 = 18;
       
  8008 /* repeat a zero length 11-138 times  (7 bits of repeat count) */
       
  8009 
       
  8010 var extra_lbits =   /* extra bits for each length code */
       
  8011   [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];
       
  8012 
       
  8013 var extra_dbits =   /* extra bits for each distance code */
       
  8014   [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];
       
  8015 
       
  8016 var extra_blbits =  /* extra bits for each bit length code */
       
  8017   [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];
       
  8018 
       
  8019 var bl_order =
       
  8020   [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
       
  8021 /* The lengths of the bit length codes are sent in order of decreasing
       
  8022  * probability, to avoid transmitting the lengths for unused bit length codes.
       
  8023  */
       
  8024 
       
  8025 /* ===========================================================================
       
  8026  * Local data. These are initialized only once.
       
  8027  */
       
  8028 
       
  8029 // We pre-fill arrays with 0 to avoid uninitialized gaps
       
  8030 
       
  8031 var DIST_CODE_LEN = 512; /* see definition of array dist_code below */
       
  8032 
       
  8033 // !!!! Use flat array insdead of structure, Freq = i*2, Len = i*2+1
       
  8034 var static_ltree  = new Array((L_CODES+2) * 2);
       
  8035 zero(static_ltree);
       
  8036 /* The static literal tree. Since the bit lengths are imposed, there is no
       
  8037  * need for the L_CODES extra codes used during heap construction. However
       
  8038  * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
       
  8039  * below).
       
  8040  */
       
  8041 
       
  8042 var static_dtree  = new Array(D_CODES * 2);
       
  8043 zero(static_dtree);
       
  8044 /* The static distance tree. (Actually a trivial tree since all codes use
       
  8045  * 5 bits.)
       
  8046  */
       
  8047 
       
  8048 var _dist_code    = new Array(DIST_CODE_LEN);
       
  8049 zero(_dist_code);
       
  8050 /* Distance codes. The first 256 values correspond to the distances
       
  8051  * 3 .. 258, the last 256 values correspond to the top 8 bits of
       
  8052  * the 15 bit distances.
       
  8053  */
       
  8054 
       
  8055 var _length_code  = new Array(MAX_MATCH-MIN_MATCH+1);
       
  8056 zero(_length_code);
       
  8057 /* length code for each normalized match length (0 == MIN_MATCH) */
       
  8058 
       
  8059 var base_length   = new Array(LENGTH_CODES);
       
  8060 zero(base_length);
       
  8061 /* First normalized length for each code (0 = MIN_MATCH) */
       
  8062 
       
  8063 var base_dist     = new Array(D_CODES);
       
  8064 zero(base_dist);
       
  8065 /* First normalized distance for each code (0 = distance of 1) */
       
  8066 
       
  8067 
       
  8068 var StaticTreeDesc = function (static_tree, extra_bits, extra_base, elems, max_length) {
       
  8069 
       
  8070   this.static_tree  = static_tree;  /* static tree or NULL */
       
  8071   this.extra_bits   = extra_bits;   /* extra bits for each code or NULL */
       
  8072   this.extra_base   = extra_base;   /* base index for extra_bits */
       
  8073   this.elems        = elems;        /* max number of elements in the tree */
       
  8074   this.max_length   = max_length;   /* max bit length for the codes */
       
  8075 
       
  8076   // show if `static_tree` has data or dummy - needed for monomorphic objects
       
  8077   this.has_stree    = static_tree && static_tree.length;
       
  8078 };
       
  8079 
       
  8080 
       
  8081 var static_l_desc;
       
  8082 var static_d_desc;
       
  8083 var static_bl_desc;
       
  8084 
       
  8085 
       
  8086 var TreeDesc = function(dyn_tree, stat_desc) {
       
  8087   this.dyn_tree = dyn_tree;     /* the dynamic tree */
       
  8088   this.max_code = 0;            /* largest code with non zero frequency */
       
  8089   this.stat_desc = stat_desc;   /* the corresponding static tree */
       
  8090 };
       
  8091 
       
  8092 
       
  8093 
       
  8094 function d_code(dist) {
       
  8095   return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
       
  8096 }
       
  8097 
       
  8098 
       
  8099 /* ===========================================================================
       
  8100  * Output a short LSB first on the stream.
       
  8101  * IN assertion: there is enough room in pendingBuf.
       
  8102  */
       
  8103 function put_short (s, w) {
       
  8104 //    put_byte(s, (uch)((w) & 0xff));
       
  8105 //    put_byte(s, (uch)((ush)(w) >> 8));
       
  8106   s.pending_buf[s.pending++] = (w) & 0xff;
       
  8107   s.pending_buf[s.pending++] = (w >>> 8) & 0xff;
       
  8108 }
       
  8109 
       
  8110 
       
  8111 /* ===========================================================================
       
  8112  * Send a value on a given number of bits.
       
  8113  * IN assertion: length <= 16 and value fits in length bits.
       
  8114  */
       
  8115 function send_bits(s, value, length) {
       
  8116   if (s.bi_valid > (Buf_size - length)) {
       
  8117     s.bi_buf |= (value << s.bi_valid) & 0xffff;
       
  8118     put_short(s, s.bi_buf);
       
  8119     s.bi_buf = value >> (Buf_size - s.bi_valid);
       
  8120     s.bi_valid += length - Buf_size;
       
  8121   } else {
       
  8122     s.bi_buf |= (value << s.bi_valid) & 0xffff;
       
  8123     s.bi_valid += length;
       
  8124   }
       
  8125 }
       
  8126 
       
  8127 
       
  8128 function send_code(s, c, tree) {
       
  8129   send_bits(s, tree[c*2]/*.Code*/, tree[c*2 + 1]/*.Len*/);
       
  8130 }
       
  8131 
       
  8132 
       
  8133 /* ===========================================================================
       
  8134  * Reverse the first len bits of a code, using straightforward code (a faster
       
  8135  * method would use a table)
       
  8136  * IN assertion: 1 <= len <= 15
       
  8137  */
       
  8138 function bi_reverse(code, len) {
       
  8139   var res = 0;
       
  8140   do {
       
  8141     res |= code & 1;
       
  8142     code >>>= 1;
       
  8143     res <<= 1;
       
  8144   } while (--len > 0);
       
  8145   return res >>> 1;
       
  8146 }
       
  8147 
       
  8148 
       
  8149 /* ===========================================================================
       
  8150  * Flush the bit buffer, keeping at most 7 bits in it.
       
  8151  */
       
  8152 function bi_flush(s) {
       
  8153   if (s.bi_valid === 16) {
       
  8154     put_short(s, s.bi_buf);
       
  8155     s.bi_buf = 0;
       
  8156     s.bi_valid = 0;
       
  8157 
       
  8158   } else if (s.bi_valid >= 8) {
       
  8159     s.pending_buf[s.pending++] = s.bi_buf & 0xff;
       
  8160     s.bi_buf >>= 8;
       
  8161     s.bi_valid -= 8;
       
  8162   }
       
  8163 }
       
  8164 
       
  8165 
       
  8166 /* ===========================================================================
       
  8167  * Compute the optimal bit lengths for a tree and update the total bit length
       
  8168  * for the current block.
       
  8169  * IN assertion: the fields freq and dad are set, heap[heap_max] and
       
  8170  *    above are the tree nodes sorted by increasing frequency.
       
  8171  * OUT assertions: the field len is set to the optimal bit length, the
       
  8172  *     array bl_count contains the frequencies for each bit length.
       
  8173  *     The length opt_len is updated; static_len is also updated if stree is
       
  8174  *     not null.
       
  8175  */
       
  8176 function gen_bitlen(s, desc)
       
  8177 //    deflate_state *s;
       
  8178 //    tree_desc *desc;    /* the tree descriptor */
       
  8179 {
       
  8180   var tree            = desc.dyn_tree;
       
  8181   var max_code        = desc.max_code;
       
  8182   var stree           = desc.stat_desc.static_tree;
       
  8183   var has_stree       = desc.stat_desc.has_stree;
       
  8184   var extra           = desc.stat_desc.extra_bits;
       
  8185   var base            = desc.stat_desc.extra_base;
       
  8186   var max_length      = desc.stat_desc.max_length;
       
  8187   var h;              /* heap index */
       
  8188   var n, m;           /* iterate over the tree elements */
       
  8189   var bits;           /* bit length */
       
  8190   var xbits;          /* extra bits */
       
  8191   var f;              /* frequency */
       
  8192   var overflow = 0;   /* number of elements with bit length too large */
       
  8193 
       
  8194   for (bits = 0; bits <= MAX_BITS; bits++) {
       
  8195     s.bl_count[bits] = 0;
       
  8196   }
       
  8197 
       
  8198   /* In a first pass, compute the optimal bit lengths (which may
       
  8199    * overflow in the case of the bit length tree).
       
  8200    */
       
  8201   tree[s.heap[s.heap_max]*2 + 1]/*.Len*/ = 0; /* root of the heap */
       
  8202 
       
  8203   for (h = s.heap_max+1; h < HEAP_SIZE; h++) {
       
  8204     n = s.heap[h];
       
  8205     bits = tree[tree[n*2 +1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
       
  8206     if (bits > max_length) {
       
  8207       bits = max_length;
       
  8208       overflow++;
       
  8209     }
       
  8210     tree[n*2 + 1]/*.Len*/ = bits;
       
  8211     /* We overwrite tree[n].Dad which is no longer needed */
       
  8212 
       
  8213     if (n > max_code) { continue; } /* not a leaf node */
       
  8214 
       
  8215     s.bl_count[bits]++;
       
  8216     xbits = 0;
       
  8217     if (n >= base) {
       
  8218       xbits = extra[n-base];
       
  8219     }
       
  8220     f = tree[n * 2]/*.Freq*/;
       
  8221     s.opt_len += f * (bits + xbits);
       
  8222     if (has_stree) {
       
  8223       s.static_len += f * (stree[n*2 + 1]/*.Len*/ + xbits);
       
  8224     }
       
  8225   }
       
  8226   if (overflow === 0) { return; }
       
  8227 
       
  8228   // Trace((stderr,"\nbit length overflow\n"));
       
  8229   /* This happens for example on obj2 and pic of the Calgary corpus */
       
  8230 
       
  8231   /* Find the first bit length which could increase: */
       
  8232   do {
       
  8233     bits = max_length-1;
       
  8234     while (s.bl_count[bits] === 0) { bits--; }
       
  8235     s.bl_count[bits]--;      /* move one leaf down the tree */
       
  8236     s.bl_count[bits+1] += 2; /* move one overflow item as its brother */
       
  8237     s.bl_count[max_length]--;
       
  8238     /* The brother of the overflow item also moves one step up,
       
  8239      * but this does not affect bl_count[max_length]
       
  8240      */
       
  8241     overflow -= 2;
       
  8242   } while (overflow > 0);
       
  8243 
       
  8244   /* Now recompute all bit lengths, scanning in increasing frequency.
       
  8245    * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
       
  8246    * lengths instead of fixing only the wrong ones. This idea is taken
       
  8247    * from 'ar' written by Haruhiko Okumura.)
       
  8248    */
       
  8249   for (bits = max_length; bits !== 0; bits--) {
       
  8250     n = s.bl_count[bits];
       
  8251     while (n !== 0) {
       
  8252       m = s.heap[--h];
       
  8253       if (m > max_code) { continue; }
       
  8254       if (tree[m*2 + 1]/*.Len*/ !== bits) {
       
  8255         // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
       
  8256         s.opt_len += (bits - tree[m*2 + 1]/*.Len*/)*tree[m*2]/*.Freq*/;
       
  8257         tree[m*2 + 1]/*.Len*/ = bits;
       
  8258       }
       
  8259       n--;
       
  8260     }
       
  8261   }
       
  8262 }
       
  8263 
       
  8264 
       
  8265 /* ===========================================================================
       
  8266  * Generate the codes for a given tree and bit counts (which need not be
       
  8267  * optimal).
       
  8268  * IN assertion: the array bl_count contains the bit length statistics for
       
  8269  * the given tree and the field len is set for all tree elements.
       
  8270  * OUT assertion: the field code is set for all tree elements of non
       
  8271  *     zero code length.
       
  8272  */
       
  8273 function gen_codes(tree, max_code, bl_count)
       
  8274 //    ct_data *tree;             /* the tree to decorate */
       
  8275 //    int max_code;              /* largest code with non zero frequency */
       
  8276 //    ushf *bl_count;            /* number of codes at each bit length */
       
  8277 {
       
  8278   var next_code = new Array(MAX_BITS+1); /* next code value for each bit length */
       
  8279   var code = 0;              /* running code value */
       
  8280   var bits;                  /* bit index */
       
  8281   var n;                     /* code index */
       
  8282 
       
  8283   /* The distribution counts are first used to generate the code values
       
  8284    * without bit reversal.
       
  8285    */
       
  8286   for (bits = 1; bits <= MAX_BITS; bits++) {
       
  8287     next_code[bits] = code = (code + bl_count[bits-1]) << 1;
       
  8288   }
       
  8289   /* Check that the bit counts in bl_count are consistent. The last code
       
  8290    * must be all ones.
       
  8291    */
       
  8292   //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
       
  8293   //        "inconsistent bit counts");
       
  8294   //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
       
  8295 
       
  8296   for (n = 0;  n <= max_code; n++) {
       
  8297     var len = tree[n*2 + 1]/*.Len*/;
       
  8298     if (len === 0) { continue; }
       
  8299     /* Now reverse the bits */
       
  8300     tree[n*2]/*.Code*/ = bi_reverse(next_code[len]++, len);
       
  8301 
       
  8302     //Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
       
  8303     //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
       
  8304   }
       
  8305 }
       
  8306 
       
  8307 
       
  8308 /* ===========================================================================
       
  8309  * Initialize the various 'constant' tables.
       
  8310  */
       
  8311 function tr_static_init() {
       
  8312   var n;        /* iterates over tree elements */
       
  8313   var bits;     /* bit counter */
       
  8314   var length;   /* length value */
       
  8315   var code;     /* code value */
       
  8316   var dist;     /* distance index */
       
  8317   var bl_count = new Array(MAX_BITS+1);
       
  8318   /* number of codes at each bit length for an optimal tree */
       
  8319 
       
  8320   // do check in _tr_init()
       
  8321   //if (static_init_done) return;
       
  8322 
       
  8323   /* For some embedded targets, global variables are not initialized: */
       
  8324 /*#ifdef NO_INIT_GLOBAL_POINTERS
       
  8325   static_l_desc.static_tree = static_ltree;
       
  8326   static_l_desc.extra_bits = extra_lbits;
       
  8327   static_d_desc.static_tree = static_dtree;
       
  8328   static_d_desc.extra_bits = extra_dbits;
       
  8329   static_bl_desc.extra_bits = extra_blbits;
       
  8330 #endif*/
       
  8331 
       
  8332   /* Initialize the mapping length (0..255) -> length code (0..28) */
       
  8333   length = 0;
       
  8334   for (code = 0; code < LENGTH_CODES-1; code++) {
       
  8335     base_length[code] = length;
       
  8336     for (n = 0; n < (1<<extra_lbits[code]); n++) {
       
  8337       _length_code[length++] = code;
       
  8338     }
       
  8339   }
       
  8340   //Assert (length == 256, "tr_static_init: length != 256");
       
  8341   /* Note that the length 255 (match length 258) can be represented
       
  8342    * in two different ways: code 284 + 5 bits or code 285, so we
       
  8343    * overwrite length_code[255] to use the best encoding:
       
  8344    */
       
  8345   _length_code[length-1] = code;
       
  8346 
       
  8347   /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
       
  8348   dist = 0;
       
  8349   for (code = 0 ; code < 16; code++) {
       
  8350     base_dist[code] = dist;
       
  8351     for (n = 0; n < (1<<extra_dbits[code]); n++) {
       
  8352       _dist_code[dist++] = code;
       
  8353     }
       
  8354   }
       
  8355   //Assert (dist == 256, "tr_static_init: dist != 256");
       
  8356   dist >>= 7; /* from now on, all distances are divided by 128 */
       
  8357   for ( ; code < D_CODES; code++) {
       
  8358     base_dist[code] = dist << 7;
       
  8359     for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
       
  8360       _dist_code[256 + dist++] = code;
       
  8361     }
       
  8362   }
       
  8363   //Assert (dist == 256, "tr_static_init: 256+dist != 512");
       
  8364 
       
  8365   /* Construct the codes of the static literal tree */
       
  8366   for (bits = 0; bits <= MAX_BITS; bits++) {
       
  8367     bl_count[bits] = 0;
       
  8368   }
       
  8369 
       
  8370   n = 0;
       
  8371   while (n <= 143) {
       
  8372     static_ltree[n*2 + 1]/*.Len*/ = 8;
       
  8373     n++;
       
  8374     bl_count[8]++;
       
  8375   }
       
  8376   while (n <= 255) {
       
  8377     static_ltree[n*2 + 1]/*.Len*/ = 9;
       
  8378     n++;
       
  8379     bl_count[9]++;
       
  8380   }
       
  8381   while (n <= 279) {
       
  8382     static_ltree[n*2 + 1]/*.Len*/ = 7;
       
  8383     n++;
       
  8384     bl_count[7]++;
       
  8385   }
       
  8386   while (n <= 287) {
       
  8387     static_ltree[n*2 + 1]/*.Len*/ = 8;
       
  8388     n++;
       
  8389     bl_count[8]++;
       
  8390   }
       
  8391   /* Codes 286 and 287 do not exist, but we must include them in the
       
  8392    * tree construction to get a canonical Huffman tree (longest code
       
  8393    * all ones)
       
  8394    */
       
  8395   gen_codes(static_ltree, L_CODES+1, bl_count);
       
  8396 
       
  8397   /* The static distance tree is trivial: */
       
  8398   for (n = 0; n < D_CODES; n++) {
       
  8399     static_dtree[n*2 + 1]/*.Len*/ = 5;
       
  8400     static_dtree[n*2]/*.Code*/ = bi_reverse(n, 5);
       
  8401   }
       
  8402 
       
  8403   // Now data ready and we can init static trees
       
  8404   static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS);
       
  8405   static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS);
       
  8406   static_bl_desc =new StaticTreeDesc(new Array(0), extra_blbits, 0,         BL_CODES, MAX_BL_BITS);
       
  8407 
       
  8408   //static_init_done = true;
       
  8409 }
       
  8410 
       
  8411 
       
  8412 /* ===========================================================================
       
  8413  * Initialize a new block.
       
  8414  */
       
  8415 function init_block(s) {
       
  8416   var n; /* iterates over tree elements */
       
  8417 
       
  8418   /* Initialize the trees. */
       
  8419   for (n = 0; n < L_CODES;  n++) { s.dyn_ltree[n*2]/*.Freq*/ = 0; }
       
  8420   for (n = 0; n < D_CODES;  n++) { s.dyn_dtree[n*2]/*.Freq*/ = 0; }
       
  8421   for (n = 0; n < BL_CODES; n++) { s.bl_tree[n*2]/*.Freq*/ = 0; }
       
  8422 
       
  8423   s.dyn_ltree[END_BLOCK*2]/*.Freq*/ = 1;
       
  8424   s.opt_len = s.static_len = 0;
       
  8425   s.last_lit = s.matches = 0;
       
  8426 }
       
  8427 
       
  8428 
       
  8429 /* ===========================================================================
       
  8430  * Flush the bit buffer and align the output on a byte boundary
       
  8431  */
       
  8432 function bi_windup(s)
       
  8433 {
       
  8434   if (s.bi_valid > 8) {
       
  8435     put_short(s, s.bi_buf);
       
  8436   } else if (s.bi_valid > 0) {
       
  8437     //put_byte(s, (Byte)s->bi_buf);
       
  8438     s.pending_buf[s.pending++] = s.bi_buf;
       
  8439   }
       
  8440   s.bi_buf = 0;
       
  8441   s.bi_valid = 0;
       
  8442 }
       
  8443 
       
  8444 /* ===========================================================================
       
  8445  * Copy a stored block, storing first the length and its
       
  8446  * one's complement if requested.
       
  8447  */
       
  8448 function copy_block(s, buf, len, header)
       
  8449 //DeflateState *s;
       
  8450 //charf    *buf;    /* the input data */
       
  8451 //unsigned len;     /* its length */
       
  8452 //int      header;  /* true if block header must be written */
       
  8453 {
       
  8454   bi_windup(s);        /* align on byte boundary */
       
  8455 
       
  8456   if (header) {
       
  8457     put_short(s, len);
       
  8458     put_short(s, ~len);
       
  8459   }
       
  8460 //  while (len--) {
       
  8461 //    put_byte(s, *buf++);
       
  8462 //  }
       
  8463   utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
       
  8464   s.pending += len;
       
  8465 }
       
  8466 
       
  8467 /* ===========================================================================
       
  8468  * Compares to subtrees, using the tree depth as tie breaker when
       
  8469  * the subtrees have equal frequency. This minimizes the worst case length.
       
  8470  */
       
  8471 function smaller(tree, n, m, depth) {
       
  8472   var _n2 = n*2;
       
  8473   var _m2 = m*2;
       
  8474   return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||
       
  8475          (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));
       
  8476 }
       
  8477 
       
  8478 /* ===========================================================================
       
  8479  * Restore the heap property by moving down the tree starting at node k,
       
  8480  * exchanging a node with the smallest of its two sons if necessary, stopping
       
  8481  * when the heap property is re-established (each father smaller than its
       
  8482  * two sons).
       
  8483  */
       
  8484 function pqdownheap(s, tree, k)
       
  8485 //    deflate_state *s;
       
  8486 //    ct_data *tree;  /* the tree to restore */
       
  8487 //    int k;               /* node to move down */
       
  8488 {
       
  8489   var v = s.heap[k];
       
  8490   var j = k << 1;  /* left son of k */
       
  8491   while (j <= s.heap_len) {
       
  8492     /* Set j to the smallest of the two sons: */
       
  8493     if (j < s.heap_len &&
       
  8494       smaller(tree, s.heap[j+1], s.heap[j], s.depth)) {
       
  8495       j++;
       
  8496     }
       
  8497     /* Exit if v is smaller than both sons */
       
  8498     if (smaller(tree, v, s.heap[j], s.depth)) { break; }
       
  8499 
       
  8500     /* Exchange v with the smallest son */
       
  8501     s.heap[k] = s.heap[j];
       
  8502     k = j;
       
  8503 
       
  8504     /* And continue down the tree, setting j to the left son of k */
       
  8505     j <<= 1;
       
  8506   }
       
  8507   s.heap[k] = v;
       
  8508 }
       
  8509 
       
  8510 
       
  8511 // inlined manually
       
  8512 // var SMALLEST = 1;
       
  8513 
       
  8514 /* ===========================================================================
       
  8515  * Send the block data compressed using the given Huffman trees
       
  8516  */
       
  8517 function compress_block(s, ltree, dtree)
       
  8518 //    deflate_state *s;
       
  8519 //    const ct_data *ltree; /* literal tree */
       
  8520 //    const ct_data *dtree; /* distance tree */
       
  8521 {
       
  8522   var dist;           /* distance of matched string */
       
  8523   var lc;             /* match length or unmatched char (if dist == 0) */
       
  8524   var lx = 0;         /* running index in l_buf */
       
  8525   var code;           /* the code to send */
       
  8526   var extra;          /* number of extra bits to send */
       
  8527 
       
  8528   if (s.last_lit !== 0) {
       
  8529     do {
       
  8530       dist = (s.pending_buf[s.d_buf + lx*2] << 8) | (s.pending_buf[s.d_buf + lx*2 + 1]);
       
  8531       lc = s.pending_buf[s.l_buf + lx];
       
  8532       lx++;
       
  8533 
       
  8534       if (dist === 0) {
       
  8535         send_code(s, lc, ltree); /* send a literal byte */
       
  8536         //Tracecv(isgraph(lc), (stderr," '%c' ", lc));
       
  8537       } else {
       
  8538         /* Here, lc is the match length - MIN_MATCH */
       
  8539         code = _length_code[lc];
       
  8540         send_code(s, code+LITERALS+1, ltree); /* send the length code */
       
  8541         extra = extra_lbits[code];
       
  8542         if (extra !== 0) {
       
  8543           lc -= base_length[code];
       
  8544           send_bits(s, lc, extra);       /* send the extra length bits */
       
  8545         }
       
  8546         dist--; /* dist is now the match distance - 1 */
       
  8547         code = d_code(dist);
       
  8548         //Assert (code < D_CODES, "bad d_code");
       
  8549 
       
  8550         send_code(s, code, dtree);       /* send the distance code */
       
  8551         extra = extra_dbits[code];
       
  8552         if (extra !== 0) {
       
  8553           dist -= base_dist[code];
       
  8554           send_bits(s, dist, extra);   /* send the extra distance bits */
       
  8555         }
       
  8556       } /* literal or match pair ? */
       
  8557 
       
  8558       /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
       
  8559       //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
       
  8560       //       "pendingBuf overflow");
       
  8561 
       
  8562     } while (lx < s.last_lit);
       
  8563   }
       
  8564 
       
  8565   send_code(s, END_BLOCK, ltree);
       
  8566 }
       
  8567 
       
  8568 
       
  8569 /* ===========================================================================
       
  8570  * Construct one Huffman tree and assigns the code bit strings and lengths.
       
  8571  * Update the total bit length for the current block.
       
  8572  * IN assertion: the field freq is set for all tree elements.
       
  8573  * OUT assertions: the fields len and code are set to the optimal bit length
       
  8574  *     and corresponding code. The length opt_len is updated; static_len is
       
  8575  *     also updated if stree is not null. The field max_code is set.
       
  8576  */
       
  8577 function build_tree(s, desc)
       
  8578 //    deflate_state *s;
       
  8579 //    tree_desc *desc; /* the tree descriptor */
       
  8580 {
       
  8581   var tree     = desc.dyn_tree;
       
  8582   var stree    = desc.stat_desc.static_tree;
       
  8583   var has_stree = desc.stat_desc.has_stree;
       
  8584   var elems    = desc.stat_desc.elems;
       
  8585   var n, m;          /* iterate over heap elements */
       
  8586   var max_code = -1; /* largest code with non zero frequency */
       
  8587   var node;          /* new node being created */
       
  8588 
       
  8589   /* Construct the initial heap, with least frequent element in
       
  8590    * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
       
  8591    * heap[0] is not used.
       
  8592    */
       
  8593   s.heap_len = 0;
       
  8594   s.heap_max = HEAP_SIZE;
       
  8595 
       
  8596   for (n = 0; n < elems; n++) {
       
  8597     if (tree[n * 2]/*.Freq*/ !== 0) {
       
  8598       s.heap[++s.heap_len] = max_code = n;
       
  8599       s.depth[n] = 0;
       
  8600 
       
  8601     } else {
       
  8602       tree[n*2 + 1]/*.Len*/ = 0;
       
  8603     }
       
  8604   }
       
  8605 
       
  8606   /* The pkzip format requires that at least one distance code exists,
       
  8607    * and that at least one bit should be sent even if there is only one
       
  8608    * possible code. So to avoid special checks later on we force at least
       
  8609    * two codes of non zero frequency.
       
  8610    */
       
  8611   while (s.heap_len < 2) {
       
  8612     node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
       
  8613     tree[node * 2]/*.Freq*/ = 1;
       
  8614     s.depth[node] = 0;
       
  8615     s.opt_len--;
       
  8616 
       
  8617     if (has_stree) {
       
  8618       s.static_len -= stree[node*2 + 1]/*.Len*/;
       
  8619     }
       
  8620     /* node is 0 or 1 so it does not have extra bits */
       
  8621   }
       
  8622   desc.max_code = max_code;
       
  8623 
       
  8624   /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
       
  8625    * establish sub-heaps of increasing lengths:
       
  8626    */
       
  8627   for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); }
       
  8628 
       
  8629   /* Construct the Huffman tree by repeatedly combining the least two
       
  8630    * frequent nodes.
       
  8631    */
       
  8632   node = elems;              /* next internal node of the tree */
       
  8633   do {
       
  8634     //pqremove(s, tree, n);  /* n = node of least frequency */
       
  8635     /*** pqremove ***/
       
  8636     n = s.heap[1/*SMALLEST*/];
       
  8637     s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--];
       
  8638     pqdownheap(s, tree, 1/*SMALLEST*/);
       
  8639     /***/
       
  8640 
       
  8641     m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */
       
  8642 
       
  8643     s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */
       
  8644     s.heap[--s.heap_max] = m;
       
  8645 
       
  8646     /* Create a new node father of n and m */
       
  8647     tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;
       
  8648     s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
       
  8649     tree[n*2 + 1]/*.Dad*/ = tree[m*2 + 1]/*.Dad*/ = node;
       
  8650 
       
  8651     /* and insert the new node in the heap */
       
  8652     s.heap[1/*SMALLEST*/] = node++;
       
  8653     pqdownheap(s, tree, 1/*SMALLEST*/);
       
  8654 
       
  8655   } while (s.heap_len >= 2);
       
  8656 
       
  8657   s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/];
       
  8658 
       
  8659   /* At this point, the fields freq and dad are set. We can now
       
  8660    * generate the bit lengths.
       
  8661    */
       
  8662   gen_bitlen(s, desc);
       
  8663 
       
  8664   /* The field len is now set, we can generate the bit codes */
       
  8665   gen_codes(tree, max_code, s.bl_count);
       
  8666 }
       
  8667 
       
  8668 
       
  8669 /* ===========================================================================
       
  8670  * Scan a literal or distance tree to determine the frequencies of the codes
       
  8671  * in the bit length tree.
       
  8672  */
       
  8673 function scan_tree(s, tree, max_code)
       
  8674 //    deflate_state *s;
       
  8675 //    ct_data *tree;   /* the tree to be scanned */
       
  8676 //    int max_code;    /* and its largest code of non zero frequency */
       
  8677 {
       
  8678   var n;                     /* iterates over all tree elements */
       
  8679   var prevlen = -1;          /* last emitted length */
       
  8680   var curlen;                /* length of current code */
       
  8681 
       
  8682   var nextlen = tree[0*2 + 1]/*.Len*/; /* length of next code */
       
  8683 
       
  8684   var count = 0;             /* repeat count of the current code */
       
  8685   var max_count = 7;         /* max repeat count */
       
  8686   var min_count = 4;         /* min repeat count */
       
  8687 
       
  8688   if (nextlen === 0) {
       
  8689     max_count = 138;
       
  8690     min_count = 3;
       
  8691   }
       
  8692   tree[(max_code+1)*2 + 1]/*.Len*/ = 0xffff; /* guard */
       
  8693 
       
  8694   for (n = 0; n <= max_code; n++) {
       
  8695     curlen = nextlen;
       
  8696     nextlen = tree[(n+1)*2 + 1]/*.Len*/;
       
  8697 
       
  8698     if (++count < max_count && curlen === nextlen) {
       
  8699       continue;
       
  8700 
       
  8701     } else if (count < min_count) {
       
  8702       s.bl_tree[curlen * 2]/*.Freq*/ += count;
       
  8703 
       
  8704     } else if (curlen !== 0) {
       
  8705 
       
  8706       if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }
       
  8707       s.bl_tree[REP_3_6*2]/*.Freq*/++;
       
  8708 
       
  8709     } else if (count <= 10) {
       
  8710       s.bl_tree[REPZ_3_10*2]/*.Freq*/++;
       
  8711 
       
  8712     } else {
       
  8713       s.bl_tree[REPZ_11_138*2]/*.Freq*/++;
       
  8714     }
       
  8715 
       
  8716     count = 0;
       
  8717     prevlen = curlen;
       
  8718 
       
  8719     if (nextlen === 0) {
       
  8720       max_count = 138;
       
  8721       min_count = 3;
       
  8722 
       
  8723     } else if (curlen === nextlen) {
       
  8724       max_count = 6;
       
  8725       min_count = 3;
       
  8726 
       
  8727     } else {
       
  8728       max_count = 7;
       
  8729       min_count = 4;
       
  8730     }
       
  8731   }
       
  8732 }
       
  8733 
       
  8734 
       
  8735 /* ===========================================================================
       
  8736  * Send a literal or distance tree in compressed form, using the codes in
       
  8737  * bl_tree.
       
  8738  */
       
  8739 function send_tree(s, tree, max_code)
       
  8740 //    deflate_state *s;
       
  8741 //    ct_data *tree; /* the tree to be scanned */
       
  8742 //    int max_code;       /* and its largest code of non zero frequency */
       
  8743 {
       
  8744   var n;                     /* iterates over all tree elements */
       
  8745   var prevlen = -1;          /* last emitted length */
       
  8746   var curlen;                /* length of current code */
       
  8747 
       
  8748   var nextlen = tree[0*2 + 1]/*.Len*/; /* length of next code */
       
  8749 
       
  8750   var count = 0;             /* repeat count of the current code */
       
  8751   var max_count = 7;         /* max repeat count */
       
  8752   var min_count = 4;         /* min repeat count */
       
  8753 
       
  8754   /* tree[max_code+1].Len = -1; */  /* guard already set */
       
  8755   if (nextlen === 0) {
       
  8756     max_count = 138;
       
  8757     min_count = 3;
       
  8758   }
       
  8759 
       
  8760   for (n = 0; n <= max_code; n++) {
       
  8761     curlen = nextlen;
       
  8762     nextlen = tree[(n+1)*2 + 1]/*.Len*/;
       
  8763 
       
  8764     if (++count < max_count && curlen === nextlen) {
       
  8765       continue;
       
  8766 
       
  8767     } else if (count < min_count) {
       
  8768       do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);
       
  8769 
       
  8770     } else if (curlen !== 0) {
       
  8771       if (curlen !== prevlen) {
       
  8772         send_code(s, curlen, s.bl_tree);
       
  8773         count--;
       
  8774       }
       
  8775       //Assert(count >= 3 && count <= 6, " 3_6?");
       
  8776       send_code(s, REP_3_6, s.bl_tree);
       
  8777       send_bits(s, count-3, 2);
       
  8778 
       
  8779     } else if (count <= 10) {
       
  8780       send_code(s, REPZ_3_10, s.bl_tree);
       
  8781       send_bits(s, count-3, 3);
       
  8782 
       
  8783     } else {
       
  8784       send_code(s, REPZ_11_138, s.bl_tree);
       
  8785       send_bits(s, count-11, 7);
       
  8786     }
       
  8787 
       
  8788     count = 0;
       
  8789     prevlen = curlen;
       
  8790     if (nextlen === 0) {
       
  8791       max_count = 138;
       
  8792       min_count = 3;
       
  8793 
       
  8794     } else if (curlen === nextlen) {
       
  8795       max_count = 6;
       
  8796       min_count = 3;
       
  8797 
       
  8798     } else {
       
  8799       max_count = 7;
       
  8800       min_count = 4;
       
  8801     }
       
  8802   }
       
  8803 }
       
  8804 
       
  8805 
       
  8806 /* ===========================================================================
       
  8807  * Construct the Huffman tree for the bit lengths and return the index in
       
  8808  * bl_order of the last bit length code to send.
       
  8809  */
       
  8810 function build_bl_tree(s) {
       
  8811   var max_blindex;  /* index of last bit length code of non zero freq */
       
  8812 
       
  8813   /* Determine the bit length frequencies for literal and distance trees */
       
  8814   scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
       
  8815   scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
       
  8816 
       
  8817   /* Build the bit length tree: */
       
  8818   build_tree(s, s.bl_desc);
       
  8819   /* opt_len now includes the length of the tree representations, except
       
  8820    * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
       
  8821    */
       
  8822 
       
  8823   /* Determine the number of bit length codes to send. The pkzip format
       
  8824    * requires that at least 4 bit length codes be sent. (appnote.txt says
       
  8825    * 3 but the actual value used is 4.)
       
  8826    */
       
  8827   for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
       
  8828     if (s.bl_tree[bl_order[max_blindex]*2 + 1]/*.Len*/ !== 0) {
       
  8829       break;
       
  8830     }
       
  8831   }
       
  8832   /* Update opt_len to include the bit length tree and counts */
       
  8833   s.opt_len += 3*(max_blindex+1) + 5+5+4;
       
  8834   //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
       
  8835   //        s->opt_len, s->static_len));
       
  8836 
       
  8837   return max_blindex;
       
  8838 }
       
  8839 
       
  8840 
       
  8841 /* ===========================================================================
       
  8842  * Send the header for a block using dynamic Huffman trees: the counts, the
       
  8843  * lengths of the bit length codes, the literal tree and the distance tree.
       
  8844  * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
       
  8845  */
       
  8846 function send_all_trees(s, lcodes, dcodes, blcodes)
       
  8847 //    deflate_state *s;
       
  8848 //    int lcodes, dcodes, blcodes; /* number of codes for each tree */
       
  8849 {
       
  8850   var rank;                    /* index in bl_order */
       
  8851 
       
  8852   //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
       
  8853   //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
       
  8854   //        "too many codes");
       
  8855   //Tracev((stderr, "\nbl counts: "));
       
  8856   send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
       
  8857   send_bits(s, dcodes-1,   5);
       
  8858   send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */
       
  8859   for (rank = 0; rank < blcodes; rank++) {
       
  8860     //Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
       
  8861     send_bits(s, s.bl_tree[bl_order[rank]*2 + 1]/*.Len*/, 3);
       
  8862   }
       
  8863   //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
       
  8864 
       
  8865   send_tree(s, s.dyn_ltree, lcodes-1); /* literal tree */
       
  8866   //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
       
  8867 
       
  8868   send_tree(s, s.dyn_dtree, dcodes-1); /* distance tree */
       
  8869   //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
       
  8870 }
       
  8871 
       
  8872 
       
  8873 /* ===========================================================================
       
  8874  * Check if the data type is TEXT or BINARY, using the following algorithm:
       
  8875  * - TEXT if the two conditions below are satisfied:
       
  8876  *    a) There are no non-portable control characters belonging to the
       
  8877  *       "black list" (0..6, 14..25, 28..31).
       
  8878  *    b) There is at least one printable character belonging to the
       
  8879  *       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
       
  8880  * - BINARY otherwise.
       
  8881  * - The following partially-portable control characters form a
       
  8882  *   "gray list" that is ignored in this detection algorithm:
       
  8883  *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
       
  8884  * IN assertion: the fields Freq of dyn_ltree are set.
       
  8885  */
       
  8886 function detect_data_type(s) {
       
  8887   /* black_mask is the bit mask of black-listed bytes
       
  8888    * set bits 0..6, 14..25, and 28..31
       
  8889    * 0xf3ffc07f = binary 11110011111111111100000001111111
       
  8890    */
       
  8891   var black_mask = 0xf3ffc07f;
       
  8892   var n;
       
  8893 
       
  8894   /* Check for non-textual ("black-listed") bytes. */
       
  8895   for (n = 0; n <= 31; n++, black_mask >>>= 1) {
       
  8896     if ((black_mask & 1) && (s.dyn_ltree[n*2]/*.Freq*/ !== 0)) {
       
  8897       return Z_BINARY;
       
  8898     }
       
  8899   }
       
  8900 
       
  8901   /* Check for textual ("white-listed") bytes. */
       
  8902   if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||
       
  8903       s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {
       
  8904     return Z_TEXT;
       
  8905   }
       
  8906   for (n = 32; n < LITERALS; n++) {
       
  8907     if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {
       
  8908       return Z_TEXT;
       
  8909     }
       
  8910   }
       
  8911 
       
  8912   /* There are no "black-listed" or "white-listed" bytes:
       
  8913    * this stream either is empty or has tolerated ("gray-listed") bytes only.
       
  8914    */
       
  8915   return Z_BINARY;
       
  8916 }
       
  8917 
       
  8918 
       
  8919 var static_init_done = false;
       
  8920 
       
  8921 /* ===========================================================================
       
  8922  * Initialize the tree data structures for a new zlib stream.
       
  8923  */
       
  8924 function _tr_init(s)
       
  8925 {
       
  8926 
       
  8927   if (!static_init_done) {
       
  8928     tr_static_init();
       
  8929     static_init_done = true;
       
  8930   }
       
  8931 
       
  8932   s.l_desc  = new TreeDesc(s.dyn_ltree, static_l_desc);
       
  8933   s.d_desc  = new TreeDesc(s.dyn_dtree, static_d_desc);
       
  8934   s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
       
  8935 
       
  8936   s.bi_buf = 0;
       
  8937   s.bi_valid = 0;
       
  8938 
       
  8939   /* Initialize the first block of the first file: */
       
  8940   init_block(s);
       
  8941 }
       
  8942 
       
  8943 
       
  8944 /* ===========================================================================
       
  8945  * Send a stored block
       
  8946  */
       
  8947 function _tr_stored_block(s, buf, stored_len, last)
       
  8948 //DeflateState *s;
       
  8949 //charf *buf;       /* input block */
       
  8950 //ulg stored_len;   /* length of input block */
       
  8951 //int last;         /* one if this is the last block for a file */
       
  8952 {
       
  8953   send_bits(s, (STORED_BLOCK<<1)+(last ? 1 : 0), 3);    /* send block type */
       
  8954   copy_block(s, buf, stored_len, true); /* with header */
       
  8955 }
       
  8956 
       
  8957 
       
  8958 /* ===========================================================================
       
  8959  * Send one empty static block to give enough lookahead for inflate.
       
  8960  * This takes 10 bits, of which 7 may remain in the bit buffer.
       
  8961  */
       
  8962 function _tr_align(s) {
       
  8963   send_bits(s, STATIC_TREES<<1, 3);
       
  8964   send_code(s, END_BLOCK, static_ltree);
       
  8965   bi_flush(s);
       
  8966 }
       
  8967 
       
  8968 
       
  8969 /* ===========================================================================
       
  8970  * Determine the best encoding for the current block: dynamic trees, static
       
  8971  * trees or store, and output the encoded block to the zip file.
       
  8972  */
       
  8973 function _tr_flush_block(s, buf, stored_len, last)
       
  8974 //DeflateState *s;
       
  8975 //charf *buf;       /* input block, or NULL if too old */
       
  8976 //ulg stored_len;   /* length of input block */
       
  8977 //int last;         /* one if this is the last block for a file */
       
  8978 {
       
  8979   var opt_lenb, static_lenb;  /* opt_len and static_len in bytes */
       
  8980   var max_blindex = 0;        /* index of last bit length code of non zero freq */
       
  8981 
       
  8982   /* Build the Huffman trees unless a stored block is forced */
       
  8983   if (s.level > 0) {
       
  8984 
       
  8985     /* Check if the file is binary or text */
       
  8986     if (s.strm.data_type === Z_UNKNOWN) {
       
  8987       s.strm.data_type = detect_data_type(s);
       
  8988     }
       
  8989 
       
  8990     /* Construct the literal and distance trees */
       
  8991     build_tree(s, s.l_desc);
       
  8992     // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
       
  8993     //        s->static_len));
       
  8994 
       
  8995     build_tree(s, s.d_desc);
       
  8996     // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
       
  8997     //        s->static_len));
       
  8998     /* At this point, opt_len and static_len are the total bit lengths of
       
  8999      * the compressed block data, excluding the tree representations.
       
  9000      */
       
  9001 
       
  9002     /* Build the bit length tree for the above two trees, and get the index
       
  9003      * in bl_order of the last bit length code to send.
       
  9004      */
       
  9005     max_blindex = build_bl_tree(s);
       
  9006 
       
  9007     /* Determine the best encoding. Compute the block lengths in bytes. */
       
  9008     opt_lenb = (s.opt_len+3+7) >>> 3;
       
  9009     static_lenb = (s.static_len+3+7) >>> 3;
       
  9010 
       
  9011     // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
       
  9012     //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
       
  9013     //        s->last_lit));
       
  9014 
       
  9015     if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }
       
  9016 
       
  9017   } else {
       
  9018     // Assert(buf != (char*)0, "lost buf");
       
  9019     opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
       
  9020   }
       
  9021 
       
  9022   if ((stored_len+4 <= opt_lenb) && (buf !== -1)) {
       
  9023     /* 4: two words for the lengths */
       
  9024 
       
  9025     /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
       
  9026      * Otherwise we can't have processed more than WSIZE input bytes since
       
  9027      * the last block flush, because compression would have been
       
  9028      * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
       
  9029      * transform a block into a stored block.
       
  9030      */
       
  9031     _tr_stored_block(s, buf, stored_len, last);
       
  9032 
       
  9033   } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
       
  9034 
       
  9035     send_bits(s, (STATIC_TREES<<1) + (last ? 1 : 0), 3);
       
  9036     compress_block(s, static_ltree, static_dtree);
       
  9037 
       
  9038   } else {
       
  9039     send_bits(s, (DYN_TREES<<1) + (last ? 1 : 0), 3);
       
  9040     send_all_trees(s, s.l_desc.max_code+1, s.d_desc.max_code+1, max_blindex+1);
       
  9041     compress_block(s, s.dyn_ltree, s.dyn_dtree);
       
  9042   }
       
  9043   // Assert (s->compressed_len == s->bits_sent, "bad compressed size");
       
  9044   /* The above check is made mod 2^32, for files larger than 512 MB
       
  9045    * and uLong implemented on 32 bits.
       
  9046    */
       
  9047   init_block(s);
       
  9048 
       
  9049   if (last) {
       
  9050     bi_windup(s);
       
  9051   }
       
  9052   // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
       
  9053   //       s->compressed_len-7*last));
       
  9054 }
       
  9055 
       
  9056 /* ===========================================================================
       
  9057  * Save the match info and tally the frequency counts. Return true if
       
  9058  * the current block must be flushed.
       
  9059  */
       
  9060 function _tr_tally(s, dist, lc)
       
  9061 //    deflate_state *s;
       
  9062 //    unsigned dist;  /* distance of matched string */
       
  9063 //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
       
  9064 {
       
  9065   //var out_length, in_length, dcode;
       
  9066 
       
  9067   s.pending_buf[s.d_buf + s.last_lit * 2]     = (dist >>> 8) & 0xff;
       
  9068   s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;
       
  9069 
       
  9070   s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
       
  9071   s.last_lit++;
       
  9072 
       
  9073   if (dist === 0) {
       
  9074     /* lc is the unmatched char */
       
  9075     s.dyn_ltree[lc*2]/*.Freq*/++;
       
  9076   } else {
       
  9077     s.matches++;
       
  9078     /* Here, lc is the match length - MIN_MATCH */
       
  9079     dist--;             /* dist = match distance - 1 */
       
  9080     //Assert((ush)dist < (ush)MAX_DIST(s) &&
       
  9081     //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
       
  9082     //       (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
       
  9083 
       
  9084     s.dyn_ltree[(_length_code[lc]+LITERALS+1) * 2]/*.Freq*/++;
       
  9085     s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
       
  9086   }
       
  9087 
       
  9088 // (!) This block is disabled in zlib defailts,
       
  9089 // don't enable it for binary compatibility
       
  9090 
       
  9091 //#ifdef TRUNCATE_BLOCK
       
  9092 //  /* Try to guess if it is profitable to stop the current block here */
       
  9093 //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {
       
  9094 //    /* Compute an upper bound for the compressed length */
       
  9095 //    out_length = s.last_lit*8;
       
  9096 //    in_length = s.strstart - s.block_start;
       
  9097 //
       
  9098 //    for (dcode = 0; dcode < D_CODES; dcode++) {
       
  9099 //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);
       
  9100 //    }
       
  9101 //    out_length >>>= 3;
       
  9102 //    //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
       
  9103 //    //       s->last_lit, in_length, out_length,
       
  9104 //    //       100L - out_length*100L/in_length));
       
  9105 //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {
       
  9106 //      return true;
       
  9107 //    }
       
  9108 //  }
       
  9109 //#endif
       
  9110 
       
  9111   return (s.last_lit === s.lit_bufsize-1);
       
  9112   /* We avoid equality with lit_bufsize because of wraparound at 64K
       
  9113    * on 16 bit machines and because stored blocks are restricted to
       
  9114    * 64K-1 bytes.
       
  9115    */
       
  9116 }
       
  9117 
       
  9118 exports._tr_init  = _tr_init;
       
  9119 exports._tr_stored_block = _tr_stored_block;
       
  9120 exports._tr_flush_block  = _tr_flush_block;
       
  9121 exports._tr_tally = _tr_tally;
       
  9122 exports._tr_align = _tr_align;
       
  9123 },{"../utils/common":27}],39:[function(_dereq_,module,exports){
       
  9124 'use strict';
       
  9125 
       
  9126 
       
  9127 function ZStream() {
       
  9128   /* next input byte */
       
  9129   this.input = null; // JS specific, because we have no pointers
       
  9130   this.next_in = 0;
       
  9131   /* number of bytes available at input */
       
  9132   this.avail_in = 0;
       
  9133   /* total number of input bytes read so far */
       
  9134   this.total_in = 0;
       
  9135   /* next output byte should be put there */
       
  9136   this.output = null; // JS specific, because we have no pointers
       
  9137   this.next_out = 0;
       
  9138   /* remaining free space at output */
       
  9139   this.avail_out = 0;
       
  9140   /* total number of bytes output so far */
       
  9141   this.total_out = 0;
       
  9142   /* last error message, NULL if no error */
       
  9143   this.msg = ''/*Z_NULL*/;
       
  9144   /* not visible by applications */
       
  9145   this.state = null;
       
  9146   /* best guess about the data type: binary or text */
       
  9147   this.data_type = 2/*Z_UNKNOWN*/;
       
  9148   /* adler32 value of the uncompressed data */
       
  9149   this.adler = 0;
       
  9150 }
       
  9151 
       
  9152 module.exports = ZStream;
       
  9153 },{}]},{},[9])
       
  9154 (9)
       
  9155 });