1 /*!

     2 

     3 JSZip v3.1.5 - A JavaScript class for generating and reading zip files

     4 <http://stuartk.com/jszip>

     5 

     6 (c) 2009-2016 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 

    13 (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.JSZip = f()}})(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);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.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(require,module,exports){

    14 'use strict';

    15 var utils = require('./utils');

    16 var support = require('./support');

    17 // private property

    18 var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

    19 

    20 

    21 // public method for encoding

    22 exports.encode = function(input) {

    23     var output = [];

    24     var chr1, chr2, chr3, enc1, enc2, enc3, enc4;

    25     var i = 0, len = input.length, remainingBytes = len;

    26 

    27     var isArray = utils.getTypeOf(input) !== "string";

    28     while (i < input.length) {

    29         remainingBytes = len - i;

    30 

    31         if (!isArray) {

    32             chr1 = input.charCodeAt(i++);

    33             chr2 = i < len ? input.charCodeAt(i++) : 0;

    34             chr3 = i < len ? input.charCodeAt(i++) : 0;

    35         } else {

    36             chr1 = input[i++];

    37             chr2 = i < len ? input[i++] : 0;

    38             chr3 = i < len ? input[i++] : 0;

    39         }

    40 

    41         enc1 = chr1 >> 2;

    42         enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);

    43         enc3 = remainingBytes > 1 ? (((chr2 & 15) << 2) | (chr3 >> 6)) : 64;

    44         enc4 = remainingBytes > 2 ? (chr3 & 63) : 64;

    45 

    46         output.push(_keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4));

    47 

    48     }

    49 

    50     return output.join("");

    51 };

    52 

    53 // public method for decoding

    54 exports.decode = function(input) {

    55     var chr1, chr2, chr3;

    56     var enc1, enc2, enc3, enc4;

    57     var i = 0, resultIndex = 0;

    58 

    59     var dataUrlPrefix = "data:";

    60 

    61     if (input.substr(0, dataUrlPrefix.length) === dataUrlPrefix) {

    62         // This is a common error: people give a data url

    63         // (data:image/png;base64,iVBOR...) with a {base64: true} and

    64         // wonders why things don't work.

    65         // We can detect that the string input looks like a data url but we

    66         // *can't* be sure it is one: removing everything up to the comma would

    67         // be too dangerous.

    68         throw new Error("Invalid base64 input, it looks like a data url.");

    69     }

    70 

    71     input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

    72 

    73     var totalLength = input.length * 3 / 4;

    74     if(input.charAt(input.length - 1) === _keyStr.charAt(64)) {

    75         totalLength--;

    76     }

    77     if(input.charAt(input.length - 2) === _keyStr.charAt(64)) {

    78         totalLength--;

    79     }

    80     if (totalLength % 1 !== 0) {

    81         // totalLength is not an integer, the length does not match a valid

    82         // base64 content. That can happen if:

    83         // - the input is not a base64 content

    84         // - the input is *almost* a base64 content, with a extra chars at the

    85         //   beginning or at the end

    86         // - the input uses a base64 variant (base64url for example)

    87         throw new Error("Invalid base64 input, bad content length.");

    88     }

    89     var output;

    90     if (support.uint8array) {

    91         output = new Uint8Array(totalLength|0);

    92     } else {

    93         output = new Array(totalLength|0);

    94     }

    95 

    96     while (i < input.length) {

    97 

    98         enc1 = _keyStr.indexOf(input.charAt(i++));

    99         enc2 = _keyStr.indexOf(input.charAt(i++));

   100         enc3 = _keyStr.indexOf(input.charAt(i++));

   101         enc4 = _keyStr.indexOf(input.charAt(i++));

   102 

   103         chr1 = (enc1 << 2) | (enc2 >> 4);

   104         chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);

   105         chr3 = ((enc3 & 3) << 6) | enc4;

   106 

   107         output[resultIndex++] = chr1;

   108 

   109         if (enc3 !== 64) {

   110             output[resultIndex++] = chr2;

   111         }

   112         if (enc4 !== 64) {

   113             output[resultIndex++] = chr3;

   114         }

   115 

   116     }

   117 

   118     return output;

   119 };

   120 

   121 },{"./support":30,"./utils":32}],2:[function(require,module,exports){

   122 'use strict';

   123 

   124 var external = require("./external");

   125 var DataWorker = require('./stream/DataWorker');

   126 var DataLengthProbe = require('./stream/DataLengthProbe');

   127 var Crc32Probe = require('./stream/Crc32Probe');

   128 var DataLengthProbe = require('./stream/DataLengthProbe');

   129 

   130 /**

   131  * Represent a compressed object, with everything needed to decompress it.

   132  * @constructor

   133  * @param {number} compressedSize the size of the data compressed.

   134  * @param {number} uncompressedSize the size of the data after decompression.

   135  * @param {number} crc32 the crc32 of the decompressed file.

   136  * @param {object} compression the type of compression, see lib/compressions.js.

   137  * @param {String|ArrayBuffer|Uint8Array|Buffer} data the compressed data.

   138  */

   139 function CompressedObject(compressedSize, uncompressedSize, crc32, compression, data) {

   140     this.compressedSize = compressedSize;

   141     this.uncompressedSize = uncompressedSize;

   142     this.crc32 = crc32;

   143     this.compression = compression;

   144     this.compressedContent = data;

   145 }

   146 

   147 CompressedObject.prototype = {

   148     /**

   149      * Create a worker to get the uncompressed content.

   150      * @return {GenericWorker} the worker.

   151      */

   152     getContentWorker : function () {

   153         var worker = new DataWorker(external.Promise.resolve(this.compressedContent))

   154         .pipe(this.compression.uncompressWorker())

   155         .pipe(new DataLengthProbe("data_length"));

   156 

   157         var that = this;

   158         worker.on("end", function () {

   159             if(this.streamInfo['data_length'] !== that.uncompressedSize) {

   160                 throw new Error("Bug : uncompressed data size mismatch");

   161             }

   162         });

   163         return worker;

   164     },

   165     /**

   166      * Create a worker to get the compressed content.

   167      * @return {GenericWorker} the worker.

   168      */

   169     getCompressedWorker : function () {

   170         return new DataWorker(external.Promise.resolve(this.compressedContent))

   171         .withStreamInfo("compressedSize", this.compressedSize)

   172         .withStreamInfo("uncompressedSize", this.uncompressedSize)

   173         .withStreamInfo("crc32", this.crc32)

   174         .withStreamInfo("compression", this.compression)

   175         ;

   176     }

   177 };

   178 

   179 /**

   180  * Chain the given worker with other workers to compress the content with the

   181  * given compresion.

   182  * @param {GenericWorker} uncompressedWorker the worker to pipe.

   183  * @param {Object} compression the compression object.

   184  * @param {Object} compressionOptions the options to use when compressing.

   185  * @return {GenericWorker} the new worker compressing the content.

   186  */

   187 CompressedObject.createWorkerFrom = function (uncompressedWorker, compression, compressionOptions) {

   188     return uncompressedWorker

   189     .pipe(new Crc32Probe())

   190     .pipe(new DataLengthProbe("uncompressedSize"))

   191     .pipe(compression.compressWorker(compressionOptions))

   192     .pipe(new DataLengthProbe("compressedSize"))

   193     .withStreamInfo("compression", compression);

   194 };

   195 

   196 module.exports = CompressedObject;

   197 

   198 },{"./external":6,"./stream/Crc32Probe":25,"./stream/DataLengthProbe":26,"./stream/DataWorker":27}],3:[function(require,module,exports){

   199 'use strict';

   200 

   201 var GenericWorker = require("./stream/GenericWorker");

   202 

   203 exports.STORE = {

   204     magic: "\x00\x00",

   205     compressWorker : function (compressionOptions) {

   206         return new GenericWorker("STORE compression");

   207     },

   208     uncompressWorker : function () {

   209         return new GenericWorker("STORE decompression");

   210     }

   211 };

   212 exports.DEFLATE = require('./flate');

   213 

   214 },{"./flate":7,"./stream/GenericWorker":28}],4:[function(require,module,exports){

   215 'use strict';

   216 

   217 var utils = require('./utils');

   218 

   219 /**

   220  * The following functions come from pako, from pako/lib/zlib/crc32.js

   221  * released under the MIT license, see pako https://github.com/nodeca/pako/

   222  */

   223 

   224 // Use ordinary array, since untyped makes no boost here

   225 function makeTable() {

   226     var c, table = [];

   227 

   228     for(var n =0; n < 256; n++){

   229         c = n;

   230         for(var k =0; k < 8; k++){

   231             c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));

   232         }

   233         table[n] = c;

   234     }

   235 

   236     return table;

   237 }

   238 

   239 // Create table on load. Just 255 signed longs. Not a problem.

   240 var crcTable = makeTable();

   241 

   242 

   243 function crc32(crc, buf, len, pos) {

   244     var t = crcTable, end = pos + len;

   245 

   246     crc = crc ^ (-1);

   247 

   248     for (var i = pos; i < end; i++ ) {

   249         crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];

   250     }

   251 

   252     return (crc ^ (-1)); // >>> 0;

   253 }

   254 

   255 // That's all for the pako functions.

   256 

   257 /**

   258  * Compute the crc32 of a string.

   259  * This is almost the same as the function crc32, but for strings. Using the

   260  * same function for the two use cases leads to horrible performances.

   261  * @param {Number} crc the starting value of the crc.

   262  * @param {String} str the string to use.

   263  * @param {Number} len the length of the string.

   264  * @param {Number} pos the starting position for the crc32 computation.

   265  * @return {Number} the computed crc32.

   266  */

   267 function crc32str(crc, str, len, pos) {

   268     var t = crcTable, end = pos + len;

   269 

   270     crc = crc ^ (-1);

   271 

   272     for (var i = pos; i < end; i++ ) {

   273         crc = (crc >>> 8) ^ t[(crc ^ str.charCodeAt(i)) & 0xFF];

   274     }

   275 

   276     return (crc ^ (-1)); // >>> 0;

   277 }

   278 

   279 module.exports = function crc32wrapper(input, crc) {

   280     if (typeof input === "undefined" || !input.length) {

   281         return 0;

   282     }

   283 

   284     var isArray = utils.getTypeOf(input) !== "string";

   285 

   286     if(isArray) {

   287         return crc32(crc|0, input, input.length, 0);

   288     } else {

   289         return crc32str(crc|0, input, input.length, 0);

   290     }

   291 };

   292 

   293 },{"./utils":32}],5:[function(require,module,exports){

   294 'use strict';

   295 exports.base64 = false;

   296 exports.binary = false;

   297 exports.dir = false;

   298 exports.createFolders = true;

   299 exports.date = null;

   300 exports.compression = null;

   301 exports.compressionOptions = null;

   302 exports.comment = null;

   303 exports.unixPermissions = null;

   304 exports.dosPermissions = null;

   305 

   306 },{}],6:[function(require,module,exports){

   307 /* global Promise */

   308 'use strict';

   309 

   310 // load the global object first:

   311 // - it should be better integrated in the system (unhandledRejection in node)

   312 // - the environment may have a custom Promise implementation (see zone.js)

   313 var ES6Promise = null;

   314 if (typeof Promise !== "undefined") {

   315     ES6Promise = Promise;

   316 } else {

   317     ES6Promise = require("lie");

   318 }

   319 

   320 /**

   321  * Let the user use/change some implementations.

   322  */

   323 module.exports = {

   324     Promise: ES6Promise

   325 };

   326 

   327 },{"lie":58}],7:[function(require,module,exports){

   328 'use strict';

   329 var USE_TYPEDARRAY = (typeof Uint8Array !== 'undefined') && (typeof Uint16Array !== 'undefined') && (typeof Uint32Array !== 'undefined');

   330 

   331 var pako = require("pako");

   332 var utils = require("./utils");

   333 var GenericWorker = require("./stream/GenericWorker");

   334 

   335 var ARRAY_TYPE = USE_TYPEDARRAY ? "uint8array" : "array";

   336 

   337 exports.magic = "\x08\x00";

   338 

   339 /**

   340  * Create a worker that uses pako to inflate/deflate.

   341  * @constructor

   342  * @param {String} action the name of the pako function to call : either "Deflate" or "Inflate".

   343  * @param {Object} options the options to use when (de)compressing.

   344  */

   345 function FlateWorker(action, options) {

   346     GenericWorker.call(this, "FlateWorker/" + action);

   347 

   348     this._pako = null;

   349     this._pakoAction = action;

   350     this._pakoOptions = options;

   351     // the `meta` object from the last chunk received

   352     // this allow this worker to pass around metadata

   353     this.meta = {};

   354 }

   355 

   356 utils.inherits(FlateWorker, GenericWorker);

   357 

   358 /**

   359  * @see GenericWorker.processChunk

   360  */

   361 FlateWorker.prototype.processChunk = function (chunk) {

   362     this.meta = chunk.meta;

   363     if (this._pako === null) {

   364         this._createPako();

   365     }

   366     this._pako.push(utils.transformTo(ARRAY_TYPE, chunk.data), false);

   367 };

   368 

   369 /**

   370  * @see GenericWorker.flush

   371  */

   372 FlateWorker.prototype.flush = function () {

   373     GenericWorker.prototype.flush.call(this);

   374     if (this._pako === null) {

   375         this._createPako();

   376     }

   377     this._pako.push([], true);

   378 };

   379 /**

   380  * @see GenericWorker.cleanUp

   381  */

   382 FlateWorker.prototype.cleanUp = function () {

   383     GenericWorker.prototype.cleanUp.call(this);

   384     this._pako = null;

   385 };

   386 

   387 /**

   388  * Create the _pako object.

   389  * TODO: lazy-loading this object isn't the best solution but it's the

   390  * quickest. The best solution is to lazy-load the worker list. See also the

   391  * issue #446.

   392  */

   393 FlateWorker.prototype._createPako = function () {

   394     this._pako = new pako[this._pakoAction]({

   395         raw: true,

   396         level: this._pakoOptions.level || -1 // default compression

   397     });

   398     var self = this;

   399     this._pako.onData = function(data) {

   400         self.push({

   401             data : data,

   402             meta : self.meta

   403         });

   404     };

   405 };

   406 

   407 exports.compressWorker = function (compressionOptions) {

   408     return new FlateWorker("Deflate", compressionOptions);

   409 };

   410 exports.uncompressWorker = function () {

   411     return new FlateWorker("Inflate", {});

   412 };

   413 

   414 },{"./stream/GenericWorker":28,"./utils":32,"pako":59}],8:[function(require,module,exports){

   415 'use strict';

   416 

   417 var utils = require('../utils');

   418 var GenericWorker = require('../stream/GenericWorker');

   419 var utf8 = require('../utf8');

   420 var crc32 = require('../crc32');

   421 var signature = require('../signature');

   422 

   423 /**

   424  * Transform an integer into a string in hexadecimal.

   425  * @private

   426  * @param {number} dec the number to convert.

   427  * @param {number} bytes the number of bytes to generate.

   428  * @returns {string} the result.

   429  */

   430 var decToHex = function(dec, bytes) {

   431     var hex = "", i;

   432     for (i = 0; i < bytes; i++) {

   433         hex += String.fromCharCode(dec & 0xff);

   434         dec = dec >>> 8;

   435     }

   436     return hex;

   437 };

   438 

   439 /**

   440  * Generate the UNIX part of the external file attributes.

   441  * @param {Object} unixPermissions the unix permissions or null.

   442  * @param {Boolean} isDir true if the entry is a directory, false otherwise.

   443  * @return {Number} a 32 bit integer.

   444  *

   445  * adapted from http://unix.stackexchange.com/questions/14705/the-zip-formats-external-file-attribute :

   446  *

   447  * TTTTsstrwxrwxrwx0000000000ADVSHR

   448  * ^^^^____________________________ file type, see zipinfo.c (UNX_*)

   449  *     ^^^_________________________ setuid, setgid, sticky

   450  *        ^^^^^^^^^________________ permissions

   451  *                 ^^^^^^^^^^______ not used ?

   452  *                           ^^^^^^ DOS attribute bits : Archive, Directory, Volume label, System file, Hidden, Read only

   453  */

   454 var generateUnixExternalFileAttr = function (unixPermissions, isDir) {

   455 

   456     var result = unixPermissions;

   457     if (!unixPermissions) {

   458         // I can't use octal values in strict mode, hence the hexa.

   459         //  040775 => 0x41fd

   460         // 0100664 => 0x81b4

   461         result = isDir ? 0x41fd : 0x81b4;

   462     }

   463     return (result & 0xFFFF) << 16;

   464 };

   465 

   466 /**

   467  * Generate the DOS part of the external file attributes.

   468  * @param {Object} dosPermissions the dos permissions or null.

   469  * @param {Boolean} isDir true if the entry is a directory, false otherwise.

   470  * @return {Number} a 32 bit integer.

   471  *

   472  * Bit 0     Read-Only

   473  * Bit 1     Hidden

   474  * Bit 2     System

   475  * Bit 3     Volume Label

   476  * Bit 4     Directory

   477  * Bit 5     Archive

   478  */

   479 var generateDosExternalFileAttr = function (dosPermissions, isDir) {

   480 

   481     // the dir flag is already set for compatibility

   482     return (dosPermissions || 0)  & 0x3F;

   483 };

   484 

   485 /**

   486  * Generate the various parts used in the construction of the final zip file.

   487  * @param {Object} streamInfo the hash with informations about the compressed file.

   488  * @param {Boolean} streamedContent is the content streamed ?

   489  * @param {Boolean} streamingEnded is the stream finished ?

   490  * @param {number} offset the current offset from the start of the zip file.

   491  * @param {String} platform let's pretend we are this platform (change platform dependents fields)

   492  * @param {Function} encodeFileName the function to encode the file name / comment.

   493  * @return {Object} the zip parts.

   494  */

   495 var generateZipParts = function(streamInfo, streamedContent, streamingEnded, offset, platform, encodeFileName) {

   496     var file = streamInfo['file'],

   497     compression = streamInfo['compression'],

   498     useCustomEncoding = encodeFileName !== utf8.utf8encode,

   499     encodedFileName = utils.transformTo("string", encodeFileName(file.name)),

   500     utfEncodedFileName = utils.transformTo("string", utf8.utf8encode(file.name)),

   501     comment = file.comment,

   502     encodedComment = utils.transformTo("string", encodeFileName(comment)),

   503     utfEncodedComment = utils.transformTo("string", utf8.utf8encode(comment)),

   504     useUTF8ForFileName = utfEncodedFileName.length !== file.name.length,

   505     useUTF8ForComment = utfEncodedComment.length !== comment.length,

   506     dosTime,

   507     dosDate,

   508     extraFields = "",

   509     unicodePathExtraField = "",

   510     unicodeCommentExtraField = "",

   511     dir = file.dir,

   512     date = file.date;

   513 

   514 

   515     var dataInfo = {

   516         crc32 : 0,

   517         compressedSize : 0,

   518         uncompressedSize : 0

   519     };

   520 

   521     // if the content is streamed, the sizes/crc32 are only available AFTER

   522     // the end of the stream.

   523     if (!streamedContent || streamingEnded) {

   524         dataInfo.crc32 = streamInfo['crc32'];

   525         dataInfo.compressedSize = streamInfo['compressedSize'];

   526         dataInfo.uncompressedSize = streamInfo['uncompressedSize'];

   527     }

   528 

   529     var bitflag = 0;

   530     if (streamedContent) {

   531         // Bit 3: the sizes/crc32 are set to zero in the local header.

   532         // The correct values are put in the data descriptor immediately

   533         // following the compressed data.

   534         bitflag |= 0x0008;

   535     }

   536     if (!useCustomEncoding && (useUTF8ForFileName || useUTF8ForComment)) {

   537         // Bit 11: Language encoding flag (EFS).

   538         bitflag |= 0x0800;

   539     }

   540 

   541 

   542     var extFileAttr = 0;

   543     var versionMadeBy = 0;

   544     if (dir) {

   545         // dos or unix, we set the dos dir flag

   546         extFileAttr |= 0x00010;

   547     }

   548     if(platform === "UNIX") {

   549         versionMadeBy = 0x031E; // UNIX, version 3.0

   550         extFileAttr |= generateUnixExternalFileAttr(file.unixPermissions, dir);

   551     } else { // DOS or other, fallback to DOS

   552         versionMadeBy = 0x0014; // DOS, version 2.0

   553         extFileAttr |= generateDosExternalFileAttr(file.dosPermissions, dir);

   554     }

   555 

   556     // date

   557     // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html

   558     // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html

   559     // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html

   560 

   561     dosTime = date.getUTCHours();

   562     dosTime = dosTime << 6;

   563     dosTime = dosTime | date.getUTCMinutes();

   564     dosTime = dosTime << 5;

   565     dosTime = dosTime | date.getUTCSeconds() / 2;

   566 

   567     dosDate = date.getUTCFullYear() - 1980;

   568     dosDate = dosDate << 4;

   569     dosDate = dosDate | (date.getUTCMonth() + 1);

   570     dosDate = dosDate << 5;

   571     dosDate = dosDate | date.getUTCDate();

   572 

   573     if (useUTF8ForFileName) {

   574         // set the unicode path extra field. unzip needs at least one extra

   575         // field to correctly handle unicode path, so using the path is as good

   576         // as any other information. This could improve the situation with

   577         // other archive managers too.

   578         // This field is usually used without the utf8 flag, with a non

   579         // unicode path in the header (winrar, winzip). This helps (a bit)

   580         // with the messy Windows' default compressed folders feature but

   581         // breaks on p7zip which doesn't seek the unicode path extra field.

   582         // So for now, UTF-8 everywhere !

   583         unicodePathExtraField =

   584             // Version

   585             decToHex(1, 1) +

   586             // NameCRC32

   587             decToHex(crc32(encodedFileName), 4) +

   588             // UnicodeName

   589             utfEncodedFileName;

   590 

   591         extraFields +=

   592             // Info-ZIP Unicode Path Extra Field

   593             "\x75\x70" +

   594             // size

   595             decToHex(unicodePathExtraField.length, 2) +

   596             // content

   597             unicodePathExtraField;

   598     }

   599 

   600     if(useUTF8ForComment) {

   601 

   602         unicodeCommentExtraField =

   603             // Version

   604             decToHex(1, 1) +

   605             // CommentCRC32

   606             decToHex(crc32(encodedComment), 4) +

   607             // UnicodeName

   608             utfEncodedComment;

   609 

   610         extraFields +=

   611             // Info-ZIP Unicode Path Extra Field

   612             "\x75\x63" +

   613             // size

   614             decToHex(unicodeCommentExtraField.length, 2) +

   615             // content

   616             unicodeCommentExtraField;

   617     }

   618 

   619     var header = "";

   620 

   621     // version needed to extract

   622     header += "\x0A\x00";

   623     // general purpose bit flag

   624     header += decToHex(bitflag, 2);

   625     // compression method

   626     header += compression.magic;

   627     // last mod file time

   628     header += decToHex(dosTime, 2);

   629     // last mod file date

   630     header += decToHex(dosDate, 2);

   631     // crc-32

   632     header += decToHex(dataInfo.crc32, 4);

   633     // compressed size

   634     header += decToHex(dataInfo.compressedSize, 4);

   635     // uncompressed size

   636     header += decToHex(dataInfo.uncompressedSize, 4);

   637     // file name length

   638     header += decToHex(encodedFileName.length, 2);

   639     // extra field length

   640     header += decToHex(extraFields.length, 2);

   641 

   642 

   643     var fileRecord = signature.LOCAL_FILE_HEADER + header + encodedFileName + extraFields;

   644 

   645     var dirRecord = signature.CENTRAL_FILE_HEADER +

   646         // version made by (00: DOS)

   647         decToHex(versionMadeBy, 2) +

   648         // file header (common to file and central directory)

   649         header +

   650         // file comment length

   651         decToHex(encodedComment.length, 2) +

   652         // disk number start

   653         "\x00\x00" +

   654         // internal file attributes TODO

   655         "\x00\x00" +

   656         // external file attributes

   657         decToHex(extFileAttr, 4) +

   658         // relative offset of local header

   659         decToHex(offset, 4) +

   660         // file name

   661         encodedFileName +

   662         // extra field

   663         extraFields +

   664         // file comment

   665         encodedComment;

   666 

   667     return {

   668         fileRecord: fileRecord,

   669         dirRecord: dirRecord

   670     };

   671 };

   672 

   673 /**

   674  * Generate the EOCD record.

   675  * @param {Number} entriesCount the number of entries in the zip file.

   676  * @param {Number} centralDirLength the length (in bytes) of the central dir.

   677  * @param {Number} localDirLength the length (in bytes) of the local dir.

   678  * @param {String} comment the zip file comment as a binary string.

   679  * @param {Function} encodeFileName the function to encode the comment.

   680  * @return {String} the EOCD record.

   681  */

   682 var generateCentralDirectoryEnd = function (entriesCount, centralDirLength, localDirLength, comment, encodeFileName) {

   683     var dirEnd = "";

   684     var encodedComment = utils.transformTo("string", encodeFileName(comment));

   685 

   686     // end of central dir signature

   687     dirEnd = signature.CENTRAL_DIRECTORY_END +

   688         // number of this disk

   689         "\x00\x00" +

   690         // number of the disk with the start of the central directory

   691         "\x00\x00" +

   692         // total number of entries in the central directory on this disk

   693         decToHex(entriesCount, 2) +

   694         // total number of entries in the central directory

   695         decToHex(entriesCount, 2) +

   696         // size of the central directory   4 bytes

   697         decToHex(centralDirLength, 4) +

   698         // offset of start of central directory with respect to the starting disk number

   699         decToHex(localDirLength, 4) +

   700         // .ZIP file comment length

   701         decToHex(encodedComment.length, 2) +

   702         // .ZIP file comment

   703         encodedComment;

   704 

   705     return dirEnd;

   706 };

   707 

   708 /**

   709  * Generate data descriptors for a file entry.

   710  * @param {Object} streamInfo the hash generated by a worker, containing informations

   711  * on the file entry.

   712  * @return {String} the data descriptors.

   713  */

   714 var generateDataDescriptors = function (streamInfo) {

   715     var descriptor = "";

   716     descriptor = signature.DATA_DESCRIPTOR +

   717         // crc-32                          4 bytes

   718         decToHex(streamInfo['crc32'], 4) +

   719         // compressed size                 4 bytes

   720         decToHex(streamInfo['compressedSize'], 4) +

   721         // uncompressed size               4 bytes

   722         decToHex(streamInfo['uncompressedSize'], 4);

   723 

   724     return descriptor;

   725 };

   726 

   727 

   728 /**

   729  * A worker to concatenate other workers to create a zip file.

   730  * @param {Boolean} streamFiles `true` to stream the content of the files,

   731  * `false` to accumulate it.

   732  * @param {String} comment the comment to use.

   733  * @param {String} platform the platform to use, "UNIX" or "DOS".

   734  * @param {Function} encodeFileName the function to encode file names and comments.

   735  */

   736 function ZipFileWorker(streamFiles, comment, platform, encodeFileName) {

   737     GenericWorker.call(this, "ZipFileWorker");

   738     // The number of bytes written so far. This doesn't count accumulated chunks.

   739     this.bytesWritten = 0;

   740     // The comment of the zip file

   741     this.zipComment = comment;

   742     // The platform "generating" the zip file.

   743     this.zipPlatform = platform;

   744     // the function to encode file names and comments.

   745     this.encodeFileName = encodeFileName;

   746     // Should we stream the content of the files ?

   747     this.streamFiles = streamFiles;

   748     // If `streamFiles` is false, we will need to accumulate the content of the

   749     // files to calculate sizes / crc32 (and write them *before* the content).

   750     // This boolean indicates if we are accumulating chunks (it will change a lot

   751     // during the lifetime of this worker).

   752     this.accumulate = false;

   753     // The buffer receiving chunks when accumulating content.

   754     this.contentBuffer = [];

   755     // The list of generated directory records.

   756     this.dirRecords = [];

   757     // The offset (in bytes) from the beginning of the zip file for the current source.

   758     this.currentSourceOffset = 0;

   759     // The total number of entries in this zip file.

   760     this.entriesCount = 0;

   761     // the name of the file currently being added, null when handling the end of the zip file.

   762     // Used for the emited metadata.

   763     this.currentFile = null;

   764 

   765 

   766 

   767     this._sources = [];

   768 }

   769 utils.inherits(ZipFileWorker, GenericWorker);

   770 

   771 /**

   772  * @see GenericWorker.push

   773  */

   774 ZipFileWorker.prototype.push = function (chunk) {

   775 

   776     var currentFilePercent = chunk.meta.percent || 0;

   777     var entriesCount = this.entriesCount;

   778     var remainingFiles = this._sources.length;

   779 

   780     if(this.accumulate) {

   781         this.contentBuffer.push(chunk);

   782     } else {

   783         this.bytesWritten += chunk.data.length;

   784 

   785         GenericWorker.prototype.push.call(this, {

   786             data : chunk.data,

   787             meta : {

   788                 currentFile : this.currentFile,

   789                 percent : entriesCount ? (currentFilePercent + 100 * (entriesCount - remainingFiles - 1)) / entriesCount : 100

   790             }

   791         });

   792     }

   793 };

   794 

   795 /**

   796  * The worker started a new source (an other worker).

   797  * @param {Object} streamInfo the streamInfo object from the new source.

   798  */

   799 ZipFileWorker.prototype.openedSource = function (streamInfo) {

   800     this.currentSourceOffset = this.bytesWritten;

   801     this.currentFile = streamInfo['file'].name;

   802 

   803     var streamedContent = this.streamFiles && !streamInfo['file'].dir;

   804 

   805     // don't stream folders (because they don't have any content)

   806     if(streamedContent) {

   807         var record = generateZipParts(streamInfo, streamedContent, false, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);

   808         this.push({

   809             data : record.fileRecord,

   810             meta : {percent:0}

   811         });

   812     } else {

   813         // we need to wait for the whole file before pushing anything

   814         this.accumulate = true;

   815     }

   816 };

   817 

   818 /**

   819  * The worker finished a source (an other worker).

   820  * @param {Object} streamInfo the streamInfo object from the finished source.

   821  */

   822 ZipFileWorker.prototype.closedSource = function (streamInfo) {

   823     this.accumulate = false;

   824     var streamedContent = this.streamFiles && !streamInfo['file'].dir;

   825     var record = generateZipParts(streamInfo, streamedContent, true, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);

   826 

   827     this.dirRecords.push(record.dirRecord);

   828     if(streamedContent) {

   829         // after the streamed file, we put data descriptors

   830         this.push({

   831             data : generateDataDescriptors(streamInfo),

   832             meta : {percent:100}

   833         });

   834     } else {

   835         // the content wasn't streamed, we need to push everything now

   836         // first the file record, then the content

   837         this.push({

   838             data : record.fileRecord,

   839             meta : {percent:0}

   840         });

   841         while(this.contentBuffer.length) {

   842             this.push(this.contentBuffer.shift());

   843         }

   844     }

   845     this.currentFile = null;

   846 };

   847 

   848 /**

   849  * @see GenericWorker.flush

   850  */

   851 ZipFileWorker.prototype.flush = function () {

   852 

   853     var localDirLength = this.bytesWritten;

   854     for(var i = 0; i < this.dirRecords.length; i++) {

   855         this.push({

   856             data : this.dirRecords[i],

   857             meta : {percent:100}

   858         });

   859     }

   860     var centralDirLength = this.bytesWritten - localDirLength;

   861 

   862     var dirEnd = generateCentralDirectoryEnd(this.dirRecords.length, centralDirLength, localDirLength, this.zipComment, this.encodeFileName);

   863 

   864     this.push({

   865         data : dirEnd,

   866         meta : {percent:100}

   867     });

   868 };

   869 

   870 /**

   871  * Prepare the next source to be read.

   872  */

   873 ZipFileWorker.prototype.prepareNextSource = function () {

   874     this.previous = this._sources.shift();

   875     this.openedSource(this.previous.streamInfo);

   876     if (this.isPaused) {

   877         this.previous.pause();

   878     } else {

   879         this.previous.resume();

   880     }

   881 };

   882 

   883 /**

   884  * @see GenericWorker.registerPrevious

   885  */

   886 ZipFileWorker.prototype.registerPrevious = function (previous) {

   887     this._sources.push(previous);

   888     var self = this;

   889 

   890     previous.on('data', function (chunk) {

   891         self.processChunk(chunk);

   892     });

   893     previous.on('end', function () {

   894         self.closedSource(self.previous.streamInfo);

   895         if(self._sources.length) {

   896             self.prepareNextSource();

   897         } else {

   898             self.end();

   899         }

   900     });

   901     previous.on('error', function (e) {

   902         self.error(e);

   903     });

   904     return this;

   905 };

   906 

   907 /**

   908  * @see GenericWorker.resume

   909  */

   910 ZipFileWorker.prototype.resume = function () {

   911     if(!GenericWorker.prototype.resume.call(this)) {

   912         return false;

   913     }

   914 

   915     if (!this.previous && this._sources.length) {

   916         this.prepareNextSource();

   917         return true;

   918     }

   919     if (!this.previous && !this._sources.length && !this.generatedError) {

   920         this.end();

   921         return true;

   922     }

   923 };

   924 

   925 /**

   926  * @see GenericWorker.error

   927  */

   928 ZipFileWorker.prototype.error = function (e) {

   929     var sources = this._sources;

   930     if(!GenericWorker.prototype.error.call(this, e)) {

   931         return false;

   932     }

   933     for(var i = 0; i < sources.length; i++) {

   934         try {

   935             sources[i].error(e);

   936         } catch(e) {

   937             // the `error` exploded, nothing to do

   938         }

   939     }

   940     return true;

   941 };

   942 

   943 /**

   944  * @see GenericWorker.lock

   945  */

   946 ZipFileWorker.prototype.lock = function () {

   947     GenericWorker.prototype.lock.call(this);

   948     var sources = this._sources;

   949     for(var i = 0; i < sources.length; i++) {

   950         sources[i].lock();

   951     }

   952 };

   953 

   954 module.exports = ZipFileWorker;

   955 

   956 },{"../crc32":4,"../signature":23,"../stream/GenericWorker":28,"../utf8":31,"../utils":32}],9:[function(require,module,exports){

   957 'use strict';

   958 

   959 var compressions = require('../compressions');

   960 var ZipFileWorker = require('./ZipFileWorker');

   961 

   962 /**

   963  * Find the compression to use.

   964  * @param {String} fileCompression the compression defined at the file level, if any.

   965  * @param {String} zipCompression the compression defined at the load() level.

   966  * @return {Object} the compression object to use.

   967  */

   968 var getCompression = function (fileCompression, zipCompression) {

   969 

   970     var compressionName = fileCompression || zipCompression;

   971     var compression = compressions[compressionName];

   972     if (!compression) {

   973         throw new Error(compressionName + " is not a valid compression method !");

   974     }

   975     return compression;

   976 };

   977 

   978 /**

   979  * Create a worker to generate a zip file.

   980  * @param {JSZip} zip the JSZip instance at the right root level.

   981  * @param {Object} options to generate the zip file.

   982  * @param {String} comment the comment to use.

   983  */

   984 exports.generateWorker = function (zip, options, comment) {

   985 

   986     var zipFileWorker = new ZipFileWorker(options.streamFiles, comment, options.platform, options.encodeFileName);

   987     var entriesCount = 0;

   988     try {

   989 

   990         zip.forEach(function (relativePath, file) {

   991             entriesCount++;

   992             var compression = getCompression(file.options.compression, options.compression);

   993             var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};

   994             var dir = file.dir, date = file.date;

   995 

   996             file._compressWorker(compression, compressionOptions)

   997             .withStreamInfo("file", {

   998                 name : relativePath,

   999                 dir : dir,

  1000                 date : date,

  1001                 comment : file.comment || "",

  1002                 unixPermissions : file.unixPermissions,

  1003                 dosPermissions : file.dosPermissions

  1004             })

  1005             .pipe(zipFileWorker);

  1006         });

  1007         zipFileWorker.entriesCount = entriesCount;

  1008     } catch (e) {

  1009         zipFileWorker.error(e);

  1010     }

  1011 

  1012     return zipFileWorker;

  1013 };

  1014 

  1015 },{"../compressions":3,"./ZipFileWorker":8}],10:[function(require,module,exports){

  1016 'use strict';

  1017 

  1018 /**

  1019  * Representation a of zip file in js

  1020  * @constructor

  1021  */

  1022 function JSZip() {

  1023     // if this constructor is used without `new`, it adds `new` before itself:

  1024     if(!(this instanceof JSZip)) {

  1025         return new JSZip();

  1026     }

  1027 

  1028     if(arguments.length) {

  1029         throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");

  1030     }

  1031 

  1032     // object containing the files :

  1033     // {

  1034     //   "folder/" : {...},

  1035     //   "folder/data.txt" : {...}

  1036     // }

  1037     this.files = {};

  1038 

  1039     this.comment = null;

  1040 

  1041     // Where we are in the hierarchy

  1042     this.root = "";

  1043     this.clone = function() {

  1044         var newObj = new JSZip();

  1045         for (var i in this) {

  1046             if (typeof this[i] !== "function") {

  1047                 newObj[i] = this[i];

  1048             }

  1049         }

  1050         return newObj;

  1051     };

  1052 }

  1053 JSZip.prototype = require('./object');

  1054 JSZip.prototype.loadAsync = require('./load');

  1055 JSZip.support = require('./support');

  1056 JSZip.defaults = require('./defaults');

  1057 

  1058 // TODO find a better way to handle this version,

  1059 // a require('package.json').version doesn't work with webpack, see #327

  1060 JSZip.version = "3.1.5";

  1061 

  1062 JSZip.loadAsync = function (content, options) {

  1063     return new JSZip().loadAsync(content, options);

  1064 };

  1065 

  1066 JSZip.external = require("./external");

  1067 module.exports = JSZip;

  1068 

  1069 },{"./defaults":5,"./external":6,"./load":11,"./object":15,"./support":30}],11:[function(require,module,exports){

  1070 'use strict';

  1071 var utils = require('./utils');

  1072 var external = require("./external");

  1073 var utf8 = require('./utf8');

  1074 var utils = require('./utils');

  1075 var ZipEntries = require('./zipEntries');

  1076 var Crc32Probe = require('./stream/Crc32Probe');

  1077 var nodejsUtils = require("./nodejsUtils");

  1078 

  1079 /**

  1080  * Check the CRC32 of an entry.

  1081  * @param {ZipEntry} zipEntry the zip entry to check.

  1082  * @return {Promise} the result.

  1083  */

  1084 function checkEntryCRC32(zipEntry) {

  1085     return new external.Promise(function (resolve, reject) {

  1086         var worker = zipEntry.decompressed.getContentWorker().pipe(new Crc32Probe());

  1087         worker.on("error", function (e) {

  1088             reject(e);

  1089         })

  1090         .on("end", function () {

  1091             if (worker.streamInfo.crc32 !== zipEntry.decompressed.crc32) {

  1092                 reject(new Error("Corrupted zip : CRC32 mismatch"));

  1093             } else {

  1094                 resolve();

  1095             }

  1096         })

  1097         .resume();

  1098     });

  1099 }

  1100 

  1101 module.exports = function(data, options) {

  1102     var zip = this;

  1103     options = utils.extend(options || {}, {

  1104         base64: false,

  1105         checkCRC32: false,

  1106         optimizedBinaryString: false,

  1107         createFolders: false,

  1108         decodeFileName: utf8.utf8decode

  1109     });

  1110 

  1111     if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {

  1112         return external.Promise.reject(new Error("JSZip can't accept a stream when loading a zip file."));

  1113     }

  1114 

  1115     return utils.prepareContent("the loaded zip file", data, true, options.optimizedBinaryString, options.base64)

  1116     .then(function(data) {

  1117         var zipEntries = new ZipEntries(options);

  1118         zipEntries.load(data);

  1119         return zipEntries;

  1120     }).then(function checkCRC32(zipEntries) {

  1121         var promises = [external.Promise.resolve(zipEntries)];

  1122         var files = zipEntries.files;

  1123         if (options.checkCRC32) {

  1124             for (var i = 0; i < files.length; i++) {

  1125                 promises.push(checkEntryCRC32(files[i]));

  1126             }

  1127         }

  1128         return external.Promise.all(promises);

  1129     }).then(function addFiles(results) {

  1130         var zipEntries = results.shift();

  1131         var files = zipEntries.files;

  1132         for (var i = 0; i < files.length; i++) {

  1133             var input = files[i];

  1134             zip.file(input.fileNameStr, input.decompressed, {